def connectionMade(self):
if self.factory.debug:
self.log.debug("WampRawSocketProtocol: connection made")
# the peer we are connected to
#
try:
peer = self.transport.getPeer()
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
# this will hold an ApplicationSession object
# once the RawSocket opening handshake has been
# completed
#
self._session = None
# Will hold the negotiated serializer once the opening handshake is complete
#
self._serializer = None
# Will be set to True once the opening handshake is complete
#
self._handshake_complete = False
# Buffer for opening handshake received bytes.
#
self._handshake_bytes = b''
# Clinet requested maximum length of serialized messages.
#
self._max_len_send = None
def connectionMade(self):
if self.factory.debug:
log.msg("WampRawSocketProtocol: connection made")
# the peer we are connected to
#
try:
peer = self.transport.getPeer()
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
# this will hold an ApplicationSession object
# once the RawSocket opening handshake has been
# completed
#
self._session = None
# Will hold the negotiated serializer once the opening handshake is complete
#
self._serializer = None
# Will be set to True once the opening handshake is complete
#
self._handshake_complete = False
# Buffer for opening handshake received bytes.
#
self._handshake_bytes = b''
# Clinet requested maximum length of serialized messages.
#
self._max_len_send = None
def __init__(self, factory, on_message, real_transport):
self.factory = factory
self.on_message = on_message
self.transport = real_transport
real_transport._transport_config = {'foo': 32}
self._transport_info = {
'type': 'mqtt',
'peer': peer2str(self.transport.getPeer()),
}
def __init__(self, factory, on_message, real_transport):
self.factory = factory
self.on_message = on_message
self.transport = real_transport
real_transport._transport_config = {u'foo': 32}
self._transport_info = {
u'type': u'mqtt',
u'peer': peer2str(self.transport.getPeer()),
}
def connectionMade(self):
# the peer we are connected to
try:
self.peer = peer2str(self.transport.getPeer())
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = u'process:{}'.format(self.transport.pid)
self._connectionMade()
self.log.debug('Connection made to {peer}', peer=self.peer)
# Set "Nagle"
try:
self.transport.setTcpNoDelay(self.tcpNoDelay)
except: # don't touch this! does not work: AttributeError, OSError
# eg Unix Domain sockets throw Errno 22 on this
pass
def connectionMade(self):
# the peer we are connected to
try:
self.peer = peer2str(self.transport.getPeer())
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = u'process:{}'.format(self.transport.pid)
self._connectionMade()
self.log.debug('Connection made to {peer}', peer=self.peer)
# Set "Nagle"
try:
self.transport.setTcpNoDelay(self.tcpNoDelay)
except: # don't touch this! does not work: AttributeError, OSError
# eg Unix Domain sockets throw Errno 22 on this
pass
def connectionMade(self):
# the peer we are connected to
try:
peer = self.transport.getPeer()
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
self._connectionMade()
# Set "Nagle"
try:
self.transport.setTcpNoDelay(self.tcpNoDelay)
except: # don't touch this! does not work: AttributeError, OSError
# eg Unix Domain sockets throw Errno 22 on this
pass
def connectionMade(self):
# the peer we are connected to
try:
peer = self.transport.getPeer()
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
self._connectionMade()
# Set "Nagle"
try:
self.transport.setTcpNoDelay(self.tcpNoDelay)
except: # don't touch this! does not work: AttributeError, OSError
# eg Unix Domain sockets throw Errno 22 on this
pass
def connectionMade(self):
if self.factory.debug:
log.msg("WAMP-over-RawSocket connection made")
## the peer we are connected to
##
try:
peer = self.transport.getPeer()
except AttributeError:
## ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
try:
self._session = self.factory._factory()
self._session.onOpen(self)
except Exception as e:
## Exceptions raised in onOpen are fatal ..
if self.factory.debug:
log.msg("ApplicationSession constructor / onOpen raised ({0})".format(e))
self.abort()
def connectionMade(self):
if self.factory.debug:
log.msg("WAMP-over-RawSocket connection made")
# the peer we are connected to
##
try:
peer = self.transport.getPeer()
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
try:
self._session = self.factory._factory()
self._session.onOpen(self)
except Exception as e:
# Exceptions raised in onOpen are fatal ..
if self.factory.debug:
log.msg("ApplicationSession constructor / onOpen raised ({0})".format(e))
self.abort()
def connectionMade(self):
self.log.debug('{klass}.connectionMade()',
klass=self.__class__.__name__)
# the peer we are connected to
#
try:
peer = self.transport.getPeer()
except AttributeError:
# ProcessProtocols lack getPeer()
self.peer = "?"
else:
self.peer = peer2str(peer)
# a Future/Deferred that fires when we hit STATE_CLOSED
self.is_closed = txaio.create_future()
# this will hold an ApplicationSession object
# once the RawSocket opening handshake has been
# completed
#
self._session = None
# Will hold the negotiated serializer once the opening handshake is complete
#
self._serializer = None
# Will be set to True once the opening handshake is complete
#
self._handshake_complete = False
# Buffer for opening handshake received bytes.
#
self._handshake_bytes = b''
# Peer requested to _receive_ this maximum length of serialized messages - hence we must not send larger msgs!
#
self._max_len_send = None
def process_connect(self, packet):
"""
Process the initial Connect message from the MQTT client.
This should return a pair `(accept_conn, session_present)`, where
`accept_conn` is a return code:
0: connection accepted
1-5: connection refused (see MQTT spec 3.2.2.3)
"""
# Connect(client_id='paho/4E23D8C09DD9C6CF2C',
# flags=ConnectFlags(username=False,
# password=False,
# will=False,
# will_retain=False,
# will_qos=0,
# clean_session=True,
# reserved=False),
# keep_alive=60,
# will_topic=None,
# will_message=None,
# username=None,
# password=None)
self.log.info(
'WampMQTTServerProtocol.process_connect(packet={packet})',
packet=packet)
# we don't support session resumption: https://github.com/crossbario/crossbar/issues/892
if not packet.flags.clean_session:
self.log.warn(
'denying MQTT connect from {peer}, as the clients wants to resume a session (which we do not support)',
peer=peer2str(self.transport.getPeer()))
return succeed((1, False))
# we won't support QoS 2: https://github.com/crossbario/crossbar/issues/1046
if packet.flags.will and packet.flags.will_qos not in [0, 1]:
self.log.warn(
'denying MQTT connect from {peer}, as the clients wants to provide a "last will" event with QoS {will_qos} (and we only support QoS 0/1 here)',
peer=peer2str(self.transport.getPeer()),
will_qos=packet.flags.will_qos)
return succeed((1, False))
# this will be resolved when the MQTT connect handshake is completed
self._waiting_for_connect = Deferred()
roles = {
"subscriber":
role.RoleSubscriberFeatures(payload_transparency=True,
pattern_based_subscription=True),
"publisher":
role.RolePublisherFeatures(payload_transparency=True,
x_acknowledged_event_delivery=True)
}
realm = self.factory._options.get('realm', None)
authmethods = []
authextra = {
'mqtt': {
'client_id': packet.client_id,
'will': bool(packet.flags.will),
'will_topic': packet.will_topic
}
}
if ISSLTransport.providedBy(self.transport):
authmethods.append("tls")
if packet.username and packet.password:
authmethods.append("ticket")
msg = message.Hello(realm=realm,
roles=roles,
authmethods=authmethods,
authid=packet.username,
authextra=authextra)
self._pw_challenge = packet.password
else:
authmethods.append("anonymous")
msg = message.Hello(realm=realm,
roles=roles,
authmethods=authmethods,
authid=packet.client_id,
authextra=authextra)
self._wamp_session.onMessage(msg)
if packet.flags.will:
# it's unclear from the MQTT spec whether a) the publication of the last will
# is to happen in-band during "connect", and if it fails, deny the connection,
# or b) the last will publication happens _after_ "connect", and the connection
# succeeds regardless whether the last will publication succeeds or not.
#
# we opt for b) here!
#
@inlineCallbacks
@self._waiting_for_connect.addCallback
def process_will(res):
self.log.info()
payload_format, mapped_topic, options = yield self.factory.transform_mqtt(
packet.will_topic, packet.will_message)
request = util.id()
msg = message.Call(
request=request,
procedure="wamp.session.add_testament",
args=[
mapped_topic,
options.get('args', None),
options.get('kwargs', None),
{
# specifiy "retain" for when the testament (last will)
# will be auto-published by the broker later
'retain': bool(packet.flags.will_retain)
}
])
self._wamp_session.onMessage(msg)
returnValue(res)
return self._waiting_for_connect
def process_connect(self, packet):
"""
Process the initial Connect message from the MQTT client.
This should return a pair `(accept_conn, session_present)`, where
`accept_conn` is a return code:
0: connection accepted
1-5: connection refused (see MQTT spec 3.2.2.3)
"""
# Connect(client_id='paho/4E23D8C09DD9C6CF2C',
# flags=ConnectFlags(username=False,
# password=False,
# will=False,
# will_retain=False,
# will_qos=0,
# clean_session=True,
# reserved=False),
# keep_alive=60,
# will_topic=None,
# will_message=None,
# username=None,
# password=None)
self.log.info('WampMQTTServerProtocol.process_connect(packet={packet})', packet=packet)
# we don't support session resumption: https://github.com/crossbario/crossbar/issues/892
if not packet.flags.clean_session:
self.log.warn('denying MQTT connect from {peer}, as the clients wants to resume a session (which we do not support)', peer=peer2str(self.transport.getPeer()))
return succeed((1, False))
# we won't support QoS 2: https://github.com/crossbario/crossbar/issues/1046
if packet.flags.will and packet.flags.will_qos not in [0, 1]:
self.log.warn('denying MQTT connect from {peer}, as the clients wants to provide a "last will" event with QoS {will_qos} (and we only support QoS 0/1 here)', peer=peer2str(self.transport.getPeer()), will_qos=packet.flags.will_qos)
return succeed((1, False))
# this will be resolved when the MQTT connect handshake is completed
self._waiting_for_connect = Deferred()
roles = {
u"subscriber": role.RoleSubscriberFeatures(
payload_transparency=True,
pattern_based_subscription=True),
u"publisher": role.RolePublisherFeatures(
payload_transparency=True,
x_acknowledged_event_delivery=True)
}
realm = self.factory._options.get(u'realm', None)
authmethods = []
authextra = {
u'mqtt': {
u'client_id': packet.client_id,
u'will': bool(packet.flags.will),
u'will_topic': packet.will_topic
}
}
if ISSLTransport.providedBy(self.transport):
authmethods.append(u"tls")
if packet.username and packet.password:
authmethods.append(u"ticket")
msg = message.Hello(
realm=realm,
roles=roles,
authmethods=authmethods,
authid=packet.username,
authextra=authextra)
self._pw_challenge = packet.password
else:
authmethods.append(u"anonymous")
msg = message.Hello(
realm=realm,
roles=roles,
authmethods=authmethods,
authid=packet.client_id,
authextra=authextra)
self._wamp_session.onMessage(msg)
if packet.flags.will:
# it's unclear from the MQTT spec whether a) the publication of the last will
# is to happen in-band during "connect", and if it fails, deny the connection,
# or b) the last will publication happens _after_ "connect", and the connection
# succeeds regardless whether the last will publication succeeds or not.
#
# we opt for b) here!
#
@inlineCallbacks
@self._waiting_for_connect.addCallback
def process_will(res):
self.log.info()
payload_format, mapped_topic, options = yield self.factory.transform_mqtt(packet.will_topic, packet.will_message)
request = util.id()
msg = message.Call(
request=request,
procedure=u"wamp.session.add_testament",
args=[
mapped_topic,
options.get('args', None),
options.get('kwargs', None),
{
# specifiy "retain" for when the testament (last will)
# will be auto-published by the broker later
u'retain': bool(packet.flags.will_retain)
}
])
self._wamp_session.onMessage(msg)
returnValue(res)
return self._waiting_for_connect
