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
