def __init__(self, worker):
log.msg("Initializing auto server")
#
# Setup the zmq socket used for receiving images.
#
self.zmq_factory = ZmqFactory()
#
# Socket for pulling images and crops from the automatic client.
#
endpoint = ZmqEndpoint(
'connect', 'tcp://localhost:{zmq_port}'.format(
zmq_port=gs.ZMQ_AUTO_WORKER_PUSH))
self.pull_socket = ZmqPullConnection(self.zmq_factory, endpoint)
self.pull_socket.onPull = self.handleNewMessage
#
# Socket for pushing results to the automatic client.
#
endpoint = ZmqEndpoint(
'connect', 'tcp://localhost:{zmq_port}'.format(
zmq_port=gs.ZMQ_AUTO_WORKER_PULL))
self.push_socket = ZmqPushConnection(self.zmq_factory, endpoint)
self.worker = worker
class ZmqAuthTestCase(unittest.TestCase, BaseLeapTest):
def setUp(self):
self.factory = ZmqFactory()
self._config_prefix = os.path.join(self.tempdir, "leap", "events")
self.public, self.secret = maybe_create_and_get_certificates(
self._config_prefix, 'server')
self.authenticator = auth.TxAuthenticator(self.factory)
self.authenticator.start()
self.auth_req = auth.TxAuthenticationRequest(self.factory)
def tearDown(self):
self.factory.shutdown()
def test_curve_auth(self):
self.auth_req.start()
self.auth_req.allow('127.0.0.1')
public_keys_dir = os.path.join(self._config_prefix, PUBLIC_KEYS_PREFIX)
self.auth_req.configure_curve(domain="*", location=public_keys_dir)
def check(ignored):
authenticator = self.authenticator.authenticator
certs = authenticator.certs['*']
self.failUnlessEqual(authenticator.whitelist, set([u'127.0.0.1']))
self.failUnlessEqual(certs[certs.keys()[0]], True)
return _wait(0.1).addCallback(check)
class ZmqAuthTestCase(unittest.TestCase, BaseLeapTest):
def setUp(self):
self.factory = ZmqFactory()
self._config_prefix = os.path.join(self.tempdir, "leap", "events")
self.public, self.secret = maybe_create_and_get_certificates(
self._config_prefix, 'server')
self.authenticator = auth.TxAuthenticator(self.factory)
self.authenticator.start()
self.auth_req = auth.TxAuthenticationRequest(self.factory)
def tearDown(self):
self.factory.shutdown()
def test_curve_auth(self):
self.auth_req.start()
self.auth_req.allow('127.0.0.1')
public_keys_dir = os.path.join(self._config_prefix, PUBLIC_KEYS_PREFIX)
self.auth_req.configure_curve(domain="*", location=public_keys_dir)
def check(ignored):
authenticator = self.authenticator.authenticator
certs = authenticator.certs['*']
self.failUnlessEqual(authenticator.whitelist, set([u'127.0.0.1']))
self.failUnlessEqual(certs[certs.keys()[0]], True)
return _wait(0.1).addCallback(check)
def __init__(self, app):
#
# Setup the zmq socket used for receiving images.
#
self.zmq_factory = ZmqFactory()
#
# Socket for pushing images and crops to the automatic processing servers.
#
endpoint = ZmqEndpoint(
'bind',
'tcp://*:{zmq_port}'.format(zmq_port=gs.ZMQ_AUTO_WORKER_PUSH))
self.push_socket = ZmqPushConnection(self.zmq_factory, endpoint)
#
# Socket for pulling results from the automatic processing servers.
#
endpoint = ZmqEndpoint(
'bind',
'tcp://*:{zmq_port}'.format(zmq_port=gs.ZMQ_AUTO_WORKER_PULL))
self.pull_socket = ZmqPullConnection(self.zmq_factory, endpoint)
self.pull_socket.onPull = self.handleNewMessage
self.app = app
def __init__(self, config, dbengine, radcache=None):
self.config = config
self.dict = dictionary.Dictionary(
os.path.join(os.path.dirname(toughradius.__file__),
'dictionarys/dictionary'))
self.db_engine = dbengine or get_engine(config)
self.mcache = radcache
self.pusher = ZmqPushConnection(
ZmqFactory(),
ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-result'))
self.stat_pusher = ZmqPushConnection(
ZmqFactory(), ZmqEndpoint('connect',
'ipc:///tmp/radiusd-stat-task'))
self.puller = ZmqPullConnection(
ZmqFactory(),
ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-message'))
self.puller.onPull = self.process
logger.info("init acct worker pusher : %s " % (self.pusher))
logger.info("init acct worker puller : %s " % (self.puller))
logger.info("init auth stat pusher : %s " % (self.stat_pusher))
self.acct_class = {
STATUS_TYPE_START: RadiusAcctStart,
STATUS_TYPE_STOP: RadiusAcctStop,
STATUS_TYPE_UPDATE: RadiusAcctUpdate,
STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff
}
def __init__(self, config, service = 'auth'):
self.config = config
self.service = service
self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_message']))
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_result']))
self.puller.onPull = self.radiusReply
logger.info('%s master message bind @ %s' % (self.service, self.pusher))
logger.info('%s master result bind @ %s' % (self.service, self.puller))
def __init__(self, config, service='auth'):
self.config = config
self.service = service
self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/radiusd-%s-message' % service))
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/radiusd-%s-result' % service))
self.puller.onPull = self.reply
logger.info("init %s master pusher : %s " % (self.service, self.pusher))
logger.info("init %s master puller : %s " % (self.service, self.puller))
def setUp(self):
self.factory = ZmqFactory()
self._config_prefix = os.path.join(self.tempdir, "leap", "events")
self.public, self.secret = maybe_create_and_get_certificates(
self._config_prefix, 'server')
self.authenticator = auth.TxAuthenticator(self.factory)
self.authenticator.start()
self.auth_req = auth.TxAuthenticationRequest(self.factory)
class ZmqConsumer(service.Service):
def __init__(self, store, zmq_endpoints):
self.store = store
self.endpoints = zmq_endpoints
self._socket = None
self._factory = None
def startService(self):
self._factory = ZmqFactory()
endpoints = [
ZmqEndpoint(ZmqEndpointType.connect, endpoint)
for endpoint in self.endpoints
]
log.msg("Configuring ZeroMQ subscription socket",
logLevel=logging.DEBUG)
for endpoint in endpoints:
log.msg("Connecting to the {endpoint} ZeroMQ endpoint".format(
endpoint=endpoint))
s = ZmqSubConnection(self._factory, endpoint)
s.subscribe(b"")
s.gotMessage = self.on_message
log.msg("ZeroMQ consumer is ready")
def on_message(self, body, topic):
topic = topic.decode("utf-8")
msg = json.loads(body)
if "msg_id" not in msg:
log.msg(
"Received a message without a msg_id from ZeroMQ on topic {topic}"
.format(topic=topic),
logLevel=logging.INFO,
)
return
msg_id = msg["msg_id"]
log.msg(
"Received from ZeroMQ on topic {topic}: {msgid}".format(
topic=topic, msgid=msg["msg_id"]),
logLevel=logging.DEBUG,
)
msg_id = YEAR_PREFIX_RE.sub("", msg_id)
if msg_id in self.store:
log.msg(
"Received a duplicate ZeroMQ message with id {msg_id} on topic {topic}"
.format(msg_id=msg_id, topic=topic),
logLevel=logging.INFO,
)
return
self.store[msg_id] = (datetime.utcnow(), msg)
def stopService(self):
log.msg("Stopping ZmqConsumer", logLevel=logging.DEBUG)
if self._factory.connections is not None:
self._factory.shutdown()
def __init__(self, config, log=None):
self.config = config
self.log = log
self.protocol = 'http'
self.cache = mcache.Mcache()
self.zauth_conn = ZmqREQConnection(ZmqFactory())
self.zacct_conn = ZmqREQConnection(ZmqFactory())
self.init_client().addCallback(self.log.info)
reactor.callLater(
1.0,
self.check_api,
)
def setUp(self):
flags.set_events_enabled(True)
self.factory = ZmqFactory()
self._server = server.ensure_server(emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0",
factory=self.factory,
enable_curve=False)
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port,
factory=self.factory,
enable_curve=False)
def __init__(self, config, dbengine, radcache=None):
self.config = config
self.dict = dictionary.Dictionary(
os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
self.db_engine = dbengine or get_engine(config)
self.aes = utils.AESCipher(key=self.config.system.secret)
self.mcache = radcache
self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-result'))
self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-message'))
self.puller.onPull = self.process
reactor.listenUDP(0, self)
logger.info("init auth worker pusher : %s " % (self.pusher))
logger.info("init auth worker puller : %s " % (self.puller))
logger.info("init auth stat pusher : %s " % (self.stat_pusher))
def startService(self):
self._factory = ZmqFactory()
endpoints = [
ZmqEndpoint(ZmqEndpointType.connect, endpoint)
for endpoint in self.endpoints
]
log.msg("Configuring ZeroMQ subscription socket",
logLevel=logging.DEBUG)
for endpoint in endpoints:
log.msg("Connecting to the {endpoint} ZeroMQ endpoint".format(
endpoint=endpoint))
s = ZmqSubConnection(self._factory, endpoint)
s.subscribe(b"")
s.gotMessage = self.on_message
log.msg("ZeroMQ consumer is ready")
def __init__(self, taskd, **kwargs):
TaseBasic.__init__(self, taskd, **kwargs)
self.flow_stat = {}
self.statdata = self.cache.get(radius_statcache_key) or statistics.MessageStat(quemax=180)
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', self.config.mqproxy['task_bind']))
self.puller.onPull = self.update_stat
logger.info('start stat mq %s' % self.puller)
def startService(self):
zf = ZmqFactory()
e = ZmqEndpoint(ZmqEndpointType.bind, ENDPOINT)
self._conn = _DispatcherREPConnection(zf, e, self._core)
reactor.callWhenRunning(self._conn.do_greet)
service.Service.startService(self)
def main(config):
zmq_requests_factory = ZmqFactory()
zmq_requests_endpoint = ZmqEndpoint(ZmqEndpointType.bind,
config['endpoint.command'])
zmq_requests = ZmqRequests(zmq_requests_factory, zmq_requests_endpoint)
zmq_broadcast_factory = ZmqFactory()
zmq_broadcast_endpoint = ZmqEndpoint(ZmqEndpointType.bind,
config['endpoint.broadcast'])
zmq_broadcast = ZmqPubConnection(zmq_broadcast_factory,
zmq_broadcast_endpoint)
api_endpoint = TCP4ClientEndpoint(reactor, config['ibtws.host'],
config['ibtws.port'])
api_endpoint.connect(IBTWSProtocolFactory(zmq_requests, zmq_broadcast))
reactor.run()
def onConnect(self, request):
global pub_sock
if pub_sock is not None:
zf = ZmqFactory()
e = ZmqEndpoint(ZmqEndpointType.connect, pub_sock)
s = ZmqSubConnection(zf, e)
s.gotMessage = lambda payload, topic: self.gotMessage(
payload, topic)
self._zmq = s
self._guards = {}
self._filters = []
# By default, subscribe messages from the current path and below
default_filter = get_physical_path_from_vhm_path(
self._environ["PATH_INFO"])
logger.debug("SUBSCRIBE " + default_filter)
self._zmq.subscribe(default_filter.encode('utf-8'))
self._filters.append(default_filter)
# Cleanup inherited environ
self._environ["HTTP_CONNECTION"] = "keep-alive"
for env in [
"HTTP_UPGRADE",
"HTTP_SEC_WEBSOCKET_EXTENSIONS",
"HTTP_SEC_WEBSOCKET_KEY",
"HTTP_SEC_WEBSOCKET_VERSION",
"wsgi.errors",
"wsgi.input",
]:
if env in self._environ:
del self._environ[env]
def __init__(self, config, dbengine, **kwargs):
self.config = config
self.que = deque()
self.db_engine = dbengine or get_engine(config, pool_size=30)
self.cache = CacheManager(redis_conf(config),
cache_name='SyncdCache-%s' % os.getpid())
self.metadata = models.get_metadata(self.db_engine)
self.tables = {
_name: _table
for _name, _table in self.metadata.tables.items()
}
self.master_bind = ZmqREPConnection(
ZmqFactory(), ZmqEndpoint('bind', config.ha.master))
self.master_bind.gotMessage = self.dataReceived
self.sync_task = HaSyncTask(config, self.db_engine, self.cache)
self.ops = {
'add': self.do_add,
'update': self.do_update,
'delete': self.do_delete
}
self.process()
logger.info(u'启动HA同步服务: [Master] {} ～ [Slave] {}'.format(
self.config.ha.master, self.config.ha.slave))
if not kwargs.get('standalone'):
self.logtrace = log_trace.LogTrace(redis_conf(config))
if 'elasticsearch' in config:
dispatch.register(eslogapi.EslogApi(config.elasticsearch))
def __init__(self, reactor, screen_ui, audio_player, first_block_hash):
f = ZmqFactory()
f.reactor = reactor
e = ZmqEndpoint("connect", "tcp://127.0.0.1:28332")
s = ZmqSubConnection(f, e)
s.subscribe("hashblock".encode("utf-8"))
s.messageReceived = self.listener
self.screen_ui = screen_ui
self.new_block_queue = []
self.queue_running = False
self.audio_player = audio_player
new_block = NewBlock(self, first_block_hash, self.screen_ui,
audio_player)
self.new_block_queue.append(new_block)
self._try_next()
def __init__(self, miner):
# create a factory
self.miner = miner
self.factory = ZmqFactory()
# create a connection to publish
publish_endpoint = ZmqEndpoint(ZmqEndpointType.bind,
"tcp://127.0.0.1:" + miner.publish_port)
self.publisher = ZmqPubConnection(self.factory, publish_endpoint)
# create connections to subscribe
self.subscribers = []
print("the ports subscribed are:")
print(miner.subscribe_ports)
for subscribe_port in miner.subscribe_ports:
subscribe_endpoint = ZmqEndpoint(
ZmqEndpointType.connect, "tcp://127.0.0.1:" + subscribe_port)
subscriber = BroadcastSubscriber(self.factory, subscribe_endpoint,
miner)
self.subscribers.append(subscriber)
# subscribe to the types of events
subscriber.subscribe(PROPOSAL_TAG.encode())
subscriber.subscribe(COMMIT_TAG.encode())
subscriber.subscribe(REINFORCEMENT_TAG.encode())
subscriber.subscribe(TRANSACTION_TAG.encode())
subscriber.subscribe(MALICIOUS_PROPOSAL_AGREEMENT_TAG.encode())
subscriber.subscribe(PROPOSAL_COMMIT_TAG.encode())
subscriber.subscribe(REINFORCEMENT_INF_TAG.encode())
def __init__(self, config, logger=None):
self.config = config
self.logger = logger or Logger()
self.debug = self.config.get('debug', True)
self.vendor = self.config.get('vendor', 'cmccv2')
self.secret = str(self.config.get('secret', 'secret'))
self.rundata = {'challenges': {}}
self.ac_handlers = {
cmcc.REQ_CHALLENGE:
chellenge_handler.ChellengeHandler(self.config, self.logger),
cmcc.REQ_AUTH:
auth_handler.AuthHandler(self.config, self.logger),
cmcc.REQ_INFO:
reqinfo_handler.ReqInfoHandler(self.config, self.logger),
cmcc.AFF_ACK_AUTH:
base_handler.EmptyHandler(self.config, self.logger),
cmcc.ACK_NTF_LOGOUT:
base_handler.EmptyHandler(self.config, self.logger),
cmcc.NTF_HEARTBEAT:
base_handler.EmptyHandler(self.config, self.logger),
cmcc.REQ_LOGOUT:
logout_handler.LogoutHandler(self.config, self.logger)
}
self.puller = ZmqPullConnection(
ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/tpsim-message'))
self.puller.onPull = self.process
reactor.listenUDP(0, self)
self.logger.info('init TpSimWorker puller : %s ' % self.puller)
def __init__(self, taskd, **kwargs):
TaseBasic.__init__(self, taskd, **kwargs)
self.statdata = statistics.MessageStat()
self.puller = ZmqPullConnection(
ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/radiusd-stat-task'))
self.puller.onPull = self.update_stat
logger.info("init Radius stat puller : %s " % (self.puller))
def setup_zmq(self):
zmq_factory = ZmqFactory()
print("subscribing on: %s" % self.endpoint)
sub_endpoint = ZmqEndpoint(ZmqEndpointType.connect, self.endpoint)
sub_connection = ZmqSubConnection(zmq_factory, sub_endpoint)
sub_connection.gotMessage = self.zmq_message
sub_connection.subscribe(INVOICE_PAYMENT_TAG)
def __init__(self):
self.queue = Queue()
self.zmq_factory = ZmqFactory()
endpoint = ZmqEndpoint(ZmqEndpointType.connect, ZMQ_ENDPOINT)
connection = ZmqSubConnection(self.zmq_factory, endpoint)
connection.gotMessage = self.set_mode
connection.subscribe(ZMQ_TAG)
def __init__(self, endpoint):
if endpoint:
logger.debug("开始运行 REQ 服务器,连接地址为:{}...".format(endpoint))
self._req = ZmqREQConnection(ZmqFactory(),
ZmqEndpoint('connect', endpoint))
else:
self._req = None
self.timeout = 0.95
def __init__(self, config, dbengine, radcache = None):
self.config = config
self.load_plugins(load_types=['radius_auth_req', 'radius_accept'])
self.dict = dictionary.Dictionary(os.path.join(os.path.dirname(taurusxradius.__file__), 'dictionarys/dictionary'))
self.db_engine = dbengine or get_engine(config)
self.aes = utils.AESCipher(key=self.config.system.secret)
self.mcache = radcache
self.reject_debug = int(self.get_param_value('radius_reject_debug', 0)) == 1
self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['auth_result']))
self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['task_connect']))
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['auth_message']))
self.puller.onPull = self.process
logger.info('radius auth worker %s start' % os.getpid())
logger.info('init auth worker pusher : %s ' % self.pusher)
logger.info('init auth worker puller : %s ' % self.puller)
logger.info('init auth stat pusher : %s ' % self.stat_pusher)
self.license_ulimit = 50000
def __init__(self, taskd, **kwargs):
TaseBasic.__init__(self, taskd, **kwargs)
self.flow_stat = {}
self.statdata = self.cache.get(
radius_statcache_key) or statistics.MessageStat()
self.puller = ZmqPullConnection(
ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/radiusd-stat-task'))
self.puller.onPull = self.update_stat
def _create_client(self, serializer=MockJSONSerializer):
factory = ZmqFactory()
endpoint = ZmqEndpoint('connect', ADDRESS)
server = MockBaseClient(factory, endpoint, serializer=serializer)
self.assertEqual(server.__serializer__, MockJSONSerializer)
self.assertIsInstance(server.factory, ZmqFactory)
self.assertIsInstance(server.endpoints[0], ZmqEndpoint)
return server
def __init__(self):
color_init()
zf = ZmqFactory()
e = ZmqEndpoint(ZmqEndpointType.connect, ENDPOINT)
self._conn = ZmqREQConnection(zf, e)
self.data = []
if self.service:
self.data = [self.service]
def push_proxy_async(address):
"""
:param address:
:returns: PushProxyAsync
"""
socket = ZmqPushConnection(ZmqFactory(), ZmqEndpoint("connect", address))
return PushProxyAsync(socket)
def dealer_proxy_async(address, timeout=1):
"""
:param address:
:returns: DealerProxyAsync
"""
socket = ZmqREQConnection(ZmqFactory(), ZmqEndpoint("connect", address))
socket.defaultRequestTimeout = timeout
return DealerProxyAsync(socket)
def setUp(self):
self.factory = ZmqFactory()
self._config_prefix = os.path.join(self.tempdir, "leap", "events")
self.public, self.secret = maybe_create_and_get_certificates(
self._config_prefix, 'server')
self.authenticator = auth.TxAuthenticator(self.factory)
self.authenticator.start()
self.auth_req = auth.TxAuthenticationRequest(self.factory)
def setUp(self):
flags.set_events_enabled(True)
self.factory = ZmqFactory()
self._server = server.ensure_server(
emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0",
factory=self.factory,
enable_curve=False)
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port,
factory=self.factory, enable_curve=False)
class EventsGenericClientTestCase(object):
def setUp(self):
flags.set_events_enabled(True)
self.factory = ZmqFactory()
self._server = server.ensure_server(
emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0",
factory=self.factory,
enable_curve=False)
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port,
factory=self.factory, enable_curve=False)
def tearDown(self):
flags.set_events_enabled(False)
self.factory.shutdown()
self._client.instance().reset()
def test_client_register(self):
"""
Ensure clients can register callbacks.
"""
callbacks = self._client.instance().callbacks
self.assertTrue(len(callbacks) == 0,
'There should be no callback for this event.')
# register one event
event1 = catalog.CLIENT_UID
def cbk1(event, _):
return True
uid1 = self._client.register(event1, cbk1)
# assert for correct registration
self.assertTrue(len(callbacks) == 1)
self.assertTrue(callbacks[event1][uid1] == cbk1,
'Could not register event in local client.')
# register another event
event2 = catalog.CLIENT_SESSION_ID
def cbk2(event, _):
return True
uid2 = self._client.register(event2, cbk2)
# assert for correct registration
self.assertTrue(len(callbacks) == 2)
self.assertTrue(callbacks[event2][uid2] == cbk2,
'Could not register event in local client.')
def test_register_signal_replace(self):
"""
Make sure clients can replace already registered callbacks.
"""
event = catalog.CLIENT_UID
d = defer.Deferred()
def cbk_fail(event, _):
return callFromThread(d.errback, event)
def cbk_succeed(event, _):
return callFromThread(d.callback, event)
self._client.register(event, cbk_fail, uid=1)
self._client.register(event, cbk_succeed, uid=1, replace=True)
self._client.emit(event, None)
return d
def test_register_signal_replace_fails_when_replace_is_false(self):
"""
Make sure clients trying to replace already registered callbacks fail
when replace=False
"""
event = catalog.CLIENT_UID
self._client.register(event, lambda event, _: None, uid=1)
self.assertRaises(
CallbackAlreadyRegisteredError,
self._client.register,
event, lambda event, _: None, uid=1, replace=False)
def test_register_more_than_one_callback_works(self):
"""
Make sure clients can replace already registered callbacks.
"""
event = catalog.CLIENT_UID
d1 = defer.Deferred()
def cbk1(event, _):
return callFromThread(d1.callback, event)
d2 = defer.Deferred()
def cbk2(event, _):
return d2.callback(event)
self._client.register(event, cbk1)
self._client.register(event, cbk2)
self._client.emit(event, None)
d = defer.gatherResults([d1, d2])
return d
def test_client_receives_signal(self):
"""
Ensure clients can receive signals.
"""
event = catalog.CLIENT_UID
d = defer.Deferred()
def cbk(events, _):
callFromThread(d.callback, event)
self._client.register(event, cbk)
self._client.emit(event, None)
return d
def test_client_unregister_all(self):
"""
Test that the client can unregister all events for one signal.
"""
event1 = catalog.CLIENT_UID
d = defer.Deferred()
# register more than one callback for the same event
self._client.register(
event1, lambda ev, _: callFromThread(d.errback, None))
self._client.register(
event1, lambda ev, _: callFromThread(d.errback, None))
# unregister and emit the event
self._client.unregister(event1)
self._client.emit(event1, None)
# register and emit another event so the deferred can succeed
event2 = catalog.CLIENT_SESSION_ID
self._client.register(
event2, lambda ev, _: callFromThread(d.callback, None))
self._client.emit(event2, None)
return d
def test_client_unregister_by_uid(self):
"""
Test that the client can unregister an event by uid.
"""
event = catalog.CLIENT_UID
d = defer.Deferred()
# register one callback that would fail
uid = self._client.register(
event, lambda ev, _: callFromThread(d.errback, None))
# register one callback that will succeed
self._client.register(
event, lambda ev, _: callFromThread(d.callback, None))
# unregister by uid and emit the event
self._client.unregister(event, uid=uid)
self._client.emit(event, None)
return d
