Ejemplo n.º 1
0
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()
Ejemplo n.º 2
0
    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)
Ejemplo n.º 3
0
def constructServer(tp, bridge, ssl=False):
    server = JsonRpcServer(bridge)
    with attachedReactor(tp, server, ssl) as clientFactory:

        try:
            yield server, clientFactory
        finally:
            server.stop()
Ejemplo n.º 4
0
def constructServer(tp, bridge, ssl=False):
    server = JsonRpcServer(bridge)
    with attachedReactor(tp, server, ssl) as clientFactory:

        try:
            yield server, clientFactory
        finally:
            server.stop()
Ejemplo n.º 5
0
    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()
Ejemplo n.º 6
0
 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()
Ejemplo n.º 7
0
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()
Ejemplo n.º 8
0
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()
Ejemplo n.º 9
0
    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()
Ejemplo n.º 10
0
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()
Ejemplo n.º 11
0
    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
Ejemplo n.º 12
0
 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()
Ejemplo n.º 13
0
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()
Ejemplo n.º 14
0
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()
Ejemplo n.º 15
0
    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)
Ejemplo n.º 16
0
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()
Ejemplo n.º 17
0
    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
Ejemplo n.º 18
0
 def __init__(self, bridge, subs, timeout):
     self._server = JsonRpcServer(bridge, timeout, _simpleThreadFactory)
     self._reactor = StompReactor(subs)
     self.startReactor()
Ejemplo n.º 19
0
 def __init__(self, bridge):
     self._server = JsonRpcServer(bridge, _simpleThreadFactory)
     self._reactors = []
Ejemplo n.º 20
0
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()
Ejemplo n.º 21
0
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()