Python register_agent_state_opts_helper Examples

Example #1

 def setUp(self):
     super(TestBaseAgentManager, self).setUp()
     agent_config.register_agent_state_opts_helper(cfg.CONF)
     cfg.CONF.set_override('report_interval', 1, 'AGENT')
     self.context = mock.Mock
     mock.patch('neutron.agent.rpc.PluginReportStateAPI').start()
     self.l2gw_agent_manager = l2gw_manager.BaseAgentManager(cfg.CONF)

Example #2

File: test_cfg_agent.py Project: stryng/networking-cisco

    def setUp(self):
        self.conf = cfg.ConfigOpts()
        config.register_agent_state_opts_helper(cfg.CONF)
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(cfg_agent.CiscoCfgAgent.OPTS, "cfg_agent")
        # set class path to the fake firewall class since the real
        # firewall calss will be in another package (neutron-fwaas)
        self.conf.set_override(
            'fw_svc_helper_class',
            'networking_cisco.tests.unit.cisco.cfg_agent.'
            'test_cfg_agent.FakeFirewallSvcHelper', 'cfg_agent')

        cfg.CONF.set_override('report_interval', 0, 'AGENT')
        super(TestCiscoCfgAgentWIthStateReporting, self).setUp()
        self.devmgr_plugin_api_cls_p = mock.patch(
            'networking_cisco.plugins.cisco.cfg_agent.cfg_agent.'
            'CiscoDeviceManagementApi')
        devmgr_plugin_api_cls = self.devmgr_plugin_api_cls_p.start()
        self.devmgr_plugin_api = mock.Mock()
        devmgr_plugin_api_cls.return_value = self.devmgr_plugin_api
        self.devmgr_plugin_api.register_for_duty.return_value = True

        self.plugin_reportstate_api_cls_p = mock.patch(
            'neutron.agent.rpc.PluginReportStateAPI')
        plugin_reportstate_api_cls = self.plugin_reportstate_api_cls_p.start()
        self.plugin_reportstate_api = mock.Mock()
        plugin_reportstate_api_cls.return_value = self.plugin_reportstate_api

        self.looping_call_p = mock.patch(
            'oslo_service.loopingcall.FixedIntervalLoopingCall')
        self.looping_call_p.start()

        mock.patch('neutron.common.rpc.create_connection').start()

Example #3

File: dhcp_agent.py Project: abhirajbutala/neutron

def register_options():
    cfg.CONF.register_opts(DhcpAgent.OPTS)
    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)
    cfg.CONF.register_opts(DeviceManager.OPTS)
    cfg.CONF.register_opts(dhcp.OPTS)
    cfg.CONF.register_opts(interface.OPTS)

Example #4

File: test_cfg_agent.py Project: tbachman/networking-cisco

    def setUp(self):
        self.conf = cfg.ConfigOpts()
        config.register_agent_state_opts_helper(cfg.CONF)
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(cfg_agent.CiscoCfgAgent.OPTS, "cfg_agent")
        cfg.CONF.set_override('report_interval', 0, 'AGENT')
        super(TestCiscoCfgAgentWithStateReporting, self).setUp()
        self.devmgr_plugin_api_cls_p = mock.patch(
            'networking_cisco.plugins.cisco.cfg_agent.cfg_agent.'
            'CiscoDeviceManagementApi')
        devmgr_plugin_api_cls = self.devmgr_plugin_api_cls_p.start()
        self.devmgr_plugin_api = mock.Mock()
        devmgr_plugin_api_cls.return_value = self.devmgr_plugin_api
        self.devmgr_plugin_api.register_for_duty.return_value = True

        self.plugin_reportstate_api_cls_p = mock.patch(
            'neutron.agent.rpc.PluginReportStateAPI')
        plugin_reportstate_api_cls = self.plugin_reportstate_api_cls_p.start()
        self.plugin_reportstate_api = mock.Mock()
        plugin_reportstate_api_cls.return_value = self.plugin_reportstate_api

        self.looping_call_p = mock.patch(
            'oslo_service.loopingcall.FixedIntervalLoopingCall')
        self.looping_call_p.start()

        mock.patch('neutron.common.rpc.create_connection').start()

Example #5

File: servicechain_agent.py Project: HybridCloud-dew/hws

def main():

    
    cfg.CONF.register_opts(ip_lib.OPTS)
    common_config.init(sys.argv[1:])
    common_config.setup_logging()
    
           
    cfg.CONF.register_opts(ServiceChainAgent.OPTS,'servicechain')
    cfg.CONF.register_opts(ServiceChainAgent.agent_opts, "AGENT") 
    config.register_root_helper(cfg.CONF)   
    config.register_agent_state_opts_helper(cfg.CONF)

        
    
    
    cfg.CONF(project='neutron')

    try:
        agent_config = create_agent_config_map(cfg.CONF)
    except ValueError as e:
        LOG.error(_('%s ServiceChain-Agent terminated!'), e)
        sys.exit(1)

    plugin = ServiceChainAgent(**agent_config)
    signal.signal(signal.SIGTERM, plugin._handle_sigterm)

    # Start everything.
    LOG.info(_("ServiceChain-Agent initialized successfully, now running... "))
    plugin.daemon_loop()
    sys.exit(0)

Example #6

File: test_manager.py Project: koteswar16/networking-l2gw

 def setUp(self):
     super(TestManager, self).setUp()
     self.conf = cfg.CONF
     config.register_ovsdb_opts_helper(self.conf)
     agent_config.register_agent_state_opts_helper(self.conf)
     self.driver_mock = mock.Mock()
     self.fake_record_dict = {n_const.OVSDB_IDENTIFIER: 'fake_ovsdb_id'}
     cfg.CONF.set_override('report_interval', 1, 'AGENT')
     self.plugin_rpc = mock.patch.object(agent_api,
                                         'L2GatewayAgentApi').start()
     self.context = mock.Mock
     self.cntxt = mock.patch.object(context,
                                    'get_admin_context_without_session'
                                    ).start()
     self.test_rpc = mock.patch.object(rpc, 'get_client').start()
     self.mock_looping_call = mock.patch.object(loopingcall,
                                                'FixedIntervalLoopingCall'
                                                ).start()
     self.l2gw_agent_manager = manager.OVSDBManager(
         self.conf)
     self.l2gw_agent_manager.plugin_rpc = self.plugin_rpc
     self.fake_config_json = {n_const.OVSDB_IDENTIFIER:
                              'fake_ovsdb_identifier',
                              'ovsdb_ip': '5.5.5.5',
                              'ovsdb_port': '6672',
                              'private_key': 'dummy_key',
                              'enable_ssl': False,
                              'certificate': 'dummy_cert',
                              'ca_cert': 'dummy_ca'}

Example #7

File: servicechain_agent.py Project: HybridCloud-dew/hws

def main():

    cfg.CONF.register_opts(ip_lib.OPTS)
    common_config.init(sys.argv[1:])
    common_config.setup_logging()

    cfg.CONF.register_opts(ServiceChainAgent.OPTS, 'servicechain')
    cfg.CONF.register_opts(ServiceChainAgent.agent_opts, "AGENT")
    config.register_root_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)

    cfg.CONF(project='neutron')

    try:
        agent_config = create_agent_config_map(cfg.CONF)
    except ValueError as e:
        LOG.error(_('%s ServiceChain-Agent terminated!'), e)
        sys.exit(1)

    plugin = ServiceChainAgent(**agent_config)
    signal.signal(signal.SIGTERM, plugin._handle_sigterm)

    # Start everything.
    LOG.info(_("ServiceChain-Agent initialized successfully, now running... "))
    plugin.daemon_loop()
    sys.exit(0)

Example #8

    def _load_device_plugins(self):
        # Load OVS plug-in, if configured, and use its database parameters
        if len(self.ovs_plugin) != 0:
            # if ovs plug-in is configured, use ovs plug-in's database parameters
            self.ovs_plugin_obj = importutils.import_object(self.ovs_plugin)
            self.omni_db_obj = importutils.import_object(
                omni_const.OMNI_DB_CLASS)
            self.omni_db_obj.initialize(None, None, None,
                                        omni_const.OVS_TABLES)

        else:
            # if ovs plug-in is not configured, use omni plug-in's database parameters
            self.omni_db_obj = importutils.import_object(
                omni_const.OMNI_DB_CLASS)
            self.omni_db_obj.initialize(None, None, None,
                                        omni_const.OMNI_TABLES)
            self._parse_network_vlan_ranges()
            self.omni_db_obj.sync_vlan_allocations(self.network_vlan_ranges)

            config.register_agent_state_opts_helper(cfg.CONF)
            config.register_root_helper(cfg.CONF)
            #cfg.CONF.register_opts(scheduler.AGENTS_SCHEDULER_OPTS) # for havana

        # Load Omni device plug-in
        if len(self.omni_plugin) != 0:
            self.omni_plugin_obj = importutils.import_object(self.omni_plugin)
            self.omni_plugin_obj.initialize(self.omni_db_obj)
        else:
            LOG.info("Omni Device plug-in is not specified in the config!!!")
            return

        LOG.info("Device plug-ins loaded!")

Example #9

File: omniswitch_network_plugin.py Project: Alcatel-LucentEnterpriseData/ALUe-OONP_H_R01

    def _load_device_plugins(self):
        # Load OVS plug-in, if configured, and use its database parameters
        if len(self.ovs_plugin) != 0:
            # if ovs plug-in is configured, use ovs plug-in's database parameters
            self.ovs_plugin_obj = importutils.import_object(self.ovs_plugin)
            self.omni_db_obj = importutils.import_object(omni_const.OMNI_DB_CLASS)
            self.omni_db_obj.initialize(None, None, None, omni_const.OVS_TABLES)

        else:
            # if ovs plug-in is not configured, use omni plug-in's database parameters
            self.omni_db_obj = importutils.import_object(omni_const.OMNI_DB_CLASS)
            self.omni_db_obj.initialize(None, None, None, omni_const.OMNI_TABLES)
            self._parse_network_vlan_ranges()
            self.omni_db_obj.sync_vlan_allocations(self.network_vlan_ranges)

            config.register_agent_state_opts_helper(cfg.CONF)
            config.register_root_helper(cfg.CONF)
            #cfg.CONF.register_opts(scheduler.AGENTS_SCHEDULER_OPTS) # for havana

        # Load Omni device plug-in
        if len(self.omni_plugin) != 0:
            self.omni_plugin_obj = importutils.import_object(self.omni_plugin)
            self.omni_plugin_obj.initialize(self.omni_db_obj)
        else:
            LOG.info("Omni Device plug-in is not specified in the config!!!")
            return

        LOG.info("Device plug-ins loaded!")

Example #10

File: test_manager.py Project: oferby/networking-l2gw

 def setUp(self):
     super(TestManager, self).setUp()
     self.conf = cfg.CONF
     config.register_ovsdb_opts_helper(self.conf)
     agent_config.register_agent_state_opts_helper(self.conf)
     self.driver_mock = mock.Mock()
     self.fake_record_dict = {n_const.OVSDB_IDENTIFIER: 'fake_ovsdb_id'}
     cfg.CONF.set_override('report_interval', 1, 'AGENT')
     self.plugin_rpc = mock.patch.object(agent_api,
                                         'L2GatewayAgentApi').start()
     self.context = mock.Mock
     self.cntxt = mock.patch.object(
         context, 'get_admin_context_without_session').start()
     self.test_rpc = mock.patch.object(rpc, 'get_client').start()
     self.mock_looping_call = mock.patch.object(
         loopingcall, 'FixedIntervalLoopingCall').start()
     self.l2gw_agent_manager = manager.OVSDBManager(self.conf)
     self.l2gw_agent_manager.plugin_rpc = self.plugin_rpc
     self.fake_config_json = {
         n_const.OVSDB_IDENTIFIER: 'fake_ovsdb_identifier',
         'ovsdb_ip': '5.5.5.5',
         'ovsdb_port': '6672',
         'private_key': 'dummy_key',
         'enable_ssl': False,
         'certificate': 'dummy_cert',
         'ca_cert': 'dummy_ca'
     }

Example #11

def register_options():
    cfg.CONF.register_opts(DhcpAgent.OPTS)
    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)
    cfg.CONF.register_opts(DeviceManager.OPTS)
    cfg.CONF.register_opts(dhcp.OPTS)
    cfg.CONF.register_opts(interface.OPTS)

Example #12

File: test_vpn_agent.py Project: rhel-osp/neutron

    def setUp(self):
        super(TestVPNAgent, self).setUp()
        self.addCleanup(mock.patch.stopall)
        self.conf = cfg.CONF
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(l3_agent.L3NATAgent.OPTS)
        self.conf.register_opts(interface.OPTS)
        agent_config.register_agent_state_opts_helper(self.conf)
        agent_config.register_root_helper(self.conf)

        self.conf.set_override('interface_driver',
                               'neutron.agent.linux.interface.NullDriver')
        self.conf.set_override('vpn_device_driver', [NOOP_DEVICE], 'vpnagent')

        for clazz in [
                'neutron.agent.linux.ip_lib.device_exists',
                'neutron.agent.linux.ip_lib.IPWrapper',
                'neutron.agent.linux.interface.NullDriver',
                'neutron.agent.linux.utils.execute'
        ]:
            mock.patch(clazz).start()

        l3pluginApi_cls = mock.patch(
            'neutron.agent.l3_agent.L3PluginApi').start()
        self.plugin_api = mock.Mock()
        l3pluginApi_cls.return_value = self.plugin_api

        looping_call_p = mock.patch(
            'neutron.openstack.common.loopingcall.FixedIntervalLoopingCall')
        looping_call_p.start()

        self.fake_host = 'fake_host'
        self.agent = agent.VPNAgent(self.fake_host)

Example #13

File: test_cfg_agent.py Project: Kannan-onecloud/networking-cisco

    def setUp(self):
        self.conf = cfg.ConfigOpts()
        config.register_agent_state_opts_helper(cfg.CONF)
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(cfg_agent.CiscoCfgAgent.OPTS, "cfg_agent")
        # set class path to the fake firewall class since the real
        # firewall calss will be in another package (neutron-fwaas)
        self.conf.set_override('fw_svc_helper_class',
                               'networking_cisco.tests.unit.cisco.cfg_agent.'
                               'test_cfg_agent.FakeFirewallSvcHelper',
                               'cfg_agent')

        cfg.CONF.set_override('report_interval', 0, 'AGENT')
        super(TestCiscoCfgAgentWIthStateReporting, self).setUp()
        self.devmgr_plugin_api_cls_p = mock.patch(
            'networking_cisco.plugins.cisco.cfg_agent.cfg_agent.'
            'CiscoDeviceManagementApi')
        devmgr_plugin_api_cls = self.devmgr_plugin_api_cls_p.start()
        self.devmgr_plugin_api = mock.Mock()
        devmgr_plugin_api_cls.return_value = self.devmgr_plugin_api
        self.devmgr_plugin_api.register_for_duty.return_value = True

        self.plugin_reportstate_api_cls_p = mock.patch(
            'neutron.agent.rpc.PluginReportStateAPI')
        plugin_reportstate_api_cls = self.plugin_reportstate_api_cls_p.start()
        self.plugin_reportstate_api = mock.Mock()
        plugin_reportstate_api_cls.return_value = self.plugin_reportstate_api

        self.looping_call_p = mock.patch(
            'oslo_service.loopingcall.FixedIntervalLoopingCall')
        self.looping_call_p.start()

        mock.patch('neutron.common.rpc.create_connection').start()

Example #14

File: test_cfg_agent.py Project: noironetworks/networking-cisco

    def setUp(self):
        self.conf = cfg.ConfigOpts()
        config.register_agent_state_opts_helper(cfg.CONF)
        self.conf.register_opts(bc_attr.core_opts)
        self.conf.register_opts(cfg_agent.OPTS, "cfg_agent")
        cfg.CONF.set_override('report_interval', 0, 'AGENT')
        super(TestCiscoCfgAgentWithStateReporting, self).setUp()
        self.devmgr_plugin_api_cls_p = mock.patch(
            'networking_cisco.plugins.cisco.cfg_agent.cfg_agent.'
            'CiscoDeviceManagementApi')
        devmgr_plugin_api_cls = self.devmgr_plugin_api_cls_p.start()
        self.devmgr_plugin_api = mock.Mock()
        devmgr_plugin_api_cls.return_value = self.devmgr_plugin_api
        self.devmgr_plugin_api.register_for_duty.return_value = True

        self.plugin_reportstate_api_cls_p = mock.patch(
            'neutron.agent.rpc.PluginReportStateAPI')
        plugin_reportstate_api_cls = self.plugin_reportstate_api_cls_p.start()
        self.plugin_reportstate_api = mock.Mock()
        plugin_reportstate_api_cls.return_value = self.plugin_reportstate_api

        self.looping_call_p = mock.patch(
            'oslo_service.loopingcall.FixedIntervalLoopingCall')
        self.looping_call_p.start()

        mock.patch('neutron.common.rpc.create_connection').start()

Example #15

File: dhcp_agent.py Project: skulker8/neutron

def register_options():
    config.register_interface_driver_opts_helper(cfg.CONF)
    config.register_use_namespaces_opts_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)
    cfg.CONF.register_opts(dhcp_config.DHCP_AGENT_OPTS)
    cfg.CONF.register_opts(dhcp_config.DHCP_OPTS)
    cfg.CONF.register_opts(dhcp_config.DNSMASQ_OPTS)
    cfg.CONF.register_opts(interface.OPTS)

Example #16

File: dhcp_agent.py Project: CingHu/neutron-ustack

def register_options():
    cfg.CONF.register_opts(DhcpAgent.OPTS)
    config.register_interface_driver_opts_helper(cfg.CONF)
    config.register_use_namespaces_opts_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)
    cfg.CONF.register_opts(dhcp.OPTS)
    cfg.CONF.register_opts(interface.OPTS)

Example #17

File: l3_data_engine.py Project: HybridCloud-dew/hws

def _register_opts(conf):
    conf.register_opts(L3DataEngine.OPTS)
    config.register_interface_driver_opts_helper(conf)
    config.register_use_namespaces_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)

Example #18

File: dhcp_agent.py Project: bopopescu/sriov

def register_options():
    cfg.CONF.register_opts(DhcpAgent.OPTS)
    config.register_interface_driver_opts_helper(cfg.CONF)
    config.register_use_namespaces_opts_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)
    cfg.CONF.register_opts(dhcp.OPTS)
    cfg.CONF.register_opts(interface.OPTS)

Example #19

def register_options(conf):
    config.register_interface_driver_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    config.register_availability_zone_opts_helper(conf)
    dhcp_config.register_agent_dhcp_opts(conf)
    conf.register_opts(metadata_config.DRIVER_OPTS)
    conf.register_opts(metadata_config.SHARED_OPTS)
    conf.register_opts(interface.OPTS)

Example #20

File: dhcp_agent.py Project: afori/neutron

def register_options():
    config.register_interface_driver_opts_helper(cfg.CONF)
    config.register_use_namespaces_opts_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)
    cfg.CONF.register_opts(dhcp_config.DHCP_AGENT_OPTS)
    cfg.CONF.register_opts(dhcp_config.DHCP_OPTS)
    cfg.CONF.register_opts(dhcp_config.DNSMASQ_OPTS)
    cfg.CONF.register_opts(interface.OPTS)

Example #21

File: test_l2_ovs_agent.py Project: Gin077/neutron

 def _get_config_opts(self):
     config = cfg.ConfigOpts()
     config.register_opts(common_config.core_opts)
     config.register_opts(interface.OPTS)
     config.register_opts(ovs_config.ovs_opts, "OVS")
     config.register_opts(ovs_config.agent_opts, "AGENT")
     agent_config.register_interface_driver_opts_helper(config)
     agent_config.register_agent_state_opts_helper(config)
     return config

Example #22

File: l3_agent.py Project: rdo-management/neutron

def register_opts(conf):
    conf.register_opts(l3_config.OPTS)
    conf.register_opts(metadata_driver.MetadataDriver.OPTS)
    conf.register_opts(ha.OPTS)
    config.register_interface_driver_opts_helper(conf)
    config.register_use_namespaces_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)

Example #23

 def _get_config_opts(self):
     config = cfg.ConfigOpts()
     config.register_opts(common_config.core_opts)
     config.register_opts(interface.OPTS)
     ovs_conf.register_ovs_agent_opts(config)
     agent_config.register_interface_driver_opts_helper(config)
     agent_config.register_agent_state_opts_helper(config)
     ext_manager.register_opts(config)
     return config

Example #24

File: base.py Project: bopopescu/OpenStack-Ocata

 def _get_config_opts(self):
     config = cfg.ConfigOpts()
     config.register_opts(common_config.core_opts)
     config.register_opts(interface.OPTS)
     ovs_conf.register_ovs_agent_opts(config)
     agent_config.register_interface_driver_opts_helper(config)
     agent_config.register_agent_state_opts_helper(config)
     ext_manager.register_opts(config)
     return config

Example #25

File: l3_agent.py Project: waltBB/neutron_read

def register_opts(conf):
    conf.register_opts(l3_config.OPTS)
    conf.register_opts(metadata_driver.MetadataDriver.OPTS)
    conf.register_opts(ha.OPTS)
    config.register_interface_driver_opts_helper(conf)
    config.register_use_namespaces_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)

Example #26

 def _get_config_opts(self):
     config = cfg.ConfigOpts()
     config.register_opts(common_config.core_opts)
     config.register_opts(interface.OPTS)
     config.register_opts(ovs_config.ovs_opts, "OVS")
     config.register_opts(ovs_config.agent_opts, "AGENT")
     agent_config.register_interface_driver_opts_helper(config)
     agent_config.register_agent_state_opts_helper(config)
     return config

Example #27

File: l3_agent.py Project: sajuptpm7/neutron-vagrant

def register_opts(conf):
    conf.register_opts(l3_config.OPTS)
    conf.register_opts(metadata_config.DRIVER_OPTS)
    conf.register_opts(metadata_config.SHARED_OPTS)
    conf.register_opts(ha.OPTS)
    config.register_interface_driver_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    config.register_availability_zone_opts_helper(conf)

Example #28

File: l2_agent.py Project: alinbalutoiu/networking-hyperv

def main():
    config.register_agent_state_opts_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    config.setup_logging()

    hyperv_agent = HyperVNeutronAgent()

    # Start everything.
    LOG.info(_LI("Agent initialized successfully, now running... "))
    hyperv_agent.daemon_loop()

Example #29

File: l2_agent.py Project: paulaCrismaru/networking-hyperv

def main():
    config.register_agent_state_opts_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    config.setup_logging()

    hyperv_agent = HyperVNeutronAgent()

    # Start everything.
    LOG.info(_LI("Agent initialized successfully, now running... "))
    hyperv_agent.daemon_loop()

Example #30

File: dhcp_agent.py Project: rajamony/neutron

def register_options(conf):
    config.register_interface_driver_opts_helper(conf)
    config.register_use_namespaces_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(dhcp_config.DHCP_AGENT_OPTS)
    conf.register_opts(dhcp_config.DHCP_OPTS)
    conf.register_opts(dhcp_config.DNSMASQ_OPTS)
    conf.register_opts(metadata_config.DRIVER_OPTS)
    conf.register_opts(metadata_config.SHARED_OPTS)
    conf.register_opts(interface.OPTS)

Example #31

def main():
    eventlet.monkey_patch()
    cfg.CONF.register_opts(UnixDomainMetadataProxy.OPTS)
    cfg.CONF.register_opts(MetadataProxyHandler.OPTS)
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    cfg.CONF(project='neutron')
    config.setup_logging(cfg.CONF)
    utils.log_opt_values(LOG)
    proxy = UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()

Example #32

File: agent.py Project: Karbit/neutron

def main():
    eventlet.monkey_patch()
    cfg.CONF.register_opts(UnixDomainMetadataProxy.OPTS)
    cfg.CONF.register_opts(MetadataProxyHandler.OPTS)
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    cfg.CONF(project='neutron')
    config.setup_logging(cfg.CONF)
    utils.log_opt_values(LOG)
    proxy = UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()

Example #33

def main():
    config.register_ovsdb_opts_helper(cfg.CONF)
    agent_config.register_agent_state_opts_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    config.setup_logging()

    mgr = manager.OVSDBManager(cfg.CONF)
    svc = L2gatewayAgentService(host=cfg.CONF.host,
                                topic=topics.L2GATEWAY_AGENT,
                                manager=mgr)
    service.launch(cfg.CONF, svc).wait()

Example #34

def main():
    cfg.CONF.register_opts(UnixDomainMetadataProxy.OPTS)
    cfg.CONF.register_opts(MetadataProxyHandler.OPTS)
    cache.register_oslo_configs(cfg.CONF)
    cfg.CONF.set_default(name='cache_url', default='memory://?default_ttl=5')
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    config.init(sys.argv[1:])
    config.setup_logging()
    utils.log_opt_values(LOG)
    proxy = UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()

Example #35

File: metadata_agent.py Project: rdo-management/neutron

def main():
    cfg.CONF.register_opts(metadata_conf.UNIX_DOMAIN_METADATA_PROXY_OPTS)
    cfg.CONF.register_opts(metadata_conf.METADATA_PROXY_HANDLER_OPTS)
    cache.register_oslo_configs(cfg.CONF)
    cfg.CONF.set_default(name='cache_url', default='memory://?default_ttl=5')
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    config.init(sys.argv[1:])
    config.setup_logging()
    utils.log_opt_values(LOG)
    proxy = agent.UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()

Example #36

File: agent.py Project: vijayendrabvs/neutron

def main():
    eventlet.monkey_patch()
    cfg.CONF.register_opts(UnixDomainMetadataProxy.OPTS)
    cfg.CONF.register_opts(MetadataProxyHandler.OPTS)
    cache.register_oslo_configs(cfg.CONF)
    cfg.CONF.set_default(name='cache_url', default='memory://?default_ttl=5')
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    cfg.CONF(project='neutron')
    config.setup_logging(cfg.CONF)
    utils.log_opt_values(LOG)
    proxy = UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()

Example #37

File: agent.py Project: B-Rich/neutron

def main():
    eventlet.monkey_patch()
    cfg.CONF.register_opts(UnixDomainMetadataProxy.OPTS)
    cfg.CONF.register_opts(MetadataProxyHandler.OPTS)
    cache.register_oslo_configs(cfg.CONF)
    cfg.CONF.set_default(name='cache_url', default='memory://?default_ttl=5')
    agent_conf.register_agent_state_opts_helper(cfg.CONF)
    cfg.CONF(project='neutron')
    config.setup_logging(cfg.CONF)
    utils.log_opt_values(LOG)
    proxy = UnixDomainMetadataProxy(cfg.CONF)
    proxy.run()

Example #38

def register_opts(conf):
    l3_config.register_l3_agent_config_opts(l3_config.OPTS, conf)
    ha_conf.register_l3_agent_ha_opts(conf)
    meta_conf.register_meta_conf_opts(meta_conf.DRIVER_OPTS, conf)
    meta_conf.register_meta_conf_opts(meta_conf.SHARED_OPTS, conf)
    config.register_interface_driver_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    conf.register_opts(pd.OPTS)
    conf.register_opts(ra.OPTS)
    config.register_availability_zone_opts_helper(conf)

Example #39

File: qos_agent.py Project: tc1989tc/neutron-qos

def main():
    conf = cfg.CONF
    conf.register_opts(QosAgent.Opts)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    common_config.init(sys.argv[1:])
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-qos-agent',
        topic=qos_rpc_agent_api.QOS_AGENT,
        manager='neutron.services.qos.agents.'
        'qos_agent.QosAgentWithStateReport')
    service.launch(server).wait()

Example #40

File: metering_agent.py Project: dhanunjaya/neutron

def main():
    conf = cfg.CONF
    conf.register_opts(MeteringAgent.Opts)
    config.register_agent_state_opts_helper(conf)
    common_config.init(sys.argv[1:])
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-metering-agent',
        topic=topics.METERING_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager='neutron.services.metering.agents.'
                'metering_agent.MeteringAgentWithStateReport')
    service.launch(cfg.CONF, server).wait()

Example #41

File: metering_agent.py Project: rajamony/neutron

def main():
    conf = cfg.CONF
    conf.register_opts(MeteringAgent.Opts)
    config.register_agent_state_opts_helper(conf)
    common_config.init(sys.argv[1:])
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-metering-agent',
        topic=topics.METERING_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager='neutron.services.metering.agents.'
        'metering_agent.MeteringAgentWithStateReport')
    service.launch(cfg.CONF, server).wait()

Example #42

File: l2gw_agent.py Project: ashishg89/networking-l2gw

def main():
    config.register_ovsdb_opts_helper(cfg.CONF)
    agent_config.register_agent_state_opts_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    config.setup_logging()

    mgr = manager.OVSDBManager(cfg.CONF)
    svc = L2gatewayAgentService(
        host=cfg.CONF.host,
        topic=topics.L2GATEWAY_AGENT,
        manager=mgr
    )
    service.launch(cfg.CONF, svc).wait()

Example #43

File: qos_agent.py Project: chenyanfun/neutron-qos

def main():
    conf = cfg.CONF
    conf.register_opts(QosAgent.Opts)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    common_config.init(sys.argv[1:])
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-qos-agent',
        topic=qos_rpc_agent_api.QOS_AGENT,
        manager='neutron.services.qos.agents.'
                'qos_agent.QosAgentWithStateReport')
    service.launch(server).wait()

Example #44

File: agent.py Project: bdrich/neutron-lbaas

def main():
    cfg.CONF.register_opts(OPTS)
    cfg.CONF.register_opts(manager.OPTS)
    # import interface options just in case the driver uses namespaces
    cfg.CONF.register_opts(interface.OPTS)
    config.register_interface_driver_opts_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)

    common_config.init(sys.argv[1:])
    config.setup_logging()

    mgr = manager.LbaasAgentManager(cfg.CONF)
    svc = LbaasAgentService(host=cfg.CONF.host, topic=l_const.LOADBALANCER_AGENT, manager=mgr)
    service.launch(cfg.CONF, svc).wait()

Example #45

File: metering_agent.py Project: pjh03/quantum

def main():
    eventlet.monkey_patch()
    conf = cfg.CONF
    conf.register_opts(MeteringAgent.Opts)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf(project='neutron')
    config.setup_logging(conf)
    server = neutron_service.Service.create(
        binary='neutron-metering-agent',
        topic=topics.METERING_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager='neutron.services.metering.agents.'
        'metering_agent.MeteringAgentWithStateReport')
    service.launch(server).wait()

Example #46

File: metering_agent.py Project: uramanan/neutron

def main():
    eventlet.monkey_patch()
    conf = cfg.CONF
    conf.register_opts(MeteringAgent.Opts)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf(project='neutron')
    config.setup_logging(conf)
    server = neutron_service.Service.create(
        binary='neutron-metering-agent',
        topic=topics.METERING_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager='neutron.services.metering.agents.'
                'metering_agent.MeteringAgentWithStateReport')
    service.launch(server).wait()

Example #47

def main(manager='networking_cisco.plugins.cisco.cfg_agent.'
                 'cfg_agent.CiscoCfgAgentWithStateReport'):
    conf = cfg.CONF
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    common_config.init(sys.argv[1:])
    conf(project='neutron')
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-cisco-cfg-agent',
        topic=c_constants.CFG_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager=manager)
    service.launch(cfg.CONF, server).wait()

Example #48

File: cfg_agent.py Project: bradleyjones/neutron

def main(manager='neutron.plugins.cisco.cfg_agent.'
                 'cfg_agent.CiscoCfgAgentWithStateReport'):
    conf = cfg.CONF
    conf.register_opts(CiscoCfgAgent.OPTS, "cfg_agent")
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    common_config.init(sys.argv[1:])
    conf(project='neutron')
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-cisco-cfg-agent',
        topic=c_constants.CFG_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager=manager)
    service.launch(server).wait()

Example #49

File: agent.py Project: Vikash082/neutron-lbaas

def main():
    cfg.CONF.register_opts(OPTS)
    cfg.CONF.register_opts(manager.OPTS)
    # import interface options just in case the driver uses namespaces
    cfg.CONF.register_opts(interface.OPTS)
    config.register_interface_driver_opts_helper(cfg.CONF)
    config.register_agent_state_opts_helper(cfg.CONF)

    common_config.init(sys.argv[1:])
    config.setup_logging()

    mgr = manager.LbaasAgentManager(cfg.CONF)
    svc = LbaasAgentService(host=cfg.CONF.host,
                            topic=topics.LOADBALANCER_AGENT,
                            manager=mgr)
    service.launch(svc).wait()

Example #50

File: varmour_router.py Project: prathyu1/neutron-fwaas

def main():
    conf = cfg.CONF
    conf.register_opts(l3_config.OPTS)
    conf.register_opts(ha.OPTS)
    config.register_interface_driver_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    common_config.init(sys.argv[1:])
    config.setup_logging()
    server = neutron_service.Service.create(
        binary='neutron-l3-agent',
        topic=f_const.L3_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager='neutron_fwaas.services.firewall.agents.varmour.'
                'varmour_router.vArmourL3NATAgentWithStateReport')
    service.launch(conf, server).wait()

Example #51

File: l3_agent.py Project: 674009287/neutron

def main(manager='neutron.agent.l3_agent.L3NATAgentWithStateReport'):
    eventlet.monkey_patch()
    conf = cfg.CONF
    conf.register_opts(L3NATAgent.OPTS)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    conf(project='neutron')
    config.setup_logging(conf)
    legacy.modernize_quantum_config(conf)
    server = neutron_service.Service.create(
        binary='neutron-l3-agent',
        topic=topics.L3_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager=manager)
    service.launch(server).wait()

Example #52

def register_opts(conf):
    conf.register_opts(l3_config.OPTS)
    conf.register_opts(metadata_config.SHARED_OPTS)
    try:
        conf.register_opts(ha.OPTS)
    except Exception:
        ha_conf.register_l3_agent_ha_opts(conf)
    config.register_interface_driver_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    try:
        config.register_use_namespaces_opts_helper(conf)
    except Exception:
        conf.register_opts(pd.OPTS)
        conf.register_opts(ra.OPTS)
        config.register_availability_zone_opts_helper(conf)

Example #53

File: l3_agent.py Project: zioc/neutron

def main(manager='neutron.agent.l3_agent.L3NATAgentWithStateReport'):
    eventlet.monkey_patch()
    conf = cfg.CONF
    conf.register_opts(L3NATAgent.OPTS)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    conf(project='neutron')
    config.setup_logging(conf)
    legacy.modernize_quantum_config(conf)
    server = neutron_service.Service.create(
        binary='neutron-l3-agent',
        topic=topics.L3_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager=manager)
    service.launch(server).wait()

Example #54

File: l3_agent.py Project: aignatov/neutron

def main(manager='neutron.agent.l3_agent.L3NATAgentWithStateReport'):
    conf = cfg.CONF
    conf.register_opts(L3NATAgent.OPTS)
    config.register_interface_driver_opts_helper(conf)
    config.register_use_namespaces_opts_helper(conf)
    config.register_agent_state_opts_helper(conf)
    config.register_root_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
    common_config.init(sys.argv[1:])
    config.setup_logging(conf)
    server = neutron_service.Service.create(
        binary='neutron-l3-agent',
        topic=topics.L3_AGENT,
        report_interval=cfg.CONF.AGENT.report_interval,
        manager=manager)
    service.launch(server).wait()