Mercurial > templog
annotate py/utils.py @ 271:11cebd6f0bfb
untested fridge.integrator
| author | Matt Johnston <matt@ucc.asn.au> |
|---|---|
| date | Wed, 11 Nov 2015 00:20:20 +0800 |
| parents | 9d0313b685ae |
| children | af924d27140f |
| rev | line source |
|---|---|
| 141 | 1 import os |
| 2 import sys | |
| 265 | 3 import ctypes |
| 141 | 4 import time |
| 5 import select | |
| 6 import logging | |
|
253
0a1b642e3086
long polling config updates
Matt Johnston <matt@ucc.asn.au>
parents:
230
diff
changeset
|
7 import binascii |
| 259 | 8 import json |
| 265 | 9 import datetime |
| 141 | 10 |
|
149
d686b111dab4
working better. logging works properly, cleanup fridge.off() happens.
Matt Johnston <matt@ucc.asn.au>
parents:
145
diff
changeset
|
11 D = logging.debug |
| 141 | 12 L = logging.info |
| 13 W = logging.warning | |
| 14 E = logging.error | |
| 15 | |
| 16 DEFAULT_TRIES = 3 | |
| 17 READLINE_SELECT_TIMEOUT = 1 | |
| 18 | |
| 144 | 19 def EX(msg, *args, **kwargs): |
| 20 kwargs['exc_info'] = True | |
| 21 logging.error(msg, *args, **kwargs) | |
| 22 | |
| 141 | 23 clock_gettime = None |
| 24 no_clock_gettime = True | |
| 25 def monotonic_time(): | |
| 26 global clock_gettime | |
| 27 global no_clock_gettime | |
| 28 if no_clock_gettime: | |
| 29 return time.time() | |
| 30 | |
| 31 class timespec(ctypes.Structure): | |
| 32 _fields_ = [ | |
| 33 ('tv_sec', ctypes.c_long), | |
| 34 ('tv_nsec', ctypes.c_long) | |
| 35 ] | |
| 36 if not clock_gettime: | |
| 37 try: | |
| 38 librt = ctypes.CDLL('librt.so.0', use_errno=True) | |
| 39 clock_gettime = librt.clock_gettime | |
| 40 clock_gettime.argtypes = [ctypes.c_int, ctypes.POINTER(timespec)] | |
| 41 except: | |
| 42 W("No clock_gettime(), using fake fallback.") | |
| 43 no_clock_gettime = True | |
| 44 return time.time() | |
| 45 | |
| 46 t = timespec() | |
| 47 CLOCK_MONOTONIC = 1 # see <linux/time.h> | |
| 48 | |
| 49 if clock_gettime(CLOCK_MONOTONIC, ctypes.pointer(t)) != 0: | |
| 50 errno_ = ctypes.get_errno() | |
| 51 raise OSError(errno_, os.strerror(errno_)) | |
| 52 return t.tv_sec + t.tv_nsec * 1e-9 | |
| 53 | |
| 54 # decorator, tries a number of times, returns None on failure, sleeps between | |
| 55 # Must be used as "@retry()" if arguments are defaulted | |
| 56 def retry(retries=DEFAULT_TRIES, try_time = 1): | |
| 57 def inner(func): | |
| 58 def new_f(*args, **kwargs): | |
| 59 for i in range(retries): | |
| 60 d = func(*args, **kwargs) | |
| 61 if d is not None: | |
| 62 return d | |
| 63 time.sleep(try_time) | |
| 64 return None | |
| 65 | |
| 230 | 66 new_f.__name__ = func.__name__ |
| 141 | 67 return new_f |
| 68 return inner | |
| 69 | |
| 70 def readline(sock): | |
| 71 timeout = READLINE_SELECT_TIMEOUT | |
| 72 buf = '' | |
| 73 while True: | |
| 74 (rlist, wlist, xlist) = select.select([sock], [], [], timeout) | |
| 75 if sock not in rlist: | |
| 76 # hit timeout | |
| 77 return None | |
| 78 | |
| 79 c = sock.recv(1) | |
| 80 if c == '': | |
| 81 # lightblue timeout | |
| 82 return None | |
| 83 if c == '\r': | |
| 84 continue | |
| 85 | |
| 86 buf += c | |
| 87 if c == '\n': | |
| 88 return buf | |
| 89 | |
| 90 # from http://blog.stalkr.net/2011/04/pctf-2011-32-thats-no-bluetooth.html | |
| 91 def crc16(buff, crc = 0, poly = 0x8408): | |
| 92 l = len(buff) | |
| 93 i = 0 | |
| 94 while i < l: | |
| 95 ch = ord(buff[i]) | |
| 96 uc = 0 | |
| 97 while uc < 8: | |
| 98 if (crc & 1) ^ (ch & 1): | |
| 99 crc = (crc >> 1) ^ poly | |
| 100 else: | |
| 101 crc >>= 1 | |
| 102 ch >>= 1 | |
| 103 uc += 1 | |
| 104 i += 1 | |
| 105 return crc | |
| 106 | |
| 107 def cheap_daemon(): | |
| 108 L("Daemonising.") | |
| 109 sys.stdout.flush() | |
| 110 sys.stderr.flush() | |
| 111 out = file('/dev/null', 'a+') | |
| 112 os.dup2(out.fileno(), sys.stdout.fileno()) | |
| 113 os.dup2(out.fileno(), sys.stderr.fileno()) | |
| 114 | |
| 115 try: | |
| 116 pid = os.fork() | |
| 117 if pid > 0: | |
| 118 sys.exit(0) | |
| 230 | 119 except OSError as e: |
| 141 | 120 E("Bad fork()") |
| 121 sys.exit(1) | |
| 122 | |
| 123 os.setsid() | |
| 124 | |
| 125 try: | |
| 126 pid = os.fork() | |
| 127 if pid > 0: | |
| 128 sys.exit(0) | |
| 230 | 129 except OSError as e: |
| 141 | 130 E("Bad fork()") |
| 131 sys.exit(1) | |
| 132 | |
| 145 | 133 def uptime(): |
| 134 try: | |
| 135 return float(open('/proc/uptime', 'r').read().split(' ', 1)[0]) | |
| 230 | 136 except Exception as e: |
| 145 | 137 return -1 |
| 141 | 138 |
| 259 | 139 |
| 140 def json_load_round_float(s, **args): | |
| 141 return json.loads(s,parse_float = lambda f: round(float(f), 2), **args) | |
| 265 | 142 |
| 143 class NotTooOften(object): | |
| 144 """ prevents things happening more than once per limit. | |
| 145 Isn't monotonic, good enough for logging. eg | |
| 146 self.logfailure = NotTooOften(180) # 3 minutes | |
| 147 ... | |
| 148 if self.logfailure(): | |
| 149 L("blah") | |
| 150 """ | |
| 151 def __init__(self, limit): | |
| 152 """ limit is a delay in seconds or TimeDelta """ | |
| 153 if type(limit) is datetime.timedelta: | |
| 154 self.limit = limit | |
| 155 else: | |
| 156 self.limit = datetime.timedelta(seconds=limit) | |
| 157 | |
| 158 # must be positive | |
| 159 assert self.limit > datetime.timedelta(0) | |
| 160 self.last = datetime.datetime(10, 1, 1) | |
| 161 | |
| 162 def __call__(self): | |
| 163 if datetime.datetime.now() - self.last > self.limit: | |
| 164 self.last = datetime.datetime.now() | |
| 165 return True | |
| 166 | |
| 167 def log(self, msg): | |
| 168 """ calls L(msg) if it isn't too often, otherwise D(msg) | |
| 169 """ | |
| 170 if self(): | |
| 171 L(msg + " (log interval %s)" % str(self.limit)) | |
| 172 else: | |
| 173 D(msg) | |
| 270 | 174 |
| 175 class StepIntegrator(object): | |
| 176 """ | |
| 271 | 177 Takes on/off events and a monotonically increasing timefn. Returns the integral |
| 178 of (now-limittime, now) over those events. | |
| 179 | |
| 270 | 180 >>> s = StepIntegrator(lambda: t, 40) |
| 181 >>> t = 1 | |
| 182 >>> s.turn(1) | |
| 183 >>> t = 10 | |
| 184 >>> s.turn(0) | |
| 185 >>> t = 20 | |
| 186 >>> s.turn(1) | |
| 187 >>> t = 30 | |
| 188 >>> print(s.integrate()) | |
| 189 19 | |
| 190 >>> s.turn(0) | |
| 191 >>> print(s.integrate()) | |
| 192 19 | |
| 193 >>> t = 35 | |
| 194 >>> print(s.integrate()) | |
| 195 19 | |
| 196 >>> t = 42 | |
| 197 >>> print(s.integrate()) | |
| 198 18 | |
| 199 >>> t = 52 | |
| 200 >>> print(s.integrate()) | |
| 201 10 | |
| 202 >>> t = 69 | |
| 203 >>> print(s.integrate()) | |
| 204 1 | |
| 205 >>> t = 70 | |
| 206 >>> print(s.integrate()) | |
| 207 0 | |
| 208 >>> t = 170 | |
| 209 >>> print(s.integrate()) | |
| 210 0 | |
| 211 """ | |
| 212 def __init__(self, timefn, limittime): | |
| 213 # _on_periods is a list of [[start, end]]. End is None if still on | |
| 214 self._on_periods = [] | |
| 215 self._timefn = timefn | |
| 216 self._limittime = limittime | |
| 217 | |
| 271 | 218 def set_limit(self, limittime): |
| 219 if self._limittime == limittime: | |
| 220 return | |
| 221 self._limittime = limittime | |
| 222 self.trim() | |
| 223 | |
| 270 | 224 def turn(self, value): |
| 225 if not self._on_periods: | |
| 226 if value: | |
| 227 self._on_periods.append([self._timefn(), None]) | |
| 228 return | |
| 229 | |
| 230 # state hasn't changed | |
| 231 on_now = (self._on_periods[-1][1] is None) | |
| 232 if value == on_now: | |
| 233 return | |
| 234 | |
| 235 if value: | |
| 236 self._on_periods.append([self._timefn(), None]) | |
| 237 else: | |
| 238 self._on_periods[-1][1] = self._timefn() | |
| 239 | |
| 240 def _trim(self): | |
| 241 begin = self._timefn() - self._limittime | |
| 242 # shortcut, first start is after begin | |
| 243 if not self._on_periods or self._on_periods[0][0] >= begin: | |
| 244 return | |
| 245 | |
| 246 new_periods = [] | |
| 247 for s, e in self._on_periods: | |
| 248 if s == e: | |
| 249 continue | |
| 250 elif s >= begin: | |
| 251 new_periods.append([s,e]) | |
| 252 elif e is not None and e < begin: | |
| 253 continue | |
| 254 else: | |
| 255 new_periods.append([begin, e]) | |
| 256 self._on_periods = new_periods | |
| 257 | |
| 258 def integrate(self): | |
| 259 self._trim() | |
| 260 tot = 0 | |
| 261 for s, e in self._on_periods: | |
| 262 if e is None: | |
| 263 e = self._timefn() | |
| 264 tot += (e-s) | |
| 265 return tot | |
| 266 | |
| 267 | |
| 268 | |
| 269 | |
| 270 | |
| 271 | |
| 272 |