139 lines
4.3 KiB
Python
139 lines
4.3 KiB
Python
import importlib
|
|
import logging
|
|
import sys
|
|
import threading
|
|
|
|
from threading import Thread
|
|
|
|
from platypush.bus import Bus
|
|
from platypush.config import Config
|
|
from platypush.utils import get_message_class_by_type
|
|
from platypush.message import Message
|
|
from platypush.message.event import Event, StopEvent
|
|
from platypush.message.request import Request
|
|
from platypush.message.response import Response
|
|
|
|
class Backend(Thread):
|
|
""" Parent class for backends """
|
|
|
|
def __init__(self, bus=None, **kwargs):
|
|
"""
|
|
Params:
|
|
bus -- Reference to the Platypush bus where the requests and the
|
|
responses will be posted [Bus]
|
|
kwargs -- key-value configuration for this backend [Dict]
|
|
"""
|
|
|
|
# If no bus is specified, create an internal queue where
|
|
# the received messages will be pushed
|
|
self.bus = bus if bus else Bus()
|
|
self.device_id = Config.get('device_id')
|
|
self.thread_id = None
|
|
self._stop = False
|
|
|
|
Thread.__init__(self)
|
|
logging.basicConfig(stream=sys.stdout, level=Config.get('logging')
|
|
if 'logging' not in kwargs
|
|
else getattr(logging, kwargs['logging']))
|
|
|
|
|
|
def on_message(self, msg):
|
|
"""
|
|
Callback when a message is received on the backend.
|
|
It parses and posts the message on the main bus.
|
|
It should be called by the derived classes whenever
|
|
a new message should be processed.
|
|
|
|
Params:
|
|
msg -- The message. It can be either a key-value
|
|
dictionary, a platypush.message.Message
|
|
object, or a string/byte UTF-8 encoded string
|
|
"""
|
|
|
|
msg = Message.parse(msg)
|
|
if 'type' not in msg:
|
|
logging.warning('Ignoring message with no type: {}'.format(msg))
|
|
return
|
|
|
|
msgtype = get_message_class_by_type(msg['type'])
|
|
msg = msgtype.build(msg)
|
|
|
|
if not getattr(msg, 'target') or msg.target != self.device_id:
|
|
return # Not for me
|
|
|
|
logging.info('Message received on the {} backend: {}'.format(
|
|
self.__class__.__name__, msg))
|
|
|
|
msg.backend = self # Augment message
|
|
|
|
if isinstance(msg, StopEvent) and msg.targets_me():
|
|
logging.info('Received STOP event on the {} backend: {}'.format(
|
|
self.__class__.__name__, msg))
|
|
self._stop = True
|
|
else:
|
|
self.bus.post(msg)
|
|
|
|
def send_request(self, request):
|
|
"""
|
|
Send a request message on the backend
|
|
Params:
|
|
request -- The request, either a dict, a string/bytes UTF-8 JSON,
|
|
or a platypush.message.request.Request object
|
|
"""
|
|
|
|
request = Request.build(request)
|
|
assert isinstance(request, Request)
|
|
|
|
request.origin = self.device_id
|
|
self.send_message(request)
|
|
|
|
def send_response(self, response):
|
|
"""
|
|
Send a response message on the backend
|
|
Params:
|
|
response -- The response, either a dict, a string/bytes UTF-8 JSON,
|
|
or a platypush.message.response.Response object
|
|
"""
|
|
|
|
response = Response.build(response)
|
|
assert isinstance(response, Response)
|
|
|
|
response.origin = self.device_id
|
|
self.send_message(response)
|
|
|
|
|
|
def send_message(self, msg):
|
|
"""
|
|
Sends a platypush.message.Message to a node.
|
|
To be implemented in the derived classes.
|
|
Always call send_request or send_response instead of send_message directly
|
|
|
|
Param:
|
|
msg -- The message
|
|
"""
|
|
|
|
raise NotImplementedError("send_message should be implemented in a derived class")
|
|
|
|
def run(self):
|
|
""" Starts the backend thread. To be implemented in the derived classes """
|
|
self.thread_id = threading.get_ident()
|
|
|
|
def on_stop(self):
|
|
""" Callback invoked when the process stops """
|
|
pass
|
|
|
|
def stop(self):
|
|
""" Stops the backend thread by sending a STOP event on its bus """
|
|
evt = StopEvent(target=self.device_id, origin=self.device_id,
|
|
thread_id=self.thread_id)
|
|
|
|
self.send_message(evt)
|
|
self.on_stop()
|
|
|
|
def should_stop(self):
|
|
return self._stop
|
|
|
|
|
|
# vim:sw=4:ts=4:et:
|
|
|