class MonitorServer(object):
monitor = None
server = None
logger = None
def __init__(self, monitor):
self.logger = logging.getLogger(self.__class__.__name__)
self.monitor = monitor
def _register_func(self, func):
def wrap(fun, *args, **kwargs):
try:
return True, fun(*args, **kwargs)
except Exception as e:
if isinstance(e, MonitorException):
return False, e.message
else:
import traceback
self.logger.error("%s" % traceback.format_exc())
raise e
partial_func = partial(wrap, func)
update_wrapper(partial_func, func)
self.server.register_function(partial_func)
def start(self):
self.logger.info("Starting...")
self.server = SimpleJSONRPCServer(('localhost', 8080),
logRequests=False)
for maybeCommand in self.monitor.__class__.__dict__.values():
if hasattr(maybeCommand, 'is_command'):
command_name = maybeCommand.__name__
self.logger.debug("Registering command %s" % command_name)
command = getattr(self.monitor, command_name)
self._register_func(command)
def stop(self):
if self.server:
self.logger.info("Stopping server")
self.server.shutdown()
self.server.server_close()
def serve_forever(self):
self.logger.info("Entering main loop")
self.server.serve_forever()
class MockRPCServiceProvider(Thread):
"""Implement a mock of a remote 3rd party JSON-RPC service provider."""
url = ('localhost', 8484)
messages = []
name = ''
ident = 0
def __init__(self, *args, **kwargs):
Thread.__init__(self)
self.server = SimpleJSONRPCServer(self.url)
self.server.register_function(self.push, 'push')
self.server.verbose = False
self.messages = []
def run(self):
logging.debug("MockRPCServiceProvider thread %i start" % self.ident)
try:
self.server.serve_forever()
except:
pass
logging.debug("MockRPCServiceProvider thread %i exit" % self.ident)
exit()
def stop(self):
logging.debug("Stop MockRPCServiceProvider")
self.server.shutdown()
self.server.server_close()
def register_function(self,*args,**kwargs):
return self.server.register_function(*args,**kwargs)
def push(self, msg, *args):
logging.debug("saving message: %s" % msg)
self.messages.append(msg)
return "ok"
def get_messages(self):
return self.messages
def test_host_only(self):
"""
Starts a Unix socket server, giving with a relative path to the socket
"""
# Ensure we have a new socket
socket_name = "test_local.socket"
if os.path.exists(socket_name):
os.remove(socket_name)
# Use a random int as result
awaited_result = random.randint(1, 100)
try:
# Prepare the server
srv = SimpleJSONRPCServer(socket_name,
address_family=socket.AF_UNIX)
srv.register_function(lambda: awaited_result, "test")
# Run the server in a thread
thread = threading.Thread(target=srv.serve_forever)
thread.start()
try:
# Run the request
client = ServerProxy("unix+http://{}".format(socket_name))
result = client.test()
self.assertEqual(result, awaited_result)
finally:
# Stop the server
srv.shutdown()
srv.server_close()
thread.join(5)
finally:
# Clean up
try:
os.remove(socket_name)
except:
pass
class JSONRPCServer(SingletonClass):
def __initialize__(self, context_root='/', server_port=8181):
SimpleJSONRPCRequestHandler.log_request = log_request
SimpleJSONRPCRequestHandler.rpc_paths = (context_root)
self.server = SimpleJSONRPCServer(('', server_port))
def registerService(self, serviceName, function):
self.server.register_function(function, name=serviceName)
def start(self):
self.server_proc = Thread(target=self.server.serve_forever)
self.server_proc.daemon = True
self.server_proc.start()
self.started = True
def stop(self):
try:
if self.started:
self.server.shutdown()
self.server.server_close()
except:
pass
