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 constructServer(tp, bridge, ssl=False):
server = JsonRpcServer(bridge)
with attachedReactor(tp, server, ssl) as clientFactory:
try:
yield server, clientFactory
finally:
server.stop()
def constructServer(tp, bridge, ssl=False):
server = JsonRpcServer(bridge)
with attachedReactor(tp, server, ssl) as clientFactory:
try:
yield server, clientFactory
finally:
server.stop()
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",
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 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 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()
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()
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()
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()
