def stop_web_transport_service(self, transport_id, path, details=None):
"""
Stop a service on a Web transport.
:param transport_id: The ID of the transport to stop the Web transport service on.
:type transport_id: str
:param path: The path (absolute URL, eg "/myservice1") of the service to stop.
:type path: str
:param details: Call details.
:type details: :class:`autobahn.wamp.types.CallDetails`
"""
self.log.info('{func}(transport_id={transport_id}, path="{path}")',
func=hltype(self.stop_web_transport_service),
transport_id=hlid(transport_id),
path=hlval(path))
transport = self.transports.get(transport_id, None)
if not transport or \
not isinstance(transport, self.personality.RouterWebTransport) or \
transport.state != self.personality.RouterTransport.STATE_STARTED:
emsg = "Cannot stop service on Web transport: no transport with ID '{}' or transport is not a Web transport".format(
transport_id)
self.log.error(emsg)
raise ApplicationError('crossbar.error.not_running', emsg)
if path not in transport.root:
emsg = "Cannot stop service on Web transport {}: no service running on path '{}'".format(
transport_id, path)
self.log.error(emsg)
raise ApplicationError('crossbar.error.not_running', emsg)
caller = details.caller if details else None
self.publish(self._uri_prefix + '.on_web_transport_service_stopping',
transport_id,
path,
options=PublishOptions(exclude=caller))
# now actually remove the web service. note: currently this is NOT async, but direct/sync.
# FIXME: check that the underlying Twisted Web resource doesn't need any stopping too!
del transport.root[path]
on_web_transport_service_stopped = {
'transport_id': transport_id,
'path': path,
}
caller = details.caller if details else None
self.publish(self._uri_prefix + '.on_web_transport_service_stopped',
transport_id,
path,
on_web_transport_service_stopped,
options=PublishOptions(exclude=caller))
return on_web_transport_service_stopped
async def publish(self, session, topic, payload):
if DEBUG_ACK_SEND:
pub = await session.publish(
topic, payload, options=PublishOptions(acknowledge=True))
print("published {}: {}".format(pub.id, payload))
else:
session.publish(topic, payload)
def publish_gsi(session):
if wamp_component.state:
options = PublishOptions(retain=True)
yield session.publish(f"{SRC_PREFIX}ltri-dota-gsi-health",
wamp_component.state.hero.health_as_color() *
LEDS_IN_ARRAY_DEFAULT,
id="ltri-dota-gsi-health",
options=options)
yield session.publish(f"{SRC_PREFIX}ltri-dota-gsi-health-inv",
wamp_component.state.hero.health_as_color_inv() *
LEDS_IN_ARRAY_DEFAULT,
id="ltri-dota-gsi-health-inv",
options=options)
yield session.publish(f"{SRC_PREFIX}ltri-dota-gsi-mana",
wamp_component.state.hero.mana_as_color() *
LEDS_IN_ARRAY_DEFAULT,
id="ltri-dota-gsi-mana",
options=options)
yield session.publish(f"{SRC_PREFIX}ltri-dota-gsi-mana-inv",
wamp_component.state.hero.mana_as_color_inv() *
LEDS_IN_ARRAY_DEFAULT,
id="ltri-dota-gsi-mana-inv",
options=options)
yield session.publish(f"{SRC_PREFIX}ltri-dota-gsi-money",
wamp_component.state.player.money_as_color() *
LEDS_IN_ARRAY_DEFAULT,
id="ltri-dota-gsi-money",
options=options)
yield session.publish(
f"{SRC_PREFIX}ltri-dota-gsi-money-inv",
wamp_component.state.player.money_as_color_inv() *
LEDS_IN_ARRAY_DEFAULT,
id="ltri-dota-gsi-money-inv",
options=options)
yield None
def test_flask(self, crossbar):
app = Flask(__name__)
wamp = FlaskAutobahnSync()
publish_opt = PublishOptions(exclude_me=False)
@wamp.register('flask.flask.rpc')
def rpc():
self.rpc_called = True
@wamp.subscribe('flask.flask.event')
def sub():
self.sub_called = True
with pytest.raises(NotRunningError):
wamp.session.call('flask.flask.rpc')
with pytest.raises(NotRunningError):
wamp.session.publish('flask.flask.event', options=publish_opt)
assert not self.rpc_called
assert not self.sub_called
wamp.init_app(app)
wamp.session.call('flask.flask.rpc')
wamp.session.publish('flask.flask.event', options=publish_opt)
sleep(0.1) # Dirty way to wait for on_event to be called...
assert self.rpc_called
assert self.sub_called
def publish_gsi(session):
if wamp_component.state:
options = PublishOptions(retain=True)
# yield session.publish(
# f"{SRC_PREFIX}ltri-csgo-gsi-de",
# []],
# id="ltri-csgo-gsi-de",
# options=options)
yield session.publish(f"{SRC_PREFIX}ltri-csgo-gsi-health",
wamp_component.state.player.state.health_as_color() * LEDS_IN_ARRAY_DEFAULT,
id="ltri-csgo-gsi-health", options=options)
yield session.publish(f"{SRC_PREFIX}ltri-csgo-gsi-health-inv",
wamp_component.state.player.state.health_as_color_inv() * LEDS_IN_ARRAY_DEFAULT,
id="ltri-csgo-gsi-health-inv", options=options)
yield session.publish(f"{SRC_PREFIX}ltri-csgo-gsi-armor",
wamp_component.state.player.state.armor_as_color() * LEDS_IN_ARRAY_DEFAULT,
id="ltri-csgo-gsi-armor", options=options)
yield session.publish(f"{SRC_PREFIX}ltri-csgo-gsi-armor-inv",
wamp_component.state.player.state.armor_as_color_inv() * LEDS_IN_ARRAY_DEFAULT,
id="ltri-csgo-gsi-armor-inv", options=options)
yield session.publish(f"{SRC_PREFIX}ltri-csgo-gsi-money",
wamp_component.state.player.state.money_as_color() * LEDS_IN_ARRAY_DEFAULT,
id="ltri-csgo-gsi-money", options=options)
yield session.publish(f"{SRC_PREFIX}ltri-csgo-gsi-money-inv",
wamp_component.state.player.state.money_as_color_inv() * LEDS_IN_ARRAY_DEFAULT,
id="ltri-csgo-gsi-money-inv", options=options)
yield None
def test_api(self, crossbar):
publish_opt = PublishOptions(exclude_me=False)
@register('api.api.rpc')
def rpc():
self.rpc_called = True
@subscribe('api.api.event')
def sub():
self.sub_called = True
with pytest.raises(NotRunningError):
call('api.api.rpc')
with pytest.raises(NotRunningError):
publish('api.api.event', options=publish_opt)
assert not self.rpc_called
assert not self.sub_called
run()
call('api.api.rpc')
publish('api.api.event', options=publish_opt)
sleep(0.1) # Dirty way to wait for on_event to be called...
assert self.rpc_called
assert self.sub_called
def publish_heartbeat_rate(self, heartbeat_rate):
"""
Publish a heartbeat rate topic.
This topic is retained so that new clients receive the event.
"""
return self.session.publish(TOPIC_HEARTBEAT_RATE,
heartbeat_rate,
options=PublishOptions(retain=True))
def test_no_publish(self, crossbar):
wamp = AutobahnSync()
wamp.run(realm=u'realm_limited')
wamp.session.subscribe(lambda: None, 'pubsub.no_publish.event')
publish_opt = PublishOptions(acknowledge=True)
with pytest.raises(ApplicationError) as exc:
res = wamp.session.publish(u'pubsub.no_publish.event',
None,
options=publish_opt)
assert str(
exc.value.args[0]
) == u"session not authorized to publish to topic 'pubsub.no_publish.event'"
async def _invoke(self):
topic = self._publisher.topic
try:
options = PublishOptions(**self._publisher.publish_options_kwargs)
session = self._publisher.manager.session.application_session
print(f'Publication to {topic} with name {self.name} starting')
self._result = session.publish(topic,
*self._args,
options=options,
**self._kwargs)
if self._result is not None and self._publisher.acknowledge:
self._result = await self._result
print(f'Publication to {topic} with name {self.name} succeeded')
except Exception as e:
print(f'Publication to {topic} with name {self.name} failed')
self._exception = e
async def publish(self, session, topic, payload):
key_id, enc_ser, ciphertext = await self._seller.wrap(
self._api_id, self._topic, payload)
if DEBUG_ACK_SEND:
pub = await session.publish(
topic,
key_id,
enc_ser,
ciphertext,
options=PublishOptions(acknowledge=True))
print("published {}: {}".format(pub.id, payload))
else:
session.publish(topic, key_id, enc_ser, ciphertext)
if DEBUG_ENABLED:
debug_topic = 'debug.' + topic
session.publish(debug_topic, payload)
def test_on_join():
monitor = mk_monitor('ws://localhost:8080/ws', 'realm')
# Fires the join event.
mock_session = MagicMock()
yield monitor.fire('join', mock_session, None)
assert mock_session.subscribe.called_once_with(monitor.on_heartbeat,
TOPIC_HEARTBEAT)
assert mock_session.publish.called_with(
TOPIC_HEARTBEAT_RATE,
HEARTBEAT_RATE,
options=PublishOptions(retain=True))
assert monitor.dead_service_check_loop is not None
assert monitor.dead_service_check_loop.running
def publish(self, topic, claims=None, context=None, options=None):
if context is None:
context = self.default_call_context
claims = context.get_claims(claims)
signed_claims = yield super(CommonSession,
self).call(u'mdstudio.auth.endpoint.sign',
claims)
options = options or PublishOptions(acknowledge=True, exclude_me=False)
result = yield super(
CommonSession, self).publish(topic,
signed_claims=signed_claims,
options=options) # type: Publication
return_value(result)
def test_on_exception(self, wamp):
events = []
class MyException(Exception):
pass
@wamp.subscribe(u'pubsub.on_exception.event')
def on_event(*args, **kwargs):
events.append((args, kwargs))
raise MyException('Ooops !')
publish_opt = PublishOptions(exclude_me=False, acknowledge=True)
wamp.session.publish('pubsub.on_exception.event',
'1',
options=publish_opt)
sleep(0.1) # Dirty way to wait for on_event to be called...
assert events == [(('1', ), {})]
def publish_message(self, user_id, message):
print("will try to send message")
try:
print("Okay")
return_val = self.wamp_client.publish(
"com.crossbar_test.notification",
message,
options=PublishOptions(acknowledge=True,
eligible_authid=user_id))
return_val.addCallback(callback)
return_val.addErrback(callback)
print(
"ok, event published to topic {}".format(
"com.crossbar_test.notification"), return_val)
except Exception as e:
print(
"publication to topic {} failed (this is expected!) {}".format(
"com.crossbar_test.notification", e))
def test_use_decorator(self, wamp):
events = []
@wamp.subscribe(u'pubsub.use_decorator.event')
def on_event(*args, **kwargs):
events.append((args, kwargs))
publish_opt = PublishOptions(exclude_me=False)
wamp.session.publish('pubsub.use_decorator.event',
'1',
options=publish_opt)
wamp.session.publish('pubsub.use_decorator.event',
'2',
options=publish_opt)
wamp.session.publish('pubsub.use_decorator.event',
opt=True,
options=publish_opt)
sleep(0.1) # Dirty way to wait for on_event to be called...
assert events == [(('1', ), {}), (('2', ), {}), ((), {'opt': True})]
def main():
timestamp = str(datetime.utcnow())
print('[Worker %s] Serve request on timestamp %s' % (worker_id, timestamp))
publish_opt = PublishOptions(exclude_me=False)
app.wamp.session.publish('com.flask_app.page_served',
worker_id,
timestamp,
options=publish_opt)
serve_history = app.wamp.session.call('com.flask_app.get_request_history',
worker_id)
txts = [
"<table>",
"<thead><th>Worker id</th><th>Request timestamp</th></thead>",
"<tbody>"
]
txts += [
"<tr><td>%s</td><td>%s</td></tr>" % (wid, ts)
for wid, ts in serve_history
]
txts.append("</tbody></table>")
return ''.join(txts)
def test_decorate_before_run(self, crossbar):
events = []
wamp = AutobahnSync()
@wamp.subscribe(u'pubsub.decorate_before_run.event')
def on_event(*args, **kwargs):
events.append((args, kwargs))
wamp.run()
publish_opt = PublishOptions(exclude_me=False)
wamp.session.publish('pubsub.decorate_before_run.event',
'1',
options=publish_opt)
wamp.session.publish('pubsub.decorate_before_run.event',
'2',
options=publish_opt)
wamp.session.publish('pubsub.decorate_before_run.event',
opt=True,
options=publish_opt)
sleep(0.1) # Dirty way to wait for on_event to be called...
assert events == [(('1', ), {}), (('2', ), {}), ((), {'opt': True})]
def start_web_transport_service(self,
transport_id,
path,
config,
details=None):
"""
Start a service on a Web transport.
:param transport_id: The ID of the transport to start the Web transport service on.
:type transport_id: str
:param path: The path (absolute URL, eg "/myservice1") on which to start the service.
:type path: str
:param config: The Web service configuration.
:type config: dict
:param details: Call details.
:type details: :class:`autobahn.wamp.types.CallDetails`
"""
if not isinstance(config, dict) or 'type' not in config:
raise ApplicationError(
'crossbar.invalid_argument',
'config parameter must be dict with type attribute')
self.log.info(
'Starting "{service_type}" Web service on path "{path}" of transport "{transport_id}" {func}',
service_type=hlval(config.get('type', 'unknown')),
path=hlval(path),
transport_id=hlid(transport_id),
func=hltype(self.start_web_transport_service))
transport = self.transports.get(transport_id, None)
if not transport:
emsg = 'Cannot start service on transport: no transport with ID "{}"'.format(
transport_id)
self.log.error(emsg)
raise ApplicationError('crossbar.error.not_running', emsg)
if not isinstance(transport, self.personality.RouterWebTransport):
emsg = 'Cannot start service on transport: transport is not a Web transport (transport_type={})'.format(
hltype(transport.__class__))
self.log.error(emsg)
raise ApplicationError('crossbar.error.not_running', emsg)
if transport.state != self.personality.RouterTransport.STATE_STARTED:
emsg = 'Cannot start service on Web transport service: transport {} is not running (transport_state={})'.format(
transport_id,
self.personality.RouterWebTransport.STATES.get(
transport.state, None))
self.log.error(emsg)
raise ApplicationError('crossbar.error.not_running', emsg)
if path in transport.root:
emsg = 'Cannot start service on Web transport "{}": a service is already running on path "{}"'.format(
transport_id, path)
self.log.error(emsg)
raise ApplicationError('crossbar.error.already_running', emsg)
caller = details.caller if details else None
self.publish(self._uri_prefix + '.on_web_transport_service_starting',
transport_id,
path,
options=PublishOptions(exclude=caller))
# now actually add the web service ..
# note: currently this is NOT async, but direct/sync.
webservice_factory = self.personality.WEB_SERVICE_FACTORIES[
config['type']]
webservice = yield maybeDeferred(webservice_factory.create, transport,
path, config)
transport.root[path] = webservice
on_web_transport_service_started = {
'transport_id': transport_id,
'path': path,
'config': config
}
caller = details.caller if details else None
self.publish(self._uri_prefix + '.on_web_transport_service_started',
transport_id,
path,
on_web_transport_service_started,
options=PublishOptions(exclude=caller))
returnValue(on_web_transport_service_started)
import inspect
from autobahn.wamp import PublishOptions
from autobahn.wamp.request import Registration
from twisted.internet.defer import inlineCallbacks
DOC_LISTENER_URI = "com.lambentri.edge.la4.doc"
pub_options = PublishOptions(acknowledge=True, exclude_me=False)
class DocMixin:
zsubs = None
regs = None
def _get_function_handle_from_uri(self, uri):
return next(
iter([i for i in self.members if i[1]._wampuris[0]._uri == uri]))
def _get_doc_from_name_handle(self, handle):
return getattr(self, handle).__doc__
def _get_args_and_kwargs_from_name_handle(self, handle):
"""TODO INSPECT RETURN on args"""
func = getattr(self, handle)
args = inspect.signature(func)
# print(args)
if args and args.parameters:
if isinstance(list(args.parameters.values())[0], dict):
x = {
k: v.get("annotation", "str")
for k, v in args.parameters.items()