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