def do_compute(call_no, mode='sleep', runtime=None, n=None): started = utcnow() process_id = os.getpid() thread_id = _thread.get_ident() if mode == 'fib': res = fib(n) elif mode == 'sleep': # yes, we do the evil blocking thing here! # this is to simulate CPU intensive stuff time.sleep(runtime) res = None else: res = random.random() ended = utcnow() result = { 'call_no': call_no, 'started': started, 'ended': ended, 'process': process_id, 'thread': thread_id, 'result': res } return result
def onConnect(self, connectionRequest): protocol, headers = WampCraServerProtocol.onConnect(self, connectionRequest) #pprint(connectionRequest.headers) ua = connectionRequest.headers.get('user-agent', None) origin = connectionRequest.headers.get('origin', None) ## Crossbar.io Tracking ID ## cbtid = None if connectionRequest.headers.has_key('cookie'): try: cookie = Cookie.SimpleCookie() cookie.load(str(connectionRequest.headers['cookie'])) except Cookie.CookieError: pass else: if cookie.has_key('cbtid'): _cbtid = cookie['cbtid'].value if self.factory.trackingCookies.has_key(_cbtid): cbtid = _cbtid #log.msg("Crossbar.io tracking ID already in cookie: %s" % cbtid) if cbtid is None: cbtid = newid() maxAge = 86400 cbtData = {'created': utcnow(), 'maxAge': maxAge, 'sessions': []} self.factory.trackingCookies[cbtid] = cbtData ## do NOT add the "secure" cookie attribute! "secure" refers to the ## scheme of the Web page that triggered the WS, not WS itself!! ## headers['Set-Cookie'] = 'cbtid=%s;max-age=%d' % (cbtid, maxAge) #log.msg("Setting new Crossbar.io tracking ID in cookie: %s" % cbtid) self._cbtid = cbtid cbSessionData = {'cbtid': cbtid, 'ua': ua, 'origin': origin, 'connected': utcnow()} i = len(self.factory.trackingCookies[cbtid]['sessions']) self.factory.trackingCookies[cbtid]['sessions'].append(cbSessionData) self._cbSession = self.factory.trackingCookies[cbtid]['sessions'][i] return (protocol, headers)
def onConnect(self, request): clients.add(self) protocol, headers = None, {} self._cbtid = None if "cookie" in request.headers: try: cookie = http.cookies.SimpleCookie() cookie.load(str(request.headers["cookie"])) except http.cookies.CookieError: pass else: if "cbtid" in cookie: cbtid = cookie["cbtid"].value if cbtid in self.factory._cookies: self._cbtid = cbtid print("Cookie already set: %s" % self._cbtid) if self._cbtid is None: self._cbtid = newid() maxAge = self.factory.session_max_age user_index = r.incr("user_index") r.hmset(self._cbtid,{"login":"******" % user_index}) cbtData = {"created": utcnow(), "maxAge": maxAge, "connections": set() } self.factory._cookies[self._cbtid] = cbtData headers["Set-Cookie"] = "cbtid=%s;max-age=%d" % (self._cbtid, maxAge) print("Setting new cookie: %s" % self._cbtid) self.factory._cookies[self._cbtid]["connections"].add(self) return (protocol, headers)
def __init__(self, service = None): self.service = service self.current = {"timestamp": utcnow(), "packets-in": 0, "bytes-in": 0, "packets-out": 0, "bytes-out": 0}
def _compute_challenge(self, user): """ Returns: challenge, signature """ challenge_obj = { 'authid': self._authid, 'authrole': self._authrole, 'authmethod': self._authmethod, 'authprovider': self._authprovider, 'session': self._session_details['session'], 'nonce': util.newid(64), 'timestamp': util.utcnow() } challenge: str = json.dumps(challenge_obj, ensure_ascii=False) secret = user['secret'].encode('utf8') signature = auth.compute_wcs(secret, challenge.encode('utf8')).decode('ascii') # extra data to send to client in CHALLENGE extra = {'challenge': challenge} # when using salted passwords, provide the client with # the salt and then PBKDF2 parameters used if 'salt' in user: extra['salt'] = user['salt'] extra['iterations'] = user.get('iterations', 1000) extra['keylen'] = user.get('keylen', 32) return extra, signature
def shutdown(self, restart=False, mode=None, details=None): """ Stop this node. """ if self._shutdown_requested: # we're already shutting down .. ignore .. return self._shutdown_requested = True self.log.warn("Shutting down node...") # publish management API event shutdown_info = { 'restart': restart, 'mode': mode, 'who': details.caller if details else None, 'when': utcnow() } yield self.publish('crossbar.node.{}.on_shutdown'.format( self._node_id), shutdown_info, options=PublishOptions( exclude=[details.caller] if details else None, acknowledge=True)) def stop_reactor(): try: self._reactor.stop() except ReactorNotRunning: pass self._reactor.callLater(0, stop_reactor) returnValue(shutdown_info)
def publish(): self._heartbeat_time = utcnow() self._heartbeat += 1 try: yield self._send_heartbeat() except: self.log.failure()
def poll(self): """ Measure current stats value and return new stats. """ Monitor.poll(self) # create new, empty event # current = { # the UTC timestamp when measurement was taken u'timestamp': utcnow(), # the effective last period in secods u'last_period': self._last_period, } # FIXME: add ratio of ram usage with open("/proc/meminfo") as f: res = f.read() new = res.split() new_clean = [x.replace(":", "") for x in new if x != 'kB'] for i in range(0, len(new_clean), 2): k = u'{}'.format(new_clean[i]) current[k] = int(new_clean[i + 1]) self._last_value = current return succeed(self._last_value)
def poll(self): """ Measure current stats value and return new stats. """ Monitor.poll(self) # create new, empty event # current = { # the UTC timestamp when measurement was taken u'timestamp': utcnow(), # the effective last period in secods u'last_period': self._last_period, } # FIXME: add ratio of ram usage with open("/proc/meminfo") as f: res = f.read() new = res.split() new_clean = [x.replace(":", "") for x in new if x != 'kB'] for i in range(0, len(new_clean), 2): k = u'{}'.format(new_clean[i]) current[k] = int( new_clean[i + 1]) self._last_value = current return succeed(self._last_value)
def create(self): """ Create a new cookie, returning the cookie ID and cookie header value. """ if self.debug: log.msg("CookieStore.create()") ## http://tools.ietf.org/html/rfc6265#page-20 ## 0: delete cookie ## -1: preserve cookie until browser is closed id = util.newid(self._cookie_id_field_length) cbtData = { 'created': util.utcnow(), 'authid': None, 'authrole': None, 'authmethod': None, 'max_age': self._cookie_max_age, 'connections': set() } self._cookies[id] = cbtData ## do NOT add the "secure" cookie attribute! "secure" refers to the ## scheme of the Web page that triggered the WS, not WS itself!! ## return id, '%s=%s;max-age=%d' % (self._cookie_id_field, id, cbtData['max_age'])
def onAuthenticated(self, authKey, perms): """ WAMP session authenticated. Register PubSub topics and RPC handlers. """ self.authenticatedAs = authKey self.cookies = perms.get('cookies', None) self.sessionInfo.authenticatedAs = authKey self._cbSession['authenticated'] = utcnow() self._cbSession['href'] = perms.get('href', None) self._cbSession['referrer'] = perms.get('referrer', None) self.registerForPubSubFromPermissions(perms['permissions']) for remoter, key, method in [("restremoter", "rest", RestRemoter.remoteCall), ("extdirectremoter", "extdirect", ExtDirectRemoter.remoteCall), ("hanaremoter", "hana", HanaRemoter.remoteCall), ("pgremoter", "pg", PgRemoter.remoteCall), ("oraremoter", "ora", OraRemoter.remoteCall), ]: if self.factory.services.has_key(remoter): r = perms[key] for uri in r: self.registerHandlerMethodForRpc(uri, self.factory.services[remoter], method, r[uri]) self.factory.dispatch("http://analytics.tavendo.de#enter", self._cbSession)
def __init__(self, uri, ordered=False, extra=None): """ :param uri: The URI (or URI pattern) for this observation. :type uri: unicode """ # URI (or URI pattern) this observation is created for self.uri = uri # flag indicating whether observers should be maintained # in an ordered set or a regular, unordered set self.ordered = ordered # arbitrary, opaque extra data attached to the observation self.extra = extra # generate a new ID for the observation self.id = util.id() # UTC timestamp this observation was created self.created = util.utcnow() # set of observers if self.ordered: self.observers = OrderedSet() else: self.observers = set()
def _isActivated(self, txn): if True: return { 'license-id': '', 'type': 'BETA', 'connected-cap': 0, 'tls-enabled': True, 'valid-from': '1970-01-01T00:00:00:00Z', 'valid-to': '2020-01-01T00:00:00:00Z' } else: now = utcnow() txn.execute( "SELECT license_id, license_type, connection_cap, tls_enabled, valid_from, valid_to FROM license WHERE enabled = 1 AND valid_from <= ? AND valid_to > ?", [now, now]) res = txn.fetchone() if res: return { 'license-id': res[0], 'type': res[1], 'connected-cap': res[2], 'tls-enabled': True if res[3] != 0 else False, 'valid-from': res[4], 'valid-to': res[5] } else: return None
def _login(self, txn, authResponse, stayLoggedIn): if self.authChallenge is None: raise Exception(URI_ERROR + "login-without-previous-request", "Login attempt without previous login request.") txn.execute("SELECT value FROM config WHERE key = ?", ['admin-password']) res = txn.fetchone() if res: pw = str(json_loads(res[0])) h = hmac.new(pw, self.authChallenge, hashlib.sha256) v = binascii.b2a_base64(h.digest()).strip() if v == str(authResponse): self.authUser = self.authChallengeUser if stayLoggedIn: cookie = ''.join([random.choice("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_") for i in xrange(64)]) now = utcnow() txn.execute("INSERT INTO cookie (created, username, value) VALUES (?, ?, ?)", [now, "admin", cookie]) self.authCookie = cookie res = cookie else: res = None self.onLogin() return res else: raise Exception(URI_ERROR + "login-failed", "Login failed.") else: raise Exception(URI_ERROR + "internal-error", "Could not retrieve admin password from database.")
def __init__(self, node): """ :param node: The node singleton for this node controller session. :type node: obj """ NativeProcessSession.__init__(self) #self.debug = node.debug self.debug = False self.debug_app = False ## associated node self._node = node self._node_id = node._node_id self._realm = node._realm self.cbdir = self._node._cbdir self._created = utcnow() self._pid = os.getpid() ## map of worker processes: worker_id -> NativeWorkerProcess self._workers = {} self._management_transport = None exit = Deferred()
def shutdown(self, restart=False, mode=None, details=None): """ Explicitly stop this node. """ if self._shutdown_requested: # we're already shutting down .. ignore .. return self._shutdown_requested = True self.log.info('Node shutdown requested ..') # publish management API event shutdown_info = { u'node_id': self._node._node_id, u'restart': restart, u'mode': mode, u'who': details.caller if details else None, u'when': utcnow() } yield self.publish(u'{}.on_shutdown'.format(self._uri_prefix), shutdown_info, options=PublishOptions( exclude=details.caller if details else None, acknowledge=True)) def stop_reactor(): try: self._reactor.stop() except ReactorNotRunning: pass self._reactor.callLater(0, stop_reactor) returnValue(shutdown_info)
def log(self, childFD, data): """ FIXME: line buffering """ assert (childFD in self._log_fds) for msg in data.split('\n'): msg = msg.strip() if msg != "": ## log entry used for buffered worker log and/or worker log events ## if self._log is not None or self._log_topic: log_entry = (self._log_lineno, utcnow(), msg) ## maintain buffered worker log ## if self._log is not None: self._log_lineno += 1 self._log.append(log_entry) if self._keeplog > 0 and len(self._log) > self._keeplog: self._log.popleft() ## publish worker log event ## if self._log_topic: self._controller.publish(self._log_topic, log_entry) ## log to controller ## log.msg(msg, system="{:<10} {:>6}".format(self.LOGNAME, self.pid), override_system=True)
def onConnect(self, connectionRequest): if self.debug: log.msg("connection received from %s speaking WebSockets protocol %d - upgrade request for host '%s', path '%s', params %s, origin '%s', protocols %s, headers %s" % (connectionRequest.peerstr, connectionRequest.version, connectionRequest.host, connectionRequest.path, str(connectionRequest.params), connectionRequest.origin, str(connectionRequest.protocols), str(connectionRequest.headers))) if connectionRequest.params.has_key("agent"): if len(connectionRequest.params["agent"]) > 1: raise Exception("multiple agents specified") self.caseAgent = connectionRequest.params["agent"][0] else: #raise Exception("no agent specified") self.caseAgent = None if connectionRequest.params.has_key("case"): if len(connectionRequest.params["case"]) > 1: raise Exception("multiple test cases specified") try: self.case = int(connectionRequest.params["case"][0]) except: raise Exception("invalid test case ID %s" % connectionRequest.params["case"][0]) if self.case: if self.case >= 1 and self.case <= len(self.factory.specCases): self.Case = self.factory.CaseSet.CasesById[self.factory.specCases[self.case - 1]] if connectionRequest.path == "/runCase": self.runCase = self.Case(self) else: raise Exception("case %s not found" % self.case) if connectionRequest.path == "/runCase": if not self.runCase: raise Exception("need case to run") if not self.caseAgent: raise Exception("need agent to run case") self.caseStarted = utcnow() print "Running test case ID %s for agent %s from peer %s" % (self.factory.CaseSet.caseClasstoId(self.Case), self.caseAgent, connectionRequest.peerstr) elif connectionRequest.path == "/updateReports": if not self.caseAgent: raise Exception("need agent to update reports for") print "Updating reports, requested by peer %s" % connectionRequest.peerstr elif connectionRequest.path == "/getCaseInfo": if not self.Case: raise Exception("need case to get info") elif connectionRequest.path == "/getCaseStatus": if not self.Case: raise Exception("need case to get status") if not self.caseAgent: raise Exception("need agent to get status") elif connectionRequest.path == "/getCaseCount": pass else: print "Entering direct command mode for peer %s" % connectionRequest.peerstr self.path = connectionRequest.path return None
def create(self): """ Create a new cookie, returning the cookie ID and cookie header value. """ # http://tools.ietf.org/html/rfc6265#page-20 # 0: delete cookie # -1: preserve cookie until browser is closed cbtid = util.newid(self._cookie_id_field_length) cbtData = { "created": util.utcnow(), "authid": None, "authrole": None, "authmethod": None, "max_age": self._cookie_max_age, "connections": set(), } self._cookies[cbtid] = cbtData self.log.debug("New cookie {cbtid} created", cbtid=cbtid) # do NOT add the "secure" cookie attribute! "secure" refers to the # scheme of the Web page that triggered the WS, not WS itself!! # return cbtid, "%s=%s;max-age=%d" % (self._cookie_id_field, cbtid, cbtData["max_age"])
def shutdown(self, restart=False, mode=None, details=None): """ Stop this node. """ if self._shutdown_requested: # we're already shutting down .. ignore .. return self._shutdown_requested = True self.log.warn("Shutting down node...") # publish management API event shutdown_info = { u'restart': restart, u'mode': mode, u'who': details.caller if details else None, u'when': utcnow() } yield self.publish( 'crossbar.node.{}.on_shutdown'.format(self._node_id), shutdown_info, options=PublishOptions(exclude=details.caller if details else None, acknowledge=True) ) def stop_reactor(): try: self._reactor.stop() except ReactorNotRunning: pass self._reactor.callLater(0, stop_reactor) returnValue(shutdown_info)
def _compute_challenge(self, user): """ Returns: challenge, signature """ challenge_obj = { u'authid': self._authid, u'authrole': self._authrole, u'authmethod': self._authmethod, u'authprovider': self._authprovider, u'session': self._session_details[u'session'], u'nonce': util.newid(64), u'timestamp': util.utcnow() } challenge = json.dumps(challenge_obj, ensure_ascii=False) # Sometimes, if it doesn't have to be Unicode, PyPy won't make it # Unicode. Make it Unicode, even if it's just ASCII. if not isinstance(challenge, six.text_type): challenge = challenge.decode('utf8') secret = user['secret'].encode('utf8') signature = auth.compute_wcs(secret, challenge.encode('utf8')).decode('ascii') # extra data to send to client in CHALLENGE extra = {u'challenge': challenge} # when using salted passwords, provide the client with # the salt and then PBKDF2 parameters used if 'salt' in user: extra[u'salt'] = user['salt'] extra[u'iterations'] = user.get('iterations', 1000) extra[u'keylen'] = user.get('keylen', 32) return extra, signature
def __init__(self, session, authid, authrole, authprovider, secret): """ :param session: The WAMP session ID of the session being authenticated. :type session: int :param authid: The authentication ID of the authenticating principal. :type authid: unicode :param authrole: The role under which the principal will be authenticated when the authentication succeeds. :type authrole: unicode :param authprovider: Optional authentication provider. :type authprovider: unicode or None :param secret: The secret of the principal being authenticated. Either a password or a salted password. :type secret: str """ self.session = session self.authmethod = u"wampcra" self.authid = authid self.authrole = authrole self.authprovider = authprovider challenge_obj = { 'authid': self.authid, 'authrole': self.authrole, 'authmethod': u'wampcra', 'authprovider': self.authprovider, 'session': self.session, 'nonce': util.newid(), 'timestamp': util.utcnow() } # challenge must be bytes self.challenge = json.dumps(challenge_obj, ensure_ascii=False).encode('utf8') self.signature = auth.compute_wcs(secret, self.challenge)
def do(txn): data = json.dumps(spec, ensure_ascii=False, allow_nan=False, separators=(',', ':'), indent=None) now = utcnow() id = newid() txn.execute( "SELECT id, spec FROM testspec WHERE name = ? AND valid_to IS NULL", [name]) res = txn.fetchone() op = None if res is not None: currId, currSpec = res if currSpec == data: return (op, currId, name) else: beforeId = currId op = 'U' txn.execute( "UPDATE testspec SET valid_to = ? WHERE id = ?", [now, currId]) else: beforeId = None op = 'I' txn.execute( "INSERT INTO testspec (id, before_id, valid_from, name, desc, mode, caseset, spec) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, beforeId, now, name, desc, mode, caseset, data]) return (op, id, name)
def lineReceived(self, line): if self._debug: print("Serial RX: {0}".format(line)) pins = range(8) try: # parse data received from MCU ## data = [int(x) for x in line.split(',')] except ValueError: print('Unable to parse value {0}'.format(line)) else: if not self._last: self._last = data else: changed = False for i in range(len(data)): #print i if i in pins: if abs(data[i] - self._last[i]) > 3: changed = True break if changed: payload = { u'id': self._id, u'timestamp': utcnow(), u'values': [1023 - data[p] for p in pins] } self._session.publish(u"io.crossbar.demo.wpad.{}.on_change".format(self._wpad_id), payload) self._last_event = payload self._last = data self._id += 1
def shutdown(self, details=None): """ Registered under: ``crossbar.worker.<worker_id>.shutdown`` Event published under: ``crossbar.worker.<worker_id>.on_shutdown_requested`` """ if self._is_shutting_down: # ignore: we are already shutting down .. return # raise ApplicationError(u'crossbar.error.operation_in_progress', 'cannot shutdown - the worker is already shutting down') else: self._is_shutting_down = True self.log.info("Shutdown of worker requested!") # publish management API event # yield self.publish( u'{}.on_shutdown_requested'.format(self._uri_prefix), { u'who': details.caller if details else None, u'when': utcnow() }, options=PublishOptions(exclude=details.caller if details else None, acknowledge=True) ) # we now call self.leave() to initiate the clean, orderly shutdown of the native worker. # the call is scheduled to run on the next reactor iteration only, because we want to first # return from the WAMP call when this procedure is called from the node controller # self._reactor.callLater(0, self.leave)
def shutdown(self, details=None): """ Registered under: ``crossbar.worker.<worker_id>.shutdown`` Event published under: ``crossbar.worker.<worker_id>.on_shutdown_requested`` """ if self._is_shutting_down: # ignore: we are already shutting down .. return # raise ApplicationError(u'crossbar.error.operation_in_progress', 'cannot shutdown - the worker is already shutting down') else: self._is_shutting_down = True self.log.info("Shutdown of worker requested!") # publish management API event # yield self.publish( u'{}.on_shutdown_requested'.format(self._uri_prefix), { u'who': details.caller if details else None, u'when': utcnow() }, options=PublishOptions(exclude=details.caller if details else None, acknowledge=True)) # we now call self.leave() to initiate the clean, orderly shutdown of the native worker. # the call is scheduled to run on the next reactor iteration only, because we want to first # return from the WAMP call when this procedure is called from the node controller # self._reactor.callLater(0, self.leave)
def create(self): """ Create a new cookie, returning the cookie ID and cookie header value. """ if self.debug: log.msg("CookieStore.create()") ## http://tools.ietf.org/html/rfc6265#page-20 ## 0: delete cookie ## -1: preserve cookie until browser is closed id = util.newid(self._cookie_id_field_length) cbtData = {'created': util.utcnow(), 'authid': None, 'authrole': None, 'authmethod': None, 'max_age': self._cookie_max_age, 'connections': set()} self._cookies[id] = cbtData ## do NOT add the "secure" cookie attribute! "secure" refers to the ## scheme of the Web page that triggered the WS, not WS itself!! ## return id, '%s=%s;max-age=%d' % (self._cookie_id_field, id, cbtData['max_age'])
def __init__(self, session, authid, authrole, authprovider, secret): """ :param session: The WAMP session ID of the session being authenticated. :type session: int :param authid: The authentication ID of the authenticating principal. :type authid: unicode :param authrole: The role under which the principal will be authenticated when the authentication succeeds. :type authrole: unicode :param authprovider: Optional authentication provider. :type authprovider: unicode or None :param secret: The secret of the principal being authenticated. Either a password or a salted password. :type secret: str """ self.session = session self.authmethod = u"wampcra" self.authid = authid self.authrole = authrole self.authprovider = authprovider challenge_obj = { 'authid': self.authid, 'authrole': self.authrole, 'authmethod': u'wampcra', 'authprovider': self.authprovider, 'session': self.session, 'nonce': util.newid(), 'timestamp': util.utcnow() } self.challenge = json.dumps(challenge_obj) self.signature = auth.compute_wcs(secret, self.challenge)
def store_event(self, publisher_id, publication_id, topic, args=None, kwargs=None): """ Persist the given event to history. :param publisher_id: The session ID of the publisher of the event being persisted. :type publisher_id: int :param publication_id: The publication ID of the event. :type publisher_id: int :param topic: The topic URI of the event. :type topic: unicode :param args: The args payload of the event. :type args: list or None :param kwargs: The kwargs payload of the event. :type kwargs: dict or None """ assert (publication_id not in self._event_store) evt = { 'timestamp': utcnow(), 'publisher': publisher_id, 'publication': publication_id, 'topic': topic, 'args': args, 'kwargs': kwargs } self._event_store[publication_id] = evt self.log.debug("event {publication_id} persisted", publication_id=publication_id)
def log(self, childFD, data): """ FIXME: line buffering """ assert(childFD in self._log_fds) for msg in data.split('\n'): msg = msg.strip() if msg != "": # log entry used for buffered worker log and/or worker log events # if self._log is not None or self._log_topic: log_entry = (self._log_lineno, utcnow(), msg) # maintain buffered worker log # if self._log is not None: self._log_lineno += 1 self._log.append(log_entry) if self._keeplog > 0 and len(self._log) > self._keeplog: self._log.popleft() # publish worker log event # if self._log_topic: self._controller.publish(self._log_topic, log_entry) # log to controller # log.msg(msg, system="{:<10} {:>6}".format(self.LOGNAME, self.pid), override_system=True)
def store_event(self, publisher_id, publication_id, topic, args=None, kwargs=None): """ Persist the given event to history. :param publisher_id: The session ID of the publisher of the event being persisted. :type publisher_id: int :param publication_id: The publication ID of the event. :type publisher_id: int :param topic: The topic URI of the event. :type topic: unicode :param args: The args payload of the event. :type args: list or None :param kwargs: The kwargs payload of the event. :type kwargs: dict or None """ assert(publication_id not in self._event_store) evt = { u'timestamp': utcnow(), u'publisher': publisher_id, u'publication': publication_id, u'topic': topic, u'args': args, u'kwargs': kwargs } self._event_store[publication_id] = evt self.log.debug("Event {publication_id} persisted", publication_id=publication_id)
def onJoin(self, details): self.log.info('Session joined on thread {thread_id}: {details}', thread_id=current_thread().ident, details=details) """Callback when the WAMP session has been established and is ready for use.""" # get the Pi serial number self._serial = get_serial() # all procedures/events will have this URI prefix self._prefix = u'io.crossbar.demo.iotstarterkit.{}.light_sensor'.format(self._serial) # print startup infos self.log.info("Crossbar.io IoT Starterkit Serial No.: {serial}", serial=self._serial) self.log.info("LightSensorComponent connected: {details}", details=details) # get component user extra configuration cfg = self.config.extra # initialize button self._light_sensor_pin = cfg['light_sensor_pin'] GPIO.setwarnings(False) config_light_sensor_gpio(self._light_sensor_pin) # setup edge detection for the light sensor GPIO.add_event_detect(self._light_sensor_pin, GPIO.RISING, callback=self.light_change, bouncetime=1000) # # for testing: print HIGH/LOW state (every 100ms) # def printit(): # threading.Timer(0.1, printit).start() # # print "Hello, World!" # if GPIO.input(self._light_sensor_pin): # print("input is HIGH") # else: # print("input is LOW") # # printit() # remember startup timestamp self._started = utcnow() # flag indicating if the button is already pressed self._is_dark = False # register procedures for proc in [ (self.started, u'started'), (self._is_dark, u'is_dark'), # (self.press, u'press'), ]: uri = u'{}.{}'.format(self._prefix, proc[1]) yield self.register(proc[0], uri) self.log.info('registered procedure {uri}', uri=uri) self._is_ready = True self.log.info("LightSensorComponent ready!")
def onJoin(self, details): self.log.info("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=id) self.subscribe(on_worker_ready, 'crossbar.node.{}.on_worker_ready'.format(self._node_id)) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # procs = [ 'shutdown', 'get_info', 'get_workers', 'get_worker_log', 'start_router', 'stop_router', 'start_container', 'stop_container', 'start_guest', 'stop_guest', 'start_websocket_testee', 'stop_websocket_testee', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) self._started = utcnow() self.publish(u"crossbar.node.on_ready", self._node_id) self.log.debug("Node controller ready")
def __init__(self, service = None): self.service = service self.current = {"timestamp": utcnow(), "mem-used": 0, "mem-free": 0, "cpu-user": 0, "cpu-system": 0, "cpu-idle": 0}
def show_fabric(self, verbose=False): res = { u'version': u'17.01.23', u'now': utcnow(), u'started': self._started, u'tick': self._tick } return res
def _onPoolConnectionCreated(self, conn): ## per connection settings conn.autocommit = True ## get connection info and store that backendPid = conn.get_backend_pid() serverVersion = conn.server_version self.poolConnections.append((backendPid, utcnow(), serverVersion, conn))
def test_purge_on_startup(self): created_time = util.utcnow() original = [{ "id": "thisIsAnID", "created": created_time, "max_age": 604800, "authid": "example.authid", "authrole": "example.authrole", "authmethod": "example.authmethod" }, { "id": "thisIsAnotherID", "created": created_time, "max_age": 604800, "authid": "example.other.authid", "authrole": "example.other.authrole", "authmethod": "example.other.authmethod" }, { "id": "thisIsAnID", "modified": created_time, "max_age": 604800, "authid": "example.second.authid", "authrole": "example.second.authrole", "authmethod": "example.second.authmethod" }] expected = [{ "id": "thisIsAnID", "created": created_time, "max_age": 604800, "authid": "example.second.authid", "authrole": "example.second.authrole", "authmethod": "example.second.authmethod" }, { "id": "thisIsAnotherID", "created": created_time, "max_age": 604800, "authid": "example.other.authid", "authrole": "example.other.authrole", "authmethod": "example.other.authmethod" }] with tempfile.NamedTemporaryFile() as fp: self.write_cookies_to_file(original, fp) config = { 'store': { 'type': 'file', 'filename': fp.name, 'purge_on_startup': True } } CookieStoreFileBacked(fp.name, config) actual = self.read_cookies_from_file(fp) self.assertEqual(actual, expected)
def _createAppCred(self, txn, spec): """ Create new application credential, runs in database transaction. """ attrs = { "label": (True, [str, unicode], AppCreds.APPCRED_LABEL_MIN_LENGTH, AppCreds.APPCRED_LABEL_MAX_LENGTH, None), "key": (True, [str, unicode], AppCreds.APPCRED_KEY_MIN_LENGTH, AppCreds.APPCRED_KEY_MAX_LENGTH, AppCreds.APPCRED_KEY_PATTERN), "secret": (True, [str, unicode], AppCreds.APPCRED_SECRET_MIN_LENGTH, AppCreds.APPCRED_SECRET_MAX_LENGTH, AppCreds.APPCRED_SECRET_PATTERN) } errcnt, errs = self.proto.checkDictArg("appcred spec", spec, attrs) txn.execute("SELECT created FROM appcredential WHERE key = ?", [spec["key"]]) if txn.fetchone() is not None: errs["key"].append( (self.proto.shrink(URI_ERROR + "duplicate-value"), "Application key '%s' already exists" % spec["key"])) errcnt += 1 if errcnt: raise Exception( URI_ERROR + "illegal-argument", "one or more illegal arguments (%d errors)" % errcnt, errs) id = newid() appcred_uri = URI_APPCRED + id label = spec["label"].strip() now = utcnow() txn.execute( "INSERT INTO appcredential (id, label, key, created, secret) VALUES (?, ?, ?, ?, ?)", [id, label, spec["key"], now, spec["secret"]]) services = self.proto.factory.services if services.has_key("restpusher"): services["restpusher"].recache(txn) if services.has_key("clientfilter"): services["clientfilter"].recache(txn) appcred = { "uri": appcred_uri, "created": now, "label": label, "key": spec["key"], "secret": spec["secret"] } self.proto.dispatch(URI_EVENT + "on-appcred-created", appcred, [self.proto]) appcred["uri"] = self.proto.shrink(appcred_uri) return appcred
def utcnow(self, details=None): """ Return current time as determined from within this process. :returns str -- Current time (UTC) in UTC ISO 8601 format. """ self.log.debug("{cls}.utcnow", cls=self.__class__.__name__) return utcnow()
def _onPoolConnectionCreated(self, conn): ## per connection settings conn.autocommit = True ## get connection info and store that backendPid = conn.get_backend_pid() serverVersion = conn.server_version self.poolConnections.append( (backendPid, utcnow(), serverVersion, conn))
def startService(self): log.msg("Starting %s service .." % self.SERVICENAME) self.current = {"timestamp": utcnow(), "packets-in": 0, "bytes-in": 0, "packets-out": 0, "bytes-out": 0} self.isRunning = True self.emitFake()
def processRecord(self, inPackets, inBytes, outPackets, outBytes): evt = {"timestamp": utcnow(), "packets-in": inPackets, "bytes-in": inBytes, "packets-out": outPackets, "bytes-out": outBytes} self.current = evt self.dispatchEvent(evt)
def onJoin(self, details): self.log.info("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=id) self.subscribe(on_worker_ready, 'crossbar.node.{}.on_worker_ready'.format(self._node_id)) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # procs = [ 'shutdown', 'get_info', 'get_workers', 'get_worker_log', 'start_router', 'stop_router', 'start_container', 'stop_container', 'start_guest', 'stop_guest', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) self._started = utcnow() self.publish(u"crossbar.node.on_ready", self._node_id) self.log.debug("Node controller ready")
def _createAppCred(self, txn, spec): """ Create new application credential, runs in database transaction. """ attrs = {"label": (True, [str, unicode], AppCreds.APPCRED_LABEL_MIN_LENGTH, AppCreds.APPCRED_LABEL_MAX_LENGTH, None), "key": (True, [str, unicode], AppCreds.APPCRED_KEY_MIN_LENGTH, AppCreds.APPCRED_KEY_MAX_LENGTH, AppCreds.APPCRED_KEY_PATTERN), "secret": (True, [str, unicode], AppCreds.APPCRED_SECRET_MIN_LENGTH, AppCreds.APPCRED_SECRET_MAX_LENGTH, AppCreds.APPCRED_SECRET_PATTERN)} errcnt, errs = self.proto.checkDictArg("appcred spec", spec, attrs) txn.execute("SELECT created FROM appcredential WHERE key = ?", [spec["key"]]) if txn.fetchone() is not None: errs["key"].append((self.proto.shrink(URI_ERROR + "duplicate-value"), "Application key '%s' already exists" % spec["key"])) errcnt += 1 if errcnt: raise Exception(URI_ERROR + "illegal-argument", "one or more illegal arguments (%d errors)" % errcnt, errs) id = newid() appcred_uri = URI_APPCRED + id label = spec["label"].strip() now = utcnow() txn.execute("INSERT INTO appcredential (id, label, key, created, secret) VALUES (?, ?, ?, ?, ?)", [id, label, spec["key"], now, spec["secret"]]) services = self.proto.factory.services if services.has_key("restpusher"): services["restpusher"].recache(txn) if services.has_key("clientfilter"): services["clientfilter"].recache(txn) appcred = {"uri": appcred_uri, "created": now, "label": label, "key": spec["key"], "secret": spec["secret"]} self.proto.dispatch(URI_EVENT + "on-appcred-created", appcred, [self.proto]) appcred["uri"] = self.proto.shrink(appcred_uri) return appcred
def processRecord(self, memUsed, memFree, cpuUser, cpuSys, cpuIdle): evt = {"timestamp": utcnow(), "mem-used": memUsed, "mem-free": memFree, "cpu-user": cpuUser, "cpu-system": cpuSys, "cpu-idle": cpuIdle} self.current = evt self.dispatchEvent(evt)
def __init__(self, service=None): self.service = service self.current = { "timestamp": utcnow(), "packets-in": 0, "bytes-in": 0, "packets-out": 0, "bytes-out": 0 }
def do(txn): ## verify that testrun exists and is not closed already ## txn.execute("SELECT started, ended FROM testrun WHERE id = ?", [runId]) res = txn.fetchone() if res is None: raise Exception("no such test run") if res[1] is not None: raise Exception("test run already closed") ## save test case results with foreign key to test run ## id = newid() now = utcnow() ci = [] for i in xrange(5): if len(testCase.index) > i: ci.append(testCase.index[i]) else: ci.append(0) if saveLog: log = result.log else: log = [] result.log = None resultData = result.serialize() txn.execute( """ INSERT INTO testresult (id, testrun_id, inserted, testee, c1, c2, c3, c4, c5, duration, passed, result) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, [ id, runId, now, testRun.testee.name, ci[0], ci[1], ci[2], ci[3], ci[4], result.ended - result.started, 1 if result.passed else 0, resultData ]) ## save test case log with foreign key to test result ## if log: lineno = 1 for l in log: txn.execute( """ INSERT INTO testlog (testresult_id, lineno, timestamp, sessionidx, sessionid, line) VALUES (?, ?, ?, ?, ?, ?) """, [id, lineno, l[0], l[1], l[2], l[3]]) lineno += 1 return id
def onJoin(self, details): from autobahn.wamp.types import SubscribeOptions self.log.debug("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): worker_id = res['id'] if worker_id in self._workers: ready = self._workers[worker_id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(worker_id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=worker_id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=worker_id) self.subscribe(on_worker_ready, u'crossbar.worker..on_worker_ready', SubscribeOptions(match=u'wildcard')) yield NativeProcess.onJoin(self, details) # above upcall registers procedures we have marked with @wamp.register(None) # we need to catch SIGINT here to properly shutdown the # node explicitly (a Twisted system trigger wouldn't allow us to distinguish # different reasons/origins of exiting ..) def signal_handler(_signal, frame): if _signal == signal.SIGINT: # CTRL-C'ing Crossbar.io is considered "willful", and hence we want to exit cleanly self._shutdown_was_clean = True elif _signal == signal.SIGTERM: self._shutdown_was_clean = False else: # FIXME: can we run into others here? self._shutdown_was_clean = False self.log.warn('Controller received SIGINT [signal={signal}]: shutting down node [shutdown_was_clean={shutdown_was_clean}] ..', signal=_signal, shutdown_was_clean=self._shutdown_was_clean) # the following will shutdown the Twisted reactor in the end self.shutdown() signal.signal(signal.SIGINT, signal_handler) self.log.info('Signal handler installed on process {pid} thread {tid}', pid=os.getpid(), tid=threading.get_ident()) self._started = utcnow() self.publish(u"crossbar.on_ready") self.log.debug("Node controller ready")
def _loop(self, index): prefix = self.config.extra['prefix'] last = None while self._running: rtts = [] batch_started_str = utcnow() batch_started = time() while (time() - batch_started) < self._period: ts_req = time_ns() res = yield self.call('{}.echo'.format(prefix), ts_req) ts_res = time_ns() assert res == ts_req rtt = ts_res - ts_req rtts.append(rtt) stats = self._pinfo.get_stats() if last: batch_duration = (stats['time'] - last['time']) / 10 ** 9 ctx = round((stats['voluntary'] - last['voluntary']) / batch_duration, 0) self.log.info('{logname}: {cpu} cpu, {mem} mem, {ctx} ctx', logname=self._logname, cpu=round(stats['cpu_percent'], 1), mem=round(stats['mem_percent'], 1), ctx=ctx) rtts = sorted(rtts) sr = WampStatsRecord() sr.key = '{}#{}.{}'.format(batch_started_str, self._logname, index) sr.count = len(rtts) sr.calls_per_sec = int(round(sr.count / batch_duration, 0)) # all times here are in microseconds: sr.avg_rtt = round(1000000. * batch_duration / float(sr.count), 1) sr.max_rtt = round(rtts[-1] / 1000, 1) sr.q50_rtt = round(rtts[int(sr.count / 2.)] / 1000, 1) sr.q99_rtt = round(rtts[int(-(sr.count / 100.))] / 1000, 1) sr.q995_rtt = round(rtts[int(-(sr.count / 995.))] / 1000, 1) with self._db.begin(write=True) as txn: self._schema.wamp_stats[txn, sr.key] = sr print("{}: {} calls, {} calls/sec, RTT (us): q50 {}, avg {}, q99 {}, q995 {}, max {}".format(sr.key, sr.count, sr.calls_per_sec, sr.q50_rtt, sr.avg_rtt, sr.q99_rtt, sr.q995_rtt, sr.max_rtt)) last = stats
def _loop(self, index): prefix = self.config.extra['prefix'] last = None while self._running: rtts = [] batch_started_str = utcnow() batch_started = time() while (time() - batch_started) < self._period: ts_req = time_ns() res = yield self.call('{}.echo'.format(prefix), ts_req) ts_res = time_ns() assert res == ts_req rtt = ts_res - ts_req rtts.append(rtt) stats = self._pinfo.get_stats() if last: batch_duration = (stats['time'] - last['time']) / 10**9 ctx = round( (stats['voluntary'] - last['voluntary']) / batch_duration, 0) self.log.info('{logname}: {cpu} cpu, {mem} mem, {ctx} ctx', logname=self._logname, cpu=round(stats['cpu_percent'], 1), mem=round(stats['mem_percent'], 1), ctx=ctx) rtts = sorted(rtts) sr = WampStatsRecord() sr.key = '{}#{}.{}'.format(batch_started_str, self._logname, index) sr.count = len(rtts) sr.calls_per_sec = int(round(sr.count / batch_duration, 0)) # all times here are in microseconds: sr.avg_rtt = round(1000000. * batch_duration / float(sr.count), 1) sr.max_rtt = round(rtts[-1] / 1000, 1) sr.q50_rtt = round(rtts[int(sr.count / 2.)] / 1000, 1) sr.q99_rtt = round(rtts[int(-(sr.count / 100.))] / 1000, 1) sr.q995_rtt = round(rtts[int(-(sr.count / 995.))] / 1000, 1) with self._db.begin(write=True) as txn: self._schema.wamp_stats[txn, sr.key] = sr print( "{}: {} calls, {} calls/sec, RTT (us): q50 {}, avg {}, q99 {}, q995 {}, max {}" .format(sr.key, sr.count, sr.calls_per_sec, sr.q50_rtt, sr.avg_rtt, sr.q99_rtt, sr.q995_rtt, sr.max_rtt)) last = stats
def connectionLost(self, reason): """ Client disconnected. Update stats. """ WampCraServerProtocol.connectionLost(self, reason) self.factory.onConnectionCountChanged() self._cbSession['lost'] = utcnow() self.factory.dispatch("http://analytics.tavendo.de#leave", self._cbSession)
def stats(self): """ """ res = {} res[u'ts'] = utcnow() res[u'cpu'] = self.cpu_stats() res[u'mem'] = self.mem_stats() res[u'net'] = self.net_stats() res[u'disk'] = self.disk_stats() return res
def stats(self): """ """ res = {} res['ts'] = utcnow() res['cpu'] = self.cpu_stats() res['mem'] = self.mem_stats() res['net'] = self.net_stats() res['disk'] = self.disk_stats() return res