def __init__(self): self.running = False #self.runningJobsLock = threading.Lock() #TODO needed? self.jobsLock = threading.Lock() self.maintenanceJobsLock = threading.Lock() self.maintenanceJobs = [] self.lastMaintenanceJobId = 0 self.runningJobs = {} #id:s as keys self.settings = Settings('telldus.scheduler') Application().registerShutdown(self.stop) Application().registerMaintenanceJobHandler( self.addMaintenanceJobGeneric) self.timezone = self.settings.get('tz', 'UTC') self.latitude = self.settings.get('latitude', '55.699592') self.longitude = self.settings.get('longitude', '13.187836') self.jobs = [] self.fetchLocalJobs() self.live = TelldusLive(self.context) self.deviceManager = DeviceManager(self.context) if self.live.isRegistered(): #probably not practically possible to end up here self.requestJobsFromServer() self.thread = threading.Thread(target=self.run) self.thread.start()
def allParameters(self): """ Similar as parameters() but this returnes more values such as the device type and the room """ params = self.parameters() if isinstance(params, dict): # Copy so we don't alter the original params = params.copy() else: # parameters() must return a dict params = {} devicetype = self.metadata('devicetype', None) if devicetype is not None: # Devicetype in metadata overrides the devicetype params['devicetype'] = devicetype else: try: params['devicetype'] = self.deviceType() except Exception as error: params['devicetype'] = Device.TYPE_UNKNOWN Application.printException(error) if self._room is None: # Make sure it's removed params.pop('room', None) else: params['room'] = self._room return params
def run(self): app = Application() path = '/tmp/%s' % self.name if os.path.exists(path): os.remove(path) s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) s.bind(path) s.listen(1) sockets = [s.fileno()] while self.running: r, w, e = select.select(sockets, [], [], 10) if len(r) == 0: continue if s.fileno() in r: conn, addr = s.accept() self.clients.append(Socket(conn)) sockets.append(conn.fileno()) for conn in self.clients: if conn.fileno() in r: d = conn.read() if conn.connected: app.queue(self.cb, conn, d) else: sockets.remove(conn.fileno()) self.clients[:] = [x for x in self.clients if x.connected] s.close()
def main(): from base import Application p = loadClasses(plugins) s = loadClasses(startup) app = Application(run=False) app.run(startup=s)
def start_app(): ''' Sparx server instantiation''' tornado.options.parse_command_line() app = Application() app.listen(options.port) logging.info('*** Sparx-core - version '+ str(version) +'. started at:\ http://localhost:%d/' % (options.port)) tornado.ioloop.IOLoop.instance().start()
def discover(self): devices = pywemo.discover_devices() for device in devices: if isinstance(device, pywemo.Bridge): Application().queue(self.bridgeFound, device) elif isinstance(device, pywemo.Switch): Application().queue(self.switchFound, device) elif isinstance(device, pywemo.Motion): Application().queue(self.motionFound, device) Application().queue(self.deviceManager.finishedLoading, 'wemo')
def run(self): self.running = True app = Application() buffer = '' ttl = None state = 0 while self.running: if self.dev is None: time.sleep(1) try: self.dev = serial.serial_for_url(self.devUrl, 115200, timeout=0) except Exception as e: self.dev = None continue if state == 0: x = self.__readByte(interruptable=True) if x == '': if self.__waitForResponse is not None and self.__waitForResponse.queued + 5 < time.time( ): self.__waitForResponse.timeout() self.__waitForResponse = None if len(self.__queue) and self.__waitForResponse is None: state = 1 continue if x == '\r': continue if x == '+': # Start of data buffer = '' continue if x == '\n': (cmd, params) = RF433Msg.parseResponse(buffer) if cmd is None: continue if self.__waitForResponse is not None: if cmd == self.__waitForResponse.cmd(): self.__waitForResponse.response(params) self.__waitForResponse = None continue app.queue(self.handler.decodeData, cmd, params) continue buffer = buffer + x elif state == 1: if len(self.__queue) == 0: state = 0 continue self.__waitForResponse = self.__queue.pop(0) self.__send(self.__waitForResponse.commandString()) self.__waitForResponse.queued = time.time() state = 0
def __init__(self): self._ready = False self._running = True self._knownDevices = None Application().registerShutdown(self.onShutdown) self.client = mqtt.Client(userdata=self) self.client_on_disconnect = self.onDisconnect self.client.on_connect = self.onConnect self.client.on_message = self.onMessage if self.config('hostname') != '': Application().queue(self.connect)
def remove(self): for cls in self.classes: plugin = self.context.components.get(cls) if not plugin: continue if not hasattr(plugin, 'tearDown'): continue try: plugin.tearDown() except Exception as error: Application.printException(error) shutil.rmtree(self.path)
def __init__(self): self.deviceManager = DeviceManager(self.context) self.username = None self.ssdp = None config = self.config('bridge') self.activated = config.get('activated', False) self.username = config.get('username', '') self.bridge = config.get('bridge', '') self.state = Hue.STATE_NO_BRIDGE self.lights = {} self.ssdp = SSDP(self.context) if self.activated: Application().queue(self.selectBridge, config.get('bridge')) Application().registerScheduledTask(self.update, minutes=1)
def registerSensorCleanup(self): Application().registerScheduledTask(self.cleanupSensors, hours=12) # every 12th hour t = Timer(10, self.cleanupSensors) # run a first time after 10 minutes t.daemon = True t.name = 'Sensor cleanup' t.start()
def __init__(self): self.running = False self.timeLock = threading.Lock() self.triggers = {} Application().registerShutdown(self.stop) self.thread = threading.Thread(target=self.run) self.thread.start()
def proxyMethod(*args, **kwargs): # We are in the script thread here, we must syncronize with the main # thread before calling the attribute condition.acquire() args = list(args) if len(args) >= 2 and lua_type(args[1]) == 'table': # First parameter is a lua table. Handle this as **kwargs call kwargs = dict(args[1]) del args[1] # TODO: Also loop through kwargs and look for lua types for i, arg in enumerate(args): if lua_type(arg) == 'function': t = LuaFunctionWrapper(self, arg) args[i] = t self.references.append(weakref.ref(t)) try: Application().queue(mainThreadCaller, args, kwargs) condition.wait( 20) # Timeout to not let the script hang forever if 'error' in retval: self.p("Error during call: %s", retval['error']) raise AttributeError(retval['error']) elif 'return' in retval: if type(retval['return']) is dict: # Wrap to lua table return self.lua.table_from(retval['return']) return retval['return'] finally: condition.release() raise AttributeError('The call to the function "%s" timed out' % attrName)
def __init__(self): self.scripts = [] self.load() self.fileobserver = Observer() self.fileobserver.schedule(FileChangedHandler(self), Board.luaScriptPath()) self.fileobserver.start() Application().registerShutdown(self.shutdown)
def __init__(self): self.running = True self.mtimes = {} self.thread = Thread(target=self.run) self.thread.start() signal.signal(signal.SIGUSR1, Developer.debugshell) # Register handler Application().registerShutdown(self.stop)
def registerSensorCleanup(self): """Register scheduled job to clean up sensors that have not been updated for a while""" Application().registerScheduledTask(self.cleanupSensors, hours=12) # every 12th hour tmr = Timer(600, self.cleanupSensors) # run a first time after 10 minutes tmr.daemon = True tmr.name = 'Sensor cleanup' tmr.start()
def __init__(self): super(Server, self).__init__() mimetypes.init() port = 80 if os.getuid() == 0 else 8080 cherrypy.config.update({ 'server.socket_host': '::', 'server.socket_port': port, 'tools.sessions.on': True, 'tools.sessions.timeout': 60, 'tools.sessions.httponly': True, }) cherrypy.tree.mount(RequestHandler(self.context), '', config={ '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': WebSocketHandler } }) cherrypy.engine.autoreload.unsubscribe() WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.engine.start() Application().registerShutdown(self.stop)
def __init__(self): self.sensor = YRSensor() deviceManager = DeviceManager(self.context) deviceManager.addDevice(self.sensor) deviceManager.finishedLoading('yr') Application().registerScheduledTask(self.__requestWeather, hours=1, runAtOnce=True)
def __disconnected(self): self.email = '' self.connected = False self.registered = False def sendNotification(): self.liveDisconnected() # Syncronize signal with main thread Application().queue(sendNotification)
def configWasUpdated(self, key, value): if key in [ 'use_via', 'useConfigUrl', 'configUrl', 'useEntityCategories', 'discovery_topic', 'device_name' ]: self.devices = [] self.cleanupDevices() self.hub.deviceName = self.config('device_name') Application().queue(self.discoverAndConnect) elif key == 'state_retain' and value == False and self.mqtt_connected_flag: self._debug('Retain set to false, clear retained states') for topic in self.config('device_topics'): self.client.publish( '%s/%s/state' % (self.config('discovery_topic'), topic), None, 0, False) elif key in ['username', 'password', 'hostname', 'port']: Application().queue(self.connect)
def detectBroadlink(self): self.devices = broadlink.discover(timeout=5) for device in self.devices: self.deviceManager.addDevice(BroadDevice(device)) self.deviceManager.finishedLoading('broadlink') Application().registerScheduledTask(self.updateValues, seconds=300, runAtOnce=True)
def __init__(self): self.loaded = False self.armState = None self.alarmDevice = AlarmDevice() deviceManager = DeviceManager(self.context) deviceManager.addDevice(self.alarmDevice) self.devices = {} Application().registerScheduledTask(fn=self.__fetch, minutes=10, runAtOnce=True)
def __init__(self): self.lastCheckedDate = None self.device = HolidayDevice() deviceManager = DeviceManager(self.context) deviceManager.addDevice(self.device) deviceManager.finishedLoading('holiday') Application().registerScheduledTask(self.checkDay, minutes=1, runAtOnce=False)
def allParameters(self): """ Similar as parameters() but this returnes more values such as the device type """ params = self.parameters() if isinstance(params, dict): # Copy so we don't alter the original params = params.copy() else: # parameters() must return a dict params = {} try: params['devicetype'] = self.deviceType() except Exception as error: params['devicetype'] = Device.TYPE_UNKNOWN Application.printException(error) return params
def __init__(self, port, context): HapConnection.HTTPDServer = self self.context = context self.connections = [] self.httpServer = ThreadedTCPServer(('', port), HapConnection) self.thread = Thread(target=self.httpServer.serve_forever, name='HomeKit http server') self.thread.daemon = True self.thread.start() Application().registerShutdown(self.shutdown)
def onMqttConnect(self, client, userdata, flags, result): self.mqtt_connected_flag = True self._debug('Mqtt connected') self.publishDevices() self.client.subscribe( '%s/+/%s/+/set' % (self.config('discovery_topic'), self.config('device_name'))) self.client.subscribe( '%s/+/%s/+/set/#' % (self.config('discovery_topic'), self.config('device_name'))) Application().queue(self.cleanupDevices)
def asyncFetch(): # This is run in a separate thread and can block try: session = verisure.Session(self.config('username'), self.config('password')) session.login() overview = session.get_overview() session.logout() except Exception as e: logging.warning("Could not fetch Verisure data") return Application().queue(parseValues, overview)
def __init__(self, run=True): self.lastMinute = None self.running = False self.timeLock = threading.Lock() # TODO, the list below should be written to file self.triggered = {} # keep track of when triggered between reloads self.triggers = {} Application(run).registerShutdown(self.stop) if run: self.thread = threading.Thread(target=self.run) self.thread.start()
def __init__(self): self.listener = None self.clientAddress = None CommandHandler.rf433 = RF433(self.context) CommandHandler.context = self.context if TelldusZWave is not None: self.zwave = TelldusZWave(self.context) Application().registerShutdown(self.__stop) self.autoDiscovery = SocketServer.UDPServer(('0.0.0.0', 30303), AutoDiscoveryHandler) self.commandSocket = SocketServer.UDPServer(('0.0.0.0', 42314), CommandHandler) Thread(target=self.__autoDiscoveryStart).start() Thread(target=self.__commandSocketStart).start()
def handle(self): sock = self.request[1] product = ''.join(x.capitalize() for x in Board.product().split('-')) live = TelldusLive(Application.defaultContext()) msg = '%s:%s:%s:%s:%s' % ( product, AutoDiscoveryHandler.getMacAddr(Board.networkInterface()), Board.secret(), Board.firmwareVersion(), live.uuid, ) sock.sendto(msg, self.client_address)