def receive_message(self, timeout):
try:
message = self._wait_for_message(timeout)
except eventlet.Timeout:
raise WampProtocolError(
"no message returned (timed-out in {})".format(timeout))
return message
def wrapper(*args, **kwargs):
message = Call(procedure=name, args=args, kwargs=kwargs)
response = self.client.make_rpc(message)
wamp_code = response.WAMP_CODE
if wamp_code == Error.WAMP_CODE:
_, _, request_id, _, endpoint, exc_args, exc_kwargs = (
response.message)
if endpoint == NOT_AUTHORISED:
raise WampyError(
"NOT_AUTHORISED: {} - {}".format(
self.client.name, exc_args[0]
)
)
raise WampyError(
'oops! wampy has failed, sorry: {}'.format(
response.message
)
)
if wamp_code != Result.WAMP_CODE:
raise WampProtocolError(
'unexpected message code: "%s (%s) %s"',
wamp_code, MESSAGE_TYPE_MAP[wamp_code],
response[5]
)
result = response.value
logger.debug("RpcProxy got result: %s", result)
return result
def handle_message(self, message, client):
# all WAMP paylods on a websocket frame are JSON
message = json.loads(message)
wamp_code = message[0]
if wamp_code not in MESSAGE_TYPE_MAP:
raise WampProtocolError(
'unexpected WAMP code: {}'.format(wamp_code)
)
logger.debug(
"received message: %s (%s)",
MESSAGE_TYPE_MAP[wamp_code], message
)
self.client = client
self.session = client.session
message_class = MESSAGE_TYPE_MAP[wamp_code]
# instantiate our Message obj using the incoming payload - but slicing
# off the WAMP code, which we already know
message_obj = message_class(*message[1:])
handler_name = "handle_{}".format(message_obj.name)
handler = getattr(self, handler_name)
handler(message_obj)
def receive_message(self, timeout):
try:
message = self.message_queue.get(timeout=timeout)
except gevent.queue.Empty:
raise WampProtocolError(
"no message returned (timed-out in {})".format(timeout)
)
return message
def recv_message(self, timeout=5):
try:
message = self._wait_for_message(timeout)
except eventlet.Timeout:
raise WampProtocolError(
"no message returned (timed-out in {})".format(timeout))
logger.debug('received message: "{}"'.format(message.name))
return message
def _subscribe_to_topic(self, handler, topic):
message = Subscribe(topic=topic)
request_id = message.request_id
try:
self.send_message(message)
except Exception as exc:
raise WampProtocolError("failed to subscribe to {}: \"{}\"".format(
topic, exc))
self.request_ids[request_id] = message, handler
def __call__(self, procedure, *args, **kwargs):
message = Call(procedure=procedure, args=args, kwargs=kwargs)
response = self.client.make_rpc(message)
wamp_code = response.WAMP_CODE
if wamp_code == Error.WAMP_CODE:
logger.error("call returned an error: %s", response)
return response
elif wamp_code == Result.WAMP_CODE:
return response.value
raise WampProtocolError("unexpected response: %s", response)
def _register_procedure(self, procedure_name, invocation_policy="single"):
""" Register a "procedure" on a Client as callable over the Router.
"""
options = {"invoke": invocation_policy}
message = Register(procedure=procedure_name, options=options)
request_id = message.request_id
try:
self.send_message(message)
except ValueError:
raise WampProtocolError("failed to register callee: %s",
procedure_name)
self.request_ids[request_id] = procedure_name
def json_serialize(message):
# WAMP serialization insists on UTF-8 encoded Unicode
try:
data = json.dumps(
message,
separators=(',', ':'),
ensure_ascii=False,
encoding='utf8',
)
except TypeError as exc:
raise WampProtocolError("Message not serialized: {} - {}".format(
message, str(exc)))
return data
def receive(self, bufsize=1):
frame = None
received_bytes = bytearray()
while True:
try:
bytes_ = self.socket.recv(bufsize)
except socket.timeout as e:
message = str(e)
raise ConnectionError('timeout: "{}"'.format(message))
except Exception as exc:
raise ConnectionError('Connection lost: "{}"'.format(exc))
if not bytes_:
break
received_bytes.extend(bytes_)
try:
frame = FrameFactory.from_bytes(received_bytes)
except IncompleteFrameError as exc:
bufsize = exc.required_bytes
else:
if frame.opcode == frame.OPCODE_PING:
# Opcode 0x9 marks a ping frame. It does not contain wamp
# data, so the frame is not returned.
# Still it must be handled or the server will close the
# connection.
async_adapter.spawn(self.handle_ping(ping_frame=frame))
received_bytes = bytearray()
continue
if frame.opcode == frame.OPCODE_PONG:
self.handle_pong(pong_frame=frame)
received_bytes = bytearray()
continue
if frame.opcode == frame.OPCODE_BINARY:
break
if frame.opcode == frame.OPCODE_CLOSE:
self.handle_close(close_frame=frame)
break
if frame is None:
raise WampProtocolError("No frame returned")
return frame
def _say_goodbye(self):
message = Goodbye()
try:
self.send_message(message)
except Exception as exc:
# we can't be sure what the Exception is here because it will
# be from the Router implementation
logger.warning("GOODBYE failed!: %s", exc)
else:
try:
message = self.recv_message(timeout=2)
if message.WAMP_CODE != Goodbye.WAMP_CODE:
raise WampProtocolError(
"Unexpected response from GOODBYE message: {}".format(
message))
except WampProtocolError:
# Server already gone away?
pass
def receive(self, bufsize=1):
frame = None
received_bytes = bytearray()
while True:
logger.debug("waiting for %s bytes", bufsize)
try:
bytes = self.socket.recv(bufsize)
except eventlet.greenlet.GreenletExit as exc:
raise ConnectionError('Connection closed: "{}"'.format(exc))
except socket.timeout as e:
message = str(e)
raise ConnectionError('timeout: "{}"'.format(message))
except Exception as exc:
raise ConnectionError(
'unexpected error reading from socket: "{}"'.format(exc))
if not bytes:
break
logger.debug("received %s bytes", bufsize)
received_bytes.extend(bytes)
try:
frame = ServerFrame(received_bytes)
except IncompleteFrameError as exc:
bufsize = exc.required_bytes
logger.debug('now requesting the missing %s bytes', bufsize)
else:
if frame.opcode == 9:
# Opcode 0x9 marks a ping frame. It does not contain wamp
# data, so the frame is not returned.
# Still it must be handled or the server will close the
# connection.
self._send_raw(PongFrame(frame.payload).payload)
received_bytes = bytearray()
continue
break
if frame is None:
raise WampProtocolError("No frame returned")
return frame
def wrapper(*args, **kwargs):
# timeout is currently handled by wampy whilst
# https://github.com/crossbario/crossbar/issues/299
# is addressed, but we pass in the value regardless, waiting
# for the feature on CrossBar.
# WAMP Call Message requires milliseconds...
options = {
'timeout': int(self.client.call_timeout * 1000),
}
message = Call(
procedure=name,
options=options,
args=args,
kwargs=kwargs,
)
response = self.client._make_rpc(message)
wamp_code = response.WAMP_CODE
if wamp_code == Error.WAMP_CODE:
_, _, request_id, _, endpoint, exc_args, exc_kwargs = (
response.message)
if endpoint == NOT_AUTHORISED:
raise WampyError("NOT_AUTHORISED: {} - {}".format(
self.client.name, exc_args[0]))
raise WampyError('oops! wampy has failed, sorry: {}'.format(
response.message))
if wamp_code != Result.WAMP_CODE:
raise WampProtocolError(
'unexpected message code: "%s (%s) %s"', wamp_code,
MESSAGE_TYPE_MAP[wamp_code], response[5])
result = response.value
logger.debug("RpcProxy got result: %s", result)
return result
def receive(self, bufsize=1):
frame = None
received_bytes = bytearray()
while True:
logger.debug("waiting for %s bytes", bufsize)
try:
bytes = self.socket.recv(bufsize)
except eventlet.greenlet.GreenletExit as exc:
raise ConnectionError('Connection closed: "{}"'.format(exc))
except socket.timeout as e:
message = str(e)
raise ConnectionError('timeout: "{}"'.format(message))
except Exception as exc:
raise ConnectionError(
'unexpected error reading from socket: "{}"'.format(exc))
if not bytes:
break
logger.debug("received %s bytes", bufsize)
received_bytes.extend(bytes)
try:
frame = ServerFrame(received_bytes)
except IncompleteFrameError as exc:
bufsize = exc.required_bytes
logger.debug('now requesting the missing %s bytes', bufsize)
else:
break
if frame is None:
raise WampProtocolError("No frame returned")
return frame
