def launch_vlc_instance(self):
while not self.thread.stopflag.is_set():
try:
nerve.log("Starting new instance of VLC")
# TODO make this more robust
cmdoptions = " --extraintf http --http-port 8081 --http-password test"
if platform.system() == 'Windows':
cmdline = "C:\\Program Files\\VideoLAN\\VLC\\vlc.exe" + cmdoptions
# TODO the creationnflags is apparently a hax to get a detached process, but i'm not sure if it works or is needed
proc = subprocess.Popen(cmdline.split(' '),
stdin=None,
stdout=None,
stderr=None,
close_fds=True,
creationflags=0x08)
else:
cmdline = "/usr/bin/vlc" + cmdoptions
#cmdline = cmd + " --extraintf rc --rc-host localhost:4212"
#proc = subprocess.Popen(cmdline.split(' '), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#proc = subprocess.Popen(cmdline.split(' '), stdin=None, stdout=None, stderr=None, close_fds=True)
proc = subprocess.Popen(cmdline.split(' '),
stdin=None,
stdout=None,
stderr=None,
close_fds=True)
return proc
except:
nerve.log(traceback.format_exc(), logtype='error')
# if the process fails to launch, we sleep for a while and then try again
time.sleep(7)
def run(self):
while not self.stopflag.wait(60):
try:
for datalog in DatalogDevice.datalogs:
datalog._collect_data()
except:
nerve.log(traceback.format_exc(), logtype='error')
def run(self):
while not self.stopflag.wait(60):
try:
for datalog in DatalogDevice.datalogs:
datalog._collect_data()
except:
nerve.log(traceback.format_exc(), logtype='error')
def run(self):
self.xmms = xmmsclient.XMMS('PyXMMS')
try:
self.xmms.connect(os.getenv("XMMS_PATH"))
except IOError as detail:
print("Connection failed:" + str(detail))
sys.exit(1)
self.xmms.playback_current_id(self._get_info)
self.xmms.broadcast_playback_current_id(self._get_info)
while not self.thread.stopflag.is_set():
fd = self.xmms.get_fd()
if self.xmms.want_ioout():
self.xmms.ioout()
(i, o, e) = select.select([fd], [], [fd], 0.1)
if i and i[0] == fd:
self.xmms.ioin()
if e and e[0] == fd:
self.xmms.disconnect()
self.thread.stopflag.set()
nerve.log("exiting XMMS2 maintenance thread.")
def run(self):
self.xmms = xmmsclient.XMMS('PyXMMS')
try:
self.xmms.connect(os.getenv("XMMS_PATH"))
except IOError as detail:
print ("Connection failed:" + str(detail))
sys.exit(1)
self.xmms.playback_current_id(self._get_info)
self.xmms.broadcast_playback_current_id(self._get_info)
while not self.thread.stopflag.is_set():
fd = self.xmms.get_fd()
if self.xmms.want_ioout():
self.xmms.ioout()
(i, o, e) = select.select([ fd ], [ ], [ fd ], 0.1)
if i and i[0] == fd:
self.xmms.ioin()
if e and e[0] == fd:
self.xmms.disconnect()
self.thread.stopflag.set()
nerve.log("exiting XMMS2 maintenance thread.")
def handle_connection(self, request):
self.conn = request.source
self.protocol = request.get_header('Sec-Websocket-Protocol', 'text')
mimetype = protocols[self.protocol] if self.protocol in protocols else 'text/plain'
self.on_connect()
#while not self.conn.stopflag.is_set():
#while not self.thread.stopflag.is_set():
while True:
try:
msg = self.conn.read_message(mimetype=mimetype)
if not msg:
break
self.on_message(msg)
except nerve.connect.QuitException:
break
except OSError as e:
nerve.log("OSError: " + str(e), logtype='error')
break
except Exception as e:
self.handle_connection_error(e, traceback.format_exc())
self.on_disconnect()
def read_message(self):
line = self.rfile.readline()
if not line:
return None
line = line.rstrip('\r\n')
nerve.log(" IN: " + line)
return nerve.connect.Message(text=line + '\n')
def handle_error(self, error, traceback, request):
accept = request.get_header('accept', default='text/html')
if 'application/json' in accept and type(error) is not nerve.users.UserPermissionsRequired:
nerve.log(traceback, logtype='error')
self.load_json_view({ 'error' : repr(error) })
else:
super().handle_error(error, traceback, request)
def send(self, message, severity='info', label=''):
# if a note with a matching label is found, update it and return
for note in self.notifications:
if label and note['label'] == label:
note['occurances'] += 1
note['acknowledged'] = False
note['severity'] = severity
note['message'] = message
note['timestamp'] = time.time()
return note['id']
# create a new note with a new id
nid = self.next_id
self.next_id += 1
self.notifications.insert(0, {
'id': nid,
'label': label,
'timestamp': time.time(),
'occurances': 1,
'acknowledged': False,
'severity': severity,
'message': message
})
self.forward(self.notifications[0])
nerve.log("[{0}] {1}".format(severity, message), logtype='notify')
return nid
def run(self):
nerve.log("Starting UDP Server")
while True:
self.open()
while True:
try:
data, addr = self.receive()
data = data.strip('\n')
(host, port) = addr
if data:
nerve.log("RECV <- " + str(host) + ":" + str(port) +
": " + data)
request = nerve.Request(self, None, 'QUERY', "/",
{'requests[]': [data]})
controller = self.make_controller(request)
controller.handle_request(request)
self.send(controller.get_output() + '\n', addr)
except socket.error as e:
nerve.log("Socket Error: " + str(e), logtype='error')
break
except:
nerve.log(traceback.format_exc(), logtype='error')
nerve.log("closing socket and retrying in 5 seconds")
self.close()
time.sleep(5)
def shutdown(self):
self.stopflag.set()
nerve.log("shutting down all threads")
nerve.Thread.stop_all()
nerve.Thread.join_all()
os.system('stty sane')
sys.exit(self.exitcode)
def HTTPQueryHandler(_queryurl, *args, **kwargs):
# TODO is this valid? To have query options in the kwargs? Might that cause problems for some things? Should the key be deleted here if
# present, so that it doesn't get encoded.
#if 'query_method' in kwargs:
# method = kwargs['query_method']
# del kwargs['query_method']
#else:
# method = 'POST'
#method = kwargs['query_method'] if 'query_method' in kwargs else 'POST'
args = nerve.Request.put_positional_args(args, kwargs)
method = 'GET' if len(kwargs) <= 0 else 'POST'
urlstring = urllib.parse.urlunparse((_queryurl.scheme, _queryurl.netloc, _queryurl.path, '', '', ''))
nerve.log("executing query: " + method + " " + urlstring + " " + repr(args) + " " + repr(kwargs), logtype='query')
r = requests.request(method, urlstring, json=None if method == 'GET' else kwargs)
if r.status_code != 200:
raise Exception("request to " + urlstring + " failed. " + str(r.status_code) + ": " + r.reason, r.text)
(mimetype, pdict) = cgi.parse_header(r.headers['content-type'])
if mimetype == 'application/json':
result = r.json()
elif mimetype == 'application/x-www-form-urlencoded':
result = urllib.parse.parse_qs(r.text, keep_blank_values=True)
else:
result = r.text
rstr = str(result)
nerve.log("result: " + ( rstr[:75] + '...' if len(rstr) > 75 else rstr ), logtype='debug')
return result
def readmsg(self):
line = self.rfile.readline()
if line == None:
return None
line = line.strip('\r\n')
nerve.log(" IN: " + line)
return Msg(line)
def send(self, message, severity='info', label=''):
# if a note with a matching label is found, update it and return
for note in self.notifications:
if label and note['label'] == label:
note['occurances'] += 1
note['acknowledged'] = False
note['severity'] = severity
note['message'] = message
note['timestamp'] = time.time()
return note['id']
# create a new note with a new id
nid = self.next_id
self.next_id += 1
self.notifications.insert(0, {
'id': nid,
'label': label,
'timestamp': time.time(),
'occurances': 1,
'acknowledged': False,
'severity': severity,
'message': message
})
self.forward(self.notifications[0])
nerve.log("[{0}] {1}".format(severity, message), logtype='notify')
return nid
def shutdown(self):
self.stopflag.set()
nerve.log("shutting down all threads")
nerve.Task.stop_all()
nerve.Task.join_all()
os.system('stty sane')
sys.exit(self.exitcode)
def read_message(self):
line = self.rfile.readline()
if not line:
return None
line = line.strip('\n')
nerve.log("RECV <- " + str(self.hostname) + ":" + str(self.port) + ": " + line)
return nerve.connect.Message(text=line)
def change_state(self, target_state):
self.pipeline.set_state(target_state)
(statechange, state, pending) = self.pipeline.get_state(timeout=5 * Gst.SECOND)
if statechange != Gst.StateChangeReturn.SUCCESS:
nerve.log("gstreamer failed waiting for state change to " + str(pending), logtype='error')
return False
return True
def readmsg(self):
line = self.rfile.readline()
if line == None:
return None
line = line.strip('\r\n')
nerve.log(" IN: " + line)
return Msg(line)
def run(self):
nerve.log("Starting UDP Server")
while True:
self.open()
while True:
try:
data, addr = self.receive()
data = data.strip('\n')
(host, port) = addr
if data:
nerve.log("RECV <- " + str(host) + ":" + str(port) + ": " + data)
request = nerve.Request(self, None, 'QUERY', "/", { 'requests[]' : [ data ] })
controller = self.make_controller(request)
controller.handle_request(request)
self.send(controller.get_output() + '\n', addr)
except socket.error as e:
nerve.log("Socket Error: " + str(e), logtype='error')
break
except:
nerve.log(traceback.format_exc(), logtype='error')
nerve.log("closing socket and retrying in 5 seconds")
self.close()
time.sleep(5)
def read_message(self, mimetype='text/plain'):
line = self.rfile.readline()
if not line:
return None
line = line.strip('\n')
nerve.log("RECV <- " + str(self.hostname) + ":" + str(self.port) +
": " + line)
return nerve.connect.Message(text=line, mimetype=mimetype)
def load_playlist(self, name):
self.pipeline.stop()
self.pipeline.queue = [ ]
for media in nerve.medialib.Playlist(name).get_list():
nerve.log("adding to playlist: " + media['artist'] + " - " + media['title'] + " (" + media['filename'] + ")")
self.pipeline.queue.append(media['filename'])
self.pipeline.play()
def handle_error(self, error, traceback, request):
accept = request.get_header('accept', default='text/html')
if 'application/json' in accept and type(
error) is not nerve.users.UserPermissionsRequired:
nerve.log(traceback, logtype='error')
self.load_json_view({'error': repr(error)})
else:
super().handle_error(error, traceback, request)
def read_message(self, mimetype='text/plain'):
# TODO should you check mimetype and die if not text?
line = self.rfile.readline()
if not line:
return None
line = line.rstrip('\r\n')
nerve.log(" IN: " + line)
return nerve.connect.Message(text=line + '\n', mimetype=mimetype)
def _on_event(event):
nerve.log(event, logtype='warning')
self.send_message(
nerve.connect.Message('application/json',
data={
'type': 'publish',
'event': event
}))
def del_object(self, name):
(path, _, leaf) = name.rpartition('/')
root = self.get_object(path)
if not root or not leaf:
nerve.log("del_object(): invalid path given, " + name,
logtype='error')
return None
return root.del_child(leaf)
def websocket_wait_for_close(self):
while True:
(opcode, payload, headbyte1, headbyte2) = self.websocket_read_frame()
if opcode == WS_OP_CLOSE:
if payload:
nerve.log("websocket: received close message: " + str(struct.unpack("!H", payload[0:2])[0]) + " - " + payload[2:].decode('utf-8'))
else:
nerve.log("websocket: received close message")
return
def fetch_json(self, list_id):
url = 'http://www.youtube.com/list_ajax?action_get_list=1&style=json&list=%s' % (list_id,)
try:
r = requests.get(url)
if r.text:
return json.loads(r.text)
except:
nerve.log("error fetching youtube list " + list_id, logtype='error')
return None
def handle_connection_error(self, error, traceback):
nerve.log(traceback, logtype='error')
#self.send_message(nerve.connect.Message(text=traceback))
self.send_message(
nerve.connect.Message(mimetype='application/json',
data={
'type': 'error',
'text': traceback
}))
def publish(topic, **event):
if not allowed_publish.match(topic):
raise Exception("invalid event topic in publish: " + topic)
# TODO what about retaining the value? This would require necessary branches to be filled out just so you can store the value somewhere, but it
# shouldn't be stored on the individual handlers; this kinda isn't the right datastructure to do it with
event['topic'] = topic
nerve.log("routing event " + repr(event), logtype='event')
_route_event(event, topic, _event_listeners)
def load_playlist(self, name):
self.pipeline.stop()
self.pipeline.queue = []
for media in nerve.medialib.Playlist(name).get_list():
nerve.log("adding to playlist: " + media['artist'] + " - " +
media['title'] + " (" + media['filename'] + ")")
self.pipeline.queue.append(media['filename'])
self.pipeline.play()
def schedule(self, timeout, asynctask, *args, **kwargs):
for (_, q_asynctask, _, _) in self.queue.queue:
if asynctask == q_asynctask:
nerve.log("asynctask already scheduled")
# TODO maybe we should only reschedule the asynctask if the new time is less than the old time
return
self.queue.put((time.time() + timeout, asynctask, args, kwargs))
with self.check:
self.check.notify()
def schedule(self, timeout, asynctask, *args, **kwargs):
for (_, q_asynctask, _, _) in self.queue.queue:
if asynctask == q_asynctask:
nerve.log("asynctask already scheduled")
# TODO maybe we should only reschedule the asynctask if the new time is less than the old time
return
self.queue.put((time.time() + timeout, asynctask, args, kwargs))
with self.check:
self.check.notify()
def publish(topic, **event):
if not allowed_publish.match(topic):
raise Exception("invalid event topic in publish: " + topic)
# TODO what about retaining the value? This would require necessary branches to be filled out just so you can store the value somewhere, but it
# shouldn't be stored on the individual handlers; this kinda isn't the right datastructure to do it with
event['topic'] = topic
nerve.log("routing event " + repr(event), logtype='event')
_route_event(event, topic, _event_listeners)
def on_message(self, ws, msg):
nerve.log(str(msg), logtype='debug')
msg = json.loads(msg)
if msg['type'] in ['reply', 'error']:
self.resolve_pending(msg)
elif msg['type'] == 'publish':
msg['event']['topic'] = str(id(self)) + '/' + msg['event']['topic']
#msg['event']['topic'] = self.url + '/' + msg['event']['topic']
nerve.events.publish(**msg['event'])
def dispatch(self, msg):
if msg.cmd == "PING":
return self.sendmsg(msg.line.replace("PING", "PONG"))
elif msg.cmd == "PRIVMSG":
if msg.nargs < 1:
return
self.on_privmsg(msg)
elif msg.cmd == "NOTICE":
if msg.nargs < 1:
return
self.on_notice(msg)
elif msg.cmd == "JOIN":
if msg.nargs < 1:
return
channel = msg.args[0]
if msg.nick == self.nick:
if channel not in self.channels:
self.channels[channel] = Channel(channel)
else:
self.channels[channel].join(msg.nick)
self.on_join(msg.nick)
elif msg.cmd == "PART":
if msg.nargs < 1:
return
channel = msg.args[0]
if msg.nick == self.nick:
# TODO rejoin??
pass
else:
self.channels[channel].part(msg.nick)
self.on_part(msg.nick)
elif msg.cmd == "QUIT":
for channel in self.channels:
channel.part(msg.nick)
self.on_quit(msg.nick)
elif msg.cmd == "MODE":
self.mode = msg.text
elif msg.cmd == "NICK":
self.on_nick(msg.nick, msg.args[0])
elif msg.cmd == str(MsgType.RPL_NAMREPLY):
if msg.nargs != 4:
return
channel = msg.args[2]
for nick in msg.args[3].split():
self.channels[channel].join(nick)
self.on_name(nick)
elif msg.cmd == str(MsgType.ERR_NICKNAMEINUSE):
nerve.log("IRC: nick %s in use on server %s." %
(self.nick, self.hostname))
# TODO add better altnick handling
self.nick = self.nick + "_"
self.sendmsg("NICK " + self.nick)
elif msg.cmd == str(MsgType.RPL_ENDOFMOTD):
self.connected = True
nerve.log("IRC: Connection complete to server " + self.hostname)
self.on_connect()
def evaluate(self):
self._start_time = time.time()
#self._output = io.StringIO()
segments = self._parse_segments(self._contents)
self._pycode = self._generate_python(segments)
self._execute_python()
self._run_time = time.time() - self._start_time
nerve.log("pyhtml executed in %.4f seconds" % (self._run_time,))
def change_state(self, target_state):
self.pipeline.set_state(target_state)
(statechange, state,
pending) = self.pipeline.get_state(timeout=5 * Gst.SECOND)
if statechange != Gst.StateChangeReturn.SUCCESS:
nerve.log("gstreamer failed waiting for state change to " +
str(pending),
logtype='error')
return False
return True
def handle_error(self, error, traceback, request):
self.set_error(error)
if not self._view:
self.load_plaintext_view('')
nerve.log(traceback, logtype='error')
#if 'text/html' in request.headers['accept']:
# render some html
#else:
# self.write(traceback)
self._view.write(traceback)
def evaluate(self):
self._start_time = time.time()
#self._output = io.StringIO()
segments = self._parse_segments(self._contents)
self._pycode = self._generate_python(segments)
self._execute_python()
self._run_time = time.time() - self._start_time
nerve.log("pyhtml executed in %.4f seconds" % (self._run_time,))
def handle_error(self, error, traceback, request):
self.set_error(error)
if not self._view:
self.load_plaintext_view('')
nerve.log(traceback, logtype='error')
#if 'text/html' in request.headers['accept']:
# render some html
#else:
# self.write(traceback)
self._view.write(traceback)
def save_object_children(self):
config = {}
for objname in self._children.keys():
if isinstance(self._children[objname], ObjectNode):
config[objname] = self._children[objname].get_config_data()
else:
nerve.log("unable to save child object " + objname + ": " +
self._children[objname],
logtype='error')
return config
def dispatch(self, msg):
if msg.cmd == "PING":
return self.sendmsg(msg.line.replace("PING", "PONG"))
elif msg.cmd == "PRIVMSG":
if msg.nargs < 1:
return
self.on_privmsg(msg)
elif msg.cmd == "NOTICE":
if msg.nargs < 1:
return
self.on_notice(msg)
elif msg.cmd == "JOIN":
if msg.nargs < 1:
return
channel = msg.args[0]
if msg.nick == self.nick:
if channel not in self.channels:
self.channels[channel] = Channel(channel)
else:
self.channels[channel].join(msg.nick)
self.on_join(msg.nick)
elif msg.cmd == "PART":
if msg.nargs < 1:
return
channel = msg.args[0]
if msg.nick == self.nick:
# TODO rejoin??
pass
else:
self.channels[channel].part(msg.nick)
self.on_part(msg.nick)
elif msg.cmd == "QUIT":
for channel in self.channels:
channel.part(msg.nick)
self.on_quit(msg.nick)
elif msg.cmd == "MODE":
self.mode = msg.text
elif msg.cmd == "NICK":
self.on_nick(msg.nick, msg.args[0])
elif msg.cmd == str(MsgType.RPL_NAMREPLY):
if msg.nargs != 4:
return
channel = msg.args[2]
for nick in msg.args[3].split():
self.channels[channel].join(nick)
self.on_name(nick)
elif msg.cmd == str(MsgType.ERR_NICKNAMEINUSE):
nerve.log("IRC: nick %s in use on server %s." % (self.nick, self.hostname))
# TODO add better altnick handling
self.nick = self.nick + "_"
self.sendmsg("NICK " + self.nick)
elif msg.cmd == str(MsgType.RPL_ENDOFMOTD):
self.connected = True
nerve.log("IRC: Connection complete to server " + self.hostname)
self.on_connect()
def check_for_deleted(self):
for libpath in self.path:
if not os.path.exists(libpath):
continue
self.db.select('id,filename')
self.db.where_like('filename', libpath + '%')
for row in self.db.get('media'):
if not os.path.exists(row[1]):
nerve.log("Removing " + row[1] + " (id: " + str(row[0]) + ")")
self.db.where('id', row[0])
self.db.delete('media')
def check_for_deleted(self):
for libpath in self.path:
if not os.path.exists(libpath):
continue
self.db.select('id,filename')
self.db.where_like('filename', libpath + '%')
for row in self.db.get('media'):
if not os.path.exists(row[1]):
nerve.log("Removing " + row[1] + " (id: " + str(row[0]) + ")")
self.db.where('id', row[0])
self.db.delete('media')
def fetch_json(self, list_id):
url = 'http://www.youtube.com/list_ajax?action_get_list=1&style=json&list=%s' % (
list_id, )
try:
r = requests.get(url)
if r.text:
return json.loads(r.text)
except:
nerve.log("error fetching youtube list " + list_id,
logtype='error')
return None
def websocket_wait_for_close(self):
while True:
(opcode, payload, headbyte1,
headbyte2) = self.websocket_read_frame()
if opcode == WS_OP_CLOSE:
if payload:
nerve.log("websocket: received close message: " +
str(struct.unpack("!H", payload[0:2])[0]) +
" - " + payload[2:].decode('utf-8'))
else:
nerve.log("websocket: received close message")
return
def _collect_data(self):
data = {}
data['timestamp'] = time.time()
for datapoint in self.get_setting('datapoints'):
try:
data[datapoint['name']] = nerve.query(datapoint['ref'])
except Exception as exc:
nerve.log("error collecting ref: " + str(datapoint['ref']) +
": " + repr(exc),
logtype='error')
data[datapoint['name']] = None
self.db.insert(self.name, data)
def connect_any(self):
while not self.stopflag.is_set():
hostname = self.client.get_setting('hostname')
port = self.client.get_setting('port')
#url = urllib.parse.urlparse(address)
try:
nerve.log("connecting to " + hostname + ":" + str(port))
self.client.connect(hostname, port)
return
except OSError as e:
nerve.log("error connecting to " + hostname + ":" + port + ": " + str(e), logtype='error')
self.stopflag.wait(10)
def connect_any(self):
while not self.stopflag.is_set():
hostname = self.client.get_setting('hostname')
port = self.client.get_setting('port')
#url = urllib.parse.urlparse(address)
try:
nerve.log("connecting to " + hostname + ":" + str(port))
self.client.connect(hostname, port)
return
except OSError as e:
nerve.log("error connecting to " + hostname + ":" + port + ": " + str(e), logtype='error')
self.stopflag.wait(10)
def connect_any(self):
while not self.stopflag.is_set():
for address in self.client.servers:
(hostname, port) = address.split(':', 1)
#url = urllib.parse.urlparse(address)
try:
nerve.log("connecting to " + hostname + ":" + port)
self.client.connect(hostname, port)
return
except OSError as e:
nerve.log("error connecting to " + hostname + ":" + port + ": " + str(e), logtype='error')
self.stopflag.wait(10)
def init_system(self):
try:
nerve.asyncs.init()
nerve.users.init()
if not self.load_config('settings.json'):
return False
if not self.run_init('init.py'):
return False
return True
except:
nerve.log(traceback.format_exc(), logtype='error')
return False
def websocket_read_message(self):
data = bytearray()
msg_opcode = None
while True:
(opcode, payload, headbyte1,
headbyte2) = self.websocket_read_frame()
if headbyte1 & WS_B1_RSV:
raise WebSocketError(
"websocket: received an invalid frame where first byte is "
+ hex(headbyte1))
if (headbyte2 & WS_B2_MASKBIT) == 0:
raise WebSocketError(
"websocket: received an invalid frame where second byte is "
+ hex(headbyte2))
if opcode & WS_OP_CONTROL:
if opcode == WS_OP_CLOSE:
self.websocket_write_close(1001, "")
self.closed = True
return (opcode, None)
elif opcode == WS_OP_PING:
nerve.log("websocket: recieved ping from " +
':'.join(self.client_address))
self.websocket_write_frame(WS_OP_PONG, payload)
continue
elif opcode == WS_OP_PONG:
continue
else:
raise WebSocketError(
"websocket: received invalid opcode " + hex(opcode))
else:
if msg_opcode == None:
msg_opcode = opcode
else:
if opcode != WS_OP_CONT:
raise WebSocketError(
"websocket: expected CONT opcode, received " +
hex(opcode))
data += payload
if headbyte1 & WS_B1_FINBIT:
break
if msg_opcode == WS_OP_TEXT:
return (msg_opcode, data.decode('utf-8'))
elif msg_opcode == WS_OP_BIN:
return (msg_opcode, data)
raise WebSocketError(
"websocket: expected non-control opcode, received " + hex(opcode))
def on_receive(self, line):
args = line.split(';')
if len(args) != 6:
nerve.log("mysensors: invalid message received: " + line, logtype='error')
return
nodeid = args[0]
sensorid = args[1]
msgtype = int(args[2])
ack = int(args[3])
subtype = int(args[4])
payload = args[5]
current_time = time.time()
node = self.get_child(nodeid)
if node:
node.last_recv = current_time
if msgtype == MsgType.PRESENTATION:
nerve.log("mysensors: new sensor presented itself: " + str(nodeid) + ":" + str(sensorid))
self._add_sensor(nodeid, sensorid, subtype, payload)
elif msgtype == MsgType.SET:
#sensor = self.get_sensor(nodeid, sensorid)
sensor = node.get_child(sensorid)
if not sensor:
sensor = self._add_sensor(nodeid, sensorid)
sensor.last_recv = current_time
sensor.last_type = subtype
sensor.last_value = payload
# TODO publish event? maybe even have a per sensor or per node flag for whether to publish
elif msgtype == MsgType.REQ:
pass
elif msgtype == MsgType.INTERNAL:
if subtype == SubTypeInternal.I_LOG_MESSAGE:
nerve.log("mysensors: " + payload)
elif subtype == SubTypeInternal.I_BATTERY_LEVEL:
node = self.get_node(nodeid)
if node:
node.battery_level = float(payload)
elif subtype == SubTypeInternal.I_SKETCH_NAME:
node = self.get_node(nodeid)
if node:
node.name = payload
elif subtype == SubTypeInternal.I_SKETCH_VERSION:
node = self.get_node(nodeid)
if node:
node.version = payload
elif subtype == SubTypeInternal.I_CONFIG:
self.send("%s;%s;3;0;%d;M" % (nodeid, sensorid, subtype))
elif msgtype == MsgType.STREAM:
pass
else:
nerve.log("received an invalid message type: " + line, logtype='error')
def run_update(self):
medialib = nerve.get_object('/modules/medialib')
self.path = medialib.get_setting('medialib_dirs')
self.ignore = medialib.get_setting('ignore_dirs')
if not self.path:
nerve.log("warning: medialib_dirs not set", logtype='warning')
return
nerve.log("Starting medialib update...")
for libpath in self.path:
for root, dirs, files in os.walk(libpath):
if len(tuple(name for name in self.ignore if name in root)) > 0:
continue
if self.stopflag.is_set():
return
nerve.log("Searching " + root)
for media in files:
#if media.endswith('.mp3'):
self.update_file(os.path.join(root, media), len(libpath.rstrip('/')) + 2)
self.check_for_deleted()
self.db.insert('info', { 'name' : 'last_updated', 'value' : str(time.time()) }, replace=True)
nerve.log("Medialib update complete")
def run(self):
while True:
for name in self.updaters.keys():
try:
self.updaters[name].check_update()
except:
nerve.log(traceback.format_exc(), logtype='error')
#nerve.query('/devices/notify/send', 'medialib update complete')
if self.stopflag.is_set():
break
if self.interrupt.wait(60):
self.interrupt.clear()
def do_request(self, request):
result = None
querystr = request.get_slug()
if querystr != '':
result = self.execute_query(querystr, **request.args)
elif 'requests[]' in request.args:
result = [ ]
for querystr in request.args['requests[]']:
try:
result.append(self.execute_query(querystr))
except:
nerve.log(traceback.format_exc(), logtype='error')
result.append('error')
self.load_json_view(result)
def __init__(self, **config):
nerve.Server.__init__(self, **config)
self.username = self.get_setting("username")
self.password = self.get_setting("password")
socketserver.TCPServer.__init__(self, ('', self.get_setting('port')), IRCRequestHandler)
#if self.get_setting('ssl_enable'):
# self.socket = ssl.wrap_socket(self.socket, certfile=self.get_setting('ssl_cert'), server_side=True)
sa = self.socket.getsockname()
nerve.log('starting http(s) on port ' + str(sa[1]))
self.thread = nerve.Task('HTTPServerTask', target=self.serve_forever)
self.thread.daemon = True
self.thread.start()
def run(self):
while not self.stopflag.is_set():
self.connect_any()
while not self.stopflag.is_set():
try:
msg = self.client.readmsg()
if not msg:
break
self.client.lastcontact = time.time()
self.client.dispatch(msg)
except:
nerve.log("error on irc server connection to " + self.client.hostname + ":" + str(self.client.port), logtype='error')
nerve.log(traceback.format_exc(), logtype='error')
self.client.close()
break
self.stopflag.wait(10)
def start(self):
signal.signal(signal.SIGINT, self.signal_handler)
if not self.init_system():
self.shutdown()
try:
nerve.Task.start_all()
#print (dir(nerve))
while not self.stopflag.wait(0.5):
pass
nerve.log("exiting main loop")
except:
nerve.log(traceback.format_exc(), logtype='error')
self.shutdown()
def handle_request(self, request):
self.initialize(request)
try:
self.do_request(request)
if self._view:
self._view.finalize()
except Exception as e:
try:
self.handle_error(e, traceback.format_exc(), request)
except:
nerve.log("error while handling exception:\n" + traceback.format_exc(), logtype='error')
finally:
self.finalize(request)
if self._error is None:
return True
return False
