class BindingJsonRpc(object): log = logging.getLogger('BindingJsonRpc') def __init__(self, bridge, subs, timeout): self._server = JsonRpcServer(bridge, timeout, _simpleThreadFactory) self._reactor = StompReactor(subs) self.startReactor() def add_socket(self, reactor, client_socket): reactor.createListener(client_socket, self._onAccept) def _onAccept(self, client): client.set_message_handler(self._server.queueRequest) @property def reactor(self): return self._reactor def start(self): t = threading.Thread(target=self._server.serve_requests, name='JsonRpcServer') t.setDaemon(True) t.start() def startReactor(self): reactorName = self._reactor.__class__.__name__ t = threading.Thread(target=self._reactor.process_requests, name='JsonRpc (%s)' % reactorName) t.setDaemon(True) t.start() def stop(self): self._server.stop() self._reactor.stop()
def test_full_pool(self): def thread_factory(callable): raise exception.ResourceExhausted("Too many tasks", resource="test", current_tasks=0) ctx = FakeContext() request = JsonRpcRequest.decode( '{"jsonrpc":"2.0","method":"Host.stats","params":{},"id":"943"}') server = JsonRpcServer(None, 0, None, threadFactory=thread_factory) server._runRequest(ctx, request) error = ctx.response.toDict().get('error') self.assertEqual(1100, error.get('code')) msg = error.get('message') self.assertTrue(msg.startswith("Not enough resources:")) # not deterministic order in a dict so we need to parse reason = json.loads(msg[22:].replace("'", '"')) self.assertEqual( { "reason": "Too many tasks", "resource": "test", "current_tasks": 0 }, reason)
def constructServer(tp, bridge, ssl=False): server = JsonRpcServer(bridge) with attachedReactor(tp, server, ssl) as clientFactory: try: yield server, clientFactory finally: server.stop()
def __init__(self, bridge, subs, timeout, scheduler): self._executor = executor.Executor(name="jsonrpc.Executor", workers_count=_THREADS, max_tasks=_TASKS, scheduler=scheduler) self._server = JsonRpcServer(bridge, timeout, self._executor.dispatch) self._reactor = StompReactor(subs) self.startReactor()
def __init__(self, bridge, subs, timeout, scheduler, cif): self._executor = executor.Executor(name="jsonrpc", workers_count=_THREADS, max_tasks=_TASKS, scheduler=scheduler) self._bridge = bridge self._server = JsonRpcServer( bridge, timeout, cif, functools.partial(self._executor.dispatch, timeout=_TIMEOUT, discard=False)) self._reactor = StompReactor(subs) self.startReactor()
class BindingJsonRpc(object): log = logging.getLogger('BindingJsonRpc') def __init__(self, bridge, subs, timeout, scheduler, cif): self._executor = executor.Executor(name="jsonrpc", workers_count=_THREADS, max_tasks=_TASKS, scheduler=scheduler) self._bridge = bridge self._server = JsonRpcServer( bridge, timeout, cif, functools.partial(self._executor.dispatch, timeout=_TIMEOUT, discard=False)) self._reactor = StompReactor(subs) self.startReactor() def add_socket(self, reactor, client_socket): reactor.createListener(client_socket, self._onAccept) def _onAccept(self, client): client.set_message_handler(self._server.queueRequest) @property def reactor(self): return self._reactor @property def bridge(self): return self._bridge def start(self): self._executor.start() t = concurrent.thread(self._server.serve_requests, name='JsonRpcServer') t.start() def startReactor(self): reactorName = self._reactor.__class__.__name__ t = concurrent.thread(self._reactor.process_requests, name='JsonRpc (%s)' % reactorName) t.start() def stop(self): self._server.stop() self._reactor.stop() self._executor.stop()
class BindingJsonRpc(object): log = logging.getLogger('BindingJsonRpc') def __init__(self, bridge, subs, timeout, scheduler, cif): self._executor = executor.Executor(name="jsonrpc.Executor", workers_count=_THREADS, max_tasks=_TASKS, scheduler=scheduler) self._server = JsonRpcServer(bridge, timeout, cif, self._executor.dispatch) self._reactor = StompReactor(subs) self.startReactor() def add_socket(self, reactor, client_socket): reactor.createListener(client_socket, self._onAccept) def _onAccept(self, client): client.set_message_handler(self._server.queueRequest) @property def reactor(self): return self._reactor def start(self): self._executor.start() t = threading.Thread(target=self._server.serve_requests, name='JsonRpcServer') t.setDaemon(True) t.start() def startReactor(self): reactorName = self._reactor.__class__.__name__ t = threading.Thread(target=self._reactor.process_requests, name='JsonRpc (%s)' % reactorName) t.setDaemon(True) t.start() def stop(self): self._server.stop() self._reactor.stop() self._executor.stop()
def __init__(self, bridge, backendConfig, truststore_path=None): reactors = {} self.bridge = bridge self.server = JsonRpcServer(bridge, _simpleThreadFactory) self._cfg = backendConfig for backendType, cfg in backendConfig: if backendType not in reactors: if backendType == "tcp": reactors["tcp"] = self._createTcpReactor(truststore_path) elif backendType == "stomp": reactors["stomp"] = \ self._createStompReactor(truststore_path) elif backendType == "amqp": if ProtonReactor is None: continue reactors["amqp"] = self._createProtonReactor() self._reactors = reactors
def constructServer(tp, bridge): queue = Queue() server = JsonRpcServer(bridge, queue) with constructReactor(tp) as (reactor, clientFactory, laddr): def _accept(listener, client): client.setInbox(queue) reactor.createListener(laddr, _accept) t = threading.Thread(target=server.serve_requests) t.setDaemon(True) t.start() def jsonClientFactory(): return JsonRpcClient(clientFactory()) try: yield server, jsonClientFactory finally: server.stop()
def test_full_pool(self): def thread_factory(callable): raise exception.ResourceExhausted("Too many tasks", resource="test", current_tasks=0) ctx = FakeContext() request = JsonRpcRequest.decode( '{"jsonrpc":"2.0","method":"Host.stats","params":{},"id":"943"}') server = JsonRpcServer(None, 0, None, threadFactory=thread_factory) server._runRequest(ctx, request) error = ctx.response.toDict().get('error') self.assertEqual(1100, error.get('code')) msg = error.get('message') self.assertTrue(msg.startswith("Not enough resources:")) # not deterministic order in a dict so we need to parse reason = json.loads(msg[22:].replace("'", '"')) self.assertEqual({"reason": "Too many tasks", "resource": "test", "current_tasks": 0}, reason)
class BindingJsonRpc(object): log = logging.getLogger('BindingJsonRpc') def __init__(self, bridge): self._server = JsonRpcServer(bridge, _simpleThreadFactory) self._reactors = [] def add_socket(self, reactor, client_socket): reactor.createListener(client_socket, self._onAccept) def _onAccept(self, listener, client): client.setMessageHandler(self._server.queueRequest) def createStompReactor(self): reactor = StompReactor() self._reactors.append(reactor) self.startReactor(reactor) return reactor def start(self): t = threading.Thread(target=self._server.serve_requests, name='JsonRpcServer') t.setDaemon(True) t.start() def startReactor(self, reactor): reactorName = reactor.__class__.__name__ t = threading.Thread(target=reactor.process_requests, name='JsonRpc (%s)' % reactorName) t.setDaemon(True) t.start() def stop(self): self._server.stop() for reactor in self._reactors: reactor.stop()
def __init__(self, bridge, backendConfig, truststore_path=None): reactors = {} self.bridge = bridge self.server = JsonRpcServer(bridge, _simpleThreadFactory) self._cfg = backendConfig for backendType, cfg in backendConfig: if backendType not in reactors: if backendType == "tcp": reactors["tcp"] = self._createTcpReactor(truststore_path) elif backendType == "amqp": if ProtonReactor is None: continue reactors["amqp"] = self._createProtonReactor() self._reactors = reactors
def __init__(self, bridge, subs, timeout): self._server = JsonRpcServer(bridge, timeout, _simpleThreadFactory) self._reactor = StompReactor(subs) self.startReactor()
def __init__(self, bridge): self._server = JsonRpcServer(bridge, _simpleThreadFactory) self._reactors = []
class BindingJsonRpc(object): log = logging.getLogger('BindingJsonRpc') def __init__(self, bridge, backendConfig, truststore_path=None): reactors = {} self.bridge = bridge self.server = JsonRpcServer(bridge, _simpleThreadFactory) self._cfg = backendConfig for backendType, cfg in backendConfig: if backendType not in reactors: if backendType == "tcp": reactors["tcp"] = self._createTcpReactor(truststore_path) elif backendType == "stomp": reactors["stomp"] = \ self._createStompReactor(truststore_path) elif backendType == "amqp": if ProtonReactor is None: continue reactors["amqp"] = self._createProtonReactor() self._reactors = reactors def _createTcpListener(self, cfg): address = cfg.get("ip", "0.0.0.0") try: port = cfg["port"] except KeyError: raise ValueError("cfg") return self._reactors["tcp"].createListener((address, port), self._onAccept) def _createStompListener(self, cfg): address = cfg.get("ip", "0.0.0.0") try: port = cfg["port"] except KeyError: raise ValueError("cfg") return self._reactors["stomp"].createListener((address, port), self._onAccept) def _onAccept(self, listener, client): client.setMessageHandler(self.server.queueRequest) def _createProtonListener(self, cfg): address = cfg.get("host", "0.0.0.0") port = cfg.get("port", 5672) return self._reactors["amqp"].createListener((address, port)) def _createTcpReactor(self, truststore_path=None): if truststore_path is None: return AsyncoreReactor() else: key_file = truststore_path + '/keys/vdsmkey.pem' cert_file = truststore_path + '/certs/vdsmcert.pem' ca_cert = truststore_path + '/certs/cacert.pem' return AsyncoreReactor(SSLContext(cert_file, key_file, ca_cert)) def _createStompReactor(self, truststore_path=None): if truststore_path is None: return StompReactor() else: key_file = truststore_path + '/keys/vdsmkey.pem' cert_file = truststore_path + '/certs/vdsmcert.pem' ca_cert = truststore_path + '/certs/cacert.pem' return StompReactor(SSLContext(cert_file, key_file, ca_cert)) def _createProtonReactor(self): return ProtonReactor() def start(self): t = threading.Thread(target=self.server.serve_requests, name='JsonRpcServer') t.setDaemon(True) t.start() for reactor in self._reactors.itervalues(): reactorName = reactor.__class__.__name__ t = threading.Thread(target=reactor.process_requests, name='JsonRpc (%s)' % reactorName) t.setDaemon(True) t.start() for backendType, cfg in self._cfg: try: if backendType == "tcp": self._createTcpListener(cfg) if backendType == "stomp": self._createStompListener(cfg) elif backendType == "amqp": self._createProtonListener(cfg) except: # TBD: propegate error and crash VDSM self.log.warning("Could not listen on reactor '%s'", reactorName, exc_info=True) def prepareForShutdown(self): self.server.stop() for reactor in self._reactors.itervalues(): reactor.stop()
class BindingJsonRpc(object): log = logging.getLogger('BindingJsonRpc') def __init__(self, bridge, backendConfig, truststore_path=None): reactors = {} self.bridge = bridge self.server = JsonRpcServer(bridge, _simpleThreadFactory) self._cfg = backendConfig for backendType, cfg in backendConfig: if backendType not in reactors: if backendType == "tcp": reactors["tcp"] = self._createTcpReactor(truststore_path) elif backendType == "amqp": if ProtonReactor is None: continue reactors["amqp"] = self._createProtonReactor() self._reactors = reactors def _createTcpListener(self, cfg): address = cfg.get("ip", "0.0.0.0") try: port = cfg["port"] except KeyError: raise ValueError("cfg") return self._reactors["tcp"].createListener((address, port), self._onAccept) def _onAccept(self, listener, client): client.setMessageHandler(self.server.queueRequest) def _createProtonListener(self, cfg): address = cfg.get("host", "0.0.0.0") port = cfg.get("port", 5672) return self._reactors["amqp"].createListener((address, port)) def _createTcpReactor(self, truststore_path=None): if truststore_path is None: return AsyncoreReactor() else: key_file = truststore_path + '/keys/vdsmkey.pem' cert_file = truststore_path + '/certs/vdsmcert.pem' ca_cert = truststore_path + '/certs/cacert.pem' return AsyncoreReactor(SSLContext(cert_file, key_file, ca_cert)) def _createProtonReactor(self): return ProtonReactor() def start(self): t = threading.Thread(target=self.server.serve_requests, name='JsonRpcServer') t.setDaemon(True) t.start() for reactor in self._reactors.itervalues(): reactorName = reactor.__class__.__name__ t = threading.Thread(target=reactor.process_requests, name='JsonRpc (%s)' % reactorName) t.setDaemon(True) t.start() for backendType, cfg in self._cfg: try: if backendType == "tcp": self._createTcpListener(cfg) elif backendType == "amqp": self._createProtonListener(cfg) except: # TBD: propegate error and crash VDSM self.log.warning("Could not listen on reactor '%s'", reactorName, exc_info=True) def prepareForShutdown(self): self.server.stop() for reactor in self._reactors.itervalues(): reactor.stop()