Module autobahn.wamp

WAMP Interfaces

class autobahn.wamp.interfaces.IObjectSerializer[source]

Raw Python object serialization and deserialization. Object serializers are used by classes implementing WAMP serializers, that is instances of autobahn.wamp.interfaces.ISerializer.

BINARY

Flag (read-only) to indicate if serializer requires a binary clean transport or if UTF8 transparency is sufficient.

serialize(obj)[source]

Serialize an object to a byte string.

Parameters:obj (any (serializable type)) – Object to serialize.
Returns:Serialized bytes.
Return type:bytes
unserialize(payload)[source]

Unserialize objects from a byte string.

Parameters:payload (bytes) – Objects to unserialize.
Returns:List of (raw) objects unserialized.
Return type:list
class autobahn.wamp.interfaces.ISerializer[source]

WAMP message serialization and deserialization.

MESSAGE_TYPE_MAP

Mapping of WAMP message type codes to WAMP message classes.

SERIALIZER_ID

The WAMP serialization format ID.

serialize(message)[source]

Serializes a WAMP message to bytes for sending over a transport.

Parameters:message (object implementing autobahn.wamp.interfaces.IMessage) – The WAMP message to be serialized.
Returns:A pair (payload, isBinary).
Return type:tuple
unserialize(payload, isBinary)[source]

Deserialize bytes from a transport and parse into WAMP messages.

Parameters:
  • payload (bytes) – Byte string from wire.
  • is_binary (bool) – Type of payload. True if payload is a binary string, else the payload is UTF-8 encoded Unicode text.
Returns:

List of a.w.m.Message objects.

Return type:

list

class autobahn.wamp.interfaces.IMessage[source]
MESSAGE_TYPE

WAMP message type code.

static parse(wmsg)[source]

Factory method that parses a unserialized raw message (as returned byte autobahn.interfaces.ISerializer.unserialize()) into an instance of this class.

Returns:The parsed WAMP message.
Return type:object implementing autobahn.wamp.interfaces.IMessage
serialize(serializer)[source]

Serialize this object into a wire level bytes representation and cache the resulting bytes. If the cache already contains an entry for the given serializer, return the cached representation directly.

Parameters:serializer (object implementing autobahn.wamp.interfaces.ISerializer) – The wire level serializer to use.
Returns:The serialized bytes.
Return type:bytes
uncache()[source]

Resets the serialization cache for this message.

class autobahn.wamp.interfaces.ITransport[source]

A WAMP transport is a bidirectional, full-duplex, reliable, ordered, message-based channel.

abort()[source]

Abort the transport abruptly. The transport will be destroyed as fast as possible, and without playing nice to the peer. This should only be used in case of fatal errors, protocol violations or possible detected attacks.

close()[source]

Close the transport regularly. The transport will perform any closing handshake if applicable. This should be used for any application initiated closing.

get_channel_id()[source]

Return the unique channel ID of the underlying transport. This is used to mitigate credential forwarding man-in-the-middle attacks when running application level authentication (eg WAMP-cryptosign) which are decoupled from the underlying transport.

The channel ID is only available when running over TLS (either WAMP-WebSocket or WAMP-RawSocket). It is not available for non-TLS transports (plain TCP or Unix domain sockets). It is also not available for WAMP-over-HTTP/Longpoll. Further, it is currently unimplemented for asyncio (only works on Twisted).

The channel ID is computed as follows:

  • for a client, the SHA256 over the “TLS Finished” message sent by the client to the server is returned.
  • for a server, the SHA256 over the “TLS Finished” message the server expected the client to send

Note: this is similar to tls-unique as described in RFC5929, but instead of returning the raw “TLS Finished” message, it returns a SHA256 over such a message. The reason is that we use the channel ID mainly with WAMP-cryptosign, which is based on Ed25519, where keys are always 32 bytes. And having a channel ID which is always 32 bytes (independent of the TLS ciphers/hashfuns in use) allows use to easily XOR channel IDs with Ed25519 keys and WAMP-cryptosign challenges.

WARNING: For safe use of this (that is, for safely binding app level authentication to the underlying transport), you MUST use TLS, and you SHOULD deactivate both TLS session renegotiation and TLS session resumption.

References:

Returns:The channel ID (if available) of the underlying WAMP transport. The channel ID is a 32 bytes value.
Return type:binary or None
isOpen()[source]

Check if the transport is open for messaging.

Returns:True, if the transport is open.
Return type:bool
send(message)[source]

Send a WAMP message over the transport to the peer. If the transport is not open, this raises autobahn.wamp.exception.TransportLost. Returns a deferred/future when the message has been processed and more messages may be sent. When send() is called while a previous deferred/future has not yet fired, the send will fail immediately.

Parameters:message (object implementing autobahn.wamp.interfaces.IMessage) – The WAMP message to send over the transport.
Returns:obj – A Deferred/Future
class autobahn.wamp.interfaces.ISession(config=None)[source]

Interface for WAMP sessions.

Parameters:config (instance of autobahn.wamp.types.ComponentConfig.) – Configuration for session.
call(procedure, *args, **kwargs)[source]

Call a remote procedure.

This will return a Deferred/Future, that when resolved, provides the actual result returned by the called remote procedure.

  • If the result is a single positional return value, it’ll be returned “as-is”.
  • If the result contains multiple positional return values or keyword return values, the result is wrapped in an instance of autobahn.wamp.types.CallResult.
  • If the call fails, the returned Deferred/Future will be rejected with an instance of autobahn.wamp.exception.ApplicationError.

If kwargs contains an options keyword argument that is an instance of autobahn.wamp.types.CallOptions, this will provide specific options for the call to perform.

When the Caller and Dealer implementations support canceling of calls, the call may be canceled by canceling the returned Deferred/Future.

Parameters:
  • procedure (unicode) – The URI of the remote procedure to be called, e.g. u"com.myapp.hello".
  • args (list) – Any positional arguments for the call.
  • kwargs (dict) – Any keyword arguments for the call.
Returns:

A Deferred/Future for the call result -

Return type:

instance of twisted.internet.defer.Deferred / asyncio.Future

define(exception, error=None)[source]

Defines an exception for a WAMP error in the context of this WAMP session.

Parameters:
  • exception (A class that derives of Exception.) – The exception class to define an error mapping for.
  • error (str) – The URI (or URI pattern) the exception class should be mapped for. Iff the exception class is decorated, this must be None.
disconnect()[source]

Close the underlying transport.

get_payload_codec()[source]

Get the current payload codec (if any) for the session.

Payload codecs are used with WAMP payload transparency mode.

Returns:The current payload codec or None if no codec is active.
Return type:object implementing autobahn.wamp.interfaces.IPayloadCodec or None
is_attached()[source]

Check if the session has currently joined a realm.

is_connected()[source]

Check if the underlying transport is connected.

join(realm, authmethods=None, authid=None, authrole=None, authextra=None, resumable=None, resume_session=None, resume_token=None)[source]

Attach the session to the given realm. A session is open as soon as it is attached to a realm.

leave(reason=None, message=None)[source]

Actively close this WAMP session.

Parameters:
  • reason (str) – An optional URI for the closing reason. If you want to permanently log out, this should be wamp.close.logout
  • message (str) – An optional (human readable) closing message, intended for logging purposes.
Returns:

may return a Future/Deferred that fires when we’ve disconnected

onChallenge(challenge)[source]

Callback fired when the peer demands authentication.

May return a Deferred/Future.

Parameters:challenge (Instance of autobahn.wamp.types.Challenge.) – The authentication challenge.
onConnect()[source]

Callback fired when the transport this session will run over has been established.

onDisconnect()[source]

Callback fired when underlying transport has been closed.

onJoin(details)[source]

Callback fired when WAMP session has been established.

May return a Deferred/Future.

Parameters:details (Instance of autobahn.wamp.types.SessionDetails.) – Session information.
onLeave(details)[source]

Callback fired when WAMP session has is closed

Parameters:details (Instance of autobahn.wamp.types.CloseDetails.) – Close information.
onUserError(fail, msg)[source]

This is called when we try to fire a callback, but get an exception from user code – for example, a registered publish callback or a registered method. By default, this prints the current stack-trace and then error-message to stdout.

ApplicationSession-derived objects may override this to provide logging if they prefer. The Twisted implemention does this. (See autobahn.twisted.wamp.ApplicationSession)

Parameters:
  • fail (instance implementing txaio.IFailedFuture) – The failure that occurred.
  • msg (str) – an informative message from the library. It is suggested you log this immediately after the exception.
onWelcome(welcome_msg)[source]

Callback fired after the peer has successfully authenticated. If this returns anything other than None/False, the session is aborted and the return value is used as an error message.

May return a Deferred/Future.

Parameters:welcome_msg – The WELCOME message received from the server
Returns:None, or an error message
publish(topic, *args, **kwargs)[source]

Publish an event to a topic.

If kwargs contains an options keyword argument that is an instance of autobahn.wamp.types.PublishOptions, this will provide specific options for the publish to perform.

Note

By default, publications are non-acknowledged and the publication can fail silently, e.g. because the session is not authorized to publish to the topic.

When publication acknowledgement is requested via options.acknowledge == True, this function returns a Deferred/Future:

  • If the publication succeeds the Deferred/Future will resolve to an object that implements autobahn.wamp.interfaces.IPublication.
  • If the publication fails the Deferred/Future will reject with an instance of autobahn.wamp.exception.ApplicationError.
Parameters:
  • topic (unicode) – The URI of the topic to publish to, e.g. u"com.myapp.mytopic1".
  • args (list) – Arbitrary application payload for the event (positional arguments).
  • kwargs (dict) – Arbitrary application payload for the event (keyword arguments).
Returns:

Acknowledgement for acknowledge publications - otherwise nothing.

Return type:

None or instance of twisted.internet.defer.Deferred / asyncio.Future

register(endpoint, procedure=None, options=None, prefix=None)[source]

Register a procedure for remote calling.

When endpoint is a callable (function, method or object that implements __call__), then procedure must be provided and an instance of twisted.internet.defer.Deferred (when running on Twisted) or an instance of asyncio.Future (when running on asyncio) is returned.

  • If the registration succeeds the returned Deferred/Future will resolve to an object that implements autobahn.wamp.interfaces.IRegistration.
  • If the registration fails the returned Deferred/Future will reject with an instance of autobahn.wamp.exception.ApplicationError.

When endpoint is an object, then each of the object’s methods that is decorated with autobahn.wamp.register() is automatically registered and a (single) DeferredList or Future is returned that gathers all individual underlying Deferreds/Futures.

Parameters:
  • endpoint (callable or object) – The endpoint called under the procedure.
  • procedure (unicode) – When endpoint is a callable, the URI (or URI pattern) of the procedure to register for. When endpoint is an object, the argument is ignored (and should be None).
  • options (instance of autobahn.wamp.types.RegisterOptions.) – Options for registering.
  • prefix (str) – if not None, this specifies a prefix to prepend to all URIs registered for this class. So if there was an @wamp.register(‘method_foo’) on a method and prefix=’com.something.’ then a method ‘com.something.method_foo’ would ultimately be registered.
Returns:

A registration or a list of registrations (or errors)

Return type:

instance(s) of twisted.internet.defer.Deferred / asyncio.Future

set_payload_codec(payload_codec)[source]

Set a payload codec on the session. To remove a previously set payload codec, set the codec to None.

Payload codecs are used with WAMP payload transparency mode.

Parameters:payload_codec (object implementing autobahn.wamp.interfaces.IPayloadCodec or None) – The payload codec that should process application payload of the given encoding.
subscribe(handler, topic=None, options=None)[source]

Subscribe to a topic for receiving events.

When handler is a callable (function, method or object that implements __call__), then topic must be provided and an instance of twisted.internet.defer.Deferred (when running on Twisted) or an instance of asyncio.Future (when running on asyncio) is returned.

  • If the subscription succeeds the Deferred/Future will resolve to an object that implements autobahn.wamp.interfaces.ISubscription.
  • If the subscription fails the Deferred/Future will reject with an instance of autobahn.wamp.exception.ApplicationError.

When handler is an object, then each of the object’s methods that is decorated with autobahn.wamp.subscribe() is automatically subscribed as event handlers, and a list of Deferreds/Futures is returned that each resolves or rejects as above.

Parameters:
  • handler (callable or object) – The event handler to receive events.
  • topic (unicode) – When handler is a callable, the URI (or URI pattern) of the topic to subscribe to. When handler is an object, this value is ignored (and should be None).
  • options (An instance of autobahn.wamp.types.SubscribeOptions.) – Options for subscribing.
Returns:

A single Deferred/Future or a list of such objects

Return type:

instance(s) of twisted.internet.defer.Deferred / asyncio.Future

class autobahn.wamp.interfaces.IPayloadCodec[source]

WAMP payload codecs are used with WAMP payload transparency mode.

In payload transparency mode, application payloads are transmitted “raw”, as binary strings, without any processing at the WAMP router.

Payload transparency can be used eg for these use cases:

  • end-to-end encryption of application payloads (WAMP-cryptobox)
  • using serializers with custom user types, where the serializer and the serializer implementation has native support for serializing custom types (such as CBOR)
  • transmitting MQTT payloads within WAMP, when the WAMP router is providing a MQTT-WAMP bridge
decode(is_originating, uri, encoded_payload)[source]

Decode application payload.

Parameters:
  • is_originating (bool) – Flag indicating whether the encoding is to be done from an originator (a caller or publisher).
  • uri (str) – The WAMP URI associated with the WAMP message for which the payload is to be encoded (eg topic or procedure).
  • payload (instance of autobahn.wamp.types.EncodedPayload) – The encoded application payload to be decoded.
Returns:

A tuple with the decoded positional and keyword-based application payload: (uri, args, kwargs)

Return type:

tuple

encode(is_originating, uri, args=None, kwargs=None)[source]

Encodes application payload.

Parameters:
  • is_originating (bool) – Flag indicating whether the encoding is to be done from an originator (a caller or publisher).
  • uri (str) – The WAMP URI associated with the WAMP message for which the payload is to be encoded (eg topic or procedure).
  • args (list or None) – Positional application payload.
  • kwargs (dict or None) – Keyword-based application payload.
Returns:

The encoded application payload or None to signal no encoding should be used.

Return type:

instance of autobahn.wamp.types.EncodedPayload

WAMP Types

class autobahn.wamp.types.ComponentConfig(realm=None, extra=None, keyring=None, controller=None, shared=None, runner=None)[source]

WAMP application component configuration. An instance of this class is provided to the constructor of autobahn.wamp.protocol.ApplicationSession.

Parameters:
  • realm (str) – The realm the session would like to join or None to let the router auto-decide the realm (if the router is configured and allowing to do so).
  • extra (arbitrary) – Optional user-supplied object with extra configuration. This can be any object you like, and is accessible in your ApplicationSession subclass via self.config.extra. dict is a good default choice. Important: if the component is to be hosted by Crossbar.io, the supplied value must be JSON serializable.
  • keyring (obj implementing IKeyRing or None) – A mapper from WAMP URIs to “from”/”to” Ed25519 keys. When using WAMP end-to-end encryption, application payload is encrypted using a symmetric message key, which in turn is encrypted using the “to” URI (topic being published to or procedure being called) public key and the “from” URI private key. In both cases, the key for the longest matching URI is used.
  • controller (instance of ApplicationSession or None) – A WAMP ApplicationSession instance that holds a session to a controlling entity. This optional feature needs to be supported by a WAMP component hosting run-time.
  • shared (dict or None) – A dict object to exchange user information or hold user objects shared between components run under the same controlling entity. This optional feature needs to be supported by a WAMP component hosting run-time. Use with caution, as using this feature can introduce coupling between components. A valid use case would be to hold a shared database connection pool.
  • runner (autobahn.twisted.wamp.ApplicationRunner) – Instance of ApplicationRunner when run under this.
class autobahn.wamp.types.HelloReturn[source]

Base class for HELLO return information.

class autobahn.wamp.types.Accept(realm=None, authid=None, authrole=None, authmethod=None, authprovider=None, authextra=None)[source]

Information to accept a HELLO.

Parameters:
  • realm (str) – The realm the client is joined to.
  • authid (str) – The authentication ID the client is assigned, e.g. "joe" or "joe@example.com".
  • authrole (str) – The authentication role the client is assigned, e.g. "anonymous", "user" or "com.myapp.user".
  • authmethod (str) – The authentication method that was used to authenticate the client, e.g. "cookie" or "wampcra".
  • authprovider (str) – The authentication provider that was used to authenticate the client, e.g. "mozilla-persona".
  • authextra (dict) – Application-specific authextra to be forwarded to the client in WELCOME.details.authextra.
class autobahn.wamp.types.Deny(reason=u'wamp.error.not_authorized', message=None)[source]

Information to deny a HELLO.

Parameters:
  • reason (str) – The reason of denying the authentication (an URI, e.g. u'wamp.error.not_authorized')
  • message (str) – A human readable message (for logging purposes).
class autobahn.wamp.types.Challenge(method, extra=None)[source]

Information to challenge the client upon HELLO.

Parameters:
  • method (str) – The authentication method for the challenge (e.g. "wampcra").
  • extra (dict) – Any extra information for the authentication challenge. This is specific to the authentication method.
class autobahn.wamp.types.HelloDetails(realm=None, authmethods=None, authid=None, authrole=None, authextra=None, session_roles=None, pending_session=None, resumable=None, resume_session=None, resume_token=None)[source]

Provides details of a WAMP session while still attaching.

Parameters:
  • realm (str or None) – The realm the client wants to join.
  • authmethods (list of str or None) – The authentication methods the client is willing to perform.
  • authid (str or None) – The authid the client wants to authenticate as.
  • authrole (str or None) – The authrole the client wants to authenticate as.
  • authextra (arbitrary or None) – Any extra information the specific authentication method requires the client to send.
  • session_roles (dict or None) – The WAMP session roles and features by the connecting client.
  • pending_session (int or None) – The session ID the session will get once successfully attached.
  • resumable (bool or None) –
  • resume_session (int or None) – The session the client would like to resume.
  • resume_token (str or None) – The secure authorisation token to resume the session.
class autobahn.wamp.types.SessionDetails(realm, session, authid=None, authrole=None, authmethod=None, authprovider=None, authextra=None, serializer=None, resumed=None, resumable=None, resume_token=None)[source]

Provides details for a WAMP session upon open.

Parameters:
  • realm (str) – The realm this WAMP session is attached to.
  • session (int) – WAMP session ID of this session.
  • resumed (bool or None) – Whether the session is a resumed one.
  • resumable (bool or None) – Whether this session can be resumed later.
  • resume_token (str or None) – The secure authorisation token to resume the session.
class autobahn.wamp.types.SessionIdent(session=None, authid=None, authrole=None)[source]

WAMP session identification information.

A WAMP session joined on a realm on a WAMP router is identified technically by its session ID (session) already.

The permissions the session has are tied to the WAMP authentication role (authrole).

The subject behind the session, eg the user or the application component is identified by the WAMP authentication ID (authid). One session is always authenticated under/as one specific authid, but a given authid might have zero, one or many sessions joined on a router at the same time.

Parameters:
  • session (int) – WAMP session ID of the session.
  • authid (str) – The WAMP authid of the session.
  • authrole (str) – The WAMP authrole of the session.
static from_calldetails(call_details)[source]

Create a new session identification object from the caller information in the call details provided.

Parameters:call_details (autobahn.wamp.types.CallDetails) – Details of a WAMP call.
Returns:New session identification object.
Return type:autobahn.wamp.types.SessionIdent
static from_eventdetails(event_details)[source]

Create a new session identification object from the publisher information in the event details provided.

Parameters:event_details (autobahn.wamp.types.EventDetails) – Details of a WAMP event.
Returns:New session identification object.
Return type:autobahn.wamp.types.SessionIdent
class autobahn.wamp.types.CloseDetails(reason=None, message=None)[source]

Provides details for a WAMP session upon close.

Parameters:
  • reason (str) – The close reason (an URI, e.g. wamp.close.normal)
  • message (str) – Closing log message.
class autobahn.wamp.types.SubscribeOptions(match=None, details=None, details_arg=None, forward_for=None, get_retained=None, correlation_id=None, correlation_uri=None, correlation_is_anchor=None, correlation_is_last=None)[source]

Used to provide options for subscribing in autobahn.wamp.interfaces.ISubscriber.subscribe().

Parameters:
  • match (str) – The topic matching method to be used for the subscription.
  • details (bool) – When invoking the handler, provide event details in a keyword parameter details.
  • details_arg (str) – DEPCREATED (use “details” flag). When invoking the handler provide event details in this keyword argument to the callable.
  • get_retained (bool or None) – Whether the client wants the retained message we may have along with the subscription.
message_attr()[source]

Returns options dict as sent within WAMP messages.

class autobahn.wamp.types.EventDetails(subscription, publication, publisher=None, publisher_authid=None, publisher_authrole=None, topic=None, retained=None, enc_algo=None, forward_for=None)[source]

Provides details on an event when calling an event handler previously registered.

Parameters:
  • subscription (instance of autobahn.wamp.request.Subscription) – The (client side) subscription object on which this event is delivered.
  • publication (int) – The publication ID of the event (always present).
  • publisher (None or int) – The WAMP session ID of the original publisher of this event. Only filled when publisher is disclosed.
  • publisher_authid (str or None) – The WAMP authid of the original publisher of this event. Only filled when publisher is disclosed.
  • publisher_authrole (str or None) – The WAMP authrole of the original publisher of this event. Only filled when publisher is disclosed.
  • topic (str or None) – For pattern-based subscriptions, the actual topic URI being published to. Only filled for pattern-based subscriptions.
  • retained (bool or None) – Whether the message was retained by the broker on the topic, rather than just published.
  • enc_algo (str or None) – Payload encryption algorithm that was in use (currently, either None or u'cryptobox').
  • forward_for (list[dict]) – When this Event is forwarded for a client (or from an intermediary router).
class autobahn.wamp.types.PublishOptions(acknowledge=None, exclude_me=None, exclude=None, exclude_authid=None, exclude_authrole=None, eligible=None, eligible_authid=None, eligible_authrole=None, retain=None, forward_for=None, correlation_id=None, correlation_uri=None, correlation_is_anchor=None, correlation_is_last=None)[source]

Used to provide options for subscribing in autobahn.wamp.interfaces.IPublisher.publish().

Parameters:
  • acknowledge (bool) – If True, acknowledge the publication with a success or error response.
  • exclude_me (bool or None) – If True, exclude the publisher from receiving the event, even if he is subscribed (and eligible).
  • exclude (int or list of int or None) – A single WAMP session ID or a list thereof to exclude from receiving this event.
  • exclude_authid (str or list of str or None) – A single WAMP authid or a list thereof to exclude from receiving this event.
  • exclude_authrole (list of str or None) – A single WAMP authrole or a list thereof to exclude from receiving this event.
  • eligible (int or list of int or None) – A single WAMP session ID or a list thereof eligible to receive this event.
  • eligible_authid (str or list of str or None) – A single WAMP authid or a list thereof eligible to receive this event.
  • eligible_authrole (str or list of str or None) – A single WAMP authrole or a list thereof eligible to receive this event.
  • retain (bool or None) – If True, request the broker retain this event.
  • forward_for (list[dict]) – When this Event is forwarded for a client (or from an intermediary router).
message_attr()[source]

Returns options dict as sent within WAMP messages.

class autobahn.wamp.types.RegisterOptions(match=None, invoke=None, concurrency=None, force_reregister=None, forward_for=None, details=None, details_arg=None, correlation_id=None, correlation_uri=None, correlation_is_anchor=None, correlation_is_last=None)[source]

Used to provide options for registering in autobahn.wamp.interfaces.ICallee.register().

Parameters:
  • match – Type of matching to use on the URI (exact, prefix or wildcard)
  • invoke – Type of invoke mechanism to use (single, first, last, roundrobin, random)
  • concurrency – if used, the number of times a particular endpoint may be called concurrently (e.g. if this is 3, and there are already 3 calls in-progress a 4th call will receive an error)
  • details_arg (str) – When invoking the endpoint, provide call details in this keyword argument to the callable.
  • details (bool) – When invoking the endpoint, provide call details in a keyword parameter details.
  • details_arg – DEPCREATED (use “details” flag). When invoking the endpoint, provide call details in this keyword argument to the callable.
  • force_reregister (bool) – if True, any other session that has already registered this URI will be ‘kicked out’ and this session will become the one that’s registered (the previous session must have used force_reregister=True as well)
  • forward_for (list[dict]) – When this Register is forwarded over a router-to-router link, or via an intermediary router.
message_attr()[source]

Returns options dict as sent within WAMP messages.

class autobahn.wamp.types.CallDetails(registration, progress=None, caller=None, caller_authid=None, caller_authrole=None, procedure=None, enc_algo=None, forward_for=None)[source]

Provides details on a call when an endpoint previously registered is being called and opted to receive call details.

Parameters:
  • registration (instance of autobahn.wamp.request.Registration) – The (client side) registration object this invocation is delivered on.
  • progress (callable or None) – A callable that will receive progressive call results.
  • caller (int or None) – The WAMP session ID of the caller, if the latter is disclosed. Only filled when caller is disclosed.
  • caller_authid (str or None) – The WAMP authid of the original caller of this event. Only filled when caller is disclosed.
  • caller_authrole (str or None) – The WAMP authrole of the original caller of this event. Only filled when caller is disclosed.
  • procedure (str or None) – For pattern-based registrations, the actual procedure URI being called.
  • enc_algo (str or None) – Payload encryption algorithm that was in use (currently, either None or “cryptobox”).
  • forward_for (list[dict]) – When this Call is forwarded for a client (or from an intermediary router).
class autobahn.wamp.types.CallOptions(on_progress=None, timeout=None, caller=None, caller_authid=None, caller_authrole=None, forward_for=None, correlation_id=None, correlation_uri=None, correlation_is_anchor=None, correlation_is_last=None, details=None)[source]

Used to provide options for calling with autobahn.wamp.interfaces.ICaller.call().

Parameters:
  • on_progress (callable) – A callback that will be called when the remote endpoint called yields interim call progress results.
  • timeout (float) – Time in seconds after which the call should be automatically canceled.
  • forward_for (list[dict]) – When this Call is forwarded for a client (or from an intermediary router).
message_attr()[source]

Returns options dict as sent within WAMP messages.

class autobahn.wamp.types.CallResult(*results, **kwresults)[source]

Wrapper for remote procedure call results that contain multiple positional return values or keyword-based return values.

Parameters:
  • results (list) – The positional result values.
  • kwresults (dict) – The keyword result values.
class autobahn.wamp.types.EncodedPayload(payload, enc_algo, enc_serializer=None, enc_key=None)[source]

Wrapper holding an encoded application payload when using WAMP payload transparency.

Parameters:
  • payload (bytes) – The encoded application payload.
  • enc_algo (str) – The payload transparency algorithm identifier to check.
  • enc_serializer (str) – The payload transparency serializer identifier to check.
  • enc_key (str or None) – If using payload transparency with an encryption algorithm, the payload encryption key.

WAMP Exceptions

exception autobahn.wamp.exception.Error[source]

Base class for all exceptions related to WAMP.

exception autobahn.wamp.exception.SessionNotReady[source]

The application tried to perform a WAMP interaction, but the session is not yet fully established.

exception autobahn.wamp.exception.SerializationError[source]

Exception raised when the WAMP serializer could not serialize the application payload (args or kwargs for CALL, PUBLISH, etc).

exception autobahn.wamp.exception.ProtocolError[source]

Exception raised when WAMP protocol was violated. Protocol errors are fatal and are handled by the WAMP implementation. They are not supposed to be handled at the application level.

exception autobahn.wamp.exception.TransportLost[source]

Exception raised when the transport underlying the WAMP session was lost or is not connected.

exception autobahn.wamp.exception.ApplicationError(error, *args, **kwargs)[source]

Base class for all exceptions that can/may be handled at the application level.

Parameters:error (str) – The URI of the error that occurred, e.g. wamp.error.not_authorized.
AUTHENTICATION_FAILED = u'wamp.error.authentication_failed'

Something failed with the authentication itself, that is, authentication could not run to end.

AUTHORIZATION_FAILED = u'wamp.error.authorization_failed'

A Dealer or Broker could not determine if the Peer is authorized to perform a join, call, register, publish or subscribe, since the authorization operation itself failed. E.g. a custom authorizer did run into an error.

CANCELED = u'wamp.error.canceled'

A Dealer or Callee canceled a call previously issued (WAMP AP).

CLOSE_REALM = u'wamp.error.close_realm'

The Peer want to leave the realm - used as a GOODBYE reason.

ENC_DECRYPT_ERROR = u'wamp.error.encryption.decrypt_error'

WAMP-cryptobox application payload end-to-end encryption error.

ENC_NO_PAYLOAD_CODEC = u'wamp.error.no_payload_codec'

WAMP message in payload transparency mode received, but no codec set or codec did not decode the payload.

ENC_TRUSTED_URI_MISMATCH = u'wamp.error.encryption.trusted_uri_mismatch'

WAMP-cryptobox application payload end-to-end encryption error.

GOODBYE_AND_OUT = u'wamp.error.goodbye_and_out'

A Peer acknowledges ending of a session - used as a GOOBYE reply reason.

INVALID_ARGUMENT = u'wamp.error.invalid_argument'

A call failed, since the given argument types or values are not acceptable to the called procedure - in which case the Callee may throw this error. Or a Router performing payload validation checked the payload (args / kwargs) of a call, call result, call error or publish, and the payload did not conform.

INVALID_PAYLOAD = u'wamp.error.invalid_payload'

The application payload could not be serialized.

INVALID_URI = u'wamp.error.invalid_uri'

Peer provided an incorrect URI for a URI-based attribute of a WAMP message such as a realm, topic or procedure.

NOT_AUTHORIZED = u'wamp.error.not_authorized'

A call, register, publish or subscribe failed, since the session is not authorized to perform the operation.

NO_AUTH_METHOD = u'wamp.error.no_auth_method'

No authentication method the peer offered is available or active.

NO_ELIGIBLE_CALLEE = u'wamp.error.no_eligible_callee'

A Dealer could not perform a call, since a procedure with the given URI is registered, but Callee Black- and Whitelisting and/or Caller Exclusion lead to the exclusion of (any) Callee providing the procedure (WAMP AP).

NO_SUCH_PRINCIPAL = u'wamp.error.no_such_principal'

A Peer was authenticated for an authid that does not or longer exists.

NO_SUCH_PROCEDURE = u'wamp.error.no_such_procedure'

A Dealer could not perform a call, since not procedure is currently registered under the given URI.

NO_SUCH_REALM = u'wamp.error.no_such_realm'

Peer wanted to join a non-existing realm (and the Router did not allow to auto-create the realm).

NO_SUCH_REGISTRATION = u'wamp.error.no_such_registration'

A Dealer could not perform a unregister, since the given registration is not active.

NO_SUCH_ROLE = u'wamp.error.no_such_role'

A Peer was to be authenticated under a Role that does not (or no longer) exists on the Router. For example, the Peer was successfully authenticated, but the Role configured does not exists - hence there is some misconfiguration in the Router.

NO_SUCH_SESSION = u'wamp.error.no_such_session'

A router could not perform an operation, since a session ID specified was non-existant.

NO_SUCH_SUBSCRIPTION = u'wamp.error.no_such_subscription'

A Broker could not perform a unsubscribe, since the given subscription is not active.

PAYLOAD_SIZE_EXCEEDED = u'wamp.error.payload_size_exceeded'

The application payload could not be transported becuase the serialized/framed payload exceeds the transport limits.

PROCEDURE_ALREADY_EXISTS = u'wamp.error.procedure_already_exists'

A procedure could not be registered, since a procedure with the given URI is already registered.

PROCEDURE_EXISTS_INVOCATION_POLICY_CONFLICT = u'wamp.error.procedure_exists_with_different_invocation_policy'

A procedure could not be registered, since a procedure with the given URI is already registered, and the registration has a conflicting invocation policy.

SYSTEM_SHUTDOWN = u'wamp.error.system_shutdown'

The Peer is shutting down completely - used as a GOODBYE (or ABORT) reason.

TIMEOUT = u'wamp.error.timeout'

A pending (in-flight) call was timed out.

error_message()[source]

Get the error message of this exception.

Returns:The error message.
Return type:str
exception autobahn.wamp.exception.NotAuthorized[source]

Not authorized to perform the respective action.

exception autobahn.wamp.exception.InvalidUri[source]

The URI for a topic, procedure or error is not a valid WAMP URI.

WAMP Authentication and Encryption

class autobahn.wamp.auth.AuthScram(**kw)[source]

Bases: object

Implements “wamp-scram” authentication for components.

NOTE: This is a prototype of a draft spec; see https://github.com/wamp-proto/wamp-proto/issues/135

on_welcome(session, authextra)[source]

When the server is satisfied, it sends a ‘WELCOME’ message.

This hook allows us an opportunity to deny the session right before it gets set up – we check the server-signature thus authorizing the server and if it fails we drop the connection.

autobahn.wamp.auth.pbkdf2(data, salt, iterations=1000, keylen=32, hashfunc=None)[source]

Returns a binary digest for the PBKDF2 hash algorithm of data with the given salt. It iterates iterations time and produces a key of keylen bytes. By default SHA-256 is used as hash function, a different hashlib hashfunc can be provided.

Parameters:
  • data (bytes) – The data for which to compute the PBKDF2 derived key.
  • salt (bytes) – The salt to use for deriving the key.
  • iterations (int) – The number of iterations to perform in PBKDF2.
  • keylen (int) – The length of the cryptographic key to derive.
  • hashfunc (str) – Name of the hash algorithm to use
Returns:

The derived cryptographic key.

Return type:

bytes

autobahn.wamp.auth.generate_totp_secret(length=10)[source]

Generates a new Base32 encoded, random secret.

Parameters:length (int) – The length of the entropy used to generate the secret.
Returns:The generated secret in Base32 (letters A-Z and digits 2-7). The length of the generated secret is length * 8 / 5 octets.
Return type:unicode
autobahn.wamp.auth.compute_totp(secret, offset=0)[source]

Computes the current TOTP code.

Parameters:
  • secret (unicode) – Base32 encoded secret.
  • offset (int) – Time offset (in steps, use eg -1, 0, +1 for compliance with RFC6238) for which to compute TOTP.
Returns:

TOTP for current time (+/- offset).

Return type:

unicode

autobahn.wamp.auth.derive_key(secret, salt, iterations=1000, keylen=32)[source]

Computes a derived cryptographic key from a password according to PBKDF2.

Parameters:
  • secret (bytes or unicode) – The secret.
  • salt (bytes or unicode) – The salt to be used.
  • iterations (int) – Number of iterations of derivation algorithm to run.
  • keylen (int) – Length of the key to derive in bytes.
Returns:

The derived key in Base64 encoding.

Return type:

bytes

autobahn.wamp.auth.generate_wcs(length=14)[source]

Generates a new random secret for use with WAMP-CRA.

The secret generated is a random character sequence drawn from

  • upper and lower case latin letters
  • digits
Parameters:length (int) – The length of the secret to generate.
Returns:The generated secret. The length of the generated is length octets.
Return type:bytes
autobahn.wamp.auth.compute_wcs(key, challenge)[source]

Compute an WAMP-CRA authentication signature from an authentication challenge and a (derived) key.

Parameters:
  • key (bytes) – The key derived (via PBKDF2) from the secret.
  • challenge (bytes) – The authentication challenge to sign.
Returns:

The authentication signature.

Return type:

bytes

class autobahn.wamp.cryptobox.EncodedPayload(payload, enc_algo, enc_serializer=None, enc_key=None)[source]

Wrapper holding an encoded application payload when using WAMP payload transparency.

Parameters:
  • payload (bytes) – The encoded application payload.
  • enc_algo (str) – The payload transparency algorithm identifier to check.
  • enc_serializer (str) – The payload transparency serializer identifier to check.
  • enc_key (str or None) – If using payload transparency with an encryption algorithm, the payload encryption key.