コード例 #1
0
    def test_6_integration_stomp_1_1_encoding_and_escaping_headers(self):
        if BROKER == 'rabbitmq':
            print 'Broker does not support unicode characters. Skipping this test case.'
            return

        version = StompSpec.VERSION_1_1
        client = Stomp(self.getConfig(version))
        try:
            client.connect(host=VIRTUALHOST, versions=[version])
        except StompProtocolError as e:
            print 'Broker does not support STOMP protocol %s. Skipping this test case. [%s]' % (
                e, version)
            return

        specialCharactersHeader = u'fen\xeatre:\r\n'
        headers = {specialCharactersHeader: u'\xbfqu\xe9 tal?, s\xfc\xdf'}
        client.send(self.DESTINATION, body='test message 1', headers=headers)
        self.assertFalse(client.canRead(self.TIMEOUT))
        token = client.subscribe(
            self.DESTINATION, {
                StompSpec.ID_HEADER: 4711,
                StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL
            })
        self.assertTrue(client.canRead(self.TIMEOUT))
        frame = client.receiveFrame()
        client.ack(frame)
        self.assertEquals(frame.version, version)
        self.assertEquals(frame.headers[specialCharactersHeader],
                          headers[specialCharactersHeader])
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.unsubscribe(token)
        client.disconnect(receipt='4712')
コード例 #2
0
    def _test_4_integration_stomp(self, version):
        client = Stomp(self.getConfig(version))
        try:
            client.connect(host=VIRTUALHOST, versions=[version])
        except StompProtocolError as e:
            print('Broker does not support STOMP protocol %s. Skipping this test case. [%s]' % (e, version))
            return

        client.send(self.DESTINATION, b'test message 1')
        client.send(self.DESTINATION, b'test message 2')
        self.assertFalse(client.canRead(self.TIMEOUT))
        token = client.subscribe(self.DESTINATION, {StompSpec.ID_HEADER: 4711, StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})
        self.assertTrue(client.canRead(self.TIMEOUT))
        client.ack(client.receiveFrame())
        self.assertTrue(client.canRead(self.TIMEOUT))
        client.ack(client.receiveFrame())
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.unsubscribe(token)
        client.send(self.DESTINATION, b'test message 3', receipt='4711')
        self.assertTrue(client.canRead(self.TIMEOUT))
        self.assertEqual(client.receiveFrame(), StompFrame(StompSpec.RECEIPT, {StompSpec.RECEIPT_ID_HEADER: '4711'}))
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.subscribe(self.DESTINATION, {StompSpec.ID_HEADER: 4711, StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})
        self.assertTrue(client.canRead(self.TIMEOUT))
        client.ack(client.receiveFrame())
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.disconnect(receipt='4712')
        self.assertEqual(client.receiveFrame(), StompFrame(StompSpec.RECEIPT, {StompSpec.RECEIPT_ID_HEADER: '4712'}))
        self.assertRaises(StompConnectionError, client.receiveFrame)
        client.connect(host=VIRTUALHOST)
        client.disconnect(receipt='4711')
        self.assertEqual(client.receiveFrame(), StompFrame(StompSpec.RECEIPT, {StompSpec.RECEIPT_ID_HEADER: '4711'}))
        client.close()
        self.assertRaises(StompConnectionError, client.canRead, 0)
コード例 #3
0
 def test_3_socket_failure_and_replay(self):
     client = Stomp(self.getConfig(StompSpec.VERSION_1_0))
     client.connect(host=VIRTUALHOST)
     headers = {StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL}
     token = client.subscribe(self.DESTINATION, headers)
     client.sendFrame(
         StompFrame(StompSpec.DISCONNECT)
     )  # DISCONNECT frame is out-of-band, as far as the session is concerned -> unexpected disconnect
     self.assertRaises(StompConnectionError, client.receiveFrame)
     client.connect(host=VIRTUALHOST)
     client.send(self.DESTINATION, 'test message 1')
     client.ack(client.receiveFrame())
     client.unsubscribe(token)
     headers = {
         StompSpec.ID_HEADER: 'bla',
         StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL
     }
     client.subscribe(self.DESTINATION, headers)
     headers[StompSpec.DESTINATION_HEADER] = self.DESTINATION
     client.sendFrame(
         StompFrame(StompSpec.DISCONNECT)
     )  # DISCONNECT frame is out-of-band, as far as the session is concerned -> unexpected disconnect
     self.assertRaises(StompConnectionError, client.receiveFrame)
     client.connect(host=VIRTUALHOST)
     client.send(self.DESTINATION, 'test message 2')
     client.ack(client.receiveFrame())
     client.unsubscribe((StompSpec.ID_HEADER, 'bla'))
     client.disconnect()
コード例 #4
0
    def test_6_integration_stomp_1_1_encoding_and_escaping_headers(self):
        if BROKER == 'rabbitmq':
            print('Broker does not support unicode characters. Skipping this test case.')
            return

        version = StompSpec.VERSION_1_1
        client = Stomp(self.getConfig(version))
        try:
            client.connect(host=VIRTUALHOST, versions=[version])
        except StompProtocolError as e:
            print('Broker does not support STOMP protocol %s. Skipping this test case. [%s]' % (e, version))
            return

        key = b'fen\xc3\xaatre'.decode('utf-8')
        value = b'\xc2\xbfqu\xc3\xa9 tal?'.decode('utf-8')
        headers = {key: value}
        client.send(self.DESTINATION, body=b'test message 1', headers=headers)
        self.assertFalse(client.canRead(self.TIMEOUT))
        token = client.subscribe(self.DESTINATION, {StompSpec.ID_HEADER: 4711, StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})
        self.assertTrue(client.canRead(self.TIMEOUT))
        frame = client.receiveFrame()
        client.ack(frame)
        self.assertEqual(frame.version, version)
        self.assertEqual(frame.headers[key], headers[key])
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.unsubscribe(token)
        client.disconnect(receipt='4712')
コード例 #5
0
    def test_6_integration_stomp_1_1_encoding_and_escaping_headers(self):
        if BROKER == 'rabbitmq':
            print 'Broker does not support unicode characters. Skipping this test case.'
            return

        version = StompSpec.VERSION_1_1
        client = Stomp(self.getConfig(version))
        try:
            client.connect(host=VIRTUALHOST, versions=[version])
        except StompProtocolError as e:
            print 'Broker does not support STOMP protocol %s. Skipping this test case. [%s]' % (e, version)
            return

        specialCharactersHeader = u'fen\xeatre:\r\n'
        headers = {specialCharactersHeader: u'\xbfqu\xe9 tal?, s\xfc\xdf'}
        client.send(self.DESTINATION, body='test message 1', headers=headers)
        self.assertFalse(client.canRead(self.TIMEOUT))
        token = client.subscribe(self.DESTINATION, {StompSpec.ID_HEADER: 4711, StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})
        self.assertTrue(client.canRead(self.TIMEOUT))
        frame = client.receiveFrame()
        client.ack(frame)
        self.assertEquals(frame.version, version)
        self.assertEquals(frame.headers[specialCharactersHeader], headers[specialCharactersHeader])
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.unsubscribe(token)
        client.disconnect(receipt='4712')
    def test_4_integration_stomp_1_1(self):
        if StompSpec.VERSION_1_1 not in commands.versions(VERSION):
            print 'This broker does not support STOMP protocol version 1.1'
            return

        client = Stomp(self.getConfig(StompSpec.VERSION_1_1))
        client.connect(host=VIRTUALHOST)

        client.send(self.DESTINATION, 'test message 1')
        client.send(self.DESTINATION, 'test message 2')
        self.assertFalse(client.canRead(self.TIMEOUT))
        token = client.subscribe(self.DESTINATION, {StompSpec.ID_HEADER: 4711, StompSpec.ACK_HEADER: 'client-individual'})
        self.assertTrue(client.canRead(self.TIMEOUT))
        client.ack(client.receiveFrame())
        self.assertTrue(client.canRead(self.TIMEOUT))
        client.ack(client.receiveFrame())
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.unsubscribe(token)
        client.send(self.DESTINATION, 'test message 3', receipt='4711')
        self.assertTrue(client.canRead(self.TIMEOUT))
        self.assertEquals(client.receiveFrame(), StompFrame(StompSpec.RECEIPT, {'receipt-id': '4711'}))
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.subscribe(self.DESTINATION, {StompSpec.ID_HEADER: 4711, StompSpec.ACK_HEADER: 'client-individual'})
        self.assertTrue(client.canRead(self.TIMEOUT))
        client.ack(client.receiveFrame())
        self.assertFalse(client.canRead(self.TIMEOUT))
        client.disconnect(receipt='4712')
        self.assertEquals(client.receiveFrame(), StompFrame(StompSpec.RECEIPT, {'receipt-id': '4712'}))
        self.assertRaises(StompConnectionError, client.receiveFrame)
        client.connect(host=VIRTUALHOST)
        client.disconnect(receipt='4711')
        self.assertEquals(client.receiveFrame(), StompFrame(StompSpec.RECEIPT, {'receipt-id': '4711'}))
        client.close()
        self.assertRaises(StompConnectionError, client.canRead, 0)
コード例 #7
0
ファイル: stomptest.py プロジェクト: siwells/sandpit
def call_route(request_queue, response_queue, request):
    """
    """
    config = {
        "stomp": {
            "server": '192.168.0.3',
            "port": 61613,
            "timeout": 15,
        }
    }

    stomp_config = StompConfig("tcp://%s:%d" % (config['stomp']['server'], config['stomp']['port']), version=StompSpec.VERSION_1_0)
    stomp = Stomp(stomp_config)
    stomp.connect()
  
    jms_id = str(uuid4())
    token = stomp.subscribe(response_queue, {'JMSCorrelationID': jms_id})
    stomp.send(request_queue, json.dumps(request), {'JMSCorrelationID': jms_id})

    response = None
    if stomp.canRead(config['stomp']['timeout']):
        response = stomp.receiveFrame()
    
    stomp.unsubscribe(token)
    return response
コード例 #8
0
 def test_3_socket_failure_and_replay(self):
     client = Stomp(self.getConfig(StompSpec.VERSION_1_0))
     client.connect(host=VIRTUALHOST)
     headers = {StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL}
     token = client.subscribe(self.DESTINATION, headers)
     client.sendFrame(StompFrame(StompSpec.DISCONNECT)) # DISCONNECT frame is out-of-band, as far as the session is concerned -> unexpected disconnect
     self.assertRaises(StompConnectionError, client.receiveFrame)
     client.connect(host=VIRTUALHOST)
     client.send(self.DESTINATION, b'test message 1')
     client.ack(client.receiveFrame())
     client.unsubscribe(token)
     headers = {StompSpec.ID_HEADER: 'bla', StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL}
     client.subscribe(self.DESTINATION, headers)
     headers[StompSpec.DESTINATION_HEADER] = self.DESTINATION
     client.sendFrame(StompFrame(StompSpec.DISCONNECT)) # DISCONNECT frame is out-of-band, as far as the session is concerned -> unexpected disconnect
     self.assertRaises(StompConnectionError, client.receiveFrame)
     client.connect(host=VIRTUALHOST)
     client.send(self.DESTINATION, b'test message 2')
     client.ack(client.receiveFrame())
     client.unsubscribe((StompSpec.ID_HEADER, 'bla'))
     client.disconnect()
コード例 #9
0
class p25_metadata_agent():
    def __init__(self, host=None, port=None):
        self.log = logging.getLogger('overseer.p25_metadata_agent')
        self.log.info('Initializing p25_metadata_agent')
        self.demod_type = 'p25'

        self.redis_demod_manager = redis_demod_manager(self)

        if (host != None):
            self.host = host
        else:
            self.host = '127.0.0.1'  #manually set here until there is a better place
        if (port != None):
            self.port = port
        else:
            self.port = 61613  #manually set here until there is a better place

        self.client = None
        self.connection_issue = True
        self.continue_running = True
        self.subscriptions = {}
        self.parameters = {}

        self.hang_time = 0.5
        self.instance_metadata = {}
        self.system_metadata = {}

        connection_handler = threading.Thread(target=self.connection_handler)
        connection_handler.daemon = True
        connection_handler.start()

        #time.sleep(0.25)
        publish_loop = threading.Thread(target=self.publish_loop)
        publish_loop.daemon = True
        publish_loop.start()

    def init_connection(self):
        self.log.info('init_connection() (activemq) to tcp://%s/:%s' %
                      (self.host, self.port))
        if (self.client != None and self.client.session.state == 'connected'):
            try:
                self.client.disconnect()
            except:
                pass

        config = StompConfig('tcp://%s:%s' % (self.host, self.port),
                             version=StompSpec.VERSION_1_1,
                             check=True)
        self.client = Stomp(config)
        self.client.connect(heartBeats=(30000, 0),
                            connectTimeout=1,
                            connectedTimeout=1)

    def connection_handler(self):
        self.log.info('connection_handler() startup')
        #This func will just try to reconnect repeatedly in a thread if we're flagged as having an issue.
        while (True):
            if (self.connection_issue == True):
                try:
                    self.init_connection()
                    self.connection_issue = False
                    for subscription in self.subscriptions:
                        self.subscribe(subscription, resub=True)

                except:
                    pass
            time.sleep(1)

    def subscribe(self, queue, resub=False):
        #This needs to exist so we can keep track of what subs we have and re-sub on reconnect
        if queue in self.subscriptions and not resub:
            return True  #we're already subscribed

        this_uuid = '%s' % uuid.uuid4()

        if (self.connection_issue == True):
            self.subscriptions[queue] = this_uuid
            return None

        try:
            self.subscriptions[queue] = this_uuid
            self.client.subscribe(
                queue, {
                    StompSpec.ID_HEADER: this_uuid,
                    StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL,
                })
        except Exception as e:
            self.log.fatal('%s' % e)
            self.connection_issue = True

    def unsubscribe(self, queue):
        if queue not in self.subscriptions:
            return False  #cant unsubscribe, we're not subscribed

        if (self.connection_issue == True):
            return None

        try:
            self.client.unsubscribe(
                self.subscriptions[queue],
                {StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})
            del self.subscriptions[queue]
        except Exception as e:
            self.log.fatal('%s' % e)
            self.connection_issue = True

    def send_event_lazy(self, destination, body):
        #If it gets there, then great, if not, well we tried!
        if (self.connection_issue == True):
            return None

        try:
            self.client.send(destination, json.dumps(body))
        except:
            self.connection_issue = True

    def notify_demod_new(self, demod_instance_uuid):
        self.log.info('Notified of new demod %s' % (demod_instance_uuid))
        self.subscribe('/topic/raw_control/%s' % (demod_instance_uuid))

    def notify_demod_expire(self, demod_instance_uuid):
        self.log.info('Notified of expired demod %s' % (demod_instance_uuid))
        self.unsubscribe('/topic/raw_control/%s' % (demod_instance_uuid))

    def get_channel_detail(self, instance, channel):
        chan_ident = (channel & 0xf000) >> 12
        chan_number = channel & 0x0fff
        try:
            base_freq = self.instance_metadata[instance][
                'channel_identifier_table'][chan_ident]['Base Frequency']
            chan_spacing = self.instance_metadata[instance][
                'channel_identifier_table'][chan_ident][
                    'Channel Spacing'] / 1000
            slots = self.instance_metadata[instance][
                'channel_identifier_table'][chan_ident]['Slots']
            modulation = self.instance_metadata[instance][
                'channel_identifier_table'][chan_ident]['Type']
        except KeyError:
            return False, False, False, False
        chan_freq = ((chan_number / slots) * chan_spacing)
        slot_number = (chan_number % slots)
        channel_frequency = math.floor((base_freq + chan_freq) * 1000000)
        channel_bandwidth = self.instance_metadata[instance][
            'channel_identifier_table'][chan_ident]['BW'] * 1000

        return channel_frequency, channel_bandwidth, slot_number, modulation

    def get_system_from_instance(self, instance_uuid):
        try:
            return self.redis_demod_manager.demods[instance_uuid][
                'system_uuid']
        except:
            return False

    def is_updated(self, instance, parameter, value):
        if instance not in self.parameters:
            self.parameters[instance] = {}
        if parameter not in self.parameters[instance]:
            self.parameters[instance][parameter] = value
            return True
        elif self.parameters[instance][parameter] != value:
            self.parameters[instance][parameter] = value
            return True
        else:
            return False

    def publish_loop(self):
        self.log.info('publish_loop() startup')
        while self.continue_running:
            if self.connection_issue == False:
                try:
                    if not self.client.canRead(0.1):
                        continue
                    frame = self.client.receiveFrame()
                    t = json.loads(frame.body)
                    instance_uuid = frame.headers['destination'].replace(
                        '/topic/raw_control/', '')
                    try:
                        instance = self.redis_demod_manager.demods[
                            instance_uuid]
                    except:
                        continue
                    #system_uuid = self.get_system_from_instance(instance_uuid)

                    if instance_uuid not in self.instance_metadata:
                        self.instance_metadata[instance_uuid] = {
                            'channel_identifier_table': {}
                        }

                    if 'crc' not in t or t['crc'] != 0:
                        continue  #Don't bother trying to work with bad data
                    to_check = []

                    if t['name'] == 'IDEN_UP_VU':
                        to_check.append({
                            'parameter': 'FIT-%s' % t['Identifier'],
                            'value': {
                                'BW': t['BW VU'],
                                'Base Frequency': t['Base Frequency'],
                                'Channel Spacing': t['Channel Spacing'],
                                'Transmit Offset': t['Transmit Offset VU'],
                                'Type': 'FDMA',
                                'Slots': 1,
                            }
                        })
                        self.instance_metadata[instance_uuid][
                            'channel_identifier_table'][t['Identifier']] = {
                                'BW': t['BW VU'],
                                'Base Frequency': t['Base Frequency'],
                                'Channel Spacing': t['Channel Spacing'],
                                'Transmit Offset': t['Transmit Offset VU'],
                                'Type': 'FDMA',
                                'Slots': 1,
                            }
                    elif t['name'] == 'IDEN_UP':
                        to_check.append({
                            'parameter': 'FIT-%s' % t['Identifier'],
                            'value': {
                                'BW': t['BW'],
                                'Base Frequency': t['Base Frequency'],
                                'Channel Spacing': t['Channel Spacing'],
                                'Transmit Offset': t['Transmit Offset'],
                                'Type': 'FDMA',
                                'Slots': 1,
                            }
                        })
                        self.instance_metadata[instance_uuid][
                            'channel_identifier_table'][t['Identifier']] = {
                                'BW': t['BW'],
                                'Base Frequency': t['Base Frequency'],
                                'Channel Spacing': t['Channel Spacing'],
                                'Transmit Offset': t['Transmit Offset'],
                                'Type': 'FDMA',
                                'Slots': 1,
                            }
                    elif t['name'] == 'IDEN_UP_TDMA':
                        to_check.append({
                            'parameter': 'FIT-%s' % t['Identifier'],
                            'value': {
                                'BW': t['BW'],
                                'Base Frequency': t['Base Frequency'],
                                'Channel Spacing': t['Channel Spacing'],
                                'Transmit Offset': t['Transmit Offset TDMA'],
                                'Type': t['Access Type'],
                                'Slots': t['Slots'],
                            }
                        })
                        self.instance_metadata[instance_uuid][
                            'channel_identifier_table'][t['Identifier']] = {
                                'BW': t['BW'],
                                'Base Frequency': t['Base Frequency'],
                                'Channel Spacing': t['Channel Spacing'],
                                'Transmit Offset': t['Transmit Offset TDMA'],
                                'Type': t['Access Type'],
                                'Slots': t['Slots'],
                            }

                    elif t['name'] == 'NET_STS_BCST':
                        to_check.append({
                            'parameter': 'WACN ID',
                            'value': hex(int(t['WACN ID']))
                        })
                        to_check.append({
                            'parameter': 'System ID',
                            'value': hex(int(t['System ID']))
                        })
                        to_check.append({
                            'parameter': 'System Service Class',
                            'value': t['System Service Class']
                        })

                        frequency, bandwidth, slot_number, modulation = self.get_channel_detail(
                            instance_uuid, t['Channel'])
                        if frequency != False:
                            to_check.append({
                                'parameter': 'Control Channel',
                                'value': {
                                    'frequency': frequency,
                                    'bandwidth': bandwidth
                                }
                            })
                    elif t['name'] == 'RFSS_STS_BCST':
                        to_check.append({
                            'parameter': 'Site ID',
                            'value': t['Site ID']
                        })
                        to_check.append({
                            'parameter': 'RF Sub-system ID',
                            'value': t['RF Sub-system ID']
                        })
                        to_check.append({
                            'parameter': 'RFSS Network Connection',
                            'value': t['A']
                        })
                    elif t['name'] == 'ADJ_STS_BCST':
                        print '%s' % t
                        pass
                    for d in to_check:
                        if self.is_updated(instance_uuid, d['parameter'],
                                           d['value']):
                            print 'Updated! %s %s %s' % (
                                instance_uuid, d['parameter'], d['value'])
                            message = {
                                'transmit_site_uuid':
                                self.redis_demod_manager.demods[instance_uuid]
                                ['transmit_site_uuid'],
                                'receive_site_uuid':
                                self.redis_demod_manager.demods[instance_uuid]
                                ['site_uuid'],
                                'parameter':
                                d['parameter'],
                                'value':
                                d['value'],
                            }

                            self.send_event_lazy('/queue/metadata/site_update',
                                                 message)

                    self.client.ack(frame)
                except Exception as e:
                    self.log.fatal('except: %s' % e)
                    raise
                    self.connection_issue = True
コード例 #10
0
ファイル: client.py プロジェクト: spaceone/circuits
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]
コード例 #11
0
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]
コード例 #12
0
class JMSClient(object):
    """Class JMSClient
    """

    _mh = None
    _client = None
    _host = None
    _port = None
    _user = None
    _passw = None
    _verbose = None
    _is_connected = None

    def __init__(self, verbose=False):
        """Class constructor

        Called when the object is initialized

        Args:                   
           verbose (bool): verbose mode

        """

        try:

            self._mh = MasterHead.get_head()

            self._verbose = verbose
            if (self._verbose):
                basicConfig()
                getLogger().setLevel(DEBUG)

        except StompError as ex:
            self._mh.demsg('htk_on_error', ex, self._mh.fromhere())

    @property
    def client(self):
        """ STOMP client property getter """

        return self._client

    @property
    def host(self):
        """ server host property getter """

        return self._host

    @property
    def port(self):
        """ server port property getter """

        return self._port

    @property
    def user(self):
        """ username property getter """

        return self._user

    @property
    def passw(self):
        """ user password property getter """

        return self._passw

    @property
    def verbose(self):
        """ verbose mode property getter """

        return self._verbose

    @property
    def is_connected(self):
        """ is_connected property getter """

        return self._is_connected

    def connect(self, host, port=61613, user=None, passw=None, timeout=10):
        """Method connects to server

        Args:
           host (str): hostname
           port (str): port
           user (str): username
           passw (str): password
           timeout (int): timeout

        Returns:
           bool: result

        Raises:
           event: jms_before_connect
           event: jms_after_connected            

        """

        try:

            msg = 'host:{0}, port:{1}, user:{2}, passw:{3}, timeout:{4}'.format(
                host, port, user, passw, timeout)
            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_connecting', msg), self._mh.fromhere())

            ev = event.Event(
                'jms_before_connect', host, port, user, passw, timeout)
            if (self._mh.fire_event(ev) > 0):
                host = ev.argv(0)
                port = ev.argv(1)
                user = ev.argv(2)
                passw = ev.argv(3)
                timeout = ev.argv(4)

            self._host = host
            self._port = port
            self._user = user
            self._passw = passw

            if (ev.will_run_default()):
                self._client = Stomp(StompConfig('tcp://{0}:{1}'.format(self._host, self._port),
                                                 login=self._user, passcode=self._passw))
                self._client.connect(
                    connectTimeout=timeout, connectedTimeout=timeout)
                self._is_connected = True

            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_connected'), self._mh.fromhere())
            ev = event.Event('jms_after_connect')
            self._mh.fire_event(ev)

            return True

        except StompError as ex:
            self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
            return False

    def disconnect(self):
        """Method disconnects from server 

        Args:   
           none       

        Returns:
           bool: result

        """

        try:

            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_disconnecting'), self._mh.fromhere())

            if (not self._is_connected):
                self._mh.demsg('htk_on_warning', self._mh._trn.msg(
                    'htk_jms_not_connected'), self._mh.fromhere())
                return False
            else:
                self._client.disconnect()
                self._client.close()
                self._is_connected = False
                self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                    'htk_jms_disconnected'), self._mh.fromhere())
                return True

        except StompError as ex:
            self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
            return False

    def send(self, destination_name, message, destination_type='queue', headers={}):
        """Method sends message

        JMS headers - JMSCorrelationID, JMSExpiration, JMSDeliveryMode, JMSPriority,
                      JMSReplyTo, JMSType

        Args:
           destination_name (str): queue|topic name
           message (str): message
           destination_type (str): queue|topic
           headers (dict): JMS headers, key - title, value - string

        Returns:
           bool: result

        Raises:
           event: jms_before_send
           event: jms_after_send             

        """

        try:

            msg = 'destination_name:{0}, message:{1}, destination_type:{2}, headers:{3}'.format(
                destination_name, message, destination_type, headers)
            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_sending_msg', msg), self._mh.fromhere())

            if (not self._is_connected):
                self._mh.demsg('htk_on_warning', self._mh._trn.msg(
                    'htk_jms_not_connected'), self._mh.fromhere())
                return False

            ev = event.Event(
                'jms_before_send', destination_name, message, destination_type, headers)
            if (self._mh.fire_event(ev) > 0):
                destination_name = ev.argv(0)
                message = ev.argv(1)
                destination_type = ev.argv(2)
                headers = ev.argv(3)

            if (ev.will_run_default()):

                headers_new = {}
                for key, value in headers.items():
                    if (key in mapping):
                        headers_new[mapping[key]] = value

                self._client.send('/{0}/{1}'.format(destination_type, destination_name), message if (
                    version_info[0] == 2) else message.encode('utf-8'), headers_new)

            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_msg_sent'), self._mh.fromhere())
            ev = event.Event('jms_after_send')
            self._mh.fire_event(ev)

            return True

        except StompError as ex:
            self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
            return False

    def receive(self, destination_name, cnt=1):
        """Method receives messages

        Args:
           destination_name (str): queue name
           cnt (int): count of messages

        Returns:
           list:  messages as dictionary {'message', JMS headers}

        Raises:
           event: jms_before_receive
           event: jms_after_receive             

        """

        try:

            msg = 'destination_name:{0}, count:{1}'.format(
                destination_name, cnt)
            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_receiving_msg', msg), self._mh.fromhere())

            if (not self._is_connected):
                self._mh.demsg('htk_on_warning', self._mh._trn.msg(
                    'htk_jms_not_connected'), self._mh.fromhere())
                return None

            ev = event.Event('jms_before_receive', destination_name, cnt)
            if (self._mh.fire_event(ev) > 0):
                destination_name = ev.argv(0)
                cnt = ev.argv(1)

            if (ev.will_run_default()):
                token = self._client.subscribe('/queue/{0}'.format(destination_name),
                                               {StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})

                msgs = []
                i = 0
                while (i < cnt and self._client.canRead(1)):
                    frame = self._client.receiveFrame()
                    if (frame.command != 'MESSAGE'):
                        break
                    self._client.ack(frame)
                    msgs.append(frame)
                    i = i + 1

                self._client.unsubscribe(token)

                messages = []
                for msg in msgs:

                    message = {}
                    message['message'] = msg.body.decode()
                    for header in msg.rawHeaders:
                        if (header[0] in mapping.values()):
                            message[
                                list(mapping.keys())[list(mapping.values()).index(header[0])]] = header[1]

                    messages.append(message)

            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_msg_received', len(messages)), self._mh.fromhere())
            ev = event.Event('jms_after_receive')
            self._mh.fire_event(ev)

            return messages

        except StompError as ex:
            self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
            return None

    def browse(self, destination_name, cnt=100, jms_correlation_id=None, jms_type=None):
        """Method browses queue

        Args:
           destination_name (str): queue name
           cnt (int): count of messages
           jms_correlation_id (str): requested JMSCorrelationID
           jms_type (str): requested JMSType

        Returns:
           list: messages as dictionary {'message', JMS headers}

        Raises:
           event: jms_before_browse
           event: jms_after_browse              

        """

        try:

            msg = 'destination_name:{0}, count:{1}, jms_correlation_id:{2}, jms_type:{3}'.format(
                destination_name, cnt, jms_correlation_id, jms_type)
            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_browsing', msg), self._mh.fromhere())

            if (not self._is_connected):
                self._mh.demsg('htk_on_warning', self._mh._trn.msg(
                    'htk_jms_not_connected'), self._mh.fromhere())
                return None

            ev = event.Event(
                'jms_before_browse', destination_name, cnt, jms_correlation_id, jms_type)
            if (self._mh.fire_event(ev) > 0):
                destination_name = ev.argv(0)
                cnt = ev.argv(1)
                jms_correlation_id = ev.argv(2)
                jms_type = ev.argv(3)

            if (ev.will_run_default()):
                token = self._client.subscribe('/queue/{0}'.format(destination_name),
                                               {StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL})

                msgs = []
                i = 0
                while (i < cnt and self._client.canRead(1)):
                    frame = self._client.receiveFrame()

                    correlation_id = None
                    type = None
                    for header in frame.rawHeaders:
                        if (header[0] == 'correlation-id'):
                            correlation_id = header[1]
                        elif (header[0] == 'type'):
                            type = header[1]

                    if ((jms_correlation_id == None or jms_correlation_id == correlation_id) and
                            (jms_type == None or jms_type == type)):
                        msgs.append(frame)
                        i = i + 1

                self._client.unsubscribe(token)

                messages = []
                for msg in msgs:

                    message = {}
                    message['message'] = msg.body.decode()
                    for header in msg.rawHeaders:
                        if (header[0] in mapping.values()):
                            message[
                                list(mapping.keys())[list(mapping.values()).index(header[0])]] = header[1]

                    messages.append(message)

            self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
                'htk_jms_msg_received', len(messages)), self._mh.fromhere())
            ev = event.Event('jms_after_browse')
            self._mh.fire_event(ev)

            return messages

        except StompError as ex:
            self._mh.demsg('htk_on_error', ex, self._mh.fromhere())
            return None
コード例 #13
0
class ByteportStompClient(AbstractByteportClient):
    DEFAULT_BROKER_HOST = 'stomp.byteport.se'
    STORE_QUEUE_NAME = '/queue/simple_string_dev_message'

    SUPPORTED_CHANNEL_TYPES = ['topic', 'queue']

    client = None

    def __init__(self, namespace, login, passcode, broker_host=DEFAULT_BROKER_HOST, device_uid=None, channel_type='topic'):
        '''
        Create a ByteportStompClient. This is a thin wrapper to the underlying STOMP-client that connets to the Byteport Broker

        If a device_uid is given, a subscription will be made for Messages sent through Byteport.

        The channel_type must be either 'topic' or 'queue'. Set top topic if unsure on what to use (use queue if you need to
        use multiple consumers for a single device, this is not how most applications are set up).

        :param namespace:
        :param login:           Broker username (Byteport web users are _not_ valid broker users). Ask [email protected] for access.
        :param passcode:        Broker passcode
        :param broker_hosts:    [optional] A list of brokers to connect to
        :param device_uid:      [optional] The device UID to subscribe for messages on
        :param channel_type:    [optional] Defaults to queue.
        :param channel_key:     [optional] Must match the configured key in the Byteport Device Manager

        '''

        self.namespace = str(namespace)
        self.device_uid = device_uid

        if channel_type not in self.SUPPORTED_CHANNEL_TYPES:
            raise Exception("Unsupported channel type: %s" % channel_type)

        broker_url = 'tcp://%s:61613' % broker_host
        self.CONFIG = StompConfig(broker_url, version=StompSpec.VERSION_1_2)
        self.client = Stomp(self.CONFIG)

        try:
            self.client.connect(headers={'login': login, 'passcode': passcode}, host='/')
            logging.info("Connected to Stomp broker at %s using protocol version %s" % (broker_host, self.client.session.version))

            # Set up a subscription on the correct queue if a Specific device UID was given
            if self.device_uid:
                subscribe_headers = dict()
                subscribe_headers[StompSpec.ACK_HEADER] = StompSpec.ACK_CLIENT_INDIVIDUAL
                subscribe_headers[StompSpec.ID_HEADER] = '0'

                device_message_queue_name = '/%s/device_messages_%s.%s' % (channel_type, namespace, device_uid)

                self.subscription_token = self.client.subscribe(device_message_queue_name, subscribe_headers)
                logging.info("Subscribing to channel %s" % device_message_queue_name)
        except StompProtocolError as e:
            logging.error("Client socket connected, but probably failed to login. (ProtocolError)")
            raise

        except StompConnectionError:
            logging.error("Failed to connect to Stomp Broker at %s" % broker_host)
            raise

    def disconnect(self):
        if self.subscription_token:
            try:
                self.client.unsubscribe(self.subscription_token)
            except Exception as e:
                logging.error(u'Unsubscribe failed, reason %s' % e)

        self.client.disconnect()

    def __send_json_message(self, json):
        self.client.send(self.STORE_QUEUE_NAME, json)

    def __send_message(self, uid, data_string, timestamp=None):

        if timestamp:
            timestamp = self.auto_timestamp(timestamp)
        else:
            timestamp = int(time.time())

        if not uid:
            uid = self.device_uid

        if not uid:
            raise Exception("Can not send data without valid Device UID!")

        message = dict()
        message['uid'] = str(uid)
        message['namespace'] = self.namespace
        message['data'] = str(data_string)
        message['timestamp'] = str(timestamp)

        self.__send_json_message(json.dumps([message]))

    def store(self, data=None, device_uid=None, timestamp=None):
        if type(data) != dict:
            raise ByteportClientException("Data must be of type dict")

        for key in data.keys():
            self.verify_field_name(key)

        delimited_data = ';'.join("%s=%s" % (key, self.utf8_encode_value(val)) for (key, val) in data.iteritems())

        self.__send_message(device_uid, delimited_data, timestamp)
コード例 #14
0
class client_activemq():
    def __init__(self, worker_threads=2):
        self.log = logging.getLogger('client_activemq')
        self.log.debug('Initializing client_activemq')

        self.host = '127.0.0.1'  #manually set here until there is a better place
        self.port = 61613  #manually set here until there is a better place
        self.worker_threads = worker_threads

        self.client = None
        self.connection_issue = True
        self.continue_running = True
        self.subscriptions = {}
        self.outbound_msg_queue = []
        self.outbound_msg_queue_lazy = []

        self.threads = []
        self.work_queue = Queue.Queue()

        connection_handler = threading.Thread(target=self.connection_handler)
        connection_handler.daemon = True
        connection_handler.start()

        send_event_hopeful_thread = threading.Thread(
            target=self.send_event_hopeful_thread)
        send_event_hopeful_thread.daemon = True
        send_event_hopeful_thread.start()

        send_event_lazy_thread = threading.Thread(
            target=self.send_event_lazy_thread)
        send_event_lazy_thread.daemon = True
        send_event_lazy_thread.start()

        publish_loop = threading.Thread(target=self.publish_loop)
        publish_loop.daemon = True
        publish_loop.start()

    def init_connection(self):
        if (self.client != None and self.client.session.state == 'connected'):
            self.log.error('Re-init connection')
            try:
                self.client.disconnect()
            except:
                pass

        config = StompConfig('tcp://%s:%s' % (self.host, self.port),
                             version=StompSpec.VERSION_1_1,
                             check=True)
        self.client = Stomp(config)
        self.client.connect(heartBeats=(30000, 0),
                            connectTimeout=1,
                            connectedTimeout=1)

    def build_worker_pool(self, capacity):
        for thread in self.threads:
            if thread.is_alive() == False:
                self.threads.remove(thread)

        while len(self.threads) < capacity:
            t = threading.Thread(target=self.worker, args=(self.work_queue, ))
            t.daemon = True
            t.start()
            self.threads.append(t)

    def connection_handler(self):
        #This func will just try to reconnect repeatedly in a thread if we're flagged as having an issue.
        while (True):
            if (self.connection_issue == True):
                try:
                    self.init_connection()
                    self.connection_issue = False
                    time.sleep(0.1)
                    for subscription in self.subscriptions:
                        self.log.info('Re-subscribing upon reconnection: %s' %
                                      subscription)
                        self.subscribe(
                            subscription,
                            self.subscriptions[subscription]['callback_class'],
                            self.subscriptions[subscription]['callback'], True,
                            self.subscriptions[subscription]['selector'])

                except Exception as e:
                    self.log.critical('Except: %s' % e)
            else:

                try:
                    self.client.beat()
                except:
                    self.log.warning('Failed to heartbeat?')
            self.build_worker_pool(self.worker_threads)
            time.sleep(10)

    def subscribe(self,
                  queue,
                  callback_class,
                  callback,
                  resub=False,
                  selector=None):
        #This needs to exist so we can keep track of what subs we have and re-sub on reconnect
        if queue in self.subscriptions and not resub:
            self.log.info('Ignoring existing subscription %s' % queue)
            return True  #we're already subscribed

        this_uuid = '%s' % uuid.uuid4()
        if (self.connection_issue == True):
            self.log.info(
                'Cannot process subscription request as were not properly connected'
            )
            self.subscriptions[queue] = {
                'uuid': this_uuid,
                'callback': callback,
                'callback_class': callback_class,
                'selector': selector
            }
            return None
        self.log.info('subscribe(%s %s %s %s)' %
                      (queue, callback_class, callback, resub))

        try:
            self.subscriptions[queue] = {
                'uuid': this_uuid,
                'callback': callback,
                'callback_class': callback_class,
                'selector': selector
            }
            if selector != None:
                self.client.subscribe(
                    queue, {
                        StompSpec.ID_HEADER: this_uuid,
                        StompSpec.ACK_HEADER: StompSpec.ACK_AUTO,
                        'selector': selector
                    })
            else:
                self.client.subscribe(
                    queue, {
                        StompSpec.ID_HEADER: this_uuid,
                        StompSpec.ACK_HEADER: StompSpec.ACK_AUTO,
                    })
        except Exception as e:
            self.log.fatal('%s' % e)
            self.connection_issue = True

    def unsubscribe(self, queue):
        if queue not in self.subscriptions:
            return False  #cant unsubscribe, we're not subscribed

        if (self.connection_issue == True):
            del self.subscriptions[queue]
            return None
        try:
            self.client.unsubscribe(self.subscriptions[queue]['uuid'])
            del self.subscriptions[queue]
        except Exception as e:
            self.log.error('%s' % e)
            self.log.error('%s' % traceback.format_exc())
            sys.exc_clear()
            self.connection_issue = True

    def send_event_lazy(self, destination, body, headers={}, persistent=False):

        headers['time_queued'] = time.time()
        self.outbound_msg_queue_lazy.append({
            'destination': destination,
            'body': body,
            'headers': headers,
            'persistent': persistent
        })

    def send_event_lazy_thread(self):
        while self.continue_running:
            time.sleep(0.001)
            #If it gets there, then great, if not, well we tried!
            if (self.connection_issue == True):
                continue
            while len(self.outbound_msg_queue_lazy
                      ) > 0 and self.connection_issue == False:
                try:
                    item = self.outbound_msg_queue_lazy.pop(0)
                    if item['persistent'] == True:
                        item['headers']['persistent'] = 'true'
                    else:
                        item['headers']['persistent'] = 'false'
                    item['headers']['time_sent'] = time.time()
                    self.client.send(item['destination'],
                                     json.dumps(item['body']), item['headers'])
                except Exception as e:
                    self.log.critical('Except: %s' % e)
                    self.outbound_msg_queue_lazy.insert(0, item)
                    self.connection_issue = True

    def send_event_hopeful(self, destination, body, persist):
        self.outbound_msg_queue.append({
            'destination': destination,
            'body': body
        })

    def send_event_hopeful_thread(self):

        while self.continue_running:
            time.sleep(0.001)
            if (self.connection_issue == True):
                continue
            while len(self.outbound_msg_queue
                      ) > 0 and self.connection_issue == False:
                try:
                    item = self.outbound_msg_queue.pop(0)
                    self.client.send(item['destination'],
                                     json.dumps(item['body']),
                                     {'persistent': 'false'})

                except Exception as e:
                    self.log.critical('Except: %s' % e)
                    self.outbound_msg_queue.insert(0, item)
                    self.connection_issue = True

    def worker(self, queue):
        while self.continue_running:
            try:
                item = queue.get()
                for x in 1, 2, 3:
                    try:
                        item['callback'](item['callback_class'], item['data'],
                                         item['headers'])
                        break
                    except Exception as e:
                        self.log.error('Exception in worker thread: %s' % e)
                        traceback.print_exc()
                        sys.exc_clear()
                        time.sleep(0.01)

                queue.task_done()
            except:
                pass

    def publish_loop(self):
        self.log.debug('publish_loop() init')
        time.sleep(0.2)
        while self.continue_running:
            if self.connection_issue == False:
                try:
                    if not self.client.canRead(0.01):
                        continue
                    try:
                        frame = self.client.receiveFrame()
                        data = json.loads(frame.body)
                        queue = frame.headers['destination']
                        try:
                            time_sent = float(frame.headers['time_sent'])
                            time_queued = float(frame.headers['time_queued'])
                            send_latency = (time.time() - time_sent)
                            queue_latency = (time_sent - time_queued)
                            if queue_latency > 0.1:
                                print 'Queue Latency: %s' % (queue_latency)
                            if send_latency > 0.1:
                                print 'Send Latency: %s' % (send_latency)
                        except:
                            pass

                        self.work_queue.put({
                            'callback':
                            self.subscriptions[queue]['callback'],
                            'callback_class':
                            self.subscriptions[queue]['callback_class'],
                            'data':
                            data,
                            'headers':
                            frame.headers,
                        })
                    #self.client.ack(frame)
                    except Exception as e:
                        raise
                        self.log.critical('Except: %s' % e)
                        #self.client.nack(frame)
                except Exception as e:
                    self.log.fatal('except: %s' % e)
                    self.connection_issue = True