def dataReceived(self, data):
if self._handshake_complete:
WampRawSocketProtocol.dataReceived(self, data)
else:
remaining = 4 - len(self._handshake_bytes)
self._handshake_bytes += data[:remaining]
if len(self._handshake_bytes) == 4:
self.log.debug(
"WampRawSocketProtocol: opening handshake received - {handshake}",
handshake=_LazyHexFormatter(self._handshake_bytes),
)
if ord(self._handshake_bytes[0:1]) != 0x7f:
self.log.debug(
"WampRawSocketProtocol: invalid magic byte (octet 1) in opening handshake: was 0x{magic}, but expected 0x7f",
magic=_LazyHexFormatter(self._handshake_bytes[0]),
)
self.abort()
# peer requests us to send messages of maximum length 2**max_len_exp
#
self._max_len_send = 2**(
9 + (ord(self._handshake_bytes[1:2]) >> 4))
self.log.debug(
"WampRawSocketProtocol: server requests us to send out most {max} bytes per message",
max=self._max_len_send,
)
# client wants to speak this serialization format
#
ser_id = ord(self._handshake_bytes[1:2]) & 0x0F
if ser_id != self._serializer.RAWSOCKET_SERIALIZER_ID:
self.log.error(
"WampRawSocketProtocol: opening handshake - no suitable serializer found (server replied {serializer}, and we requested {serializers})",
serializer=ser_id,
serializers=self._serializer.RAWSOCKET_SERIALIZER_ID,
)
self.abort()
self._handshake_complete = True
self._on_handshake_complete()
self.log.debug(
"WampRawSocketProtocol: opening handshake completed (using serializer {serializer})",
serializer=self._serializer,
)
# consume any remaining data received already ..
#
data = data[remaining:]
if data:
self.dataReceived(data)
def dataReceived(self, data):
if self._handshake_complete:
WampRawSocketProtocol.dataReceived(self, data)
else:
remaining = 4 - len(self._handshake_bytes)
self._handshake_bytes += data[:remaining]
if len(self._handshake_bytes) == 4:
self.log.debug(
"WampRawSocketProtocol: opening handshake received - {handshake}",
handshake=_LazyHexFormatter(self._handshake_bytes),
)
if ord(self._handshake_bytes[0:1]) != 0x7f:
self.log.debug(
"WampRawSocketProtocol: invalid magic byte (octet 1) in opening handshake: was 0x{magic}, but expected 0x7f",
magic=_LazyHexFormatter(self._handshake_bytes[0]),
)
self.abort()
# peer requests us to send messages of maximum length 2**max_len_exp
#
self._max_len_send = 2 ** (9 + (ord(self._handshake_bytes[1:2]) >> 4))
self.log.debug(
"WampRawSocketProtocol: server requests us to send out most {max} bytes per message",
max=self._max_len_send,
)
# client wants to speak this serialization format
#
ser_id = ord(self._handshake_bytes[1:2]) & 0x0F
if ser_id != self._serializer.RAWSOCKET_SERIALIZER_ID:
self.log.error(
"WampRawSocketProtocol: opening handshake - no suitable serializer found (server replied {serializer}, and we requested {serializers})",
serializer=ser_id,
serializers=self._serializer.RAWSOCKET_SERIALIZER_ID,
)
self.abort()
self._handshake_complete = True
self._on_handshake_complete()
self.log.debug(
"WampRawSocketProtocol: opening handshake completed (using serializer {serializer})",
serializer=self._serializer,
)
# consume any remaining data received already ..
#
data = data[remaining:]
if data:
self.dataReceived(data)
def render_POST(self, request):
"""
A client sends a message via WAMP-over-Longpoll by HTTP/POSTing
to this Web resource. The body of the POST should contain a batch
of WAMP messages which are serialized according to the selected
serializer, and delimited by a single ``\0`` byte in between two WAMP
messages in the batch.
"""
payload = request.content.read()
self.log.debug(
"WampLongPoll: receiving data for transport '{tid}'\n{octets}",
tid=self._parent._transport_id,
octets=_LazyHexFormatter(payload),
)
try:
# process (batch of) WAMP message(s)
self._parent.onMessage(payload, None)
except Exception:
f = create_failure()
self.log.error(
"Could not unserialize WAMP message: {msg}",
msg=failure_message(f),
)
self.log.debug("{tb}", tb=failure_format_traceback(f))
return self._parent._parent._fail_request(
request, b"could not unserialize WAMP message.")
else:
request.setResponseCode(http.NO_CONTENT)
self._parent._parent._set_standard_headers(request)
self._parent._isalive = True
return b""
def send(self, msg):
"""
Implements :func:`autobahn.wamp.interfaces.ITransport.send`
"""
if self.isOpen():
try:
self.log.debug(
"WampLongPoll: TX {octets}",
octets=_LazyHexFormatter(msg),
)
payload, isBinary = self._serializer.serialize(msg)
except Exception as e:
# all exceptions raised from above should be serialization errors ..
f = create_failure()
self.log.error(
"Unable to serialize WAMP application payload: {msg}",
msg=failure_message(f),
)
self.log.debug("{tb}", tb=failure_format_traceback(f))
raise SerializationError(
"unable to serialize WAMP application payload ({0})".
format(e))
else:
self._receive.queue(payload)
else:
raise TransportLost()
def send(self, msg):
"""
Implements :func:`autobahn.wamp.interfaces.ITransport.send`
"""
if self.isOpen():
self.log.trace('{klass}.send() (serializer={serializer}): TX WAMP message: "{msg}"',
klass=self.__class__.__name__, msg=msg, serializer=self._serializer)
try:
payload, _ = self._serializer.serialize(msg)
except SerializationError as e:
# all exceptions raised from above should be serialization errors ..
raise SerializationError("WampRawSocketProtocol: unable to serialize WAMP application payload ({0})".format(e))
else:
payload_len = len(payload)
if 0 < self._max_len_send < payload_len:
emsg = 'tried to send RawSocket message with size {} exceeding payload limit of {} octets'.format(
payload_len, self._max_len_send)
self.log.warn(emsg)
raise PayloadExceededError(emsg)
else:
self.sendString(payload)
self.log.trace('{klass}.send(): TX {octets} octets',
klass=self.__class__.__name__, octets=_LazyHexFormatter(payload))
else:
raise TransportLost()
def onMessage(self, payload, isBinary):
"""
Callback from :func:`autobahn.websocket.interfaces.IWebSocketChannel.onMessage`
"""
for msg in self._serializer.unserialize(payload, isBinary):
self.log.debug(
"WampLongPoll: RX {octets}",
octets=_LazyHexFormatter(msg),
)
self._session.onMessage(msg)
def onMessage(self, payload, isBinary):
"""
Callback from :func:`autobahn.websocket.interfaces.IWebSocketChannel.onMessage`
"""
for msg in self._serializer.unserialize(payload, isBinary):
self.log.debug(
"WampLongPoll: RX {octets}",
octets=_LazyHexFormatter(msg),
)
self._session.onMessage(msg)
def stringReceived(self, payload):
self.log.trace('{klass}.stringReceived(): RX {octets} octets',
klass=self.__class__.__name__,
octets=_LazyHexFormatter(payload))
try:
for msg in self._serializer.unserialize(payload):
self.log.trace(
"{klass}.stringReceived: RX WAMP message: {msg}",
klass=self.__class__.__name__,
msg=msg)
self._session.onMessage(msg)
except CancelledError as e:
self.log.debug(
"{klass}.stringReceived: WAMP CancelledError - connection will continue!\n{err}",
klass=self.__class__.__name__,
err=e)
except InvalidUriError as e:
self.log.warn(
"{klass}.stringReceived: WAMP InvalidUriError - aborting connection!\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
except ProtocolError as e:
self.log.warn(
"{klass}.stringReceived: WAMP ProtocolError - aborting connection!\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
except PayloadExceededError as e:
self.log.warn(
"{klass}.stringReceived: WAMP PayloadExceededError - aborting connection!\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
except SerializationError as e:
self.log.warn(
"{klass}.stringReceived: WAMP SerializationError - aborting connection!\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
except Exception as e:
self.log.failure()
self.log.warn(
"{klass}.stringReceived: WAMP Exception - aborting connection!\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
def stringReceived(self, payload):
self.log.debug("WampRawSocketProtocol: RX octets: {octets}", octets=_LazyHexFormatter(payload))
try:
for msg in self._serializer.unserialize(payload):
self.log.debug("WampRawSocketProtocol: RX WAMP message: {msg}", msg=msg)
self._session.onMessage(msg)
except ProtocolError as e:
self.log.warn("WampRawSocketProtocol: WAMP Protocol Error ({err}) - aborting connection", err=e)
self.abort()
except Exception as e:
self.log.warn("WampRawSocketProtocol: WAMP Internal Error ({err}) - aborting connection", err=e)
self.abort()
def stringReceived(self, payload):
self.log.debug("WampRawSocketProtocol: RX octets: {octets}", octets=_LazyHexFormatter(payload))
try:
for msg in self._serializer.unserialize(payload):
self.log.debug("WampRawSocketProtocol: RX WAMP message: {msg}", msg=msg)
self._session.onMessage(msg)
except ProtocolError as e:
self.log.warn("WampRawSocketProtocol: WAMP Protocol Error ({err}) - aborting connection", err=e)
self.abort()
except Exception as e:
self.log.warn("WampRawSocketProtocol: WAMP Internal Error ({err}) - aborting connection", err=e)
self.abort()
def send(self, msg):
"""
Implements :func:`autobahn.wamp.interfaces.ITransport.send`
"""
if self.isOpen():
self.log.trace("WampRawSocketProtocol (serializer={serializer}): TX WAMP message: {msg}", msg=msg, serializer=self._serializer)
try:
payload, _ = self._serializer.serialize(msg)
except Exception as e:
# all exceptions raised from above should be serialization errors ..
raise SerializationError("WampRawSocketProtocol: unable to serialize WAMP application payload ({0})".format(e))
else:
self.sendString(payload)
self.log.trace("WampRawSocketProtocol: TX octets: {octets}", octets=_LazyHexFormatter(payload))
else:
raise TransportLost()
def send(self, msg):
"""
Implements :func:`autobahn.wamp.interfaces.ITransport.send`
"""
if self.isOpen():
self.log.trace("WampRawSocketProtocol: TX WAMP message: {msg}", msg=msg)
try:
payload, _ = self._serializer.serialize(msg)
except Exception as e:
# all exceptions raised from above should be serialization errors ..
raise SerializationError("WampRawSocketProtocol: unable to serialize WAMP application payload ({0})".format(e))
else:
self.sendString(payload)
self.log.trace("WampRawSocketProtocol: TX octets: {octets}", octets=_LazyHexFormatter(payload))
else:
raise TransportLost()
def data_received(self, data):
self.log.debug('RawSocker Asyncio: data received {data}', data=_LazyHexFormatter(data))
if self._handshake_done:
return PrefixProtocol.data_received(self, data)
else:
self._buffer += data
if len(self._buffer) >= 4:
try:
self.process_handshake()
except HandshakeError as e:
self.protocol_error('Handshake error : {err}'.format(err=e))
return
self._handshake_done = True
self._on_handshake_complete()
data = self._buffer[4:]
self._buffer = b''
if data:
PrefixProtocol.data_received(self, data)
def data_received(self, data):
self.log.debug('RawSocker Asyncio: data received {data}', data=_LazyHexFormatter(data))
if self._handshake_done:
return PrefixProtocol.data_received(self, data)
else:
self._buffer += data
if len(self._buffer) >= 4:
try:
self.process_handshake()
except HandshakeError as e:
self.protocol_error('Handshake error : {err}'.format(err=e))
return
self._handshake_done = True
self._on_handshake_complete()
data = self._buffer[4:]
self._buffer = b''
if data:
PrefixProtocol.data_received(self, data)
def stringReceived(self, payload):
self.log.trace("WampRawSocketProtocol: RX octets: {octets}", octets=_LazyHexFormatter(payload))
try:
for msg in self._serializer.unserialize(payload):
self.log.trace("WampRawSocketProtocol: RX WAMP message: {msg}", msg=msg)
self._session.onMessage(msg)
except CancelledError as e:
self.log.warn("{klass}.stringReceived: WAMP CancelledError - connection will continue\n{err}",
klass=self.__class__.__name__,
err=e)
except ProtocolError as e:
self.log.warn("{klass}.stringReceived: WAMP ProtocolError - aborting connection\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
except Exception as e:
self.log.warn("{klass}.stringReceived: WAMP Exception - aborting connection\n{err}",
klass=self.__class__.__name__,
err=e)
self.abort()
def render_POST(self, request):
"""
A client sends a message via WAMP-over-Longpoll by HTTP/POSTing
to this Web resource. The body of the POST should contain a batch
of WAMP messages which are serialized according to the selected
serializer, and delimited by a single ``\0`` byte in between two WAMP
messages in the batch.
"""
payload = request.content.read()
self.log.debug(
"WampLongPoll: receiving data for transport '{tid}'\n{octets}",
tid=self._parent._transport_id,
octets=_LazyHexFormatter(payload),
)
try:
# process (batch of) WAMP message(s)
self._parent.onMessage(payload, None)
except Exception:
f = create_failure()
self.log.error(
"Could not unserialize WAMP message: {msg}",
msg=failure_message(f),
)
self.log.debug("{tb}", tb=failure_format_traceback(f))
return self._parent._parent._fail_request(
request,
b"could not unserialize WAMP message."
)
else:
request.setResponseCode(http.NO_CONTENT)
self._parent._parent._set_standard_headers(request)
self._parent._isalive = True
return b""
def send(self, msg):
"""
Implements :func:`autobahn.wamp.interfaces.ITransport.send`
"""
if self.isOpen():
try:
self.log.debug(
"WampLongPoll: TX {octets}",
octets=_LazyHexFormatter(msg),
)
payload, isBinary = self._serializer.serialize(msg)
except Exception as e:
# all exceptions raised from above should be serialization errors ..
f = create_failure()
self.log.error(
"Unable to serialize WAMP application payload: {msg}",
msg=failure_message(f),
)
self.log.debug("{tb}", tb=failure_format_traceback(f))
raise SerializationError("unable to serialize WAMP application payload ({0})".format(e))
else:
self._receive.queue(payload)
else:
raise TransportLost()
def dataReceived(self, data):
if self._handshake_complete:
WampRawSocketProtocol.dataReceived(self, data)
else:
remaining = 4 - len(self._handshake_bytes)
self._handshake_bytes += data[:remaining]
if len(self._handshake_bytes) == 4:
self.log.debug(
"WampRawSocketProtocol: opening handshake received - {octets}",
octets=_LazyHexFormatter(self._handshake_bytes),
)
if ord(self._handshake_bytes[0:1]) != 0x7f:
self.log.error(
"WampRawSocketProtocol: invalid magic byte (octet 1) in"
" opening handshake: was 0x{magic}, but expected 0x7f",
magic=_LazyHexFormatter(self._handshake_bytes[0]),
)
self.abort()
# peer requests us to send messages of maximum length 2**max_len_exp
#
self._max_len_send = 2**(
9 + (ord(self._handshake_bytes[1:2]) >> 4))
self.log.debug(
"WampRawSocketProtocol: client requests us to send out most {max_bytes} bytes per message",
max_bytes=self._max_len_send,
)
# client wants to speak this serialization format
#
ser_id = ord(self._handshake_bytes[1:2]) & 0x0F
if ser_id in self.factory._serializers:
self._serializer = self.factory._serializers[ser_id]
self.log.debug(
"WampRawSocketProtocol: client wants to use serializer '{serializer}'",
serializer=ser_id,
)
else:
self.log.debug(
"WampRawSocketProtocol: opening handshake - no suitable serializer found (client requested {serializer}, and we have {serializers}",
serializer=ser_id,
serializers=self.factory._serializers.keys(),
)
self.abort()
# we request the peer to send message of maximum length 2**reply_max_len_exp
#
reply_max_len_exp = 24
# send out handshake reply
#
reply_octet2 = bytes(
bytearray([((reply_max_len_exp - 9) << 4)
| self._serializer.RAWSOCKET_SERIALIZER_ID]))
self.transport.write(b'\x7F') # magic byte
self.transport.write(reply_octet2) # max length / serializer
self.transport.write(b'\x00\x00') # reserved octets
self._handshake_complete = True
self._on_handshake_complete()
self.log.debug(
"WampRawSocketProtocol: opening handshake completed: {serializer}",
serializer=self._serializer,
)
# consume any remaining data received already ..
#
data = data[remaining:]
if data:
self.dataReceived(data)
def dataReceived(self, data):
if self._handshake_complete:
WampRawSocketProtocol.dataReceived(self, data)
else:
remaining = 4 - len(self._handshake_bytes)
self._handshake_bytes += data[:remaining]
if len(self._handshake_bytes) == 4:
self.log.debug(
"WampRawSocketProtocol: opening handshake received - {octets}",
octets=_LazyHexFormatter(self._handshake_bytes),
)
if ord(self._handshake_bytes[0:1]) != 0x7f:
self.log.error(
"WampRawSocketProtocol: invalid magic byte (octet 1) in"
" opening handshake: was 0x{magic}, but expected 0x7f",
magic=_LazyHexFormatter(self._handshake_bytes[0]),
)
self.abort()
# peer requests us to send messages of maximum length 2**max_len_exp
#
self._max_len_send = 2 ** (9 + (ord(self._handshake_bytes[1:2]) >> 4))
self.log.debug(
"WampRawSocketProtocol: client requests us to send out most {max_bytes} bytes per message",
max_bytes=self._max_len_send,
)
# client wants to speak this serialization format
#
ser_id = ord(self._handshake_bytes[1:2]) & 0x0F
if ser_id in self.factory._serializers:
self._serializer = self.factory._serializers[ser_id]
self.log.debug(
"WampRawSocketProtocol: client wants to use serializer '{serializer}'",
serializer=ser_id,
)
else:
self.log.debug(
"WampRawSocketProtocol: opening handshake - no suitable serializer found (client requested {serializer}, and we have {serializers}",
serializer=ser_id,
serializers=self.factory._serializers.keys(),
)
self.abort()
# we request the peer to send message of maximum length 2**reply_max_len_exp
#
reply_max_len_exp = 24
# send out handshake reply
#
reply_octet2 = bytes(bytearray([
((reply_max_len_exp - 9) << 4) | self._serializer.RAWSOCKET_SERIALIZER_ID]))
self.transport.write(b'\x7F') # magic byte
self.transport.write(reply_octet2) # max length / serializer
self.transport.write(b'\x00\x00') # reserved octets
self._handshake_complete = True
self._on_handshake_complete()
self.log.debug(
"WampRawSocketProtocol: opening handshake completed: {serializer}",
serializer=self._serializer,
)
# consume any remaining data received already ..
#
data = data[remaining:]
if data:
self.dataReceived(data)
def dataReceived(self, data):
if self._handshake_complete:
WampRawSocketProtocol.dataReceived(self, data)
else:
remaining = 4 - len(self._handshake_bytes)
self._handshake_bytes += data[:remaining]
if len(self._handshake_bytes) == 4:
self.log.debug(
"WampRawSocketServerProtocol: opening handshake received - 0x{octets}",
octets=_LazyHexFormatter(self._handshake_bytes),
)
# first octet must be magic octet 0x7f
#
_magic = ord(self._handshake_bytes[0:1])
if _magic != 127:
self.log.warn(
"WampRawSocketServerProtocol: invalid magic byte (octet 1) in"
" opening handshake: was {magic}, but expected 127",
magic=_magic,
)
self.abort()
else:
self.log.debug('WampRawSocketServerProtocol: correct magic byte received')
# peer requests us to send messages of maximum length 2**max_len_exp
#
self._max_len_send = 2 ** (9 + (ord(self._handshake_bytes[1:2]) >> 4))
self.log.debug(
"WampRawSocketServerProtocol: client requests us to send out most {max_bytes} bytes per message",
max_bytes=self._max_len_send,
)
# client wants to speak this serialization format
#
ser_id = ord(self._handshake_bytes[1:2]) & 0x0F
if ser_id in self.factory._serializers:
self._serializer = copy.copy(self.factory._serializers[ser_id])
self.log.debug(
"WampRawSocketServerProtocol: client wants to use serializer '{serializer}'",
serializer=ser_id,
)
else:
self.log.warn(
"WampRawSocketServerProtocol: opening handshake - no suitable serializer found (client requested {serializer}, and we have {serializers}",
serializer=ser_id,
serializers=self.factory._serializers.keys(),
)
self.abort()
# we request the client to send message of maximum length 2**reply_max_len_exp
#
reply_max_len_exp = int(math.ceil(math.log(self._max_message_size, 2)))
# this is an instance attribute on the Twisted base class for maximum size
# of _received_ messages
self.MAX_LENGTH = 2**reply_max_len_exp
# send out handshake reply
#
reply_octet2 = bytes(bytearray([
((reply_max_len_exp - 9) << 4) | self._serializer.RAWSOCKET_SERIALIZER_ID]))
self.transport.write(b'\x7F') # magic byte
self.transport.write(reply_octet2) # max length / serializer
self.transport.write(b'\x00\x00') # reserved octets
self._handshake_complete = True
self._on_handshake_complete()
self.log.debug(
"WampRawSocketServerProtocol: opening handshake completed: {serializer}",
serializer=self._serializer,
)
# consume any remaining data received already ..
#
data = data[remaining:]
if data:
self.dataReceived(data)
