def __init__(self, factory, realm, options=None, store=None, mqtt_payload_format=None):
"""
:param factory: The router factory this router was created by.
:type factory: Object that implements :class:`autobahn.wamp.interfaces.IRouterFactory`..
:param realm: The realm this router is working for.
:type realm: str
:param options: Router options.
:type options: Instance of :class:`crossbar.router.RouterOptions`.
:param mqtt_payload_format: The format that MQTT messages on this realm are in.
:type mqtt_payload_format: str
"""
self._factory = factory
self._options = options or RouterOptions()
self._store = store
self._realm = realm
self.realm = realm.config[u'name']
self._trace_traffic = False
self._trace_traffic_roles_include = None
self._trace_traffic_roles_exclude = [u'trusted']
# map: session_id -> session
self._session_id_to_session = {}
self._broker = self.broker(self, self._options)
self._dealer = self.dealer(self, self._options)
self._attached = 0
self._mqtt_payload_format = mqtt_payload_format
self._roles = {
u'trusted': RouterTrustedRole(self, u'trusted')
}
def __init__(self, router, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`crossbar.router.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`crossbar.router.types.RouterOptions`.
"""
self._router = router
self._options = options or RouterOptions()
# subscription map managed by this broker
self._subscription_map = UriObservationMap()
# map: session -> set of subscriptions (needed for detach)
self._session_to_subscriptions = {}
# check all topic URIs with strict rules
self._option_uri_strict = self._options.uri_check == RouterOptions.URI_CHECK_STRICT
# supported features from "WAMP Advanced Profile"
self._role_features = role.RoleBrokerFeatures(
publisher_identification=True,
pattern_based_subscription=True,
subscription_meta_api=True,
subscriber_blackwhite_listing=True,
publisher_exclusion=True,
subscription_revocation=True)
def __init__(self, factory, realm, options=None, store=None):
"""
:param factory: The router factory this router was created by.
:type factory: Object that implements :class:`autobahn.wamp.interfaces.IRouterFactory`..
:param realm: The realm this router is working for.
:type realm: str
:param options: Router options.
:type options: Instance of :class:`autobahn.wamp.types.RouterOptions`.
"""
self._factory = factory
self._options = options or RouterOptions()
self._store = store
self._realm = realm
self.realm = realm.config['name']
self._trace_traffic = False
self._trace_traffic_roles_include = None
self._trace_traffic_roles_exclude = [u'trusted']
# map: session_id -> session
self._session_id_to_session = {}
self._broker = self.broker(self, self._options)
self._dealer = self.dealer(self, self._options)
self._attached = 0
self._roles = {"trusted": RouterTrustedRole(self, "trusted")}
def __init__(self, router, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`crossbar.router.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`crossbar.router.types.RouterOptions`.
"""
self._router = router
self._options = options or RouterOptions()
# generator for WAMP request IDs
self._request_id_gen = util.IdGenerator()
# registration map managed by this dealer
self._registration_map = UriObservationMap(ordered=True)
# map: session -> set of registrations (needed for detach)
self._session_to_registrations = {}
# pending callee invocation requests
self._invocations = {}
# check all procedure URIs with strict rules
self._option_uri_strict = self._options.uri_check == RouterOptions.URI_CHECK_STRICT
# supported features from "WAMP Advanced Profile"
self._role_features = role.RoleDealerFeatures(
caller_identification=True,
pattern_based_registration=True,
session_meta_api=True,
registration_meta_api=True,
shared_registration=True,
progressive_call_results=True,
registration_revocation=True)
def __init__(self,
node_id: str,
worker_id: str,
worker,
options: Optional[RouterOptions] = None):
"""
:param node_id: Node (management) ID.
:param worker_id: (Router) worker (management) ID.
:param worker: Router worker.
:param options: Default router options.
"""
self._node_id = node_id
self._worker_id = worker_id
self._worker = worker
self._routers: Dict[str, Router] = {}
self._options = options or RouterOptions(
uri_check=RouterOptions.URI_CHECK_LOOSE)
# XXX this should get passed in from somewhere
from twisted.internet import reactor
self._reactor = reactor
from crossbar.worker.router import RouterController
from crossbar.worker.proxy import ProxyController
assert worker is None or isinstance(
worker, RouterController) or isinstance(worker, ProxyController)
def __init__(self, router, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`crossbar.router.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`crossbar.router.types.RouterOptions`.
"""
self._router = router
self._options = options or RouterOptions()
# generator for WAMP request IDs
self._request_id_gen = util.IdGenerator()
# registration map managed by this dealer
self._registration_map = UriObservationMap(ordered=True)
# map: session -> set of registrations (needed for detach)
self._session_to_registrations = {}
# map: session -> in-flight invocations
self._callee_to_invocations = {}
# BEWARE: this map must be kept up-to-date along with the
# _invocations map below! Use the helper methods
# _add_invoke_request and _remove_invoke_request
# map: session -> in-flight invocations
self._caller_to_invocations = {}
# careful here: the 'request' IDs are unique per-session
# (only) so we map from (session_id, call) tuples to in-flight invocations
# map: (session_id, call) -> in-flight invocations
self._invocations_by_call = {}
# pending callee invocation requests
self._invocations = {}
# check all procedure URIs with strict rules
self._option_uri_strict = self._options.uri_check == RouterOptions.URI_CHECK_STRICT
# supported features from "WAMP Advanced Profile"
self._role_features = role.RoleDealerFeatures(caller_identification=True,
pattern_based_registration=True,
session_meta_api=True,
registration_meta_api=True,
shared_registration=True,
progressive_call_results=True,
registration_revocation=True,
payload_transparency=True,
testament_meta_api=True,
payload_encryption_cryptobox=True,
call_canceling=True)
# store for call queues
if self._router._store:
self._call_store = self._router._store.call_store
else:
self._call_store = None
def __init__(self, options=None):
"""
:param options: Default router options.
:type options: Instance of :class:`crossbar.router.RouterOptions`.
"""
self._routers = {}
self._options = options or RouterOptions(uri_check=RouterOptions.URI_CHECK_LOOSE)
self._auto_create_realms = False
def start_realm(self, realm):
"""
Starts a realm on this router.
:param realm: The realm to start.
:type realm: instance of :class:`crossbar.worker.router.RouterRealm`.
:returns: The router instance for the started realm.
:rtype: instance of :class:`crossbar.router.session.CrossbarRouter`
"""
self.log.debug("CrossbarRouterFactory.start_realm(realm = {realm})",
realm=realm)
# get name of realm (an URI in general)
#
uri = realm.config['name']
assert (uri not in self._routers)
# if configuration of realm contains a "store" item, set up a
# realm store as appropriate ..
store = None
if 'store' in realm.config:
store_config = realm.config['store']
if store_config['type'] == 'lmdb':
# if LMDB is available, and a realm store / database is configured,
# create an LMDB environment
if not HAS_LMDB:
raise Exception("LDMB not available")
store = LmdbRealmStore(store_config)
elif store_config['type'] == 'memory':
store = MemoryRealmStore(store_config)
else:
raise Exception('logic error')
# now create a router for the realm
#
options = RouterOptions(
uri_check=self._options.uri_check,
event_dispatching_chunk_size=self._options.
event_dispatching_chunk_size,
)
for arg in ['uri_check', 'event_dispatching_chunk_size']:
if arg in realm.config.get('options', {}):
setattr(options, arg, realm.config['options'][arg])
router = Router(self, realm, options, store=store)
self._routers[uri] = router
self.log.debug("Router created for realm '{uri}'", uri=uri)
return router
def __init__(self, node_id, options=None):
"""
:param options: Default router options.
:type options: Instance of :class:`autobahn.wamp.types.RouterOptions`.
"""
assert (type(node_id) == six.text_type)
self._node_id = node_id
self._routers = {}
self._options = options or RouterOptions(
uri_check=RouterOptions.URI_CHECK_LOOSE)
self._auto_create_realms = False
def __init__(self,
factory,
realm,
options: Optional[RouterOptions] = None,
store: Optional[IRealmStore] = None,
inventory: Optional[IInventory] = None):
"""
:param factory: The router factory this router was created by.
:type factory: Object that implements :class:`autobahn.wamp.interfaces.IRouterFactory`.
:param realm: The realm this router is working for.
:type realm: Instance of :class:`crossbar.worker.router.RouterRealm`.
:param options: Router options.
:param store: Router realm store to use (optional).
"""
self._factory = factory
self._realm = realm
self._options = options or RouterOptions()
self._store: Optional[IRealmStore] = store
self._inventory: Optional[IInventory] = inventory
self.realm = realm.config['name']
self._trace_traffic = False
self._trace_traffic_roles_include = None
self._trace_traffic_roles_exclude = ['trusted']
# map: session_id -> session
self._session_id_to_session: Dict[int, ISession] = {}
# map: authid -> set(session)
self._authid_to_sessions: Dict[str, Set[ISession]] = {}
# map: authrole -> set(session)
self._authrole_to_sessions: Dict[str, Set[ISession]] = {}
# map: (realm, authrole, uri, action) -> authorization
self._authorization_cache: Dict[Tuple[str, str, str, str],
Dict[str, Any]] = {}
self._broker = self.broker(self, factory._reactor, self._options)
self._dealer = self.dealer(self, factory._reactor, self._options)
self._attached = 0
self._roles = {'trusted': RouterTrustedRole(self, 'trusted')}
# FIXME: this was previously just checking for existence of
# self._factory._worker._maybe_trace_tx_msg / _maybe_trace_rx_msg
self._is_traced = False
self.reset_stats()
def __init__(self, node_id, worker, options=None):
"""
:param options: Default router options.
:type options: Instance of :class:`crossbar.router.RouterOptions`.
"""
self._node_id = node_id
self._worker = worker
self._routers = {}
self._options = options or RouterOptions(uri_check=RouterOptions.URI_CHECK_LOOSE)
# XXX this should get passed in from .. somewhere
from twisted.internet import reactor
self._reactor = reactor
def __init__(self, router, reactor, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`crossbar.router.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`crossbar.router.types.RouterOptions`.
"""
self._router = router
self._reactor = reactor
self._options = options or RouterOptions()
# generator for WAMP request IDs
self._request_id_gen = util.IdGenerator()
# subscription map managed by this broker
self._subscription_map = UriObservationMap()
# map: session -> set of subscriptions (needed for detach)
self._session_to_subscriptions = {}
# check all topic URIs with strict rules
self._option_uri_strict = self._options.uri_check == RouterOptions.URI_CHECK_STRICT
# supported features from "WAMP Advanced Profile"
self._role_features = role.RoleBrokerFeatures(
publisher_identification=True,
pattern_based_subscription=True,
session_meta_api=True,
subscription_meta_api=True,
subscriber_blackwhite_listing=True,
publisher_exclusion=True,
subscription_revocation=True,
event_retention=True,
payload_transparency=True,
payload_encryption_cryptobox=True)
# store for event history
if self._router._store:
self._event_store = self._router._store.event_store
else:
self._event_store = None
# if there is a store, let the store attach itself to all the subscriptions
# it is configured to track
if self._event_store:
self._event_store.attach_subscription_map(self._subscription_map)
def start_realm(self, realm):
"""
Starts a realm on this router.
:param realm: The realm to start.
:type realm: instance of :class:`crossbar.worker.router.RouterRealm`.
:returns: The router instance for the started realm.
:rtype: instance of :class:`crossbar.router.session.CrossbarRouter`
"""
self.log.debug("CrossbarRouterFactory.start_realm(realm = {realm})",
realm=realm)
# get name of realm (an URI in general)
#
uri = realm.config['name']
assert (uri not in self._routers)
# if configuration of realm contains a "store" item, set up a
# realm store as appropriate ..
store = None
if 'store' in realm.config:
psn = self._worker.personality
store = psn.create_realm_store(psn, self, realm.config['store'])
self.log.info('Initialized realm store {rsk} for realm "{realm}"',
rsk=store.__class__,
realm=uri)
# now create a router for the realm
#
options = RouterOptions(
uri_check=self._options.uri_check,
event_dispatching_chunk_size=self._options.
event_dispatching_chunk_size,
)
for arg in ['uri_check', 'event_dispatching_chunk_size']:
if arg in realm.config.get('options', {}):
setattr(options, arg, realm.config['options'][arg])
router = Router(self, realm, options, store=store)
self._routers[uri] = router
self.log.info('{klass}.start_realm: router created for realm "{uri}"',
klass=self.__class__.__name__,
uri=uri)
return router
def __init__(self, factory, realm, options=None, store=None):
"""
:param factory: The router factory this router was created by.
:type factory: Object that implements :class:`autobahn.wamp.interfaces.IRouterFactory`..
:param realm: The realm this router is working for.
:type realm: str
:param options: Router options.
:type options: Instance of :class:`crossbar.router.RouterOptions`.
"""
self._factory = factory
self._options = options or RouterOptions()
self._store = store
self._realm = realm
self.realm = realm.config[u'name']
self._trace_traffic = False
self._trace_traffic_roles_include = None
self._trace_traffic_roles_exclude = [u'trusted']
# map: session_id -> session
self._session_id_to_session = {}
# map: authid -> set(session)
self._authid_to_sessions = {}
# map: authrole -> set(session)
self._authrole_to_sessions = {}
self._broker = self.broker(self, factory._reactor, self._options)
self._dealer = self.dealer(self, factory._reactor, self._options)
self._attached = 0
self._roles = {
u'trusted': RouterTrustedRole(self, u'trusted')
}
# FIXME: this was previsouly just checking for existence of
# self._factory._worker._maybe_trace_tx_msg / _maybe_trace_rx_msg
self._is_traced = False
self.reset_stats()
def __init__(self,
node_id: str,
worker_id: str,
worker,
options: Optional[RouterOptions] = None):
"""
:param node_id: Node (management) ID.
:param worker_id: (Router) worker (management) ID.
:param worker: Router worker.
:param options: Default router options.
"""
self._node_id = node_id
self._worker_id = worker_id
self._worker = worker
self._routers = {}
self._options = options or RouterOptions(
uri_check=RouterOptions.URI_CHECK_LOOSE)
# XXX this should get passed in from .. somewhere
from twisted.internet import reactor
self._reactor = reactor
def start_realm(self, realm: RouterRealm) -> Router:
"""
Starts a realm on this router.
:param realm: The realm to start.
:returns: The router instance for the started realm.
:rtype: instance of :class:`crossbar.router.session.CrossbarRouter`
"""
# extract name (URI in general) of realm from realm configuration
assert 'name' in realm.config
uri = realm.config['name']
assert type(uri) == str
self.log.info('{func}: realm={realm} with URI "{uri}"',
func=hltype(self.start_realm),
realm=realm,
uri=hlval(uri))
if realm in self._routers:
raise RuntimeError(
'router for realm "{}" already running'.format(uri))
# setup optional store for realm persistence features
store: Optional[IRealmStore] = None
if 'store' in realm.config and realm.config['store']:
# the worker's node personality
psn = self._worker.personality
store = psn.create_realm_store(psn, self, realm.config['store'])
self.log.info(
'{func}: initialized realm store {store_class} for realm "{realm}"',
func=hltype(self.start_realm),
store_class=hlval(store.__class__, color='green'),
realm=hlval(uri))
# setup optional inventory for realm API catalogs
inventory: Optional[IInventory] = None
if 'inventory' in realm.config and realm.config['inventory']:
# the worker's node personality
psn = self._worker.personality
inventory = psn.create_realm_inventory(psn, self,
realm.config['inventory'])
assert inventory
self.log.info(
'{func}: initialized realm inventory <{inventory_type}> for realm "{realm}", '
'loaded {total_count} types, from config:\n{config}',
func=hltype(self.start_realm),
inventory_type=hlval(inventory.type, color='green'),
total_count=hlval(inventory.repo.total_count),
realm=hlval(uri),
config=pformat(realm.config['inventory']))
# setup realm options
options = RouterOptions(
uri_check=self._options.uri_check,
event_dispatching_chunk_size=self._options.
event_dispatching_chunk_size,
)
for arg in ['uri_check', 'event_dispatching_chunk_size']:
if arg in realm.config.get('options', {}):
setattr(options, arg, realm.config['options'][arg])
# now create a router for the realm
router = self.router(self,
realm,
options,
store=store,
inventory=inventory)
self._routers[uri] = router
return router
