예제 #1
0
파일: query.py 프로젝트: f3at/feat
def select_ids(connection, query, skip=0, limit=None, include_responses=False):
    temp, responses = yield _get_query_response(connection, query)

    total_count = len(temp)
    if limit is not None:
        stop = skip + limit
    else:
        stop = None

    name, direction = query.sorting
    index = first(v.entries for k, v in responses.iteritems() if k.field == name)

    if direction == Direction.DESC:
        index = reversed(index)

    if query.aggregate:
        # we have to copy the collection, because _get_sorted_slice()
        # treats it as a buffer, and modifies the content
        aggregate_index = set(temp)

    r = Result(_get_sorted_slice(index, temp, skip, stop))
    r.total_count = total_count

    # count reductions for aggregated fields based on the view index
    if query.aggregate:
        r.aggregations = list()
        for handler, field in query.aggregate:
            value_index = first(v for k, v in responses.iteritems() if k.field == field)
            r.aggregations.append(handler(x for x in value_iterator(aggregate_index, value_index)))
    if include_responses:
        defer.returnValue((r, responses))
    else:
        defer.returnValue(r)
예제 #2
0
파일: query.py 프로젝트: f3at/feat
    def get_basic_queries(self):
        if not hasattr(self, "_cached_basic_queries"):
            temp = list()
            for part in self.parts:
                temp.extend(part.get_basic_queries())

            # if we want to sort by the field which is not available in
            # the query we will need to query for the full range of the
            # index
            if self.sorting:
                sortby = self.sorting[0]
                if not first(x for x in temp if sortby == x.field):
                    temp.append(Condition(sortby, Evaluator.none, None))

            # if we want a value of some field included in the result we
            # need to make sure its also fetched along the query
            for part in self.include_value + [x[1] for x in self.aggregate]:
                included = first(x.field for x in temp if x.field == part)
                if not included:
                    temp.append(Condition(part, Evaluator.none, None))

            # remove duplicates
            self._cached_basic_queries = resp = list()
            while temp:
                x = temp.pop(0)
                if x not in resp:
                    resp.append(x)

        return self._cached_basic_queries
예제 #3
0
    def prolog(self):
        setup = text_helper.format_block(
            """
        agency = spawn_agency()
        host1 = agency.get_host_agent()

        agency = spawn_agency()

        host1.start_agent(descriptor_factory('test_exportable_agent'))
        wait_for_idle()

        agency = spawn_agency()

        agency = spawn_agency()
        host2 = agency.get_host_agent()
        host2.start_agent(descriptor_factory('export_agent'))
        wait_for_idle()
        host2.start_agent(descriptor_factory('migration_agent'))
        wait_for_idle()
        """
        )
        yield self.process(setup)

        self.export = first(self.driver.iter_agents("export_agent")).get_agent()
        self.migration = first(self.driver.iter_agents("migration_agent")).get_agent()
        self.assertEqual(1, self.count_agents("test_exportable_agent"))
        self.assertEqual(2, self.count_agents("test_child_agent"))
        self.host1 = self.get_local("host1")
        self.host2 = self.get_local("host2")
예제 #4
0
    def prolog(self):
        hostdef = host.HostDef(categories=dict(address=Address.fixed),
                               ports_ranges=dict(dns=(8000, 8000)))
        self.set_local('hostdef', hostdef)

        setup = text_helper.format_block("""
        a = spawn_agency()
        a.disable_protocol('setup-monitoring', 'Task')
        medium = a.start_agent(descriptor_factory('host_agent'),\
                               hostdef=hostdef)
        host = medium.get_agent()
        wait_for_idle()
        """)

        dns = text_helper.format_block("""
        host.start_agent(descriptor_factory('dns_agent'))
        """)

        api = text_helper.format_block("""
        host.start_agent(descriptor_factory('api_agent'))
        wait_for_idle()
        """)

        yield self.process(setup)
        yield self.process(dns)
        yield self.process(api)
        self.dns = first(self.driver.iter_agents('dns_agent')).get_agent()
        self.api = first(self.driver.iter_agents('api_agent')).get_agent()
예제 #5
0
    def prolog(self):
        setup = format_block("""
        agency = spawn_agency()
        agency = spawn_agency()
        """)

        yield self.process(setup)
        yield self.wait_for_idle(20)
        self.raage_medium = first(self.driver.iter_agents('raage_agent'))
        self.shard_medium = first(self.driver.iter_agents('shard_agent'))
예제 #6
0
    def prolog(self):
        setup1 = text_helper.format_block(
            """
        agency = spawn_agency()
        host1 = agency.get_host_agent()
        wait_for_idle()

        agency = spawn_agency()

        host1.start_agent(descriptor_factory('test_exportable_agent'))
        wait_for_idle()

        agency = spawn_agency()

        agency = spawn_agency()
        host2 = agency.get_host_agent()
        host2.start_agent(descriptor_factory('export_agent'))
        wait_for_idle()
        """
        )
        yield self.process(self.drivers[0], setup1)

        setup2 = text_helper.format_block(
            """
        agency = spawn_agency(hostdef=hostdef1)
        host = agency.get_host_agent()
        host.start_agent(descriptor_factory('alert_agent'))
        host.start_agent(descriptor_factory('migration_agent'))
        wait_for_idle()
        """
        )

        hd1 = host.HostDef()
        hd1.resources["epu"] = self.epu_in_new_cluster
        self.drivers[1].set_local("hostdef1", hd1)
        hd2 = host.HostDef()
        hd2.resources["epu"] = 500
        self.drivers[1].set_local("hostdef2", hd2)
        yield self.process(self.drivers[1], setup2)

        self.export = first(self.drivers[0].iter_agents("export_agent")).get_agent()
        self.migration = first(self.drivers[1].iter_agents("migration_agent")).get_agent()
        self.host1 = self.drivers[0].get_local("host1")
        self.host2 = self.drivers[0].get_local("host2")
        self.alert = first(self.drivers[1].iter_agents("alert_agent")).get_agent()

        recp = yield self.export.get_own_address()
        self.assertIsInstance(recp, recipient.Recipient)
        url = self.export.get_tunneling_url()
        yield self.migration.add_tunneling_route(recp, url)
        yield self.migration.handshake(recp)
        yield self.migration.set_current("testing_site")
예제 #7
0
파일: query.py 프로젝트: f3at/feat
def values(connection, query, field, unique=True):
    if field not in query.fields:
        raise ValueError("%r doesn't have %s field defined" % (type(query), field))
    query.include_value.append(field)
    query.reset()  # ensures the field condition gets included

    temp, responses = yield _get_query_response(connection, query)
    index = first(v for k, v in responses.iteritems() if k.field == field)
    if not index.includes_values:
        raise ValueError(
            "The query controller of %s field "
            "of %s query is not marked to "
            "keep the value in the cache. You have to enable "
            "it to make query.value() work." % (field, query.name)
        )
    if unique:
        resp = set()
        for x in temp:
            resp.add(index.get_value(x))
        defer.returnValue(list(resp))
    else:
        resp = list()
        for x in temp:
            resp.append(index.get_value(x))
        defer.returnValue(resp)
예제 #8
0
    def prolog(self):
        setup = format_block("""
        test_desc = descriptor_factory('contract-running-agent')

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent', shard='s1'), \
                           run_startup=False)

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent', shard='s1'), \
                           run_startup=False)

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent', shard='s1'), \
                           run_startup=False)
        agent = _.get_agent()
        agent.wait_for_ready()
        agent.start_agent(test_desc)
        """)
        yield self.process(setup)
        medium = first(self.driver.iter_agents('contract-running-agent'))
        self.agent = medium.get_agent()
예제 #9
0
 def _topology_fixes(self, state, migration):
     """
     This is part of algorithms logic which is not static. It combines
     information from the shard view and migration to figure out if
     migration involves terminating the shard(s). In this case it removes
     the steps for migrating structural agents (strategy "locally") from
     the migration plan.
     """
     kill_list = migration.get_kill_list()
     for shard, hosts in kill_list.iteritems():
         shard_view = first(x for x in state.shards if x.shard == shard)
         if shard_view is None:
             self.warning(
                 "Shard %r has not been found in shard view. "
                 "This is really strange! Shard structure taken "
                 "for analyzing: \n%s",
                 shard,
                 state.shards,
             )
             continue
         shard_is_terminating = set(hosts) == set(shard_view.hosts)
         if shard_is_terminating:
             self.log("Detected that shard %r will be terminating, removing" " local steps of the migration.", shard)
             migration = migration.remove_local_migrations(shard)
     return migration
예제 #10
0
    def testMigrateOutShard(self):
        exports = self.migration._get_exports()
        self.assertEqual(1, len(exports.entries))
        self.assertIn("testing_site", exports.entries)

        yield self.migration.set_current("testing_site")
        shards = yield self.migration.get_structure()

        # we will migrate first shard (with only migratable agents)
        shard = recipient.IRecipient(self.host1).route
        to_migrate = first(x for x in shards if x.shard == shard)
        self.assertIsNot(None, to_migrate)

        migration = yield self.migration.prepare_shard_migration(to_migrate)
        self.assertTrue(migration.completable)
        self.assertFalse(migration.completed)
        show = yield self.migration.show_migration(migration.ident)
        self.assertIsInstance(show, str)

        # apply first step manually just to check it works
        yield self.migration.apply_migration_step(migration, 0)

        yield self.migration.apply_migration(migration)
        yield self.wait_for_idle(10)

        self.assertEqual(1, self.count_agents("test_exportable_agent"))
        self.assertEqual(2, self.count_agents("test_child_agent"))
        self.assertEqual(2, self.count_agents("host_agent"))
        self.assertEqual(1, self.count_agents("shard_agent"))
        self.assertEqual(1, self.count_agents("raage_agent"))
        self.assertEqual(1, self.count_agents("monitor_agent"))
예제 #11
0
파일: tools.py 프로젝트: f3at/feat
    def iterate(self):
        if not self.query:
            self.info("Design document id: %s has no views to rebuild",
                      self.design_doc.doc_id)
            self.stop()
            return

        self.count += 1

        if self.count == 1:
            self.trigger_rebuild()
        else:
            from feat.common import first

            active_tasks = yield self.db.couchdb_call(
                self.db.couchdb.get, '/_active_tasks')
            relevant = first(
                x for x in active_tasks
                if (x.get('type') == 'indexer' and
                    x.get('database') == self.db.db_name and
                    x.get('design_document') == self.design_doc.doc_id))

            if relevant:
                self.info('The progress of updating %s is %s%%',
                          self.design_doc.doc_id, relevant.get('progress'))
                # if the updater is in progress don't wait for the view
                # result
                if self.query_defer:
                    self.debug('Not waiting for the result of the query.')
                    self.query_defer.cancel()
            else:
                self.trigger_rebuild()
예제 #12
0
    def testKillHost(self):
        self.assertEqual(1, self.count_agents('host_agent'))
        self.assertEqual(1, self.count_agents('shard_agent'))
        self.assertEqual(1, self.count_agents('raage_agent'))
        self.assertEqual(1, self.count_agents('monitor_agent'))

        yield self.wait_for_idle(10)
        medium = self.get_local('medium')
        desc = medium.get_descriptor()

        @defer.inlineCallbacks
        def has_monitor():
            p = yield medium.agent.query_partners('monitors')
            defer.returnValue(len(p) > 0)
        yield self.wait_for(has_monitor, 10)
        yield medium.terminate_hard()
        self.assertEqual(0, self.count_agents('host_agent'))
        agency = self.get_local('agency')
        self.assertEqual(1, desc.instance_id)

        yield agency.start_agent(desc)
        yield self.wait_for_idle(10)
        new_desc = yield self.driver._database_connection.get_document(
            desc.doc_id)
        self.assertEqual(2, new_desc.instance_id)
        self.assertEqual(1, self.count_agents('shard_agent'))
        self.assertEqual(1, self.count_agents('raage_agent'))
        self.assertEqual(1, self.count_agents('monitor_agent'))

        monitor = first(self.driver.iter_agents('monitor_agent')).get_agent()
        hosts = yield monitor.query_partners('hosts')
        self.assertEqual(2, hosts[0].instance_id)
예제 #13
0
파일: host_restart.py 프로젝트: f3at/feat
def do_cleanup(connection, host_agent_id):
    '''
    Performs cleanup after the host agent who left his descriptor in database.
    Deletes the descriptor and the descriptors of the partners he was hosting.
    '''
    desc = yield safe_get(connection, host_agent_id)
    if isinstance(desc, host.Descriptor):
        for partner in desc.partners:
            partner_desc = yield safe_get(connection, partner.recipient.key)
            if partner_desc:
                host_part = first(x for x in partner_desc.partners
                                  if x.role == 'host')
                if host_part is None:
                    log.warning('host_restart',
                                'Agent id: %s type: %s did not have any '
                                'host partner. So we are leaving it be.',
                                partner_desc.doc_id,
                                partner_desc.type_name)
                elif host_part.recipient.key == host_agent_id:
                    log.info('host_restart', "Deleting document with ID: %s",
                             partner_desc.doc_id)
                    yield connection.delete_document(partner_desc)
                else:
                    log.warning('host_restart',
                                "Not deleting descriptor of the agent id: %s, "
                                "agent_type: %s, as it seems to be hosted by "
                                "the host agent: %s. Although keep in mind "
                                "that he will not receive the goodbye "
                                "notification from us!",
                                partner_desc.doc_id,
                                partner_desc.type_name,
                                host_part.recipient.key)
        log.info('host_restart', "Deleting document with ID: %s",
                 desc.doc_id)
        yield connection.delete_document(desc)
예제 #14
0
파일: messaging.py 프로젝트: f3at/feat
 def _get_own_address(self):
     res = first(x.recipient for x in self._bindings if x.recipient.type == RecipientType.agent)
     if res is None:
         raise ValueError(
             "We have been asked to give the our address " "but so far no personal binding have been " "created."
         )
     return res
예제 #15
0
 def _get_contractor(self, *_):
     self.medium = first(x for x in self.agent._protocols.itervalues()
                         if isinstance(x, AgencyContractor))
     if self.medium is None:
         self.fail('Contractor not found')
     self.contractor = self.medium.get_agent_side()
     self.remote_id = self.medium.guid
     return self.contractor
예제 #16
0
        def closed_handler(s, state):
            s.log('Contracts closed, terminating.')
            bidded = state.medium.contractors.with_state(ContractorState.bid)
            to_elect = first(x.bid for x in bidded
                             if x.bid.payload['cost'] == 3)

            state.medium.elect(to_elect)
            state.medium.terminate()
예제 #17
0
 def _select_reference_handler(self, model, reference):
     if reference is None:
         self._highlight_selected()
         return
     src = self._get_node(str(reference.owner_url))
     dst = self._get_node(str(reference.url))
     edge = first(x for x in self._xdot.graph.edges if x.src == src and x.dst == dst)
     if edge:
         self._xdot.set_highlight([src, edge])
예제 #18
0
파일: query.py 프로젝트: f3at/feat
def include_values(docs, responses, query):
    # dict field_name -> ParsedIndex
    lookup = dict(
        (field, first(v for k, v in responses.iteritems() if k.field == field)) for field in query.include_value
    )
    for doc in docs:
        for name, cache_entry in lookup.iteritems():
            setattr(doc, name, cache_entry.get_value(doc.doc_id))
    return docs
예제 #19
0
파일: agency.py 프로젝트: pepribas/F3AT
 def find_agent(self, desc):
     '''find_agent(agent_id_or_descriptor) -> Gives medium class of the
     agent if the agency hosts it.'''
     agent_id = (desc.doc_id
                 if isinstance(desc, descriptor.Descriptor)
                 else desc)
     self.log("I'm trying to find the agent with id: %s", agent_id)
     result = first(x for x in self._agents
                    if x._descriptor.doc_id == agent_id)
     return defer.succeed(result)
예제 #20
0
    def prolog(self):
        setup = format_block("""
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'))

        wait_for_idle()

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'))

        wait_for_idle()
        """)

        yield self.process(setup)
        yield self.wait_for_idle(20)
        self.raage_medium = first(self.driver.iter_agents('raage_agent'))
        self.shard_medium = first(self.driver.iter_agents('shard_agent'))
예제 #21
0
파일: common.py 프로젝트: zaheerm/feat
    def __init__(self, friend, **opts):
        if self.stages is None:
            raise NotImplementedError("stages attribute needs to be set")

        log.Logger.__init__(self, friend)
        initial_state = first(iter(self.stages))
        StateMachineMixin.__init__(self, initial_state)

        self.friend = friend
        self.opts = opts
        self._observer = observer.Observer(self._initiate)
예제 #22
0
    def testStartStandaloneAgent(self):
        yield self.agency.initiate()
        yield self.wait_for_host_agent(20)
        host_a = self.agency.get_host_agent()
        yield host_a.wait_for_ready()
        self.info("Host agent is ready, starting standalone agent.")

        yield self.agency.spawn_agent("standalone")

        yield self.wait_for_standalone()
        part = host_a.query_partners_with_role('all', 'standalone')

        agent_ids = [host_a.get_own_address().key, part[0].recipient.key]
        # check that journaling works as it should
        yield self.assert_journal_contains(agent_ids)

        # now test the find_agent logic
        host = yield self.agency.find_agent(agent_ids[0])
        self.assertIsInstance(host, base_agency.AgencyAgent)
        stand = yield self.agency.find_agent(agent_ids[1])
        self.assertIsInstance(stand, broker.AgentReference)

        slave = first(x for x in self.agency._broker.slaves.itervalues()
                      if x.is_standalone)

        self.assertIsInstance(slave, broker.SlaveReference)
        host = yield slave.callRemote('find_agent', agent_ids[0])
        self.assertIsInstance(host, base_agency.AgencyAgent)
        stand = yield slave.callRemote('find_agent', agent_ids[1])
        self.assertIsInstance(stand, broker.AgentReference)

        not_found = yield slave.callRemote('find_agent', 'unknown id')
        self.assertIs(None, not_found)

        # asserts on slaves registry
        self.assertEqual(2, len(self.agency._broker.slaves))
        self.assertEqual(1, len(slave.agents))
        self.assertEqual(agent_ids[1], slave.agents.keys()[0])

        # asserts on logs and journal entries in journal database
        jour = self.agency._journaler._writer
        yield self.wait_for(jour.is_idle, 10)
        categories = yield jour.get_log_categories()
        self.assertTrue(set(['host_agent', 'standalone', 'agency']).issubset(
            set(categories)))
        log_names = yield jour.get_log_names('host_agent')
        self.assertEqual([agent_ids[0]], log_names)
        log_names = yield jour.get_log_names('standalone')
        self.assertEqual([agent_ids[1]], log_names)
        yield self.assert_has_logs('host_agent', agent_ids[0])
        yield self.assert_has_logs('standalone', agent_ids[1])

        self.info("Just before validating models.")
        yield self.validate_model_tree(self.agency)
예제 #23
0
    def testMigrateAgentWhileNotHavingResource(self):
        yield self.migration.set_current('testing_site')
        shards = yield self.migration.get_structure()

        # we will migrate first shard (with only migratable agents)
        shard = recipient.IRecipient(self.host1).route
        to_migrate = first(x for x in shards if x.shard == shard)
        self.assertIsNot(None, to_migrate)

        migration = yield self.migration.prepare_shard_migration(to_migrate)

        # here we don't have enough epu in new cluster so first attempt to
        # spawn agent should fail. Cluster 1 should stabilize with exported
        # agent terminated and rest not touched. We should also get the alert
        # about the failure

        d = self.migration.apply_migration(migration)

        def condition():
            return len(self.alert.get_alerts()) > 0

        # now we will retry 3 times to find allocation before giving up
        yield self.wait_for(condition, 200)
        self.assertEqual(0,
                         self.drivers[0].count_agents('test_exportable_agent'))
        self.assertEqual(2,
                         self.drivers[0].count_agents('test_child_agent'))

        spawn_host = text_helper.format_block("""
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'), hostdef=hostdef2)
        """)
        yield self.process(self.drivers[1], spawn_host)
        self.migration.spawn_next_agent()
        yield d
        yield self.wait_for_idle(10)

        self.assertEqual(1,
                         self.drivers[1].count_agents('test_exportable_agent'))
        self.assertEqual(2, self.drivers[1].count_agents('test_child_agent'))
        self.assertEqual(2, self.drivers[1].count_agents('host_agent'))
        self.assertEqual(1, self.drivers[1].count_agents('shard_agent'))
        self.assertEqual(1, self.drivers[1].count_agents('raage_agent'))
        self.assertEqual(1, self.drivers[1].count_agents('monitor_agent'))

        self.assertEqual(0,
                         self.drivers[0].count_agents('test_exportable_agent'))
        self.assertEqual(0, self.drivers[0].count_agents('test_child_agent'))
        self.assertEqual(2, self.drivers[0].count_agents('host_agent'))
        self.assertEqual(1, self.drivers[0].count_agents('shard_agent'))
        self.assertEqual(1, self.drivers[0].count_agents('raage_agent'))
        self.assertEqual(1, self.drivers[0].count_agents('monitor_agent'))
예제 #24
0
 def prolog(self):
     setup = format_block("""
     agency = spawn_agency()
     agency.disable_protocol('setup-monitoring', 'Task')
     descriptor_factory('test-agent')
     agency.start_agent(_, host='127.0.0.1', port=%(port)s, \
                        exchange=%(exchange)s, \
                        exchange_type=%(type)s)
     """) % dict(port=1234,
                 exchange="'exchange'", type="'direct'")
     yield self.process(setup)
     self.agent = first(self.driver.iter_agents('test-agent')).get_agent()
예제 #25
0
    def prolog(self):
        setup = text_helper.format_block("""
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'))
        host1 = _.get_agent()
        wait_for_idle()

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'))
        wait_for_idle()

        host1.start_agent(descriptor_factory('test_exportable_agent'))
        wait_for_idle()

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'))
        wait_for_idle()

        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'))
        host2 = _.get_agent()
        host2.start_agent(descriptor_factory('export_agent'))
        wait_for_idle()
        host2.start_agent(descriptor_factory('migration_agent'))
        wait_for_idle()
        """)
        yield self.process(setup)

        self.export = first(
            self.driver.iter_agents('export_agent')).get_agent()
        self.migration = first(
            self.driver.iter_agents('migration_agent')).get_agent()
        self.assertEqual(1, self.count_agents('test_exportable_agent'))
        self.assertEqual(2, self.count_agents('test_child_agent'))
        self.host1 = self.get_local('host1')
        self.host2 = self.get_local('host2')
예제 #26
0
 def prolog(self):
     setup = format_block("""
     spawn_agency(start_host=False, \
                  'feat.agents.base.amqp.interface.IAMQPClientFactory')
     agency = _
     descriptor_factory('test-agent')
     agency.start_agent(_, host='127.0.0.1', port=%(port)s, \
                        exchange=%(exchange)s, \
                        exchange_type=%(type)s)
     """) % dict(port=self.rabbit.get_config()['port'],
                 exchange="'exchange'", type="'direct'")
     yield self.process(setup)
     self.agent = first(self.driver.iter_agents('test-agent'))
예제 #27
0
    def testStoringEntries(self):
        l = self._generate_log
        e = self._generate_entry

        yield self.journalers[1].insert_entries([
            l(message="some cool msg"),
            e(agent_id='standalone_agent')])
        histories = yield self.sql_writer.get_histories()
        self.assertEqual(1, len(histories))
        self.assertEqual('standalone_agent', histories[0].agent_id)

        logs = yield self.sql_writer.get_log_entries()
        self.assertTrue(first(x for x in logs
                              if x['message'] == 'some cool msg'))
예제 #28
0
    def testArmagedon(self):
        '''
        In this test we kill the host with Raage and Shard.
        Then we assert that they were recreated.
        '''
        d1 = self.raage_medium._terminate()
        d2 = self.shard_medium._terminate()
        d3 = first(self.driver.iter_agents('host_agent'))._terminate()
        yield defer.DeferredList([d1, d2, d3])

        yield self.wait_for_idle(30)
        self.assertEqual(1, self.count_agents('raage_agent'))
        self.assertEqual(1, self.count_agents('shard_agent'))
        self.assertEqual(1, self.count_agents('host_agent'))
예제 #29
0
    def prolog(self):
        setup = format_block("""
        test_desc = descriptor_factory('contract-running-agent')

        agency = spawn_agency()
        agency = spawn_agency()
        agency = spawn_agency()
        agent = agency.get_host_agent()
        agent.wait_for_ready()
        agent.start_agent(test_desc)
        """)
        yield self.process(setup)
        medium = first(self.driver.iter_agents('contract-running-agent'))
        self.agent = medium.get_agent()
예제 #30
0
    def prolog(self):
        setup = format_block("""
        # Host 1 will run Raage, Host, Shard and Requesting agents
        load('feat.test.integration.resource')
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        host_desc = descriptor_factory('host_agent')
        req_desc = descriptor_factory('requesting_agent')
        agency.start_agent(host_desc, hostdef=hostdef1)
        host = _.get_agent()

        wait_for_idle()
        host.start_agent(req_desc)

        # Host 2 run only host agent
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'), hostdef=hostdef1)
        wait_for_idle()

        # Host 3 will run Shard, Host and Raage
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'), hostdef=hostdef2)
        wait_for_idle()

        # Host 4 will run only host agent
        agency = spawn_agency()
        agency.disable_protocol('setup-monitoring', 'Task')
        agency.start_agent(descriptor_factory('host_agent'), hostdef=hostdef2)
        """)

        # host definition in first shard (no space to allocate)
        hostdef1 = host.HostDef(resources=dict(host=0, epu=10, local=1))
        self.set_local("hostdef1", hostdef1)

        # host definition in second shard (no space to allocate)
        hostdef2 = host.HostDef(resources=dict(host=1, epu=10))
        self.set_local("hostdef2", hostdef2)

        yield self.process(setup)
        yield self.wait_for_idle(20)

        raage_mediums = self.driver.iter_agents('raage_agent')
        self.raage_agents = [x.get_agent() for x in raage_mediums]
        host_mediums = self.driver.iter_agents('host_agent')
        self.host_agents = [x.get_agent() for x in host_mediums]
        self.req_agent = first(
            self.driver.iter_agents('requesting_agent')).get_agent()
예제 #31
0
 def get_item(self, job_id):
     return first(x for x in self.items if x[0] == job_id)