def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"]["target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: if not cmdstring.split(CONST.DELIMITER)[0] in CFG.CEC_DEV.keys(): return # it is not my device [item, command] = cmdstring.split(CONST.DELIMITER)[-2:] self.cmdhandler[command](self, item) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err))) # events if data_dict["method"] == METHOD.EVENT: for event in data_dict["params"]["events"]: try: if event in self.eventhandler.keys(): self.eventhandler[event](self) except Exception as err: logger.logError("Failed to handle event '%s' error: %s" % (event, str(err)))
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"]["target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: cmd = None path = self.items for p in cmdstring.split(CONST.DELIMITER): cmd = p path = path[p] adresses = path try: iter_test = iter(adresses) except TypeError, te: adresses = (adresses,) self.cmdhandler[cmd](self, adresses) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err)))
def cecLogCallback(self, level, timestamp, message): """ cec-callback for log """ libCECloglevel_dict = {cec.CEC_LOG_ERROR: "ERROR", cec.CEC_LOG_WARNING: "WARNING", cec.CEC_LOG_NOTICE: "NOTICE", cec.CEC_LOG_TRAFFIC: "TRAFFIC", cec.CEC_LOG_DEBUG: "DEBUG", } if hasattr(CFG, 'CEC_LOG_TO_DEFAULT_LOG') and CFG.CEC_LOG_TO_DEFAULT_LOG: logger.logDebug("[CEC_LOG_%s] %s %s" % (libCECloglevel_dict[level], str(timestamp), message)) if level == cec.CEC_LOG_DEBUG: pattern_active_source = "^making .* \((.+?)\) the active source$" m_active_source = re.search(pattern_active_source, message) if m_active_source: iAddress = int(m_active_source.group(1), 16) osdName = self.getDeviceOSDName(int(iAddress)) logger.logInfo("Source %s is active" % osdName) try: self.sendEvents(EVENT.CECLOG_ACTIVESOURCE_TEMPLATE % osdName) except Exception as err: logger.logError("error %s" % str(err))
def responseLoop(self): """ communication, recv - response loop untile exit data received """ logger.logDebug("Waiting for message main loop") while True: logger.logDebug("Waiting for message...") (recv_data, addr) = self.recv() if recv_data in EXIT_DATA: break (recv_data, addr) = self.dataPreHandler(recv_data, addr) try: reply_data = self.datahandler(recv_data, addr) except Exception as err: logger.logError("Handling data error: %s" % str(err)) reply_data = MESSAGE_HANDLER_ERROR if not self.replying: continue if self.send(reply_data, addr) != CONST.RET_OK: logger.logError("Sending response data '%s' failed!" % str(reply_data)) if reply_data in EXIT_DATA: break
def start(self): """ start main process if not debug - daemonize """ logger.logInfo("Starting...") pid = self.status() if pid: logger.logError("Daemon already running with pid %s" % self.pidfile) return CONST.RET_ERROR # Start the daemon if not self.debug: logger.logDebug("Demonizing...") if self.daemonize() > CONST.RET_OK: return CONST.RET_ERROR logger.logInfo("Running") try: self.run() logger.logDebug("Main loop finished") except Exception as err: logger.logError("Main loop error: %s" % str(err)) return CONST.RET_ERROR return CONST.RET_OK
def send(self, data, addr=None): """ send data to addr :param data: response data :param addr: to """ if not addr: addr = self.addr logger.logDebug("To '%s' sending data: '%s'" % (str(addr), str(data).strip())) if not self.sock: self.initClient() # conection error? try repair... if not self.sock: logger.logError( "Socket not ready! Cant't send to '%s' data '%s'." % (str(addr), str(data).strip())) return CONST.RET_IO_ERROR try: if self.protocol == SOCKET_TCP: self.sock.send(data) if self.protocol == SOCKET_UDP: self.sock.sendto(data, addr) except socket.error as err: logger.logError("Sending data failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) return CONST.RET_IO_ERROR return CONST.RET_OK
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ myhostname = socket.gethostname() # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"][ "target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: cmd = self.items for p in cmdstring.split(CONST.DELIMITER): cmd = cmd[p] self.systemCmd(cmd) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err)))
def send(self, data, addr = None): """ send data to addr :param data: response data :param addr: to """ if not addr: addr = self.addr logger.logDebug("To '%s' sending data: '%s'" % (str(addr), str(data).strip())) if not self.sock: self.initClient() # conection error? try repair... if not self.sock: logger.logError("Socket not ready! Cant't send to '%s' data '%s'." % (str(addr), str(data).strip())) return CONST.RET_IO_ERROR try: if self.protocol == SOCKET_TCP: self.sock.send(data) if self.protocol == SOCKET_UDP: self.sock.sendto(data, addr) except socket.error as err: logger.logError("Sending data failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) return CONST.RET_IO_ERROR return CONST.RET_OK
def setStatus(self, devid, newstatus, switch=1): done = False for attempt in ("first", "second", "third"): try: logger.logDebug("%s try to set status on %s" % (attempt, devid)) key = CFG.DEVICES[devid] tuyadev = pytuya.OutletDevice(devid, key[0], key[1]) status = tuyadev.status()['dps'][str(switch)] if status == newstatus: logger.logDebug("status already set, skipping %s" % devid) break tuyadev.set_status(newstatus, switch) time.sleep(CFG.SLEEP_INTERVAL) status = tuyadev.status()['dps'][str(switch)] if status == newstatus: logger.logDebug("status successfully set %s" % devid) done = True except: logger.logError("failed to set status of %s" % devid) if done: break
def initClient(self): """ initialize client socket """ self.close() if isinstance(self.addr, tuple) and self.addr[0] == BROADCAST_HOST: addtional_option = socket.SO_BROADCAST else: addtional_option = socket.SO_REUSEADDR try: self.sock = socket.socket(self.af, self.protocol) self.sock.setsockopt(socket.SOL_SOCKET, addtional_option, 1) self.sock.settimeout(None) self.sock.setblocking(1) if self.protocol == SOCKET_TCP: self.sock.connect(self.addr) except socket.error as err: logger.logError("Initilizing socket client failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) self.sock = None return CONST.RET_ERROR return CONST.RET_OK
def recv(self): """ get incomming data """ (recv_data, addr) = (None, None) if not self.sock: logger.logError("Cant't receive data. Socket not ready") return (None, None) try: if self.protocol == SOCKET_TCP: recv_data = self.sock.recv(2048) addr = self.addr if self.protocol == SOCKET_UDP: recv_data, addr = self.sock.recvfrom(2048) except socket.error as err: logger.logError("Receiving data failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) return (None, None) logger.logDebug("From: '%s' received data: '%s'" % (str(addr), str(recv_data).strip())) return (recv_data, addr)
def start(self): """ start main process if not debug - daemonize """ logger.logInfo("Starting...") pid = self.status() if pid: logger.logError("Daemon already running with pid %s" % self.pidfile) return CONST.RET_ERROR # Start the daemon if not self.debug: logger.logDebug("Demonizing...") if self.daemonize() > CONST.RET_OK: return CONST.RET_ERROR logger.logInfo("Running") try: self.run() logger.logDebug("Main loop finished") except Exception as err: logger.logError("Main loop error: %s" % str(err)) return CONST.RET_ERROR return CONST.RET_OK
def setTuyaStatus(self, devid, newstatus, switch=1): done = False for attempt in ("first", "second", "third"): try: logger.logDebug("%s try to set status on %s" % (attempt, devid)) key = CFG.DEVICES[devid] tuyadev = pytuya.OutletDevice(devid, key[0], key[1]) status = tuyadev.status()['dps'][str(switch)] if status == newstatus: logger.logDebug("status already set, skipping %s" % devid) break tuyadev.set_status(newstatus, switch) time.sleep(CFG.SLEEP_INTERVAL) status = tuyadev.status()['dps'][str(switch)] if status == newstatus: logger.logDebug("status successfully set %s" % devid) done = True except: logger.logError("failed to set status of %s" % devid) if done: break
def keepAliveThread(self, starter, immortal): """ main auto reconnect thre4ad :param starter: function recconection connection :param imortal: function, that should be recovered when fail """ attempcounter = 0 while True: try: immortal() except Exception as err: logger.logError("Always alive process error: %s" % str(err)) if self.keepalive: attempcounter += 1 if attempcounter % 3 == 0: waittime = attempcounter else: waittime = 1 time.sleep(min(180, waittime)) if starter() != CONST.RET_OK: logger.logWarning("Resuscitation function failed") continue break
def stop(self): """ stop process """ logger.logInfo("Stoping...") try: pf = file(self.pidfile, 'r') pid = int(pf.read().strip()) pf.close() except IOError: pid = None if not pid: logger.logInfo("Pidfile %s does not exist. Daemon not running." % self.pidfile) # no pidfile - no error return CONST.RET_OK #Try killing the daemon process try: logger.logDebug("Trying to kill pid %s" % pid) while True: os.kill(pid, SIGTERM) time.sleep(0.1) except OSError, err: err = str(err) if err.find("No such process") > 0: if os.path.exists(self.pidfile): self.delPID() else: logger.logError(str(err)) return CONST.RET_ERROR
def stop(self): """ stop process """ logger.logInfo("Stoping...") try: pf = file(self.pidfile,'r') pid = int(pf.read().strip()) pf.close() except IOError: pid = None if not pid: logger.logInfo("Pidfile %s does not exist. Daemon not running." % self.pidfile) # no pidfile - no error return CONST.RET_OK #Try killing the daemon process try: logger.logDebug("Trying to kill pid %s" % pid) while True: os.kill(pid, SIGTERM) time.sleep(0.1) except OSError, err: err = str(err) if err.find("No such process") > 0: if os.path.exists(self.pidfile): self.delPID() else: logger.logError(str(err)) return CONST.RET_ERROR
def cecLogCallback(self, level, timestamp, message): """ cec-callback for log """ libCECloglevel_dict = { cec.CEC_LOG_ERROR: "ERROR", cec.CEC_LOG_WARNING: "WARNING", cec.CEC_LOG_NOTICE: "NOTICE", cec.CEC_LOG_TRAFFIC: "TRAFFIC", cec.CEC_LOG_DEBUG: "DEBUG", } if hasattr(CFG, 'CEC_LOG_TO_DEFAULT_LOG') and CFG.CEC_LOG_TO_DEFAULT_LOG: logger.logDebug( "[CEC_LOG_%s] %s %s" % (libCECloglevel_dict[level], str(timestamp), message)) if level == cec.CEC_LOG_DEBUG: pattern_active_source = "^making .* \((.+?)\) the active source$" m_active_source = re.search(pattern_active_source, message) if m_active_source: iAddress = int(m_active_source.group(1), 16) osdName = self.getDeviceOSDName(int(iAddress)) logger.logInfo("Source %s is active" % osdName) try: self.sendEvents(EVENT.CECLOG_ACTIVESOURCE_TEMPLATE % osdName) except Exception as err: logger.logError("error %s" % str(err))
def responseLoop(self): """ communication, recv - response loop untile exit data received """ logger.logDebug("Waiting for message main loop") while True: logger.logDebug("Waiting for message...") (recv_data, addr) = self.recv() if recv_data in EXIT_DATA: break (recv_data, addr) = self.dataPreHandler(recv_data, addr) try: reply_data = self.datahandler(recv_data, addr) except Exception as err: logger.logError("Handling data error: %s" % str(err)) reply_data = MESSAGE_HANDLER_ERROR if not self.replying: continue if self.send(reply_data, addr) != CONST.RET_OK: logger.logError("Sending response data '%s' failed!" % str(reply_data)) if reply_data in EXIT_DATA: break
def keepAliveThread(self, starter, immortal): """ main auto reconnect thre4ad :param starter: function recconection connection :param imortal: function, that should be recovered when fail """ attempcounter = 0 while True: try: immortal() except Exception as err: logger.logError("Always alive process error: %s" % str(err)) if self.keepalive: attempcounter += 1 if attempcounter % 3 == 0: waittime = attempcounter else: waittime = 1 time.sleep(min(180, waittime)) if starter() != CONST.RET_OK: logger.logWarning("Resuscitation function failed") continue break
def initClient(self): """ initialize client socket """ self.close() if isinstance(self.addr, tuple) and self.addr[0] == BROADCAST_HOST: addtional_option = socket.SO_BROADCAST else: addtional_option = socket.SO_REUSEADDR try: self.sock = socket.socket(self.af, self.protocol) self.sock.setsockopt(socket.SOL_SOCKET, addtional_option, 1) self.sock.settimeout(None) self.sock.setblocking(1) if self.protocol == SOCKET_TCP: self.sock.connect(self.addr) except socket.error as err: logger.logError("Initilizing socket client failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) self.sock = None return CONST.RET_ERROR return CONST.RET_OK
def recv(self): """ get incomming data """ (recv_data, addr) = (None, None) if not self.sock: logger.logError("Cant't receive data. Socket not ready") return (None, None) try: if self.protocol == SOCKET_TCP: recv_data = self.sock.recv(2048) addr = self.addr if self.protocol == SOCKET_UDP: recv_data, addr = self.sock.recvfrom(2048) except socket.error as err: logger.logError("Receiving data failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) return (None, None) logger.logDebug("From: '%s' received data: '%s'" % (str(addr), str(recv_data).strip())) return (recv_data, addr)
def delPID(self): """ delete pidfile """ try: os.remove(self.pidfile) except: logger.logError("Remove pidfile %s failed" % self.pidfile)
def delPID(self): """ delete pidfile """ try: os.remove(self.pidfile) except: logger.logError("Remove pidfile %s failed" % self.pidfile)
def transmitCode(self, code): """ transmit code using pi_switch :param code: code to transmit """ try: logger.logDebug("Transmitting code: %s" % str(code)) self.ac_socks.send(code) time.sleep(CFG.MIN_TRNASMIT_INTERVAL) except Exception as err: logger.logError("Transmitting AC socket code error: %s" % str(err))
def daemonize(self): """ daemonize process """ try: pid = os.fork() if pid > 0: sys.exit(0) except OSError, e: logger.logError("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror)) return CONST.RET_ERROR
def daemonize(self): """ daemonize process """ try: pid = os.fork() if pid > 0: sys.exit(0) except OSError, e: logger.logError("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror)) return CONST.RET_ERROR
def sendDictAsJSON(self, data_dict): """ convert distionary to json and send :pram data_dict: python dictionary with data to send """ try: data = json.dumps(data_dict, encoding="utf-8") except Exception as err: logger.logError("Dump data to JSON failed: %s" % str(err)) return CONST.RET_ERROR return self.sendData(data)
def sendDictAsJSON(self, data_dict): """ convert distionary to json and send :pram data_dict: python dictionary with data to send """ try: data = json.dumps(data_dict, encoding="utf-8") except Exception as err: logger.logError("Dump data to JSON failed: %s" % str(err)) return CONST.RET_ERROR return self.sendData(data)
def GET(self, media, filename): """ get """ try: workingdir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "gui_web_templates") fullfilename = os.path.join(workingdir, media, filename) f = open(fullfilename, 'r') return f.read() except Exception as err: logger.logError(str(err)) return ''
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"][ "target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: #if not cmdstring.split(CONST.DELIMITER)[0] in cfg.MY_PLACES: # continue dev_cmd = self.items for p in cmdstring.split(CONST.DELIMITER): dev_cmd = dev_cmd[p] if (len(dev_cmd) == 2): self.setStatus(dev_cmd[0], dev_cmd[1]) if (len(dev_cmd) == 3): self.setStatus(dev_cmd[0], dev_cmd[1], dev_cmd[2]) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err))) # events if data_dict["method"] == METHOD.EVENT: for event in data_dict["params"]["events"]: try: event = event.split(CONST.DELIMITER) if len(event) == 2: if event[0] in self.eventhandler.keys(): self.eventhandler[event[0]](self, event[1]) elif event in self.eventhandler.keys(): self.eventhandler[event](self) except Exception as err: logger.logError( "Failed to handle event '%s' error: %s" % (event, str(err)))
def GET(self, media, filename): """ get """ try: workingdir = os.path.join( os.path.dirname(os.path.abspath(__file__)), "gui_web_templates") fullfilename = os.path.join(workingdir, media, filename) f = open(fullfilename, 'r') return f.read() except Exception as err: logger.logError(str(err)) return ''
def initlibCEC(self): """ initialize hdmi-cec """ try: self.libCEC = cec.ICECAdapter.Create(self.cecconfig) except Exception as err: logger.logError("Creating CEC adapter error: %s" % str(err) ) adapter = self.detectAdapter() if adapter == None: logger.logInfo("No CEC adapters found") else: if self.libCEC.Open(adapter): logger.logInfo("CEC connection opened") else: logger.logInfo("Failed to open a connection to the CEC adapter")
def initConfig(self, this_cec_name): """ initialize cec config :param this_cec_name: name for this device """ logger.logDebug("Initializing libCEC config") try: self.cecconfig.strDeviceName = self.this_cec_name # 0 = do not make the primary device the active source self.cecconfig.bActivateSource = 0 # https://github.com/Pulse-Eight/libcec/blob/2c675dac48387c48c7f43c5d2547ef0c4ef5c7dd/include/cectypes.h #self.cecconfig.bMonitorOnly = 1 self.cecconfig.deviceTypes.Add(cec.CEC_DEVICE_TYPE_RECORDING_DEVICE) self.cecconfig.clientVersion = cec.LIBCEC_VERSION_CURRENT except Exception as err: logger.logError("Initializing libCEC config error: %s" % str(err) )
def listenTCPThread(self): """ TCP listener thread """ logger.logInfo("TCP listener started on '%s'" % str(self.addr)) while True: try: (client_sock, client_addr) = self.sock.accept() except socket.error as err: logger.logError("Failed to accept TCP connection. Error Code: " + str(err[0]) + ' Message: ' + err[1]) break logger.logDebug("Connection with '%s' accepted." % str(client_addr)) threading.Thread(target=self.startComunication, args=(client_addr, client_sock)).start() logger.logInfo("TCP listener on '%s' ended" % str(self.addr))
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"]["target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: #if not cmdstring.split(CONST.DELIMITER)[0] in cfg.MY_PLACES: # continue dev_cmd = self.items for p in cmdstring.split(CONST.DELIMITER): dev_cmd = dev_cmd[p] if (len(dev_cmd) == 2): self.setStatus(dev_cmd[0], dev_cmd[1]) if (len(dev_cmd) == 3): self.setStatus(dev_cmd[0], dev_cmd[1], dev_cmd[2]) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err))) # events if data_dict["method"] == METHOD.EVENT: for event in data_dict["params"]["events"]: try: event = event.split(CONST.DELIMITER) if len(event) == 2: if event[0] in self.eventhandler.keys(): self.eventhandler[event[0]](self, event[1]) elif event in self.eventhandler.keys(): self.eventhandler[event](self) except Exception as err: logger.logError("Failed to handle event '%s' error: %s" % (event, str(err)))
def initlibCEC(self): """ initialize hdmi-cec """ try: self.libCEC = cec.ICECAdapter.Create(self.cecconfig) except Exception as err: logger.logError("Creating CEC adapter error: %s" % str(err)) adapter = self.detectAdapter() if adapter == None: logger.logInfo("No CEC adapters found") else: if self.libCEC.Open(adapter): logger.logInfo("CEC connection opened") else: logger.logInfo( "Failed to open a connection to the CEC adapter")
def run(self): """ plugin main """ try: sys.argv = [sys.argv[0], str(CFG.PORT)] fvars = globals() # manual inheritance for i in [attr for attr in dir(self) if not callable(attr) and not attr.startswith("__")]: fvars[i] = eval('self.' + i) web_app = web.application(self.urls, fvars) web_app.internalerror = web.debugerror web_app.run() except Exception as err: logger.logError("error starting web: %s" % err )
def initConfig(self, this_cec_name): """ initialize cec config :param this_cec_name: name for this device """ logger.logDebug("Initializing libCEC config") try: self.cecconfig.strDeviceName = self.this_cec_name # 0 = do not make the primary device the active source self.cecconfig.bActivateSource = 0 # https://github.com/Pulse-Eight/libcec/blob/2c675dac48387c48c7f43c5d2547ef0c4ef5c7dd/include/cectypes.h #self.cecconfig.bMonitorOnly = 1 self.cecconfig.deviceTypes.Add( cec.CEC_DEVICE_TYPE_RECORDING_DEVICE) self.cecconfig.clientVersion = cec.LIBCEC_VERSION_CURRENT except Exception as err: logger.logError("Initializing libCEC config error: %s" % str(err))
def detectDevices(self): """ detect hdmi-cec devices """ logger.logDebug("Detecting CEC devices") try: self.libCEC.RescanActiveDevices() addresses = self.libCEC.GetActiveDevices() activeSource = self.libCEC.GetActiveSource() logger.logInfo("CEC active device: %s" % self.getDeviceOSDName(activeSource) ) for iAddress in range(0, 15): if addresses.IsSet(iAddress): self.devices[self.libCEC.GetDeviceOSDName(iAddress)] = self.Device(iAddress, self.libCEC) logger.logInfo("CEC device %s detected on address: %i" % (self.libCEC.GetDeviceOSDName(iAddress), iAddress) ) except Exception as err: logger.logError("Detecting CEC devices error: %s" % str(err) )
def detectAdapter(self): """ detect an adapter and return the com port path """ logger.logDebug("Detecting CEC adapters") try: adapter_found = None adapters = self.libCEC.DetectAdapters() for adapter in adapters: logger.logInfo("CEC adapter found on port: %s vendor: %s product: %s" % (adapter.strComName, hex(adapter.iVendorId), hex(adapter.iProductId))) adapter_found = adapter.strComName return adapter_found except Exception as err: logger.logError("Detecting CEC adapter error: %s" % str(err) ) return None
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"][ "target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: path = self.items if not cmdstring.split( CONST.DELIMITER)[0] in cfg.MY_PLACES: continue for p in cmdstring.split(CONST.DELIMITER): path = path[p] code = path self.tasker.putTask(code) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err))) # events if data_dict["method"] == METHOD.EVENT: for event in data_dict["params"]["events"]: try: if event in self.eventhandler.keys(): self.eventhandler[event](self) except Exception as err: logger.logError( "Failed to handle event '%s' error: %s" % (event, str(err)))
def startServer(self): """ TCP/UDP server creation """ self.close() try: self.sock = socket.socket(self.af, self.protocol) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1) self.sock.settimeout(None) self.sock.setblocking(1) self.sock.bind(self.addr) if self.protocol == SOCKET_TCP: self.sock.listen(5) except socket.error as err: logger.logError("Starting socket server on '" + str(self.addr)+ "' failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) self.sock = None return CONST.RET_ERROR return CONST.RET_OK
def listenTCPThread(self): """ TCP listener thread """ logger.logInfo("TCP listener started on '%s'" % str(self.addr)) while True: try: (client_sock, client_addr) = self.sock.accept() except socket.error as err: logger.logError( "Failed to accept TCP connection. Error Code: " + str(err[0]) + ' Message: ' + err[1]) break logger.logDebug("Connection with '%s' accepted." % str(client_addr)) threading.Thread(target=self.startComunication, args=(client_addr, client_sock)).start() logger.logInfo("TCP listener on '%s' ended" % str(self.addr))
def run(self): """ plugin main """ try: sys.argv = [sys.argv[0], str(CFG.PORT)] fvars = globals() # manual inheritance for i in [ attr for attr in dir(self) if not callable(attr) and not attr.startswith("__") ]: fvars[i] = eval('self.' + i) web_app = web.application(self.urls, fvars) web_app.internalerror = web.debugerror web_app.run() except Exception as err: logger.logError("error starting web: %s" % err)
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"][ "target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: if not cmdstring.split( CONST.DELIMITER)[0] in CFG.CEC_DEV.keys(): return # it is not my device [item, command] = cmdstring.split(CONST.DELIMITER)[-2:] self.cmdhandler[command](self, item) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err))) # events if data_dict["method"] == METHOD.EVENT: for event in data_dict["params"]["events"]: try: if event in self.eventhandler.keys(): self.eventhandler[event](self) except Exception as err: logger.logError( "Failed to handle event '%s' error: %s" % (event, str(err)))
def detectAdapter(self): """ detect an adapter and return the com port path """ logger.logDebug("Detecting CEC adapters") try: adapter_found = None adapters = self.libCEC.DetectAdapters() for adapter in adapters: logger.logInfo( "CEC adapter found on port: %s vendor: %s product: %s" % (adapter.strComName, hex( adapter.iVendorId), hex(adapter.iProductId))) adapter_found = adapter.strComName return adapter_found except Exception as err: logger.logError("Detecting CEC adapter error: %s" % str(err)) return None
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"]["target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: path = self.items if not cmdstring.split(CONST.DELIMITER)[0] in CFG.MY_PLACES: continue for p in cmdstring.split(CONST.DELIMITER): path = path[p] code = path self.tasker.putTask(code) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err))) # events if data_dict["method"] == METHOD.EVENT: for event in data_dict["params"]["events"]: try: if event in self.eventhandler.keys(): self.eventhandler[event](self) except Exception as err: logger.logError("Failed to handle event '%s' error: %s" % (event, str(err)))
def receiveData(self, data_dict): """ handle received data :param data_dict: received data """ myhostname = socket.gethostname() # try autoresponse first self.autoResponder(data_dict) if "method" in data_dict.keys(): # cmds if data_dict["method"] == METHOD.CMD and data_dict["params"]["target"] == self.plugin_name: for cmdstring in data_dict["params"]["cmds"]: try: cmd = self.items for p in cmdstring.split(CONST.DELIMITER): cmd = cmd[p] self.systemCmd(cmd) except Exception as err: logger.logError("Failed to run command %s: %s" % (str(cmdstring), str(err)))
def startServer(self): """ TCP/UDP server creation """ self.close() try: self.sock = socket.socket(self.af, self.protocol) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.settimeout(None) self.sock.setblocking(1) self.sock.bind(self.addr) if self.protocol == SOCKET_TCP: self.sock.listen(5) except socket.error as err: logger.logError("Starting socket server on '" + str(self.addr) + "' failed. Error Code: " + str(err[0]) + ' Message: ' + err[1]) self.sock = None return CONST.RET_ERROR return CONST.RET_OK
def POST(self): """ post """ global items try: input = web.input() if 'pwd' in input.keys( ) and input['pwd'] == CFG.WEB_HOOK_PASSWORD: logger.logDebug("password ok") if 'action' in input.keys( ) and input['action'] in items.keys(): if len(items[input['action']]) > 0: sendEvents(items[input['action']]) return "ok" else: logger.logDebug("wrong action") else: logger.logDebug("wrong password") except Exception as err: logger.logError(str(err)) return "none"
def detectDevices(self): """ detect hdmi-cec devices """ logger.logDebug("Detecting CEC devices") try: self.libCEC.RescanActiveDevices() addresses = self.libCEC.GetActiveDevices() activeSource = self.libCEC.GetActiveSource() logger.logInfo("CEC active device: %s" % self.getDeviceOSDName(activeSource)) for iAddress in range(0, 15): if addresses.IsSet(iAddress): self.devices[self.libCEC.GetDeviceOSDName( iAddress)] = self.Device(iAddress, self.libCEC) logger.logInfo( "CEC device %s detected on address: %i" % (self.libCEC.GetDeviceOSDName(iAddress), iAddress)) except Exception as err: logger.logError("Detecting CEC devices error: %s" % str(err))
class Daemon(object): """ deamon class - inspired by: http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/ """ def __init__(self, pidfile, debug): """ deamon init function :param pidfile: used pidfile :param debug: True/False - affects forking """ self.pidfile = pidfile self.debug = debug def daemonize(self): """ daemonize process """ try: pid = os.fork() if pid > 0: sys.exit(0) except OSError, e: logger.logError("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror)) return CONST.RET_ERROR logger.logDebug("fork #1 finished") # decouple from parent environment os.chdir("/") os.setsid() os.umask(0) try: pid = os.fork() if pid > 0: sys.exit(0) except OSError, e: logger.logError("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror)) return CONST.RET_ERROR