def __handle_message_request(self, client, id, bindata):
request = serial.unpack(Request, bindata)
if request is None:
return
reply = ListReply(client, request.request_id, id, request.page, path=request.path)
if id == message.REQ_PLAYLIST:
self.request_playlist(reply)
elif id == message.REQ_QUEUE:
self.request_queue(reply)
elif id == message.REQ_MLIB:
self.request_mlib(reply, request.path)
elif id == message.REQ_FILES:
reply.nested, reply.ids, reply.names = self.__filelib.get_level(request.path)
reply.send()
elif id == message.REQ_SEARCH:
self.request_search(reply, request.path)
else:
log.error("** BUG ** unexpected request message: %d" % id)
def __handle_message_action(self, id, bindata):
a = serial.unpack(Action, bindata)
if a is None:
return
if id == message.ACT_PLAYLIST:
self.action_playlist_item(a.id, a.positions, a.items)
elif id == message.ACT_QUEUE:
self.action_queue_item(a.id, a.positions, a.items)
elif id == message.ACT_MLIB and a.id < 0: # list action id
self.action_mlib_list(a.id, a.path)
elif id == message.ACT_MLIB and a.id > 0: # item action id
self.action_mlib_item(a.id, a.path, a.positions, a.items)
elif id == message.ACT_FILES:
uris = self.__util_files_to_uris(a.items)
self.action_files(a.id, a.items, uris)
elif id == message.ACT_SEARCH:
self.action_search_item(a.id, a.positions, a.items)
else:
log.error("** BUG ** unexpected action message: %d" % id)
def test_serialize_deserialize(self):
sc1 = _SerialzableClass()
sc1.init()
#bindata = self.__serialize(sc1)
bindata = serial.pack(sc1)
self.assertFalse(bindata is None)
sc2 = _SerialzableClass()
serial.unpack(sc2, bindata)
self.assertFalse(sc2.sa1 is None)
self.assertTrue(len(sc2.sa1) > 2)
self.assertEquals(sc2.sa1[2], "") # None becomes empty string
sc2.sa1[2] = None
self.assertEquals(sc2.ia2, []) # None becomes empty list
sc2.ia2 = None
self.assertEquals(sc1, sc2)
sc3 = serial.unpack(_SerialzableClass, "%strash" % bindata)
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass, "df")
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass(), "dfäsadfasd")
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass, "")
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass(), None)
self.assertTrue(sc3 is None)
def test_serialize_deserialize(self):
sc1 = _SerialzableClass()
sc1.init()
#bindata = self.__serialize(sc1)
bindata = serial.pack(sc1)
self.assertFalse(bindata is None)
sc2 = _SerialzableClass()
serial.unpack(sc2, bindata)
self.assertFalse(sc2.sa1 is None)
self.assertTrue(len(sc2.sa1) > 2)
self.assertEquals(sc2.sa1[2], "") # None becomes empty string
sc2.sa1[2] = None
self.assertEquals(sc2.ia2, []) # None becomes empty list
sc2.ia2 = None
self.assertEquals(sc1, sc2)
sc3 = serial.unpack(_SerialzableClass, "%strash" % bindata)
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass, "df")
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass(), "dfäsadfasd")
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass, "")
self.assertTrue(sc3 is None)
sc3 = serial.unpack(_SerialzableClass(), None)
self.assertTrue(sc3 is None)
def __io_recv(self, fd, cond):
""" GObject callback function (when there is data to receive). """
log.debug("data from client %s available" % self)
# --- init buffers on new message -------------------------------------
if (self.__rcv_buff_header.rest + self.__rcv_buff_data.rest == 0):
self.__rcv_msg_id = message.IGNORE
self.__rcv_msg_size = 0 # will be set later
self.__rcv_buff_header.data = ""
self.__rcv_buff_header.rest = ClientConnection.IO_HEADER_LEN
self.__rcv_buff_data.data = ""
self.__rcv_buff_data.rest = 0 # will be set later
# --- receive header --------------------------------------------------
if self.__rcv_buff_header.rest > 0:
ok = self.__recv_buff(self.__rcv_buff_header)
if not ok:
return False
if self.__rcv_buff_header.rest > 0:
return True # more data to read, come back later
id, size = struct.unpack('!hi', self.__rcv_buff_header.data)
if size > ClientConnection.IO_MSG_MAX_SIZE:
log.warning("msg from %s too big (%d bytes)" % (self, size))
self.disconnect()
return False
log.debug("incoming msg: %d, %dB" % (id, size))
self.__rcv_buff_data.rest = size
self.__rcv_msg_id, self.__rcv_msg_size = id, size
if size > 0:
return True # more data to read, come back later
# --- receive content -------------------------------------------------
if self.__rcv_buff_data.rest > 0:
ok = self.__recv_buff(self.__rcv_buff_data)
if not ok:
return False
if self.__rcv_buff_data.rest > 0:
return True # more data to read, come back later
# --- message complete ------------------------------------------------
msg_id = self.__rcv_msg_id
msg_data = self.__rcv_buff_data.data
log.debug("incoming msg ")
if msg_id == message.IGNORE:
log.debug("received ignore msg (probably a ping)")
elif msg_id == message.CONN_SLEEP:
self.__psave = True
elif msg_id == message.CONN_WAKEUP:
self.__psave = False
self.__msg_handler_fn(self, message.PRIV_INITIAL_SYNC, None)
elif msg_id == message.CONN_CINFO:
log.debug("received client info from %s" % self)
serial.unpack(self.info, msg_data)
if not self in self.__clients: # initial client info
device = self.info.device.copy()
device["conn"] = self.__conn_type
report.log_device(device)
self.__clients.append(self)
log.debug("sending player info to %s" % self)
self.send(self.__pinfo_msg)
self.__msg_handler_fn(self, message.PRIV_INITIAL_SYNC, None)
else:
self.__msg_handler_fn(self, msg_id, msg_data)
return True
def __handle_message_control(self, id, bindata):
if id == message.CTRL_PLAYPAUSE:
self.ctrl_toggle_playing()
elif id == message.CTRL_NEXT:
self.ctrl_next()
elif id == message.CTRL_PREV:
self.ctrl_previous()
elif id == message.CTRL_SEEK:
control = serial.unpack(Control, bindata)
if control is None:
return
self.ctrl_seek(control.param)
elif id == message.CTRL_VOLUME:
control = serial.unpack(Control, bindata)
if control is None:
return
if self.config.custom_volume_cmd:
self.__ctrl_volume_custom(control.param)
else:
self.ctrl_volume(control.param)
elif id == message.CTRL_REPEAT:
self.ctrl_toggle_repeat()
elif id == message.CTRL_SHUFFLE:
self.ctrl_toggle_shuffle()
elif id == message.CTRL_RATE:
control = serial.unpack(Control, bindata)
if control is None:
return
self.ctrl_rate(control.param)
elif id == message.CTRL_TAG:
tag = serial.unpack(Tagging, bindata)
if tag is None:
return
self.ctrl_tag(tag.id, tag.tags)
elif id == message.CTRL_FULLSCREEN:
self.ctrl_toggle_fullscreen()
elif id == message.CTRL_SHUTDOWN:
self.__ctrl_shutdown_system()
else:
log.error("** BUG ** unexpected control message: %d" % id)
def __io_recv(self, fd, cond):
""" GObject callback function (when there is data to receive). """
log.debug("data from client %s available" % self)
# --- init buffers on new message -------------------------------------
if (self.__rcv_buff_header.rest + self.__rcv_buff_data.rest == 0):
self.__rcv_msg_id = message.IGNORE
self.__rcv_msg_size = 0 # will be set later
self.__rcv_buff_header.data = ""
self.__rcv_buff_header.rest = ClientConnection.IO_HEADER_LEN
self.__rcv_buff_data.data = ""
self.__rcv_buff_data.rest = 0 # will be set later
# --- receive header --------------------------------------------------
if self.__rcv_buff_header.rest > 0:
ok = self.__recv_buff(self.__rcv_buff_header)
if not ok:
return False
if self.__rcv_buff_header.rest > 0:
return True # more data to read, come back later
id, size = struct.unpack('!hi', self.__rcv_buff_header.data)
if size > ClientConnection.IO_MSG_MAX_SIZE:
log.warning("msg from %s too big (%d bytes)" % (self, size))
self.disconnect()
return False
log.debug("incoming msg: %d, %dB" % (id, size))
self.__rcv_buff_data.rest = size
self.__rcv_msg_id, self.__rcv_msg_size = id, size
if size > 0:
return True # more data to read, come back later
# --- receive content -------------------------------------------------
if self.__rcv_buff_data.rest > 0:
ok = self.__recv_buff(self.__rcv_buff_data)
if not ok:
return False
if self.__rcv_buff_data.rest > 0:
return True # more data to read, come back later
# --- message complete ------------------------------------------------
msg_id = self.__rcv_msg_id
msg_data = self.__rcv_buff_data.data
log.debug("incoming msg ")
if msg_id == message.IGNORE:
log.debug("received ignore msg (probably a ping)")
elif msg_id == message.CONN_SLEEP:
self.__psave = True
elif msg_id == message.CONN_WAKEUP:
self.__psave = False
self.__msg_handler_fn(self, message.PRIV_INITIAL_SYNC, None)
elif msg_id == message.CONN_CINFO:
log.debug("received client info from %s" % self)
serial.unpack(self.info, msg_data)
if not self in self.__clients: # initial client info
device = self.info.device.copy()
device["conn"] = self.__conn_type
report.log_device(device)
self.__clients.append(self)
log.debug("sending player info to %s" % self)
self.send(self.__pinfo_msg)
self.__msg_handler_fn(self, message.PRIV_INITIAL_SYNC, None)
else:
self.__msg_handler_fn(self, msg_id, msg_data)
return True
