class Client(object): def __init__(self): self.stompest = None self.greenlet = None self.subscriptions = {} self._last_id = 0 def _next_id(self): self._last_id += 1 return self._last_id def connect(self): if not self.stompest: CONFIG, EXTRA = _get_config() self._hostname = EXTRA.get('hostname', None) self.stompest = Stomp(CONFIG) if self.stompest.session.state != StompSession.DISCONNECTED: return while True: try: self.stompest.connect(host=self._hostname) logger.info('Connected') break except StompConnectTimeout: continue if not self.greenlet: self.greenlet = gevent.spawn(self._run) def _run(self): while True: try: frame = self.stompest.receiveFrame() self.stompest.ack(frame) if frame.command == 'ERROR': logger.error(frame.info()) elif frame.command == 'MESSAGE': token = self.stompest.message(frame) if self.subscriptions.get(token): subscription = self.subscriptions[token] subscription.call(frame) else: logger.error("Received a message for %s (%s) but there was no matching subscription." % (frame.headers.get(StompSpec.DESTINATION_HEADER, '???'), token)) else: logger.warning("Unknown frame: %s" % frame.info()) # @todo Handle receipts except (gevent.GreenletExit, KeyboardInterrupt): # @todo Include a receipt in the disconnect. And instead of breaking right away wait for the # receipt frame before disconnecting and consider waiting on any greenlets we started. self.stompest.disconnect() break except StompConnectionError: # We've been disconnected from the server. Try reconnecting to it. self.connect() def on(self, destination, callback): self.connect() token = self.stompest.subscribe(destination, { StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL, StompSpec.ID_HEADER: self._next_id(), }) subscription = Subscription( conn=self, destination=destination, token=token, callback=callback ) self.subscriptions[subscription.token] = subscription; # @todo consider adding optional support for additional custom headers def send(self, cmd, destination): self.connect() body = json.dumps(cmd) headers = {} headers[StompSpec.CONTENT_TYPE_HEADER] = 'application/json;charset=UTF-8' self.stompest.send(destination, body, headers) def join(self): try: self.connect() except (gevent.GreenletExit, KeyboardInterrupt): return try: gevent.joinall([self.greenlet]) except KeyboardInterrupt: self.greenlet.kill(block=True)
class StompClient(BaseComponent): channel = "stomp" def init( self, host, port, username=None, password=None, connect_timeout=3, connected_timeout=3, version=StompSpec.VERSION_1_2, accept_versions=["1.0", "1.1", "1.2"], heartbeats=(0, 0), ssl_context=None, use_ssl=True, key_file=None, cert_file=None, ca_certs=None, ssl_version=ssl.PROTOCOL_SSLv23, # means 'latest available' key_file_password=None, proxy_host=None, proxy_port=None, proxy_user=None, proxy_password=None, channel=channel): """ Initialize StompClient. Called after __init__ """ self.channel = channel if proxy_host: LOG.info("Connect to %s:%s through proxy %s:%d", host, port, proxy_host, proxy_port) else: LOG.info("Connect to %s:%s", host, port) if use_ssl and not ssl_context: ssl_params = dict(key_file=key_file, cert_file=cert_file, ca_certs=ca_certs, ssl_version=ssl_version, password=key_file_password) LOG.info("Request to use old-style socket wrapper: %s", ssl_params) ssl_context = ssl_params if use_ssl: uri = "ssl://%s:%s" % (host, port) else: uri = "tcp://%s:%s" % (host, port) # Configure failover options so it only tries to connect once self._stomp_server = "failover:(%s)?maxReconnectAttempts=1,startupMaxReconnectAttempts=1" % uri self._stomp_config = StompConfig(uri=self._stomp_server, sslContext=ssl_context, version=version, login=username, passcode=password) self._heartbeats = heartbeats self._accept_versions = accept_versions self._connect_timeout = connect_timeout self._connected_timeout = connected_timeout Stomp._transportFactory = EnhancedStompFrameTransport Stomp._transportFactory.proxy_host = proxy_host Stomp._transportFactory.proxy_port = proxy_port Stomp._transportFactory.proxy_user = proxy_user Stomp._transportFactory.proxy_password = proxy_password self._client = Stomp(self._stomp_config) self._subscribed = {} self.server_heartbeat = None self.client_heartbeat = None self.last_heartbeat = 0 self.ALLOWANCE = 2 # multiplier for heartbeat timeouts @property def connected(self): if self._client.session: return self._client.session.state == StompSession.CONNECTED else: return False @property def socket_connected(self): try: if self._client._transport: return True except: pass return False @property def subscribed(self): return self._subscribed.keys() @property def stomp_logger(self): return LOG_CATEGORY @handler("Disconnect") def _disconnect(self, receipt=None, flush=True, reconnect=False): try: if flush: self._subscribed = {} if self.connected: self._client.disconnect(receipt=receipt) except Exception as e: LOG.error("Failed to disconnect client") try: self.fire(Disconnected(reconnect=reconnect)) self._client.close(flush=flush) except Exception as e: LOG.error("Failed to close client connection") return "disconnected" def start_heartbeats(self): LOG.info("Client HB: %s Server HB: %s", self._client.clientHeartBeat, self._client.serverHeartBeat) if self._client.clientHeartBeat: if self.client_heartbeat: # Timer already exists, just reset it self.client_heartbeat.reset() else: LOG.info("Client will send heartbeats to server") # Send heartbeats at 80% of agreed rate self.client_heartbeat = Timer( (self._client.clientHeartBeat / 1000.0) * 0.8, ClientHeartbeat(), persist=True) self.client_heartbeat.register(self) else: LOG.info("No Client heartbeats will be sent") if self._client.serverHeartBeat: if self.server_heartbeat: # Timer already exists, just reset it self.server_heartbeat.reset() else: LOG.info("Requested heartbeats from server.") # Allow a grace period on server heartbeats self.server_heartbeat = Timer( (self._client.serverHeartBeat / 1000.0) * self.ALLOWANCE, ServerHeartbeat(), persist=True) self.server_heartbeat.register(self) else: LOG.info("Expecting no heartbeats from Server") @handler("Connect") def connect(self, event, host=None, *args, **kwargs): """ connect to Stomp server """ LOG.info("Connect to Stomp...") try: self._client.connect(heartBeats=self._heartbeats, host=host, versions=self._accept_versions, connectTimeout=self._connect_timeout, connectedTimeout=self._connected_timeout) LOG.debug("State after Connection Attempt: %s", self._client.session.state) if self.connected: LOG.info("Connected to %s", self._stomp_server) self.fire(Connected()) self.start_heartbeats() return "success" except StompConnectionError as err: LOG.debug(traceback.format_exc()) self.fire(ConnectionFailed(self._stomp_server)) event.success = False return "fail" @handler("ServerHeartbeat") def check_server_heartbeat(self, event): """ Confirm that heartbeat from server hasn't timed out """ now = time.time() self.last_heartbeat = self._client.lastReceived or self.last_heartbeat if self.last_heartbeat: elapsed = now - self.last_heartbeat else: elapsed = -1 if ((self._client.serverHeartBeat / 1000.0) * self.ALLOWANCE + self.last_heartbeat) < now: LOG.error( "Server heartbeat timeout. %d seconds since last heartbeat.", elapsed) event.success = False self.fire(HeartbeatTimeout()) @handler("ClientHeartbeat") def send_heartbeat(self, event): if self.connected: LOG.debug("Sending heartbeat") try: self._client.beat() except (StompConnectionError, StompError) as err: event.success = False self.fire(OnStompError(None, err)) @handler("generate_events") def generate_events(self, event): event.reduce_time_left(0.1) if not self.connected: return try: if self._client.canRead(0): frame = self._client.receiveFrame() LOG.debug("Recieved frame %s", frame) if frame.command == StompSpec.ERROR: self.fire(OnStompError(frame, None)) else: self.fire(Message(frame)) except (StompConnectionError, StompError) as err: LOG.error("Failed attempt to generate events.") self.fire(OnStompError(None, err)) @handler("Send") def send(self, event, destination, body, headers=None, receipt=None): LOG.debug("send()") try: self._client.send(destination, body=body.encode('utf-8'), headers=headers, receipt=receipt) LOG.debug("Message sent") except (StompConnectionError, StompError) as err: LOG.error("Error sending frame") event.success = False self.fire(OnStompError(None, err)) raise # To fire Send_failure event @handler("Subscribe") def _subscribe(self, event, destination, additional_headers=None, ack=ACK_CLIENT_INDIVIDUAL): if ack not in ACK_MODES: raise ValueError("Invalid client ack mode specified") if destination in self._client.session._subscriptions: LOG.debug("Ignoring subscribe request to %s. Already subscribed.", destination) LOG.info("Subscribe to message destination %s", destination) try: headers = {StompSpec.ACK_HEADER: ack, 'id': destination} if additional_headers: headers.update(additional_headers) # Set ID to match destination name for easy reference later frame, token = self._client.subscribe(destination, headers) self._subscribed[destination] = token except (StompConnectionError, StompError) as err: LOG.error("Failed to subscribe to queue.") event.success = False LOG.debug(traceback.format_exc()) self.fire(OnStompError(None, err)) @handler("Unsubscribe") def _unsubscribe(self, event, destination): if destination not in self._subscribed: LOG.error("Unsubscribe Request Ignored. Not subscribed to %s", destination) return try: token = self._subscribed.pop(destination) frame = self._client.unsubscribe(token) LOG.debug("Unsubscribed: %s", frame) except (StompConnectionError, StompError) as err: event.success = False LOG.error("Unsubscribe Failed.") self.fire(OnStompError(frame, err)) @handler("Message") def on_message(self, event, headers, message): LOG.debug("Stomp message received") @handler("Ack") def ack_frame(self, event, frame): LOG.debug("ack_frame()") try: self._client.ack(frame) LOG.debug("Ack Sent") except (StompConnectionError, StompError) as err: LOG.error("Error sending ack") event.success = False self.fire(OnStompError(frame, err)) raise # To fire Ack_failure event def get_subscription(self, frame): """ Get subscription from frame """ _, token = self._client.message(frame) return self._subscribed[token]
class StompClient(BaseComponent): """ Send and Receive messages from a STOMP queue """ channel = "stomp" def init(self, host, port, username=None, password=None, connect_timeout=3, connected_timeout=3, version=StompSpec.VERSION_1_2, accept_versions=["1.0", "1.1", "1.2"], heartbeats=(0, 0), ssl_context=None, use_ssl=True, key_file=None, cert_file=None, ca_certs=None, ssl_version=ssl.PROTOCOL_SSLv23, key_file_password=None, proxy_host=None, proxy_port=None, proxy_user=None, proxy_password=None, channel=channel): """ Initialize StompClient. Called after __init__ """ self.channel = channel if proxy_host: LOG.info("Connect to %s:%s through proxy %s:%d", host, port, proxy_host, proxy_port) else: LOG.info("Connect to %s:%s", host, port) if use_ssl and not ssl_context: ssl_params = dict(key_file=key_file, cert_file=cert_file, ca_certs=ca_certs, ssl_version=ssl_version, password=key_file_password) LOG.info("Request to use old-style socket wrapper: %s", ssl_params) ssl_context = ssl_params if use_ssl: uri = "ssl://%s:%s" % (host, port) else: uri = "tcp://%s:%s" % (host, port) # Configure failover options so it only tries to connect once self._stomp_server = "failover:(%s)?maxReconnectAttempts=1,startupMaxReconnectAttempts=1" % uri self._stomp_config = StompConfig(uri=self._stomp_server, sslContext=ssl_context, version=version, login=username, passcode=password) self._heartbeats = heartbeats self._accept_versions = accept_versions self._connect_timeout = connect_timeout self._connected_timeout = connected_timeout Stomp._transportFactory = EnhancedStompFrameTransport Stomp._transportFactory.proxy_host = proxy_host Stomp._transportFactory.proxy_port = proxy_port Stomp._transportFactory.proxy_user = proxy_user Stomp._transportFactory.proxy_password = proxy_password self._client = Stomp(self._stomp_config) self._subscribed = {} self.server_heartbeat = None self.client_heartbeat = None self.ALLOWANCE = 2 # multiplier for heartbeat timeouts @property def connected(self): if self._client.session: return self._client.session.state == StompSession.CONNECTED else: return False @property def subscribed(self): return self._subscribed.keys() @property def stomp_logger(self): return LOG_CATEGORY @handler("disconnect") def _disconnect(self, receipt=None): if self.connected: self._client.disconnect(receipt=receipt) self._client.close(flush=True) self.fire(disconnected(reconnect=False)) self._subscribed = {} return "disconnected" def start_heartbeats(self): LOG.info("Client HB: %s Server HB: %s", self._client.clientHeartBeat, self._client.serverHeartBeat) if self._client.clientHeartBeat: if self.client_heartbeat: # Timer already exists, just reset it self.client_heartbeat.reset() else: LOG.info("Client will send heartbeats to server") # Send heartbeats at 80% of agreed rate self.client_heartbeat = Timer((self._client.clientHeartBeat / 1000.0) * 0.8, client_heartbeat(), persist=True) self.client_heartbeat.register(self) else: LOG.info("No Client heartbeats will be sent") if self._client.serverHeartBeat: if self.server_heartbeat: # Timer already exists, just reset it self.server_heartbeat.reset() else: LOG.info("Requested heartbeats from server.") # Allow a grace period on server heartbeats self.server_heartbeat = Timer((self._client.serverHeartBeat / 1000.0) * self.ALLOWANCE, server_heartbeat(), persist=True) self.server_heartbeat.register(self) else: LOG.info("Expecting no heartbeats from Server") @handler("connect") def connect(self, event, host=None, *args, **kwargs): """ connect to Stomp server """ LOG.info("Connect to Stomp...") try: self._client.connect(heartBeats=self._heartbeats, host=host, versions=self._accept_versions, connectTimeout=self._connect_timeout, connectedTimeout=self._connected_timeout) LOG.info("State after Connection Attempt: %s", self._client.session.state) if self.connected: LOG.info("Connected to %s", self._stomp_server) self.fire(connected()) self.start_heartbeats() return "success" except StompConnectionError: LOG.debug(traceback.format_exc()) self.fire(connection_failed(self._stomp_server)) event.success = False return "fail" @handler("server_heartbeat") def check_server_heartbeat(self, event): """ Confirm that heartbeat from server hasn't timed out """ now = time.time() last = self._client.lastReceived or 0 if last: elapsed = now - last else: elapsed = -1 LOG.debug("Last received data %d seconds ago", elapsed) if ((self._client.serverHeartBeat / 1000.0) * self.ALLOWANCE + last) < now: LOG.error("Server heartbeat timeout. %d seconds since last heartbeat. Disconnecting.", elapsed) event.success = False self.fire(heartbeat_timeout()) if self.connected: self._client.disconnect() # TODO: Try to auto-reconnect? @handler("client_heartbeat") def send_heartbeat(self, event): if self.connected: LOG.debug("Sending heartbeat") try: self._client.beat() except StompConnectionError: event.success = False self.fire(disconnected()) @handler("generate_events") def generate_events(self, event): if not self.connected: return try: if self._client.canRead(1): frame = self._client.receiveFrame() LOG.debug("Recieved frame %s", frame) self.fire(message(frame)) except StompConnectionError: self.fire(disconnected()) @handler("send") def send(self, event, destination, body, headers=None, receipt=None): LOG.debug("send()") if not self.connected: LOG.error("Can't send when Stomp is disconnected") self.fire(on_stomp_error(None, Exception("Message send attempted with stomp disconnected"))) event.success = False return try: self._client.send(destination, body=body.encode('utf-8'), headers=headers, receipt=receipt) LOG.debug("Message sent") except StompConnectionError as err: event.success = False self.fire(disconnected()) except StompError as err: LOG.error("Error sending ack") event.success = False self.fire(on_stomp_error(None, err)) @handler("subscribe") def _subscribe(self, event, destination, ack=ACK_CLIENT_INDIVIDUAL): if ack not in ACK_MODES: raise ValueError("Invalid client ack mode specified") LOG.info("Subscribe to message destination %s", destination) try: # Set ID to match destination name for easy reference later frame, token = self._client.subscribe(destination, headers={StompSpec.ACK_HEADER: ack, 'id': destination}) self._subscribed[destination] = token except StompConnectionError as err: event.success = False self.fire(disconnected()) except StompError as err: event.success = False LOG.debug(traceback.format_exc()) self.fire(on_stomp_error(None, err)) @handler("unsubscribe") def _unsubscribe(self, event, destination): if destination not in self._subscribed: LOG.error("Unsubscribe Request Ignored. Not subscribed to %s", destination) return try: token = self._subscribed.pop(destination) frame = self._client.unsubscribe(token) LOG.debug("Unsubscribed: %s", frame) except StompConnectionError as err: event.success = False self.fire(disconnected()) except StompError as err: LOG.error("Error sending ack") event.success = False self.fire(on_stomp_error(frame, err)) @handler("message") def on_message(self, event, headers, message): LOG.info("Stomp message received") @handler("ack") def ack_frame(self, event, frame): LOG.debug("ack_frame()") try: self._client.ack(frame) LOG.debug("Ack Sent") except StompConnectionError as err: LOG.error("Error sending ack") event.success = False self.fire(disconnected()) except StompError as err: LOG.error("Error sending ack") event.success = False self.fire(on_stomp_error(frame, err)) def get_subscription(self, frame): """ Get subscription from frame """ LOG.info(self._subscribed) _, token = self._client.message(frame) return self._subscribed[token]
class Client(object): def __init__(self): self.stompest = None self.greenlet = None self.subscriptions = {} self._last_id = 0 def _next_id(self): self._last_id += 1 return self._last_id def connect(self): if not self.stompest: CONFIG, EXTRA = _get_config() self._hostname = EXTRA.get('hostname', None) self.stompest = Stomp(CONFIG) if self.stompest.session.state != StompSession.DISCONNECTED: return while True: try: self.stompest.connect(host=self._hostname) logger.info('Connected') break except StompConnectTimeout: continue if not self.greenlet: self.greenlet = gevent.spawn(self._run) def _run(self): while True: try: frame = self.stompest.receiveFrame() self.stompest.ack(frame) if frame.command == 'ERROR': logger.error(frame.info()) elif frame.command == 'MESSAGE': token = self.stompest.message(frame) if self.subscriptions.get(token): subscription = self.subscriptions[token] subscription.call(frame) else: logger.error( "Received a message for %s (%s) but there was no matching subscription." % (frame.headers.get(StompSpec.DESTINATION_HEADER, '???'), token)) else: logger.warning("Unknown frame: %s" % frame.info()) # @todo Handle receipts except (gevent.GreenletExit, KeyboardInterrupt): # @todo Include a receipt in the disconnect. And instead of breaking right away wait for the # receipt frame before disconnecting and consider waiting on any greenlets we started. self.stompest.disconnect() break except StompConnectionError: # We've been disconnected from the server. Try reconnecting to it. self.connect() def on(self, destination, callback): self.connect() token = self.stompest.subscribe( destination, { StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL, StompSpec.ID_HEADER: self._next_id(), }) subscription = Subscription(conn=self, destination=destination, token=token, callback=callback) self.subscriptions[subscription.token] = subscription # @todo consider adding optional support for additional custom headers def send(self, cmd, destination): self.connect() body = json.dumps(cmd) headers = {} headers[ StompSpec.CONTENT_TYPE_HEADER] = 'application/json;charset=UTF-8' self.stompest.send(destination, body, headers) def join(self): try: self.connect() except (gevent.GreenletExit, KeyboardInterrupt): return try: gevent.joinall([self.greenlet]) except KeyboardInterrupt: self.greenlet.kill(block=True)