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 #2
0
    def _init_vif(self, plugin):
        if plugin == 1:
            try:
                import neutron.agent.linux.interface as interface
                from neutron.agent.linux.interface import OVSInterfaceDriver
                conf = config.setup_conf()
                conf.register_opts(interface.OPTS)
                config.register_root_helper(conf)
                return OVSInterfaceDriver(conf)
            except:
                pass
        else:
            ROOT_HELPER_OPTS = [
                cfg.StrOpt('root_helper', default='sudo',
                           help=_('Root helper application.')),
                cfg.BoolOpt('ovs_use_veth', default=True,
                            help = _("ovs_use_veth")),
                cfg.StrOpt('ovs_integration_bridge',
                           default='br-int',
                           help=_('Name of Open vSwitch bridge to use'))
                            ]
            try:        
                from neutron_plugin_contrail.plugins.opencontrail.agent.contrail_vif_driver import ContrailInterfaceDriver
                contrail_conf = cfg.ConfigOpts()
                contrail_conf.register_opts(ROOT_HELPER_OPTS)
                contrail_conf.register_opts(ROOT_HELPER_OPTS, 'AGENT')
                return ContrailInterfaceDriver(contrail_conf)
            except:
                pass

        return None
Example #3
0
    def setUp(self):
        super(TestL3AgentEventHandler, self).setUp()
        cfg.CONF.register_opts(l3_agent.L3NATAgent.OPTS)
        cfg.CONF.set_override("interface_driver", "neutron.agent.linux.interface.NullDriver")
        cfg.CONF.set_override("use_namespaces", True)
        agent_config.register_root_helper(cfg.CONF)

        device_exists_p = mock.patch("neutron.agent.linux.ip_lib.device_exists")
        device_exists_p.start()

        utils_exec_p = mock.patch("neutron.agent.linux.utils.execute")
        utils_exec_p.start()

        drv_cls_p = mock.patch("neutron.agent.linux.interface.NullDriver")
        driver_cls = drv_cls_p.start()
        mock_driver = mock.MagicMock()
        mock_driver.DEV_NAME_LEN = interface.LinuxInterfaceDriver.DEV_NAME_LEN
        driver_cls.return_value = mock_driver

        l3_plugin_p = mock.patch("neutron.agent.l3_agent.L3PluginApi")
        l3_plugin_cls = l3_plugin_p.start()
        l3_plugin_cls.return_value = mock.Mock()

        self.external_process_p = mock.patch("neutron.agent.linux.external_process.ProcessManager")
        self.external_process_p.start()
        looping_call_p = mock.patch("neutron.openstack.common.loopingcall.FixedIntervalLoopingCall")
        looping_call_p.start()
        self.agent = l3_agent.L3NATAgent(HOSTNAME)
        self.addCleanup(mock.patch.stopall)
Example #4
0
    def setUp(self):
        super(TestMeteringOperations, self).setUp()
        cfg.CONF.register_opts(metering_agent.MeteringAgent.Opts)
        config.register_root_helper(cfg.CONF)

        self.noop_driver = "neutron.services.metering.drivers.noop." "noop_driver.NoopMeteringDriver"
        cfg.CONF.set_override("driver", self.noop_driver)
        cfg.CONF.set_override("measure_interval", 0)
        cfg.CONF.set_override("report_interval", 0)

        notifier_api._drivers = None
        cfg.CONF.set_override("notification_driver", [test_notifier.__name__])

        metering_rpc = "neutron.services.metering.agents.metering_agent." "MeteringPluginRpc._get_sync_data_metering"
        self.metering_rpc_patch = mock.patch(metering_rpc, return_value=[])
        self.metering_rpc_patch.start()

        self.driver_patch = mock.patch(self.noop_driver, autospec=True)
        self.driver_patch.start()

        loopingcall_patch = mock.patch("neutron.openstack.common.loopingcall.FixedIntervalLoopingCall")
        loopingcall_patch.start()

        self.agent = metering_agent.MeteringAgent("my agent", cfg.CONF)
        self.driver = self.agent.metering_driver

        self.addCleanup(mock.patch.stopall)
Example #5
0
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 #6
0
    def setUp(self):
        super(TestMeteringOperations, self).setUp()
        cfg.CONF.register_opts(metering_agent.MeteringAgent.Opts)
        config.register_root_helper(cfg.CONF)

        self.noop_driver = ('neutron.services.metering.drivers.noop.'
                            'noop_driver.NoopMeteringDriver')
        cfg.CONF.set_override('driver', self.noop_driver)
        cfg.CONF.set_override('measure_interval', 0)
        cfg.CONF.set_override('report_interval', 0)

        self.setup_notification_driver()

        metering_rpc = ('neutron.services.metering.agents.metering_agent.'
                        'MeteringPluginRpc._get_sync_data_metering')
        self.metering_rpc_patch = mock.patch(metering_rpc, return_value=[])
        self.metering_rpc_patch.start()

        self.driver_patch = mock.patch(self.noop_driver, autospec=True)
        self.driver_patch.start()

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

        self.agent = metering_agent.MeteringAgent('my agent', cfg.CONF)
        self.driver = self.agent.metering_driver
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)
def main():
    cfg.CONF.register_opts(ip_lib.OPTS)
    cfg.CONF.register_opts(dhcp_config.DHCP_OPTS)
    config.register_root_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    common_config.setup_logging()
    q_utils.log_opt_values(LOG)

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

    is_xen_compute_host = 'rootwrap-xen-dom0' in cfg.CONF.AGENT.root_helper
    if is_xen_compute_host:
        # Force ip_lib to always use the root helper to ensure that ip
        # commands target xen dom0 rather than domU.
        cfg.CONF.set_default('ip_lib_force_root', True)
    try:
        agent = GBPOvsAgent(root_helper=cfg.CONF.AGENT.root_helper,
                            **agent_config)
    except RuntimeError as e:
        LOG.error(_("%s Agent terminated!"), e)
        sys.exit(1)
    signal.signal(signal.SIGTERM, agent._handle_sigterm)

    # Start everything.
    LOG.info(_("Agent initialized successfully, now running... "))
    agent.daemon_loop()
def setup_conf():
    """Setup the cfg for the clean up utility.

    Use separate setup_conf for the utility because there are many options
    from the main config that do not apply during clean-up.
    """

    cli_opts = [
        cfg.BoolOpt('force',
                    default=False,
                    help=_('Delete the namespace by removing all devices.')),
    ]

    opts = [
        cfg.StrOpt('dhcp_driver',
                   default='neutron.agent.linux.dhcp.Dnsmasq',
                   help=_("The driver used to manage the DHCP server.")),
    ]

    conf = cfg.CONF
    conf.register_cli_opts(cli_opts)
    conf.register_opts(opts)
    agent_config.register_root_helper(conf)
    conf.register_opts(dhcp.OPTS)
    return conf
def main():
    cfg.CONF.register_opts(ip_lib.OPTS)
    config.register_root_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    common_config.setup_logging()
    q_utils.log_opt_values(LOG)
    bridge_classes = {
            'br_int': df_ovs_bridge.DFOVSAgentBridge,
            'br_phys': br_phys.OVSPhysicalBridge,
            'br_tun': br_tun.OVSTunnelBridge
                }
    try:
        agent_config = ona.create_agent_config_map(cfg.CONF)
    except ValueError as e:
        LOG.error(_LE('%s Agent terminated!'), e)
        sys.exit(1)

    is_xen_compute_host = 'rootwrap-xen-dom0' in cfg.CONF.AGENT.root_helper
    if is_xen_compute_host:
        # Force ip_lib to always use the root helper to ensure that ip
        # commands target xen dom0 rather than domU.
        cfg.CONF.set_default('ip_lib_force_root', True)

    agent = L2OVSControllerAgent(bridge_classes, **agent_config)

    signal.signal(signal.SIGTERM, agent._handle_sigterm)

    # Start everything.
    LOG.info(_LI("Agent initialized successfully, now running... "))
    agent.daemon_loop()
Example #11
0
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)
def register_config():
    cfg.CONF.register_opts(restproxy_opts, "RESTPROXY")
    cfg.CONF.register_opts(router_opts, "ROUTER")
    cfg.CONF.register_opts(nova_opts, "NOVA")
    cfg.CONF.register_opts(agent_opts, "RESTPROXYAGENT")
    # include for report_interval
    cfg.CONF.register_opts(agconfig.AGENT_STATE_OPTS, "AGENT")
    agconfig.register_root_helper(cfg.CONF)
Example #13
0
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 #14
0
    def setUp(self):
        super(BaseSudoTestCase, self).setUp()
        self.sudo_enabled = base.bool_from_env('OS_SUDO_TESTING')
        self.fail_on_missing_deps = (
            base.bool_from_env('OS_FAIL_ON_MISSING_DEPS'))

        self.root_helper = os.environ.get('OS_ROOTWRAP_CMD', SUDO_CMD)
        config.register_root_helper(cfg.CONF)
        cfg.CONF.set_override('root_helper', self.root_helper, group='AGENT')
    def setUp(self):
        super(TestFwaasL3AgentRpcCallback, self).setUp()
        self.addCleanup(mock.patch.stopall)

        self.conf = cfg.ConfigOpts()
        self.conf.register_opts(base_config.core_opts)
        agent_config.register_root_helper(self.conf)
        self.conf.root_helper = 'sudo'
        self.api = FWaasAgent(self.conf)
Example #16
0
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 #17
0
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)
    config.register_root_helper(conf)
    conf.register_opts(interface.OPTS)
    conf.register_opts(external_process.OPTS)
 def setUp(self):
     super(TestVyattaVPNService, self).setUp()
     self.conf = cfg.CONF
     agent_config.register_root_helper(self.conf)
     self.ri_kwargs = {'root_helper': self.conf.AGENT.root_helper,
                       'agent_conf': self.conf,
                       'interface_driver': mock.sentinel.interface_driver}
     self.agent = mock.Mock()
     self.vyatta_service = vyatta_vpn_service.VyattaVPNService(
         self.agent)
     self.l3_agent = self.vyatta_service.l3_agent
Example #19
0
    def setUp(self):
        super(TestFwaasL3AgentRpcCallback, self).setUp()
        self.addCleanup(mock.patch.stopall)

        self.conf = cfg.ConfigOpts()
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(l3_agent.L3NATAgent.OPTS)
        agent_config.register_root_helper(self.conf)
        self.conf.root_helper = 'sudo'
        self.api = FWaasAgent(self.conf)
        self.api.fwaas_driver = test_firewall_agent_api.NoopFwaasDriver()
Example #20
0
    def setUp(self):
        super(BaseSudoTestCase, self).setUp()
        if not base.bool_from_env('OS_SUDO_TESTING'):
            self.skipTest('Testing with sudo is not enabled')

        config.register_root_helper(cfg.CONF)
        self.config(group='AGENT',
                    root_helper=os.environ.get('OS_ROOTWRAP_CMD', SUDO_CMD))
        self.config(group='AGENT',
                    root_helper_daemon=os.environ.get(
                        'OS_ROOTWRAP_DAEMON_CMD'))
Example #21
0
    def setUp(self):
        super(TestBasicRouterOperations, self).setUp()
        self.conf = cfg.ConfigOpts()
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(l3_agent.L3NATAgent.OPTS)
        agent_config.register_interface_driver_opts_helper(self.conf)
        agent_config.register_use_namespaces_opts_helper(self.conf)
        agent_config.register_root_helper(self.conf)
        self.conf.register_opts(interface.OPTS)
        self.conf.set_override('router_id', 'fake_id')
        self.conf.set_override('interface_driver',
                               'neutron.agent.linux.interface.NullDriver')
        self.conf.set_override('send_arp_for_ha', 1)
        self.conf.root_helper = 'sudo'

        self.device_exists_p = mock.patch(
            'neutron.agent.linux.ip_lib.device_exists')
        self.device_exists = self.device_exists_p.start()

        self.utils_exec_p = mock.patch(
            'neutron.agent.linux.utils.execute')
        self.utils_exec = self.utils_exec_p.start()

        self.external_process_p = mock.patch(
            'neutron.agent.linux.external_process.ProcessManager')
        self.external_process = self.external_process_p.start()

        self.send_arp_p = mock.patch(
            'neutron.agent.l3_agent.L3NATAgent._send_gratuitous_arp_packet')
        self.send_arp = self.send_arp_p.start()

        self.dvr_cls_p = mock.patch('neutron.agent.linux.interface.NullDriver')
        driver_cls = self.dvr_cls_p.start()
        self.mock_driver = mock.MagicMock()
        self.mock_driver.DEV_NAME_LEN = (
            interface.LinuxInterfaceDriver.DEV_NAME_LEN)
        driver_cls.return_value = self.mock_driver

        self.ip_cls_p = mock.patch('neutron.agent.linux.ip_lib.IPWrapper')
        ip_cls = self.ip_cls_p.start()
        self.mock_ip = mock.MagicMock()
        ip_cls.return_value = self.mock_ip

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

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

        self.addCleanup(mock.patch.stopall)
    def setUp(self):
        super(TestMeteringDriver, self).setUp()
        cfg.CONF.register_opts(metering_agent.MeteringAgent.Opts)
        config.register_root_helper(cfg.CONF)

        self.noop_driver = "neutron.services.metering.drivers.noop." "noop_driver.NoopMeteringDriver"
        cfg.CONF.set_override("driver", self.noop_driver)

        self.agent = metering_agent.MeteringAgent("my agent", cfg.CONF)
        self.driver = mock.Mock()
        self.agent.metering_driver = self.driver
 def setUp(self):
     super(TestBase, self).setUp()
     self.conf = config.setup_conf()
     self.conf.register_opts(interface.OPTS)
     config.register_root_helper(self.conf)
     self.ip_dev_p = mock.patch.object(ip_lib, 'IPDevice')
     self.ip_dev = self.ip_dev_p.start()
     self.ip_p = mock.patch.object(ip_lib, 'IPWrapper')
     self.ip = self.ip_p.start()
     self.device_exists_p = mock.patch.object(ip_lib, 'device_exists')
     self.device_exists = self.device_exists_p.start()
 def setUp(self, mock_get_port_ofport, mock_set_secure_mode,
           mock_create_ovs_bridge, mock_setup_base_flows):
     super(TestOVSFirewallDriver, self).setUp()
     config.register_root_helper(cfg.CONF)
     cfg.CONF.set_override('security_bridge_mapping',
                           "br-fake:fake_if", 'SECURITYGROUP')
     mock_get_port_ofport.return_value = 5
     self.ovs_firewall = ovs_fw.OVSFirewallDriver()
     self.ovs_firewall.sg_br = mock.Mock()
     self.mock_br = ovs_lib.DeferredOVSBridge(self.ovs_firewall.sg_br)
     self.LOG = ovs_fw.LOG
Example #25
0
 def _configure(self):
     config.setup_logging()
     config.register_root_helper(cfg.CONF)
     cfg.CONF.set_override('root_helper', self.root_helper, group='AGENT')
     config.register_interface_driver_opts_helper(cfg.CONF)
     cfg.CONF.set_override(
         'interface_driver',
         'neutron.agent.linux.interface.OVSInterfaceDriver')
     cfg.CONF.register_opts(interface.OPTS)
     self.driver = importutils.import_object(cfg.CONF.interface_driver,
                                             cfg.CONF)
Example #26
0
 def setUp(self):
     super(TestVyattaVPNService, self).setUp()
     self.conf = cfg.CONF
     agent_config.register_root_helper(self.conf)
     self.ri_kwargs = {
         'root_helper': self.conf.AGENT.root_helper,
         'agent_conf': self.conf,
         'interface_driver': mock.sentinel.interface_driver
     }
     self.agent = mock.Mock()
     self.vyatta_service = vyatta_vpn_service.VyattaVPNService(self.agent)
     self.l3_agent = self.vyatta_service.l3_agent
Example #27
0
    def setUp(self):
        super(TestMeteringDriver, self).setUp()
        cfg.CONF.register_opts(metering_agent.MeteringAgent.Opts)
        config.register_root_helper(cfg.CONF)

        self.noop_driver = ('neutron.services.metering.drivers.noop.'
                            'noop_driver.NoopMeteringDriver')
        cfg.CONF.set_override('driver', self.noop_driver)

        self.agent = metering_agent.MeteringAgent('my agent', cfg.CONF)
        self.driver = mock.Mock()
        self.agent.metering_driver = self.driver
Example #28
0
    def setUp(self):
        super(BaseSudoTestCase, self).setUp()
        if not base.bool_from_env('OS_SUDO_TESTING'):
            self.skipTest('Testing with sudo is not enabled')

        config.register_root_helper(cfg.CONF)
        self.config(group='AGENT',
                    root_helper=os.environ.get('OS_ROOTWRAP_CMD', SUDO_CMD))
        self.config(group='AGENT',
                    root_helper_daemon=os.environ.get(
                        'OS_ROOTWRAP_DAEMON_CMD'))
        config.setup_privsep()
Example #29
0
 def setUp(self, mock_ovsdb_api, mock_get_port_ofport, mock_set_secure_mode,
           mock_create_ovs_bridge, mock_setup_base_flows,
           mock_check_ovs_firewall_restart,):
     super(TestOVSFirewallDriver, self).setUp()
     config.register_root_helper(cfg.CONF)
     cfg.CONF.set_override('security_bridge_mapping',
                           "fake_sec_br:fake_if", 'SECURITYGROUP')
     mock_get_port_ofport.return_value = 5
     self.ovs_firewall = ovs_fw.OVSFirewallDriver()
     self.ovs_firewall.sg_br = mock.Mock()
     self.mock_br = ovs_lib.DeferredOVSBridge(self.ovs_firewall.sg_br)
     self.LOG = ovs_fw.LOG
 def setUp(self):
     self.conf = config.setup_conf()
     self.conf.register_opts(interface.OPTS)
     config.register_root_helper(self.conf)
     self.driver = interface.MidonetInterfaceDriver(self.conf)
     self.network_id = uuidutils.generate_uuid()
     self.port_id = uuidutils.generate_uuid()
     self.device_name = "tap0"
     self.mac_address = "aa:bb:cc:dd:ee:ff"
     self.bridge = "br-test"
     self.namespace = "ns-test"
     super(TestMidonetInterfaceDriver, self).setUp()
    def setUp(self):
        super(TestFwaasL3AgentRpcCallback, self).setUp()

        self.conf = cfg.ConfigOpts()
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(l3_agent.L3NATAgent.OPTS)
        agent_config.register_use_namespaces_opts_helper(self.conf)
        agent_config.register_root_helper(self.conf)
        self.conf.root_helper = 'sudo'
        self.conf.register_opts(firewall_agent_api.FWaaSOpts, 'fwaas')
        self.api = FWaasAgent(self.conf)
        self.api.fwaas_driver = test_firewall_agent_api.NoopFwaasDriver()
Example #32
0
    def setUp(self):
        super(TestFwaasL3AgentRpcCallback, self).setUp()

        self.conf = cfg.ConfigOpts()
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(l3_agent.L3NATAgent.OPTS)
        agent_config.register_use_namespaces_opts_helper(self.conf)
        agent_config.register_root_helper(self.conf)
        self.conf.root_helper = 'sudo'
        self.conf.register_opts(firewall_agent_api.FWaaSOpts, 'fwaas')
        self.api = FWaasAgent(self.conf)
        self.api.fwaas_driver = test_firewall_agent_api.NoopFwaasDriver()
Example #33
0
    def setUp(self):
        super(BaseSudoTestCase, self).setUp()

        if not base.bool_from_env('OS_SUDO_TESTING'):
            self.skipTest('Testing with sudo is not enabled')

        self.fail_on_missing_deps = (
            base.bool_from_env('OS_FAIL_ON_MISSING_DEPS'))

        config.register_root_helper(cfg.CONF)
        self.config(group='AGENT',
                    root_helper=os.environ.get('OS_ROOTWRAP_CMD', SUDO_CMD))
Example #34
0
    def setUp(self):
        super(TestBasicRouterOperations, self).setUp()
        self.conf = cfg.ConfigOpts()
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(l3_agent.L3NATAgent.OPTS)
        agent_config.register_interface_driver_opts_helper(self.conf)
        agent_config.register_use_namespaces_opts_helper(self.conf)
        agent_config.register_root_helper(self.conf)
        self.conf.register_opts(interface.OPTS)
        self.conf.set_override('router_id', 'fake_id')
        self.conf.set_override('interface_driver',
                               'neutron.agent.linux.interface.NullDriver')
        self.conf.set_override('send_arp_for_ha', 1)
        self.conf.root_helper = 'sudo'

        self.device_exists_p = mock.patch(
            'neutron.agent.linux.ip_lib.device_exists')
        self.device_exists = self.device_exists_p.start()

        self.utils_exec_p = mock.patch('neutron.agent.linux.utils.execute')
        self.utils_exec = self.utils_exec_p.start()

        self.external_process_p = mock.patch(
            'neutron.agent.linux.external_process.ProcessManager')
        self.external_process = self.external_process_p.start()

        self.send_arp_p = mock.patch(
            'neutron.agent.l3_agent.L3NATAgent._send_gratuitous_arp_packet')
        self.send_arp = self.send_arp_p.start()

        self.dvr_cls_p = mock.patch('neutron.agent.linux.interface.NullDriver')
        driver_cls = self.dvr_cls_p.start()
        self.mock_driver = mock.MagicMock()
        self.mock_driver.DEV_NAME_LEN = (
            interface.LinuxInterfaceDriver.DEV_NAME_LEN)
        driver_cls.return_value = self.mock_driver

        self.ip_cls_p = mock.patch('neutron.agent.linux.ip_lib.IPWrapper')
        ip_cls = self.ip_cls_p.start()
        self.mock_ip = mock.MagicMock()
        ip_cls.return_value = self.mock_ip

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

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

        self.addCleanup(mock.patch.stopall)
Example #35
0
    def setUp(self):
        super(BaseSudoTestCase, self).setUp()

        if not base.bool_from_env('OS_SUDO_TESTING'):
            self.skipTest('Testing with sudo is not enabled')

        self.fail_on_missing_deps = (
            base.bool_from_env('OS_FAIL_ON_MISSING_DEPS'))

        config.register_root_helper(cfg.CONF)
        self.config(group='AGENT',
                    root_helper=os.environ.get('OS_ROOTWRAP_CMD', SUDO_CMD))
 def setUp(self):
     self.conf = config.setup_conf()
     self.conf.register_opts(interface.OPTS)
     config.register_root_helper(self.conf)
     self.driver = interface.MidonetInterfaceDriver(self.conf)
     self.network_id = uuidutils.generate_uuid()
     self.port_id = uuidutils.generate_uuid()
     self.device_name = "tap0"
     self.mac_address = "aa:bb:cc:dd:ee:ff"
     self.bridge = "br-test"
     self.namespace = "ns-test"
     super(TestMidonetInterfaceDriver, self).setUp()
Example #37
0
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 #38
0
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()
    def setUp(self):
        super(TestRouterInfo, self).setUp()

        conf = agent_config.setup_conf()
        agent_config.register_root_helper(conf)
        conf.root_helper = 'sudo'

        self.ip_cls_p = mock.patch('neutron.agent.linux.ip_lib.IPWrapper')
        ip_cls = self.ip_cls_p.start()
        self.mock_ip = mock.MagicMock()
        ip_cls.return_value = self.mock_ip
        self.ri_kwargs = {'root_helper': conf.root_helper,
                          'agent_conf': conf,
                          'interface_driver': mock.sentinel.interface_driver}
Example #40
0
 def __init__(self, host, conf=None):
     super(TunnelAgent, self).__init__(host=host)
     if conf:
         self.conf = conf
     else:
         self.conf = cfg.CONF
     config.register_root_helper(self.conf)
     self.context = context.get_admin_context_without_session()
     self.root_helper = config.get_root_helper(self.conf)
     self.setup_device_drivers(host)
     self.sync_tunnels(self.context)
     self.rpc_loop = loopingcall.FixedIntervalLoopingCall(
         self._rpc_loop_nosync)
     self.rpc_loop.start(interval=cfg.CONF.tunnel_agent.rpc_loop_interval)
Example #41
0
 def setUp(self):
     super(TestBase, self).setUp()
     self.conf = config.setup_conf()
     self.conf.register_opts(interface.OPTS)
     config.register_root_helper(self.conf)
     self.ip_dev_p = mock.patch.object(ip_lib, 'IPDevice')
     self.ip_dev = self.ip_dev_p.start()
     self.addCleanup(self.ip_dev_p.stop)
     self.ip_p = mock.patch.object(ip_lib, 'IPWrapper')
     self.ip = self.ip_p.start()
     self.addCleanup(self.ip_p.stop)
     self.device_exists_p = mock.patch.object(ip_lib, 'device_exists')
     self.device_exists = self.device_exists_p.start()
     self.addCleanup(self.device_exists_p.stop)
Example #42
0
def main():
    conf = cfg.CONF
    conf.register_opts(MeteringAgent.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-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 #43
0
 def initialize_app(self, argv):
     super(NeutronDebugShell, self).initialize_app(argv)
     if not self.options.config_file:
         raise exc.CommandError(
             _("You must provide a config file for bridge -"
               " either --config-file or env[NEUTRON_TEST_CONFIG_FILE]"))
     client = self.client_manager.neutron
     cfg.CONF.register_opts(interface.OPTS)
     cfg.CONF.register_opts(NeutronDebugAgent.OPTS)
     config.register_root_helper(cfg.CONF)
     cfg.CONF(['--config-file', self.options.config_file])
     config.setup_logging(cfg.CONF)
     legacy.modernize_quantum_config(cfg.CONF)
     driver = importutils.import_object(cfg.CONF.interface_driver, cfg.CONF)
     self.debug_agent = NeutronDebugAgent(cfg.CONF, client, driver)
Example #44
0
 def setUp(self):
     self.conf = config.setup_conf()
     self.conf.register_opts(interface.OPTS)
     config.register_root_helper(self.conf)
     self.device_exists_p = mock.patch.object(ip_lib, 'device_exists')
     self.device_exists = self.device_exists_p.start()
     self.addCleanup(mock.patch.stopall)
     self.driver = interface.MidonetInterfaceDriver(self.conf)
     self.network_id = uuidutils.generate_uuid()
     self.port_id = uuidutils.generate_uuid()
     self.device_name = "tap0"
     self.mac_address = "aa:bb:cc:dd:ee:ff"
     self.bridge = "br-test"
     self.namespace = "ns-test"
     super(TestMidonetInterfaceDriver, self).setUp()
Example #45
0
def main():
    cfg.CONF.register_opts(OPTS)
    cfg.CONF.register_opts(manager.OPTS)
    config.register_root_helper(cfg.CONF)

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

    mgr = manager.LbaasProxyManager(cfg.CONF)
    svc = LbaasProxyService(
        host=cfg.CONF.host,
        topic='%s-%s' %
        (topics.LOADBALANCER_INTEGRATION, cfg.CONF.cluster_name),
        manager=mgr)
    service.launch(svc).wait()
    def setUp(self):
        super(TestBasicRouterOperations, self).setUp()
        self.conf = agent_config.setup_conf()
        self.conf.register_opts(base_config.core_opts)
        self.conf.register_opts(varmour_router.vArmourL3NATAgent.OPTS)
        self.conf.register_opts(l3_ha_agent.OPTS)
        agent_config.register_interface_driver_opts_helper(self.conf)
        agent_config.register_use_namespaces_opts_helper(self.conf)
        agent_config.register_root_helper(self.conf)
        self.conf.register_opts(external_process.OPTS)
        self.conf.register_opts(interface.OPTS)
        self.conf.set_override('interface_driver',
                               'neutron.agent.linux.interface.NullDriver')
        self.conf.root_helper = 'sudo'
        self.conf.state_path = ''

        self.device_exists_p = mock.patch(
            'neutron.agent.linux.ip_lib.device_exists')
        self.device_exists = self.device_exists_p.start()

        self.utils_exec_p = mock.patch(
            'neutron.agent.linux.utils.execute')
        self.utils_exec = self.utils_exec_p.start()

        self.external_process_p = mock.patch(
            'neutron.agent.linux.external_process.ProcessManager')
        self.external_process = self.external_process_p.start()

        self.makedirs_p = mock.patch('os.makedirs')
        self.makedirs = self.makedirs_p.start()

        self.dvr_cls_p = mock.patch('neutron.agent.linux.interface.NullDriver')
        driver_cls = self.dvr_cls_p.start()
        self.mock_driver = mock.MagicMock()
        self.mock_driver.DEV_NAME_LEN = (
            interface.LinuxInterfaceDriver.DEV_NAME_LEN)
        driver_cls.return_value = self.mock_driver

        self.ip_cls_p = mock.patch('neutron.agent.linux.ip_lib.IPWrapper')
        ip_cls = self.ip_cls_p.start()
        self.mock_ip = mock.MagicMock()
        ip_cls.return_value = self.mock_ip

        mock.patch('neutron.agent.l3_agent.L3PluginApi').start()

        self.looping_call_p = mock.patch(
            'neutron.openstack.common.loopingcall.FixedIntervalLoopingCall')
        self.looping_call_p.start()
Example #47
0
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
0
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()
Example #49
0
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 #50
0
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)
    config.register_root_helper(cfg.CONF)

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

    mgr = manager.LbaasAgentManager(cfg.CONF)
    svc = LbaasAgentService(host=cfg.CONF.host,
                            topic=constants.LOADBALANCER_AGENTV2,
                            manager=mgr)
    service.launch(cfg.CONF, svc).wait()
Example #51
0
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)
    config.register_root_helper(cfg.CONF)

    cfg.CONF(project='neutron')
    config.setup_logging(cfg.CONF)

    mgr = manager.LbaasAgentManager(cfg.CONF)
    svc = LbaasAgentService(host=cfg.CONF.host,
                            topic=topics.LOADBALANCER_AGENT,
                            manager=mgr)
    service.launch(svc).wait()
Example #52
0
def main():
    # Load the configuration parameters.
    cfg.CONF.register_opts(OPTS)
    config.register_root_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    config.setup_logging()

    # Set up RPC
    mgr = taas_ovs_agent.TaasOvsAgentRpcCallback(cfg.CONF)
    endpoints = [mgr]
    conn = n_rpc.create_connection()
    conn.create_consumer(topics.TAAS_AGENT, endpoints, fanout=False)
    conn.consume_in_threads()

    svc = TaaSOVSAgentService(host=cfg.CONF.host,
                              topic=topics.TAAS_PLUGIN,
                              manager=mgr)
    service.launch(cfg.CONF, svc).wait()
Example #53
0
def main():
    eventlet.monkey_patch()
    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_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)

    cfg.CONF(project='neutron')
    config.setup_logging(cfg.CONF)
    legacy.modernize_quantum_config(cfg.CONF)

    mgr = manager.LbaasAgentManager(cfg.CONF)
    svc = LbaasAgentService(host=cfg.CONF.host,
                            topic=plugin_driver.TOPIC_LOADBALANCER_AGENT,
                            manager=mgr)
    service.launch(svc).wait()
Example #54
0
def main():
    conf = cfg.CONF
    conf.register_opts(vArmourL3NATAgent.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)
    conf(project='neutron')
    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='neutron.services.firewall.agents.varmour.varmour_router.'
        'vArmourL3NATAgentWithStateReport')
    service.launch(server).wait()
Example #55
0
    def setUp(self):
        super(BaseSudoTestCase, self).setUp()
        if not base.bool_from_env('OS_SUDO_TESTING'):
            self.skipTest('Testing with sudo is not enabled')

        # Have each test log into its own log file
        cfg.CONF.set_override('debug', True)
        common_utils.ensure_dir(DEFAULT_LOG_DIR)
        log_file = base.sanitize_log_path(
            os.path.join(DEFAULT_LOG_DIR, "%s.log" % self.id()))
        cfg.CONF.set_override('log_file', log_file)
        config.setup_logging()

        config.register_root_helper(cfg.CONF)
        self.config(group='AGENT',
                    root_helper=os.environ.get('OS_ROOTWRAP_CMD', SUDO_CMD))
        self.config(
            group='AGENT',
            root_helper_daemon=os.environ.get('OS_ROOTWRAP_DAEMON_CMD'))
Example #56
0
def main():
    cfg.CONF.register_opts(OPTS)
    cfg.CONF.register_opts(manager.OPTS)
    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)

    if preJuno:
        cfg.CONF(project='neutron')
        config.setup_logging(cfg.CONF)
        legacy.modernize_quantum_config(cfg.CONF)
    else:
        common_config.init(sys.argv[1:])
        config.setup_logging()

    mgr = manager.LbaasAgentManager(cfg.CONF)
    svc = LbaasAgentService(host=mgr.agent_host,
                            topic=lbaasconstants.TOPIC_LOADBALANCER_AGENT,
                            manager=mgr)
    service.launch(svc).wait()
Example #57
0
def main():
    """F5 LBaaS agent for OpenStack."""
    cfg.CONF.register_opts(OPTS)
    cfg.CONF.register_opts(manager.OPTS)
    cfg.CONF.register_opts(interface.OPTS)

    config.register_agent_state_opts_helper(cfg.CONF)
    config.register_root_helper(cfg.CONF)

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

    mgr = manager.LbaasAgentManager(cfg.CONF)

    svc = F5AgentService(host=mgr.agent_host,
                         topic=f5constants.TOPIC_LOADBALANCER_AGENT_V2,
                         manager=mgr)
    service.launch(cfg.CONF, svc).wait()
Example #58
0
def setup_conf():
    """Setup the cfg for the clean up utility.

    Use separate setup_conf for the utility because there are many options
    from the main config that do not apply during clean-up.
    """

    cli_opts = [
        cfg.BoolOpt('force',
                    default=False,
                    help=_('Delete the namespace by removing all devices.')),
    ]

    conf = cfg.CONF
    conf.register_cli_opts(cli_opts)
    agent_config.register_root_helper(conf)
    conf.register_opts(dhcp.OPTS)
    conf.register_opts(dhcp_agent.DhcpAgent.OPTS)
    conf.register_opts(interface.OPTS)
    return conf
def main():
    cfg.CONF.register_opts(ip_lib.OPTS)
    cfg.CONF.register_opts(dhcp_config.DHCP_OPTS)
    config.register_root_helper(cfg.CONF)
    common_config.init(sys.argv[1:])
    common_config.setup_logging()
    q_utils.log_opt_values(LOG)

    agent_mode = cfg.CONF.OPFLEX.agent_mode
    if agent_mode == 'dvs':
        agent = main_dvs()
    elif agent_mode == 'dvs_no_binding':
        agent = main_dvs(no_binding=True)
    else:
        agent = main_opflex()
    if not agent:
        sys.exit(1)

    LOG.info(_("Agent initialized successfully, now running... "))
    agent.daemon_loop()