def processRegister(self, session, register):
"""
Implements :func:`autobahn.wamp.interfaces.IDealer.processRegister`
"""
assert(session in self._session_to_registrations)
## check topic URI
##
if self._option_uri_strict and not _URI_PAT_STRICT.match(register.procedure):
reply = message.Error(message.Register.MESSAGE_TYPE, register.request, ApplicationError.INVALID_URI)
else:
if not register.procedure in self._procs_to_regs:
registration_id = util.id()
self._procs_to_regs[register.procedure] = (registration_id, session)
self._regs_to_procs[registration_id] = register.procedure
self._session_to_registrations[session].add(registration_id)
reply = message.Registered(register.request, registration_id)
else:
reply = message.Error(message.Register.MESSAGE_TYPE, register.request, ApplicationError.PROCEDURE_ALREADY_EXISTS)
session._transport.send(reply)
def processCall(self, session, call):
"""
Implements :func:`autobahn.wamp.interfaces.IDealer.processCall`
"""
assert(session in self._session_to_registrations)
## check topic URI
##
if self._option_uri_strict and not _URI_PAT_STRICT.match(call.procedure):
reply = message.Error(message.Register.MESSAGE_TYPE, call.request, ApplicationError.INVALID_URI)
session._transport.send(reply)
else:
if call.procedure in self._procs_to_regs:
registration_id, endpoint_session = self._procs_to_regs[call.procedure]
request_id = util.id()
if call.discloseMe:
caller = session._session_id
else:
caller = None
invocation = message.Invocation(request_id,
registration_id,
args = call.args,
kwargs = call.kwargs,
timeout = call.timeout,
receive_progress = call.receive_progress,
caller = caller)
self._invocations[request_id] = (call, session)
endpoint_session._transport.send(invocation)
else:
reply = message.Error(message.Call.MESSAGE_TYPE, call.request, ApplicationError.NO_SUCH_PROCEDURE)
session._transport.send(reply)
def processSubscribe(self, session, subscribe):
"""
Implements :func:`autobahn.wamp.interfaces.IBroker.processSubscribe`
"""
assert(session in self._session_to_subscriptions)
## check topic URI
##
if self._option_uri_strict and not _URI_PAT_STRICT.match(subscribe.topic):
reply = message.Error(message.Subscribe.MESSAGE_TYPE, subscribe.request, ApplicationError.INVALID_URI)
else:
if not subscribe.topic in self._topic_to_sessions:
subscription = util.id()
self._topic_to_sessions[subscribe.topic] = (subscription, set())
subscription, subscribers = self._topic_to_sessions[subscribe.topic]
if not session in subscribers:
subscribers.add(session)
if not subscription in self._subscription_to_sessions:
self._subscription_to_sessions[subscription] = (subscribe.topic, set())
_, subscribers = self._subscription_to_sessions[subscription]
if not session in subscribers:
subscribers.add(session)
if not subscription in self._session_to_subscriptions[session]:
self._session_to_subscriptions[session].add(subscription)
reply = message.Subscribed(subscribe.request, subscription)
session._transport.send(reply)
def processPublish(self, session, publish):
"""
Implements :func:`autobahn.wamp.interfaces.IBroker.processPublish`
"""
assert(session in self._session_to_subscriptions)
## check topic URI
##
if self._option_uri_strict and not _URI_PAT_STRICT.match(publish.topic):
if publish.acknowledge:
reply = message.Error(message.Publish.MESSAGE_TYPE, publish.request, ApplicationError.INVALID_URI)
session._transport.send(reply)
return
if publish.topic in self._topic_to_sessions and self._topic_to_sessions[publish.topic]:
## initial list of receivers are all subscribers ..
##
subscription, receivers = self._topic_to_sessions[publish.topic]
## filter by "eligible" receivers
##
if publish.eligible:
eligible = []
for s in publish.eligible:
if s in self._session_id_to_session:
eligible.append(self._session_id_to_session[s])
if eligible:
receivers = set(eligible) & receivers
## remove "excluded" receivers
##
if publish.exclude:
exclude = []
for s in publish.exclude:
if s in self._session_id_to_session:
exclude.append(self._session_id_to_session[s])
if exclude:
receivers = receivers - set(exclude)
## remove publisher
##
if publish.excludeMe is None or not publish.excludeMe:
# receivers.discard(session) # bad: this would modify our actual subscriber list
me_also = False
else:
me_also = True
else:
subscription, receivers = None, []
publication = util.id()
## send publish acknowledge when requested
##
if publish.acknowledge:
msg = message.Published(publish.request, publication)
session._transport.send(msg)
## if receivers is non-empty, dispatch event ..
##
if receivers:
if publish.discloseMe:
publisher = session._session_id
else:
publisher = None
msg = message.Event(subscription,
publication,
args = publish.args,
kwargs = publish.kwargs,
publisher = publisher)
for receiver in receivers:
if me_also or receiver != session:
receiver._transport.send(msg)