def handle_read(self): """ Stream incoming messages into MessagePack, and action them when ready. """ try: self.unpacker.feed(self.recv(1)) for message in self.unpacker: log.info("%s received: %s", self.name, message) # Attempt to call the requested method on the proxy. # try: method = message.keys()[0] try: getattr(self.proxy, method)(message[method]) except AttributeError as excp: log.error("Failed to call method %s: %s", method, excp) except AttributeError as excp: log.error("Failed to call a method: %s", excp) except socket.error as excp: log.error("Failed to receive: %s", excp)
def select_new(self): log.info("Perfoming new media select") with self.database: data = self.database.select_media_by_modified() return data
def select_like_media(self, term): log.info("Perfoming search with term: %s", term) with self.database: data = self.database.select_media_like_term(term) return data
def _open_connection(self): log.info("Opening database connection") self.connection = sqlite3.connect(self.database) self.connection.text_factory = str self.connection.row_factory = self._dictionary_factory self.cursor = self.connection.cursor()
def select_all_media(self): log.info("Perfoming all media select") with self.database: data = self.database.select_media() return data
def handle_read(self): """ Stream incoming messages into MessagePack and action them when ready. """ self.unpacker.feed(self.recv(1)) for message in self.unpacker: if not self.name: # The first message received from a new connection will be the # name of the client, which we can store and use in future to # access this connection. # try: Communicate.connections[message] = self self.name = message log.info("%s connected", self.name) except TypeError as excp: log.error("Failed to set name: %s", excp) else: log.info("Received from %s: %s", self.name, message) # Attempt to call the requested method on the proxy. # method = message.keys()[0] try: getattr(CommunicationServer.proxy, method)(message[method]) except AttributeError as excp: log.error("Failed to call method %s: %s", method, excp)
def handle_close(self): self.close() self.connected = False log.info("CommunicationClient closed") time.sleep(5) log.warn("Attempting to reconnect to server") self._connect()
def select_latest_viewed_by_show(self, show): log.info("Perfoming latest viewed select for show: %s", show) with self.database: data = self.database.select_latest_viewed_by_show(show) if data: return data["id"]
def __init__(self, client, proxy, host, port, name): super(CommunicationThread, self).__init__() log.info("CommunicationThread initialised") self.handler = CommunicationHandler(client, proxy, host, port, name) CommunicationThread.packer = self.handler.packer self.run = self.handler.run self._send_client = self.handler._send_client self._send_server = self.handler._send_server
def __init__(self, proxy, host, port, name, qthread=False): asyncore.dispatcher.__init__(self) log.info("CommunicationClient initialised") self.unpacker = msgpack.Unpacker() self.proxy = proxy() self.host = host self.port = port self.name = name self.qthread = qthread self._connect()
def select_viewed(self, media_id=None): log.info("Perfoming viewed media select") with self.database: if media_id: data = self.database.select_viewed_by_id(media_id) if data: data = data[0] else: data = self.database.select_viewed() return data
def _send_server(self, names, message): """ Send a message to the named connection(s). """ try: for name in names: connection = Communicate.connections[name] connection.send(self.packer.pack(message)) log.info("Sent to %s: %s", name, message) except (KeyError, RuntimeError) as excp: log.error("Send failed: %s", excp) return False return True
def __init__(self, proxy, host, port): asyncore.dispatcher.__init__(self) log.info("CommunicationServer initialised") CommunicationServer.proxy = proxy() self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.set_reuse_addr() try: self.bind((host, port)) except socket.error as excp: log.error("Failed to bind socket: %s", excp) raise log.warn("Listening on port: %s", port) self.listen(5)
def select_media(self, media_id): log.info("Perfoming media ID select: %s", media_id) data = {} for key in self._cache.keys(): data = self._cache[key].get(media_id, {}) if data: break if data: log.info("Returning media select from cache") return data with self.database: data = self.database.select_media_by_id(media_id) if data.get(media_id): category = data[media_id]["category"] if not self._cache.get(category): self._cache[category] = {} self._cache[category][media_id] = data[media_id] log.info("Returning media select from database") return data.get(media_id)
def select_next_tracks(self, media_id): log.info("Perfoming select next tracks for media: %s", media_id) try: media_id = int(media_id) with self.database: data = self.database.select_media_by_id(media_id)[media_id] except Exception as excp: log.error("Select next tracks failed: %s", excp) return [] if data["category"] != "Music": return [] artist = data["name_one"] album = data["name_two"] with self.database: data = self.database.select_tracks(artist, album) return data
def _send_client(self, message): """ Check for an active connection and then send a message to the server. """ try: # Check that we are connected. if self.connection.connected: # Write the message to the buffer so that it will be sent. self.connection.buffer_ = self.packer.pack(message) log.info("%s buffered: %s", self.name, message) else: log.error("Send failed: No active connection found") return False except AttributeError as excp: log.error("Send failed: %s", excp) return False return True
def select_category(self, category): log.info("Perfoming category select: %s", category) data = self._cache.get(category, {}) if data: log.info("Returning category select from cache") return data with self.database: data = self.database.select_media_by_category(category) self._cache[category] = data log.info("Returning category select from database") return data
def empty_queue(self): log.info("Emptying queue") self._queue = []
def _close_connection(self): log.info("Closing database connection") self.connection.commit() self.cursor.close() self.connection.close()