def startBrokerAccess(self):
     """
     New-style management access to the broker.  Can be used in lieu of startQmf.
     """
     if 'broker_conn' not in self.__dict__:
         self.broker_conn = qpid.messaging.Connection(str(self.broker))
         self.broker_conn.open()
         self.broker_access = BrokerAgent(self.broker_conn)
示例#2
0
def checkOverStockedQueues(host):
    connection = Connection.establish(host)
    broker = BrokerAgent(connection)
    queues = broker.getAllQueues()
    result = list()
    for q in queues:
        if (q.msgDepth != 0):
            print(q.name + " " + str(q.msgDepth))
            result.append([q.name, q.msgDepth])
    return result
示例#3
0
 def test_relay(self):
     brokerB = self.amqp_broker()
     agentB = BrokerAgent(brokerB.connect())
     agentB.create("queue", "q")
     self.agent.create("domain", "BrokerB", {
         "url": brokerB.host_port(),
         "sasl_mechanisms": "NONE"
     })
     #send to q on broker B through brokerA
     self.send_and_receive(send_config=Config(self.broker,
                                              address="q@BrokerB"),
                           recv_config=Config(brokerB))
示例#4
0
 def _node_disambiguation_precreated(self, ambiguous_send):
     agent = BrokerAgent(self.conn)
     agent.addExchange("fanout", "ambiguous")
     agent.addQueue("ambiguous")
     try:
         r1 = self.ssn.receiver("ambiguous; {node:{type:topic}}")
         r2 = self.ssn.receiver("ambiguous; {node:{type:queue}}")
         self._node_disambiguation_test(r1,
                                        r2,
                                        ambiguous_send=ambiguous_send)
     finally:
         agent.delExchange("ambiguous")
         agent.delQueue("ambiguous", False, False)
示例#5
0
 def test_ambiguous_delete_2(self):
     agent = BrokerAgent(self.conn)
     agent.addExchange("fanout", "ambiguous")
     agent.addQueue("ambiguous")
     self.ssn.receiver(
         "ambiguous; {delete:receiver, node:{type:queue}}").close()
     exchange = agent.getExchange("ambiguous")
     queue = agent.getQueue("ambiguous")
     try:
         assert (exchange)
         assert (not queue)
     finally:
         if exchange: agent.delExchange("ambiguous")
         if queue: agent.delQueue("ambiguous", False, False)
示例#6
0
 def test_ambiguous_create_2(self):
     #create exchange first, then queue
     r1 = self.ssn.receiver(
         "ambiguous; {create:receiver, node:{type:topic}}")
     r2 = self.ssn.receiver(
         "ambiguous; {create:receiver, node:{type:queue}}")
     agent = BrokerAgent(self.conn)
     exchange = agent.getExchange("ambiguous")
     queue = agent.getQueue("ambiguous")
     try:
         assert (exchange)
         assert (queue)
         self._node_disambiguation_test(r1, r2)
     finally:
         if exchange: agent.delExchange("ambiguous")
         if queue: agent.delQueue("ambiguous", False, False)
示例#7
0
 def test_outgoing_link(self):
     brokerB = self.amqp_broker()
     agentB = BrokerAgent(brokerB.connect())
     self.agent.create("queue", "q")
     agentB.create("queue", "q")
     self.agent.create("domain", "BrokerB", {
         "url": brokerB.host_port(),
         "sasl_mechanisms": "NONE"
     })
     self.agent.create("outgoing", "Link1", {
         "domain": "BrokerB",
         "source": "q",
         "target": "q"
     })
     #send to brokerA, receive from brokerB
     self.send_and_receive(recv_config=Config(brokerB))
示例#8
0
def migrate(*args, **kwargs):
    """
    Migrate qpid queues:
    - Ensure pulp.task is no longer *exclusive*.
    - Rename agent queues: consumer_id> => pulp.agent.<consumer_id>
    """
    transport = pulp_conf.get('messaging', 'transport')
    if transport != 'qpid':
        # not using qpid
        return

    if not QPID_MESSAGING_AVAILABLE:
        msg = _(
            'Migration 0009 did not run because the python package qpid.messaging is not '
            'installed. Pulp\'s Qpid client dependencies can be installed with the '
            '\"pulp-server-qpid\" package group. See the installation docs for more '
            'information. Alternatively, you may reconfigure Pulp to use RabbitMQ.'
        )
        _logger.error(msg)
        raise Exception(msg)

    if not QPIDTOOLLIBS_AVAILABLE:
        msg = _(
            'Migration 0009 did not run because the python package qpidtoollibs is not '
            'installed. Pulp\'s Qpid client dependencies can be installed with the '
            '\"pulp-server-qpid\" package group. See the installation docs for more '
            'information. Alternatively, you may reconfigure Pulp to use RabbitMQ.'
        )
        _logger.error(msg)
        raise Exception(msg)

    url = urlparse(pulp_conf.get('messaging', 'url'))
    connection = Connection(host=url.hostname,
                            port=url.port,
                            transport=url.scheme,
                            reconnect=False,
                            ssl_certfile=pulp_conf.get('messaging',
                                                       'clientcert'),
                            ssl_skip_hostname_check=True)

    connection.attach()
    broker = BrokerAgent(connection)
    _migrate_reply_queue(broker)
    _migrate_agent_queues(broker)
    connection.detach()
示例#9
0
def migrate(*args, **kwargs):
    """
    Migrate qpid queues:
    - Ensure pulp.task is no longer *exclusive*.
    - Rename agent queues: consumer_id> => pulp.agent.<consumer_id>
    """
    transport = pulp_conf.get('messaging', 'transport')
    if transport != 'qpid':
        # not using qpid
        return

    if not QPID_MESSAGING_AVAILABLE:
        msg = _(
            'Migration 0009 did not run because the python package qpid.messaging is not '
            'installed. Please install qpid.messaging and rerun the migrations. See %s'
            'for more information.')
        msg = msg % QPID_MESSAGING_URL
        _logger.error(msg)
        raise Exception(msg)

    if not QPIDTOOLLIBS_AVAILABLE:
        msg = _(
            'Migration 0009 did not run because the python package qpidtoollibs is not '
            'installed. Please install qpidtoollibs and rerun the migrations. See %s for more '
            'information.')
        msg = msg % QPIDTOOLLIBS_URL
        _logger.error(msg)
        raise Exception(msg)

    url = urlparse(pulp_conf.get('messaging', 'url'))
    connection = Connection(host=url.hostname,
                            port=url.port,
                            transport=url.scheme,
                            reconnect=False,
                            ssl_certfile=pulp_conf.get('messaging',
                                                       'clientcert'),
                            ssl_skip_hostname_check=True)

    connection.attach()
    broker = BrokerAgent(connection)
    _migrate_reply_queue(broker)
    _migrate_agent_queues(broker)
    connection.detach()
示例#10
0
 def __init__(self, address, **kwargs):
     self._connection = Connection.establish(
         address, client_properties={"qpid.ha-admin": 1}, **kwargs)
     self._agent = BrokerAgent(self._connection)
示例#11
0
except ImportError:
    print 'Cannot run test without python MagicMock'
    print 'Please install MagicMock: pip install mock'
    exit(3)

connection = None
broker = None

try:
    logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
                        level=logging.INFO)
    logger = logging.getLogger(__name__)

    # setup broker connection
    connection = Connection.establish('127.0.0.1')
    broker = BrokerAgent(connection)

    # add test service busname
    busname = 'test-lofarbus-%s' % (uuid.uuid1())
    broker.addExchange('topic', busname)

    # the system under test is the service and the rpc, not the RADatabase
    # so, patch (mock) the RADatabase class during these tests.
    # when the service instantiates an RADatabase it will get the mocked class.
    with patch('lofar.sas.resourceassignment.database.radb.RADatabase',
               autospec=True) as MockRADatabase:
        mock = MockRADatabase.return_value
        # modify the return values of the various RADatabase methods with pre-cooked answers
        mock.getTaskStatuses.return_value = [{
            'id': 1,
            'name': 'opened'
示例#12
0
 def setup_access(self):
     if 'broker_agent' not in self.__dict__:
         self.conn2 = qpid.messaging.Connection(self.broker)
         self.conn2.open()
         self.broker_agent = BrokerAgent(self.conn2)
     return self.broker_agent
示例#13
0
    def test_08_integration_test_with_messagebus(self):
        """ Full blown integration test listening for notifications on the bus,
        and checking which dir is up for a visit next.
        Needs a working local qpid broker. Test is skipped if qpid not available.
        """
        try:
            broker = None
            connection = None

            import uuid
            from threading import Event
            from qpid.messaging import Connection, ConnectError
            from qpidtoollibs import BrokerAgent
            from lofar.messaging.messagebus import ToBus
            from lofar.messaging.messages import EventMessage
            from lofar.lta.ingest.common.config import DEFAULT_INGEST_NOTIFICATION_PREFIX

            # setup broker connection
            connection = Connection.establish('127.0.0.1')
            broker = BrokerAgent(connection)

            # add test service bus
            busname = 'test-LTASOIngestEventHandler-%s' % (uuid.uuid1())
            broker.addExchange('topic', busname)

            sync_event = Event()

            class SyncedLTASOIngestEventHandler(LTASOIngestEventHandler):
                """This derived LTASOIngestEventHandler behaves exactly like the normal
                object under test LTASOIngestEventHandler, but it also sets a sync_event
                to sync between the listener thread and this main test thread"""
                def _handleMessage(self, msg):
                    super(SyncedLTASOIngestEventHandler,
                          self)._handleMessage(msg)
                    sync_event.set()

            with SyncedLTASOIngestEventHandler(self.dbcreds, busname=busname):
                for site in self.db.sites():
                    for root_dir in self.db.rootDirectoriesForSite(site['id']):
                        self._markAllDirectoriesRecentlyVisited()

                        # create the subdir surl
                        sub_dir_name = '/foo'
                        sub_dir_path = root_dir['dir_name'] + sub_dir_name
                        surl = site['url'] + sub_dir_path

                        with ToBus(busname) as sender:
                            msg = EventMessage(
                                subject=DEFAULT_INGEST_NOTIFICATION_PREFIX +
                                "TaskFinished",
                                content={'srm_url': surl})
                            sender.send(msg)

                        # wait for the handler to have processed the message
                        self.assertTrue(sync_event.wait(2))
                        sync_event.clear()

                        # surl should have been scheduled for a visit, all other dir's were marked as visited already...
                        # so there should be a new dir for this surl, and it should be the least_recent_visited_dir
                        site_visit_stats = self.db.visitStats(
                            datetime.utcnow())[site['name']]

                        least_recent_visited_dir_id = site_visit_stats.get(
                            'least_recent_visited_dir_id')
                        self.assertIsNotNone(least_recent_visited_dir_id)

                        least_recent_visited_dir = self.db.directory(
                            least_recent_visited_dir_id)
                        self.assertEqual(sub_dir_path,
                                         least_recent_visited_dir['dir_name'])

        except ImportError as e:
            logger.warning("skipping test due to: %s", e)
        except ConnectError as e:
            logger.warning("skipping test due to: %s", e)
        finally:
            # cleanup test bus and exit
            if broker:
                broker.delExchange(busname)
            if connection:
                connection.close()
示例#14
0
 def __init__(self, address, **kwargs):
     self._connection = Connection.establish(
         address, client_properties={"qpid.ha-admin": 1}, **kwargs)
     self._agent = BrokerAgent(self._connection)
     assert self._agent.getHaBroker(
     ), "HA module not loaded in broker at: %s" % (address)
示例#15
0
 def setUp(self):
     BrokerTest.setUp(self)
     os.putenv("QPID_LOAD_MODULE", BrokerTest.amqpc_lib)
     self.broker = self.amqp_broker()
     self.default_config = Config(self.broker)
     self.agent = BrokerAgent(self.broker.connect())