def testDefaultConfig(self):
     parser = optparse.OptionParser()
     agency.add_options(parser)
     options = parser.get_default_values()
     self.assertTrue(hasattr(options, 'msg_host'))
     self.assertTrue(hasattr(options, 'msg_port'))
     self.assertTrue(hasattr(options, 'msg_user'))
     self.assertTrue(hasattr(options, 'msg_password'))
     self.assertTrue(hasattr(options, 'db_host'))
     self.assertTrue(hasattr(options, 'db_port'))
     self.assertTrue(hasattr(options, 'db_name'))
     self.assertTrue(hasattr(options, 'manhole_public_key'))
     self.assertTrue(hasattr(options, 'manhole_private_key'))
     self.assertTrue(hasattr(options, 'manhole_authorized_keys'))
     self.assertTrue(hasattr(options, 'manhole_port'))
     a = agency.Agency.from_config(dict())
     self.assertEqual(a.config['msg']['host'], agency.DEFAULT_MSG_HOST)
     self.assertEqual(a.config['msg']['port'], agency.DEFAULT_MSG_PORT)
     self.assertEqual(a.config['msg']['user'], agency.DEFAULT_MSG_USER)
     self.assertEqual(a.config['msg']['password'],
                      agency.DEFAULT_MSG_PASSWORD)
     self.assertEqual(a.config['db']['host'], agency.DEFAULT_DB_HOST)
     self.assertEqual(a.config['db']['port'], agency.DEFAULT_DB_PORT)
     self.assertEqual(a.config['db']['name'], agency.DEFAULT_DB_NAME)
     self.assertEqual(a.config['manhole']['public_key'],
                      agency.DEFAULT_MH_PUBKEY)
     self.assertEqual(a.config['manhole']['private_key'],
                      agency.DEFAULT_MH_PRIVKEY)
     self.assertEqual(a.config['manhole']['authorized_keys'],
                      agency.DEFAULT_MH_AUTH)
     self.assertEqual(a.config['manhole']['port'], agency.DEFAULT_MH_PORT)
Example #2
0
def bootstrap(parser=None, args=None, descriptors=None):
    """Bootstrap a feat process, handling command line arguments.
    @param parser: the option parser to use; more options will be
        added to the parser; if not specified or None
        a new one will be created
    @type  parser: optparse.OptionParser or None
    @param args: the command line arguments to parse; if not specified
        or None, sys.argv[1:] will be used
    @type  args: [str()] or None
    @param descriptors: the descriptors of the agent to starts in addition
        of the host agent; if not specified or None
        no additional agents will be started
    @type  descriptors: [Descriptor()] or None
    @return: the deferred of the bootstrap chain
    @rtype:  defer.Deferred()"""

    parser = parser or optparse.OptionParser()
    add_options(parser)
    net_agency.add_options(parser)

    with _Bootstrap(parser=parser, args=args) as bootstrap:
        agency = bootstrap.agency
        opts = bootstrap.opts
        args = bootstrap.args
        opts, args = check_options(opts, args)

        descriptors = descriptors or []
        d = agency.initiate()

        if not opts.standalone:
            # specific to running normal agency
            for name in opts.agents:
                factory = descriptor.lookup(name)
                if factory is None:
                    msg = "No descriptor factory found for agent %s" % name
                    raise OptionError(msg)
                descriptors.append(factory())

            hostdef = opts.hostdef
            if opts.hostres or opts.hostcat:
                hostdef = host.HostDef()
                for resdef in opts.hostres:
                    parts = resdef.split(":", 1)
                    name = parts[0]
                    value = 1
                    if len(parts) > 1:
                        try:
                            value = int(parts[1])
                        except ValueError:
                            raise OptionError("Invalid host resource: %s"
                                              % resdef)
                    hostdef.resources[name] = value

                for catdef in opts.hostcat:
                    name, value = check_category(catdef)
                    hostdef.categories[name] = value

            agency.set_host_def(hostdef)

            for desc in descriptors:
                log.debug("feat", "Starting agent with descriptor %r", desc)
                d.addCallback(defer.drop_param, agency.spawn_agent, desc)
        else:
            # standalone specific
            kwargs = opts.standalone_kwargs or dict()
            d.addCallback(defer.drop_param, agency.spawn_agent,
                          opts.agents[0], **kwargs)
        return d