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 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 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 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 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 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 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 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 cecSourceActivatedCallback(self, logicalAddress, activated): """ cec-callback for activated source """ logger.logDebug("[SOURCEACTIVATED] %s:%s active source: %s" % (str(logicalAddress), str(activated), self.GetActiveSourceOsdName())) self.sendEvents(EVENT.CEC_ACTIVESOURCE_TEMPLATE % str(activated))
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 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 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 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 receiveData(self, data_dict): """ default receiver function :param data_dict: received data """ logger.logDebug("Input data '%s' not handled" % str(data_dict).strip()) return CONST.RET_OK
def receiveData(self, data_dict): """ default receiver function :param data_dict: received data """ logger.logDebug("Input data '%s' not handled" % str(data_dict).strip()) return CONST.RET_OK
def turnOnBottom(self): """ turn on bottom two """ if self.daytime.isShining(): logger.logDebug("Doing nothing due to day time.") return self.turnOn(CFG.OUTPUT_BOTTOM)
def turnOnTop(self): """ turn on top two """ if self.daytime.isShining(): logger.logDebug("Doing nothing due to day time.") return self.turnOn(CFG.OUTPUT_TOP)
def turnOnAll(self): """ turn on all """ if self.daytime.isShining(): logger.logDebug("Doing nothing due to day time.") return self.turnOn(CFG.OUTPUT_ALL)
def cecSourceActivatedCallback(self, logicalAddress, activated): """ cec-callback for activated source """ logger.logDebug("[SOURCEACTIVATED] %s:%s active source: %s" % (str(logicalAddress), str(activated), self.GetActiveSourceOsdName())) self.sendEvents(EVENT.CEC_ACTIVESOURCE_TEMPLATE % str(activated))
def toggle(self, arr): """ piface functions (toggle command) :param arr: all items will be handled """ logger.logDebug("Toggle %s" % str(arr)) for i in arr: if i in CFG.OUTPUT_CLOCKWISE: self.pifacedigital.output_pins[i].toggle()
def turnOff(self, arr): """ piface functions (off command) :param arr: all items will be handled """ logger.logDebug("Turn off %s" % str(arr)) for i in arr: if i in CFG.OUTPUT_CLOCKWISE: self.pifacedigital.output_pins[i].turn_off()
def menuHandler(self, widget, data = None): """ send command on item click """ target = data.split(CONST.DELIMITER)[0] cmdstring = CONST.DELIMITER.join(data.split(CONST.DELIMITER)[1:]) logger.logDebug("Sending cmd for %s: '%s'" % (target, cmdstring) ) self.sendCommands([cmdstring], target)
def menuHandler(self, widget, data=None): """ send command on item click """ target = data.split(CONST.DELIMITER)[0] cmdstring = CONST.DELIMITER.join(data.split(CONST.DELIMITER)[1:]) logger.logDebug("Sending cmd for %s: '%s'" % (target, cmdstring)) self.sendCommands([cmdstring], target)
def initDefaultCB(self): """ initialize default callbacks """ logger.logDebug("Settings CEC default callbacks") self.setLogCallback(self.cecLogCallback) self.setKeyPressCallback(self.cecKeyPressCallback) self.setCommandCallback(self.cecCommandCallback) self.setMenuStateCallback(self.cecMenuStateCallback) self.setSourceActivatedCallback(self.cecSourceActivatedCallback)
def initDefaultCB(self): """ initialize default callbacks """ logger.logDebug("Settings CEC default callbacks") self.setLogCallback(self.cecLogCallback) self.setKeyPressCallback(self.cecKeyPressCallback) self.setCommandCallback(self.cecCommandCallback) self.setMenuStateCallback(self.cecMenuStateCallback) self.setSourceActivatedCallback(self.cecSourceActivatedCallback)
def menuHandler(self, widget, data = None): """ handle data when menu item used :param widget: :param data: full item string """ target = data.split(CONST.DELIMITER)[0] cmdstring = CONST.DELIMITER.join(data.split(CONST.DELIMITER)[1:]) logger.logDebug("Sending cmd for %s: '%s'" % (target, cmdstring) ) self.sendCommands([cmdstring], target)
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 run(self): """ create gtk systry menu and ask for items """ self.askForItems() try: self.systray = gtk.StatusIcon() self.systray.set_from_stock(gtk.STOCK_ABOUT) self.systray.connect('popup-menu', self.onRightClick) gtk.main() except Exception as err: logger.logDebug("error: %s", err )
def run(self): """ create gtk systry menu and ask for items """ self.askForItems() try: self.systray = gtk.StatusIcon() self.systray.set_from_stock(gtk.STOCK_ABOUT) self.systray.connect('popup-menu', self.onRightClick) gtk.main() except Exception as err: logger.logDebug("error: %s", err)
def lightLighting(self): """ event specific function """ if self.daytime.isShining(): logger.logDebug("Doing nothing due to day time.") return if not CFG.AC_SOCK_2 in CFG.MY_PLACES: return code = self.items[CFG.AC_SOCK_2][CFG.AC_SOCK_2_2][CMD.ON] self.tasker.putTask(code)
def morningLight(self): """ event specific function never used yet """ if self.daytime.isShining(): logger.logDebug("Doing nothing due to day time.") return if not CFG.AC_SOCK_1 in CFG.MY_PLACES: return code = self.items[CFG.AC_SOCK_1][CFG.AC_SOCK_1_1][CMD.ON] self.tasker.putTask(code) code = self.items[CFG.AC_SOCK_1][CFG.AC_SOCK_1_2][CMD.ON] self.tasker.putTask(code)
def goForBeerLighting(self): """ event specific function """ if self.daytime.isShining(): logger.logDebug("Doing nothing due to day time.") return ac_sockets_to_on = [(CFG.AC_SOCK_2, CFG.AC_SOCK_2_2, CMD.ON), (CFG.AC_SOCK_3, CFG.AC_SOCK_2_4, CMD.ON)] for (place, ac_sock, sockcmd) in ac_sockets_to_on: if not place in CFG.MY_PLACES: continue code = self.items[place][ac_sock][sockcmd] self.tasker.putTask(code)
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 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 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 POST(self, id): """ post """ id=id.encode('utf-8') if (str(id) == "askForItems"): global items items.clear() askForItems() time.sleep(2) id = id + CONST.DELIMITER + web.data().encode('utf-8').split("=")[1] target = id.split(CONST.DELIMITER)[0] cmdstring = CONST.DELIMITER.join(id.split(CONST.DELIMITER)[1:]) logger.logDebug("Sending cmd for %s: '%s'" % (target, cmdstring) ) sendCommands([cmdstring], target) raise web.seeother('/')
def taskThread(self): """ tasker main thread - loop """ logger.logDebug("Task thread started") self.tasks = Queue.Queue() while True: try: task = self.tasks.get() if self.handler: try: self.handler(task) except Exception as err: logger.logDebug("Task error: %s" % str(err)) self.tasks.task_done() except: pass
def taskThread(self): """ tasker main thread - loop """ logger.logDebug("Task thread started") self.tasks = Queue.Queue() while True: try: task = self.tasks.get() if self.handler: try: self.handler(task) except Exception as err: logger.logDebug("Task error: %s" % str(err)) self.tasks.task_done() except: pass
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 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 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 POST(self, id): """ post """ id = id.encode('utf-8') if (str(id) == "askForItems"): global items items.clear() askForItems() time.sleep(2) id = id + CONST.DELIMITER + web.data().encode('utf-8').split( "=")[1] target = id.split(CONST.DELIMITER)[0] cmdstring = CONST.DELIMITER.join(id.split(CONST.DELIMITER)[1:]) logger.logDebug("Sending cmd for %s: '%s'" % (target, cmdstring)) sendCommands([cmdstring], target) raise web.seeother('/')
def listenServer(self): """ server listener """ logger.logDebug("Starting listener on '%s'" % str(self.addr)) if self.protocol == SOCKET_TCP: listenerthread = self.listenTCPThread if self.protocol == SOCKET_UDP: listenerthread = self.listenUDPThread if self.keepalive: t_target = self.keepAliveThread t_args = (self.startServer, listenerthread) else: t_target = listenerthread t_args = () t = threading.Thread(target=t_target, args=t_args) t.setDaemon(True) t.start()
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 listenServer(self): """ server listener """ logger.logDebug("Starting listener on '%s'" % str(self.addr)) if self.protocol == SOCKET_TCP: listenerthread = self.listenTCPThread if self.protocol == SOCKET_UDP: listenerthread = self.listenUDPThread if self.keepalive: t_target = self.keepAliveThread t_args = (self.startServer, listenerthread) else: t_target = listenerthread t_args = () t = threading.Thread(target = t_target, args = t_args) t.setDaemon(True) t.start()
def run(self): """ plugin main """ self.rfdevice.enable_rx() timestamp = None lastcode = None while True: if self.rfdevice.rx_code_timestamp != timestamp: try: if lastcode == self.rfdevice.rx_code and self.rfdevice.rx_code_timestamp < timestamp + 1000000: timestamp = self.rfdevice.rx_code_timestamp logger.logDebug("rf433_receive skipping: %s" % str(timestamp)) time.sleep(CFG.SLEEP_INTERVAL) continue except: logger.logDebug("rf433_receive passing: %s" % str(timestamp)) logger.logDebug("rf433_receive timestamp: %s" % str(timestamp)) timestamp = self.rfdevice.rx_code_timestamp lastcode = self.rfdevice.rx_code logger.logDebug( "rf433_receive code: %s length %s protocol: %s" % (str(self.rfdevice.rx_code), str(self.rfdevice.rx_pulselength), str(self.rfdevice.rx_proto))) keycode = str(self.rfdevice.rx_code) if keycode in CFG.RF433.keys() and CFG.RF433[keycode][0]: if len(CFG.RF433[keycode]) == 2: self.setTuyaStatus(CFG.RF433[keycode][0], CFG.RF433[keycode][1]) if len(CFG.RF433[keycode]) == 3: self.setTuyaStatus(CFG.RF433[keycode][0], CFG.RF433[keycode][1], CFG.RF433[keycode][2]) time.sleep(CFG.SLEEP_INTERVAL) else: self.sendEvents(EVENT.RF433_PRESSED % self.rfdevice.rx_code) time.sleep(CFG.SLEEP_INTERVAL) rfdevice.cleanup()
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
def run(self): """ plugin main """ self.rfdevice.enable_rx() timestamp = None lastcode = None while True: if self.rfdevice.rx_code_timestamp != timestamp: try: if lastcode == self.rfdevice.rx_code and self.rfdevice.rx_code_timestamp < timestamp + 1000000: timestamp = self.rfdevice.rx_code_timestamp logger.logDebug("rf433_receive skipping: %s" % str(timestamp)) time.sleep(CFG.SLEEP_INTERVAL) continue except: logger.logDebug("rf433_receive passing: %s" % str(timestamp)) logger.logDebug("rf433_receive timestamp: %s" % str(timestamp)) timestamp = self.rfdevice.rx_code_timestamp lastcode = self.rfdevice.rx_code logger.logDebug("rf433_receive code: %s length %s protocol: %s" % (str(self.rfdevice.rx_code), str(self.rfdevice.rx_pulselength), str(self.rfdevice.rx_proto))) keycode = str(self.rfdevice.rx_code) if keycode in CFG.RF433.keys() and CFG.RF433[keycode][0]: if len(CFG.RF433[keycode]) == 2: self.setTuyaStatus(CFG.RF433[keycode][0], CFG.RF433[keycode][1]) if len(CFG.RF433[keycode]) == 3: self.setTuyaStatus(CFG.RF433[keycode][0], CFG.RF433[keycode][1], CFG.RF433[keycode][2]) time.sleep(CFG.SLEEP_INTERVAL) else: self.sendEvents(EVENT.RF433_PRESSED % self.rfdevice.rx_code) time.sleep(CFG.SLEEP_INTERVAL) rfdevice.cleanup()
def cecKeyPressCallback(self, keycode, duration): """ cec-callback for key press """ if duration == 0: logger.logDebug("[KEY] %s pressed, time: %s" % (str(keycode), str(duration))) self.sendEvents(EVENT.CEC_KEYPRESSED_TEMPLATE % keycode) if duration > 0: logger.logDebug("[KEY] %s released, time: %s" % (str(keycode), str(duration))) self.sendEvents(EVENT.CEC_KEYRELEASED_TEMPLATE % keycode) if keycode in self.keymap.keys(): if hasattr(CFG, 'EMIT_REMOTECONTROL_KEYS' ) and CFG.EMIT_REMOTECONTROL_KEYS: self.uidevice.emit_click(self.keymap[keycode]) logger.logDebug("[KEY] code %s emitted" % str(self.keymap[keycode]))
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"
# 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 logger.logDebug("fork #2 finished") try: # redirect standard file descriptors if not yet logger.closestdIO() except: pass # write pidfile atexit.register(self.delPID) pid = str(os.getpid()) file(self.pidfile, 'w+').write("%s\n" % pid) logger.logInfo("Sucessfully daemonized with pid: %s" % pid) return CONST.RET_OK
def cecMenuStateCallback(self, state): """ cec-callback for menu state """ logger.logDebug("[MENUSTATE] %s" % str(state))
def cecCommandCallback(self, cmd): """ cec-callback for command """ logger.logDebug("[COMMAND] %s" % cmd)