def __init__(self, config, state, eventcallback):
self.nodes = config['nodes']
self.byname = dict()
self.config = config
self.receiver = eventcallback
zopts = {'user_path': '.', 'cmd_line': '--logging false'}
if self.config.has_key('config_path'):
zopts['config_path'] = self.config['config_path']
options = PyOptions(**zopts)
options.lock()
self.manager = PyManager()
self.manager.create()
logger.debug('Startup: Add watcher')
self.manager.addWatcher(self.callback)
logger.debug('Startup: Add device')
self.manager.addDriver(self.config['device'])
logger.info('Startup Complete')
# subscribe to shutdown event
eventcallback(event('shutdown', '', 'subscribe', 'shutdown'))
eventcallback(event('openzwave', '', 'subscribe', 'ALL'))
eventcallback(
event(
**{
'id': 'command-add',
'type': 'command',
'data': {
'operation': 'add',
'command': COMMANDS
}
}))
def __init__(self, config, state, eventcallback):
# create xmpp client
self.client = xmpp.Client(config['domain'])
# id, event = '', type = 'message', agent = '', user = ''
# subscribe to shutdown event
eventcallback(event('shutdown', '', 'subscribe', 'shutdown'))
# subscribe to xmpp_message events
eventcallback(event('xmpp_message', '', 'subscribe', 'ALL'))
# turn on timestamps in the log
self.client._DEBUG.time_stamp = 1
# open logfile
if config.has_key('logfile') and len(config['logfile']):
try:
self.client._DEBUG._fh = open(config['logfile'], 'w')
except:
logger.critical('Cannot open {} for writing'.format(
config['logfile']))
sys.exit(0)
# ...connect it to SSL port directly
port = 5222
if config.has_key('port'): port = config['port']
if not self.client.connect(server=(config['server'], port)):
raise IOError('Can not connect to server.')
# ...authorize client
if not self.client.auth(config['user'], config['password'],
config['server']):
raise IOError('Can not auth with server.')
self.client.sendInitPresence()
# ...work some time
self.client.Process(1)
# register xmpp messsage handler
self.daemonize = False
self.receiver = eventcallback
self.client.RegisterHandler('message', self.receive)
self.daemonizeit()
def __init__(self, host, tcp_port, udp_port):
self.types = {'tcp': self.enable_tcp, 'udp': self.enable_udp}
self.type_accept = {'tcp': self.accept_tcp, 'udp': self.accept_udp}
self.type_send = {'tcp': self.send_tcp, 'udp': self.send_udp}
self.buffer = ""
#events
self.started = event()
self.received_tcp = event()
self.received_udp = event()
self.stop = event()
self.new_udp_client = event()
self.new_tcp_client = event()
self.error = event()
self.socket_closed = event()
self.ip = socket.gethostbyname(socket.gethostname())
self.tcp_port = tcp_port
self.udp_port = udp_port
self.host = host
self.type = type
self.tcp = self.setup_socket('tcp')
self.udp = self.setup_socket('udp')
self.inputs = [self.udp, self.tcp]
self.outputs = []
self.connections = []
self.running = False
def __init__(self, host, tcp_port, udp_port):
self.types = {'tcp':self.enable_tcp, 'udp':self.enable_udp}
self.type_accept = {'tcp':self.accept_tcp, 'udp':self.accept_udp}
self.type_send = {'tcp':self.send_tcp, 'udp':self.send_udp}
self.buffer = ""
#events
self.started = event()
self.received_tcp = event()
self.received_udp = event()
self.stop = event()
self.new_udp_client = event()
self.new_tcp_client = event()
self.error = event()
self.socket_closed = event()
self.ip = socket.gethostbyname(socket.gethostname())
self.tcp_port = tcp_port
self.udp_port = udp_port
self.host = host
self.type = type
self.tcp = self.setup_socket('tcp')
self.udp = self.setup_socket('udp')
self.inputs = [self.udp, self.tcp]
self.outputs = []
self.connections = []
self.running = False
def event(self, cmdevent):
data = cmdevent.eventdata()
body = cmdevent.eventbody()
if 'operation' in data:
if data['operation'] == 'add':
self.add(data['command'])
elif data['operation'] == 'remove':
self.add(data['command'])
elif data['operation'] == 'list':
clist = self.list()
if 'returnevent' in data:
data['returnevent'].data['return'] = clist
self.eventhcallback(data['returnevent'])
elif len(body) > 0:
ret = self.handle(cmdevent.eventuser(), body)
# send response
if 'returnid' in data:
re = event(
**{
'id': data['returnid'],
'event': ret,
'user': cmdevent.eventuser()
})
self.eventcallback(re)
else:
logger.critical("Cannot process event: {}".format(cmdevent.dump()))
def shutdown(self):
logging.info("Shutdown started - Queue size: %i",
self.eventqueue.qsize())
#res = self.storage.store()
self.scheduler.removeall()
# send shutdown event to all agents
self.eventqueue.put(event('shutdown'))
self.eventqueue.join()
logging.info("Shutdown complete")
def on_motion():
# Creating a new event automatically logs it
e = event()
logger.info("on_motion")
c.click(cfg.camera.photo_count, cfg.camera.photo_delay_sec, f'Event:{e.id}')
init_sleep = e.get_seconds_until_stop()
sleep(init_sleep if init_sleep > 0 else 1)
return e
def run(self, cmdinfo, args, user):
logger.debug("Got command args: {}".format(args))
#logger.debug("globals: {}".format(globals()))
#logger.debug("locals: {}".format(locals()))
#reply = globals()['self.'+ commandInfo['handler']](args)
reply = str()
# execute a callable object
if 'handler' in cmdinfo:
logger.debug("Found command handler: {}".format(
cmdinfo['handler']))
logger.debug("Command function type: {}".format(
type(cmdinfo['handler'])))
logger.debug("Command function callable? {}".format(
callable(cmdinfo['handler'])))
if callable(cmdinfo['handler']):
reply = cmdinfo['handler'](args)
else:
logger.critical(
"Command defined is not callable, skipping: {}".format(
cmdinfo['handler']))
reply = 'An error occurred'
# create an event
elif 'handlerevent' in cmdinfo:
handevent = dict(cmdinfo['handlerevent'])
logger.debug("Found command handler event: {}".format(handevent))
if not 'data' in handevent: handevent['data'] = dict()
handevent['data']['args'] = args
handevent['user'] = user
he = event(**handevent)
self.eventcallback(he)
# run a function by name
else:
logger.debug("Found command handler name: {}".format(
cmdinfo['handlername']))
func = getattr(self, cmdinfo['handlername'], None)
logger.debug("Command function type: {}".format(type(func)))
if func is None: return "Could not locate function"
logger.debug("Got function: {}".format(func))
reply = func(args)
#reply = eval(('self.'+ commandInfo['handler'])(args))
#reply = globals()[commandInfo['handler']](args)
logger.debug("Got reply:\n{}".format(reply))
if reply is None:
return ('no response')
else:
return (reply)
def receive(self, con, xmppevent):
type = xmppevent.getType()
from_id = xmppevent.getFrom().getStripped()
if type in ['message', 'chat', None]:
if xmppevent.getBody():
#print from_id+':', event.getBody()
ce = event(
**{
'id': 'command-{}'.format(from_id),
'event': xmppevent.getBody(),
'type': 'command',
'user': from_id,
'data': {
'returnid': 'xmpp_message'
}
})
#self.receiver(event(from_id, event.getBody()))
self.receiver(ce)
self.add(id, when, event)
# MAIN #
if __name__ == '__main__':
logging.basicConfig(format='%(asctime)s %(levelname)s %(name)s: %(message)s',
datefmt='%Y/%m/%d-%H:%M:%S', level=logging.DEBUG)
def dummycallback(event):
logger.debug('Callback received event: %s', event.eventbody())
s = schedule(dummycallback, {})
logger.debug('Scheduling events')
# An example of scheduling Zwave events
s.add('Nightly zwave healNetwork', {'hourlist': [3], 'recurring': True},
event('openzwave', 'healNetwork', 'message'))
s.add('Porchlight One-Time 20:28 OFF Schedule', {'hourlist': [20], 'minutelist': [28]},
event('openzwave', 'setValue', 'message', '', '', { 'node': 'RGB Light - Porch', 'name': 'Level', 'value': 0 }))
s.add('Porchlight Spring ON Schedule', {'monthnames': ['march', 'april', 'may'], 'hourlist': [20], 'minutelist': [30], 'recurring': True},
event('openzwave', 'setValue', 'message', '', '', { 'node': 'RGB Light - Porch', 'name': 'Level', 'value': 50 }))
s.add('Porchlight Spring OFF Schedule', {'monthnames': ['march', 'april', 'may'], 'hourlist': [6], 'recurring': True},
event('openzwave', 'setValue', 'message', '', '', { 'node': 'RGB Light - Porch', 'name': 'Level', 'value': 0 }))
s.add('Porchlight Summer ON Schedule', {'monthnames': ['june', 'july', 'august'], 'hourlist': [21], 'recurring': True},
event('openzwave', 'setValue', 'message', '', '', { 'node': 'RGB Light - Porch', 'name': 'Level', 'value': 50 }))
s.add('Porchlight Summer OFF Schedule', {'monthnames': ['march', 'april', 'may'], 'hourlist': [5], 'recurring': True},
event('openzwave', 'setValue', 'message', '', '', { 'node': 'RGB Light - Porch', 'name': 'Level', 'value': 0 }))
s.add('Livingroom Dimmer OFF Schedule', {'hourlist': [22], 'recurring': True},
event('openzwave', 'setValue', 'message', '', '', { 'node': 'Dimmer - Livingroom', 'name': 'Level', 'value': 0 }))
def callback(self, args):
msg = ''
if not args:
logger.warning('Callback args are undefined')
return
nodeid = args['nodeId']
try: #if self.nodes.has_key(nodeid):
nodename = self.nodes[nodeid]['name']
self.nodes[nodeid]['lastseen'] = time()
except KeyError:
nodename = 'Node ' + str(nodeid)
self.nodes[nodeid] = {'name': nodename, 'lastseen': time()}
try:
self.nodes[nodeid]['values']
except KeyError:
self.nodes[nodeid]['values'] = dict()
try:
self.nodes[nodeid]['bylabel']
except KeyError:
self.nodes[nodeid]['bylabel'] = dict()
if nodename not in self.byname:
self.byname[nodename] = self.nodes[nodeid]
msg = nodename + ': ' + str(args['notificationType'])
if 'valueId' in args:
v = args['valueId']
#print('valueID: {}'.format(v['id']))
if not self.nodes[nodeid]['values'].has_key(v['id']):
self.nodes[nodeid]['values'][v['id']] = {'id': v['id']}
if v.has_key('label'):
self.nodes[nodeid]['values'][v['id']]['label'] = v['label']
msg += ' ' + v['label'] + ' ='
if not self.nodes[nodeid]['bylabel'].has_key(v['label']):
self.nodes[nodeid]['bylabel'][
v['label']] = self.nodes[nodeid]['values'][v['id']]
if v.has_key('value'):
self.nodes[nodeid]['values'][v['id']]['value'] = v['value']
if self.config['convertctof'] == True and v['units'].lower(
) == 'c':
v['value'] = self.convertCtoF(v['value'])
self.nodes[nodeid]['values'][v['id']]['value'] = v['value']
v['units'] = 'F'
msg += ' ' + str(v['value'])
else:
self.nodes[nodeid]['values'][v['id']]['value'] = ''
try:
self.nodes[nodeid]['values'][v['id']]['units'] = v['units']
msg += ' ' + str(v['units'])
except KeyError:
self.nodes[nodeid]['values'][v['id']]['units'] = ''
if v.get('readOnly'):
self.nodes[nodeid]['values'][v['id']]['readonly'] = True
msg += ' (ReadOnly)'
else:
self.nodes[nodeid]['values'][v['id']]['readonly'] = False
self.nodes[nodeid]['values'][v['id']]['updated'] = time()
if args['notificationType'] == 'Notification':
msg += ' notificationCode = ' + str(args['notificationCode'])
if args['notificationType'] == 'NodeEvent':
msg += ' event = ' + str(args['event'])
if args['notificationType'] == 'Group':
msg += ' groupIdx = ' + str(args['groupIdx'])
# {'homeId': 25480663, 'notificationType': 'DriverReady', 'nodeId': 1}
if args['notificationType'] == 'DriverReady' and args['nodeId'] == 1:
self.homeid = args['homeId']
logger.debug("DriverReady - homeId: %i", args['homeId'])
self.receiver(event('openzwave', msg))
if __name__ == "__main__":
from sys import argv
from logging import basicConfig
from logging import DEBUG as logging_DEBUG
basicConfig(format='%(asctime)s %(levelname)s %(name)s: %(message)s',
datefmt='%Y/%m/%d-%H:%M:%S',
level=logging_DEBUG)
argv.pop(0) # remove program name from arg list
def dummycallback(event):
logger.debug("Dummycallback got event: {}".format(event.dump()))
c = command(dummycallback)
# direct
logger.debug('Command list: {}'.format(c.list()))
response = c.handle('*****@*****.**', ' '.join(argv))
logger.debug('Got command response: {}'.format(response))
# using event
e1 = event(
**{
'id': 'eventid1',
'event': 'help',
'type': 'command',
'user': '******',
'data': {
'returnid': 'someid'
}
})
c.event(e1)
Given any number of dicts, shallow copy and merge into a new dict,
precedence goes to key value pairs in latter dicts.
"""
def merge_dicts(firstdict, *dict_args):
for dictionary in dict_args:
firstdict.update(dictionary)
# MAIN #
if __name__ == '__main__':
mcc = mcp()
# Most code here needs to be moved to core-logic or user-logic files
# id, event = '', type = 'message', agent = '', user = '', data = dict()
tm = event('xmpp_message', 'starting up', 'message', 'xmpp_message',
'USER@DOMAIN')
mcc.queueevent(tm)
mcc.scheduler.add('Nightly zwave healNetwork', {
'hourlist': [3],
'recurring': True
}, event('openzwave', 'healNetwork', 'message'))
mcc.scheduler.add(
'Porchlight Spring ON Schedule', {
'monthnames': ['march', 'april', 'may'],
'hourlist': [20],
'minutelist': [30],
'recurring': True
},
event('openzwave', 'setValue', 'message', '', '', {
