def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
integ_br = cfg.CONF.OVS.integration_bridge
polling_interval = cfg.CONF.AGENT.polling_interval
root_helper = cfg.CONF.AGENT.root_helper
tunnel_ip = _get_tunnel_ip()
LOG.debug(_('tunnel_ip %s'), tunnel_ip)
ovsdb_port = cfg.CONF.OVS.ovsdb_port
LOG.debug(_('ovsdb_port %s'), ovsdb_port)
ovsdb_ip = _get_ovsdb_ip()
LOG.debug(_('ovsdb_ip %s'), ovsdb_ip)
try:
agent = OVSNeutronOFPRyuAgent(integ_br, tunnel_ip, ovsdb_ip,
ovsdb_port, polling_interval,
root_helper)
except httplib.HTTPException as e:
LOG.error(_("Initialization failed: %s"), e)
sys.exit(1)
LOG.info(_("Ryu initialization on the node is done. "
"Agent initialized successfully, now running..."))
agent.daemon_loop()
sys.exit(0)
def setUp(self):
super(TestBase, self).setUp()
tox_path = os.environ.get("VIRTUAL_ENV")
cfg.CONF.set_override('state_path', tox_path)
neutron_conf_path = "%s/etc/neutron/neutron.conf" % tox_path
try:
open(neutron_conf_path, "r")
except IOError:
open(neutron_conf_path, "w")
args = ['--config-file', neutron_conf_path]
config.init(args=args)
self.context = context.Context('fake', 'fake', is_admin=False)
self.admin_context = context.Context('fake', 'fake', is_admin=True)
class FakeContext(object):
def __new__(cls, *args, **kwargs):
return super(FakeContext, cls).__new__(cls)
def __enter__(*args, **kwargs):
pass
def __exit__(*args, **kwargs):
pass
self.context.session.begin = FakeContext
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
q_utils.log_opt_values(LOG)
bridge_classes = {
'br_int': br_int.OVSIntegrationBridge,
'br_phys': br_phys.OVSPhysicalBridge,
'br_tun': br_tun.OVSTunnelBridge,
}
ovs_neutron_agent.prepare_xen_compute()
ovs_neutron_agent.validate_tunnel_config(
cfg.CONF.AGENT.tunnel_types,
cfg.CONF.OVS.local_ip
)
try:
agent = OVSSfcAgent(bridge_classes, cfg.CONF)
except (RuntimeError, ValueError) as e:
LOG.exception(e)
LOG.error(_LE('Agent terminated!'))
sys.exit(1)
LOG.info(_LI("Agent initialized successfully, now running... "))
agent.daemon_loop()
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()
def main():
register_options(cfg.CONF)
calico_config.register_options(cfg.CONF)
common_config.init(sys.argv[1:])
setup_logging()
agent = CalicoDhcpAgent()
agent.run()
def main():
# this is from neutron.plugins.ml2.drivers.openvswitch.agent.main
common_config.init(sys.argv[1:])
n_utils.log_opt_values(LOG)
common_config.setup_logging()
# this is from neutron.plugins.ml2.drivers.openvswitch.agent.openflow.
# ovs_ofctl.main
bridge_classes = {
'br_int': br_int.OVSIntegrationBridge,
'br_phys': br_phys.OVSPhysicalBridge,
'br_tun': br_tun.OVSTunnelBridge,
}
# this is from neutron.plugins.ml2.drivers.openvswitch.agent.
# ovs_neutron_agent
try:
agent_config = create_agent_config_map(cfg.CONF)
except ValueError:
LOG.exception(_LE("Agent failed to create agent config map"))
raise SystemExit(1)
prepare_xen_compute()
validate_local_ip(agent_config['local_ip'])
try:
agent = OVSBagpipeNeutronAgent(bridge_classes, **agent_config)
except (RuntimeError, ValueError) as e:
LOG.error(_LE("%s Agent terminated!"), e)
sys.exit(1)
agent.daemon_loop()
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
register_options()
service.launch(config.CONF,
notification.NotificationService(),
config.CONF.infoblox.ipam_agent_workers).wait()
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
try:
config_parser = SriovNicAgentConfigParser()
config_parser.parse()
device_mappings = config_parser.device_mappings
exclude_devices = config_parser.exclude_devices
rp_bandwidths = config_parser.rp_bandwidths
rp_inventory_defaults = config_parser.rp_inventory_defaults
except ValueError:
LOG.exception("Failed on Agent configuration parse. "
"Agent terminated!")
raise SystemExit(1)
LOG.info("Physical Devices mappings: %s", device_mappings)
LOG.info("Exclude Devices: %s", exclude_devices)
polling_interval = cfg.CONF.AGENT.polling_interval
try:
agent = SriovNicSwitchAgent(device_mappings,
exclude_devices,
polling_interval,
rp_bandwidths,
rp_inventory_defaults)
except exc.SriovNicError:
LOG.exception("Agent Initialization Failed")
raise SystemExit(1)
# Start everything.
setup_profiler.setup("neutron-sriov-nic-agent", cfg.CONF.host)
LOG.info("Agent initialized successfully, now running... ")
agent.daemon_loop()
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
try:
config_parser = SriovNicAgentConfigParser()
config_parser.parse()
device_mappings = config_parser.device_mappings
exclude_devices = config_parser.exclude_devices
except ValueError:
LOG.exception(_LE("Failed on Agent configuration parse. "
"Agent terminated!"))
raise SystemExit(1)
LOG.info(_LI("Physical Devices mappings: %s"), device_mappings)
LOG.info(_LI("Exclude Devices: %s"), exclude_devices)
polling_interval = cfg.CONF.AGENT.polling_interval
try:
agent = SriovNicSwitchAgent(device_mappings,
exclude_devices,
polling_interval)
except exc.SriovNicError:
LOG.exception(_LE("Agent Initialization Failed"))
raise SystemExit(1)
# Start everything.
LOG.info(_LI("Agent initialized successfully, now running... "))
agent.daemon_loop()
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 main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
try:
interface_mappings = utils.parse_mappings(
cfg.CONF.ESWITCH.physical_interface_mappings)
except ValueError as e:
LOG.error(_LE("Parsing physical_interface_mappings failed: %s. "
"Agent terminated!"), e)
sys.exit(1)
LOG.info(_LI("Interface mappings: %s"), interface_mappings)
try:
agent = mlnx_eswitch_neutron_agent.MlnxEswitchNeutronAgent(
interface_mappings)
except Exception as e:
LOG.error(_LE("Failed on Agent initialisation : %s. "
"Agent terminated!"), e)
sys.exit(1)
# Start everything.
LOG.info(_LI("Agent initialised successfully, now running... "))
agent.run()
sys.exit(0)
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
agent_config.setup_privsep()
try:
interface_mappings = helpers.parse_mappings(
cfg.CONF.LINUX_BRIDGE.physical_interface_mappings)
except ValueError as e:
LOG.error("Parsing physical_interface_mappings failed: %s. "
"Agent terminated!", e)
sys.exit(1)
LOG.info("Interface mappings: %s", interface_mappings)
try:
bridge_mappings = helpers.parse_mappings(
cfg.CONF.LINUX_BRIDGE.bridge_mappings)
except ValueError as e:
LOG.error("Parsing bridge_mappings failed: %s. "
"Agent terminated!", e)
sys.exit(1)
LOG.info("Bridge mappings: %s", bridge_mappings)
manager = LinuxBridgeManager(bridge_mappings, interface_mappings)
linuxbridge_capabilities.register()
polling_interval = cfg.CONF.AGENT.polling_interval
quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout
agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout,
constants.AGENT_TYPE_LINUXBRIDGE,
LB_AGENT_BINARY)
setup_profiler.setup("neutron-linuxbridge-agent", cfg.CONF.host)
LOG.info("Agent initialized successfully, now running... ")
launcher = service.launch(cfg.CONF, agent, restart_method='mutate')
launcher.wait()
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(common_params.df_opts, 'df')
common_config.init(sys.argv[1:])
config.setup_logging()
service = PublisherService()
service.initialize()
service.run()
def main():
cfg.CONF.register_cli_opts(cli_opts)
config.init(sys.argv[1:])
# Enable logging but prevent output to stderr.
cfg.CONF.use_stderr = False
config.setup_logging()
if not cfg.CONF.config_file:
sys.exit(_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
router.APIRouter.factory({})
manager.init()
gbp_plugin = directory.get_plugin('GROUP_POLICY')
if not gbp_plugin:
sys.exit("GBP service plugin not configured.")
result = gbp_plugin.validate_state(cfg.CONF.repair)
if result in [api.VALIDATION_FAILED_REPAIRABLE,
api.VALIDATION_FAILED_UNREPAIRABLE,
api.VALIDATION_FAILED_WITH_EXCEPTION]:
sys.exit(result)
return 0
def main():
# the configuration will be read into the cfg.CONF global data structure
config.init(sys.argv[1:])
if not cfg.CONF.config_file:
sys.exit(_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
try:
pool = eventlet.GreenPool()
neutron_api = service.serve_wsgi(service.NeutronApiService)
api_thread = pool.spawn(neutron_api.wait)
try:
neutron_rpc = service.serve_rpc()
except NotImplementedError:
LOG.info(_LI("RPC was already started in parent process by "
"plugin."))
else:
rpc_thread = pool.spawn(neutron_rpc.wait)
# api and rpc should die together. When one dies, kill the other.
rpc_thread.link(lambda gt: api_thread.kill())
api_thread.link(lambda gt: rpc_thread.kill())
pool.waitall()
except KeyboardInterrupt:
pass
except RuntimeError as e:
sys.exit(_("ERROR: %s") % e)
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
try:
interface_mappings = n_utils.parse_mappings(
cfg.CONF.LINUX_BRIDGE.physical_interface_mappings)
except ValueError as e:
LOG.error(_LE("Parsing physical_interface_mappings failed: %s. "
"Agent terminated!"), e)
sys.exit(1)
LOG.info(_LI("Interface mappings: %s"), interface_mappings)
try:
bridge_mappings = n_utils.parse_mappings(
cfg.CONF.LINUX_BRIDGE.bridge_mappings)
except ValueError as e:
LOG.error(_LE("Parsing bridge_mappings failed: %s. "
"Agent terminated!"), e)
sys.exit(1)
LOG.info(_LI("Bridge mappings: %s"), bridge_mappings)
manager = LinuxBridgeManager(bridge_mappings, interface_mappings)
polling_interval = cfg.CONF.AGENT.polling_interval
quitting_rpc_timeout = cfg.CONF.AGENT.quitting_rpc_timeout
agent = ca.CommonAgentLoop(manager, polling_interval, quitting_rpc_timeout,
constants.AGENT_TYPE_LINUXBRIDGE,
LB_AGENT_BINARY)
LOG.info(_LI("Agent initialized successfully, now running... "))
launcher = service.launch(cfg.CONF, agent)
launcher.wait()
def set_up_mocks(self):
# Mock the configuration file
args = ['--config-file', base.etcdir('neutron.conf')]
neutron_config.init(args=args)
# Configure the ML2 mechanism drivers and network types
ml2_opts = {
'mechanism_drivers': ['cisco_ucsm'],
'tenant_network_types': ['vlan'],
}
for opt, val in ml2_opts.items():
ml2_config.cfg.CONF.set_override(opt, val, 'ml2')
# Configure the Cisco UCS Manager mechanism driver
ucsm_test_config = {
'ml2_cisco_ucsm_ip: 1.1.1.1': {
'ucsm_username': UCSM_USERNAME_1,
'ucsm_password': UCSM_PASSWORD_1,
},
'ml2_cisco_ucsm_ip: 2.2.2.2': {
'ucsm_username': UCSM_USERNAME_2,
'ucsm_password': UCSM_PASSWORD_2,
},
}
self.mocked_parser = mock.patch.object(cfg,
'MultiConfigParser').start()
self.mocked_parser.return_value.read.return_value = [ucsm_test_config]
self.mocked_parser.return_value.parsed = [ucsm_test_config]
def set_up_mocks(self):
# Mock the configuration file
args = ["--config-file", base.etcdir("neutron.conf")]
neutron_config.init(args=args)
# Configure the ML2 mechanism drivers and network types
ml2_opts = {"mechanism_drivers": ["cisco_ucsm"], "tenant_network_types": ["vlan"]}
for opt, val in ml2_opts.items():
ml2_config.cfg.CONF.set_override(opt, val, "ml2")
# Configure the Cisco UCS Manager mechanism driver
ucsm_test_config = {
"ml2_cisco_ucsm_ip: 1.1.1.1": {
"ucsm_username": [UCSM_USERNAME_1],
"ucsm_password": [UCSM_PASSWORD_1],
"ucsm_virtio_eth_ports": UCSM_VIRTIO_ETH_PORTS_1,
"vnic_template_list": ["test-physnet:org-root:Test-VNIC"],
"sriov_qos_policy": ["Test"],
},
"ml2_cisco_ucsm_ip: 2.2.2.2": {
"ucsm_username": [UCSM_USERNAME_2],
"ucsm_password": [UCSM_PASSWORD_2],
"ucsm_virtio_eth_ports": UCSM_VIRTIO_ETH_PORTS_2,
"vnic_template_list": ["physnet2:org-root/org-Test-Sub:Test"],
},
"sriov_multivlan_trunk": {"test_network1": ["5, 7 - 9"], "test_network2": ["500 - 509, 700"]},
}
expected_ucsm_dict = {
"1.1.1.1": (UCSM_USERNAME_1, UCSM_PASSWORD_1),
"2.2.2.2": (UCSM_USERNAME_2, UCSM_PASSWORD_2),
}
expected_ucsm_port_dict = {
"1.1.1.1": [const.ETH_PREFIX + "eth0", const.ETH_PREFIX + "eth1"],
"2.2.2.2": [const.ETH_PREFIX + "eth2", const.ETH_PREFIX + "eth3"],
}
expected_vnic_template_dict = {
("1.1.1.1", "test-physnet"): ("org-root", "Test-VNIC"),
("2.2.2.2", "physnet2"): ("org-root/org-Test-Sub", "Test"),
}
expected_sriov_qos_policy = {"1.1.1.1": "Test"}
expected_multivlan_trunk_dict = {
"test_network1": [5, 7, 8, 9],
"test_network2": [500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 700],
}
self.mocked_parser = mock.patch.object(cfg, "MultiConfigParser").start()
self.mocked_parser.return_value.read.return_value = [ucsm_test_config]
self.mocked_parser.return_value.parsed = [ucsm_test_config]
ucsm_config.UcsmConfig()
self.assertEqual(expected_ucsm_dict, ucsm_config.UcsmConfig.ucsm_dict)
self.assertEqual(expected_ucsm_port_dict, ucsm_config.UcsmConfig.ucsm_port_dict)
self.assertEqual(expected_vnic_template_dict, ucsm_config.UcsmConfig.vnic_template_dict)
self.assertEqual(expected_sriov_qos_policy, ucsm_config.UcsmConfig.sriov_qos_policy)
self.assertEqual(expected_multivlan_trunk_dict, ucsm_config.UcsmConfig.multivlan_trunk_dict)
def main():
logging_config.init(sys.argv[1:])
logging_config.setup_logging()
polling_interval = cfg.CONF.AGENT.polling_interval
agent = NECNWANeutronAgent(polling_interval)
agent.daemon_loop()
def main():
# Read in the command line args
n_config.init(sys.argv[1:])
n_config.setup_logging()
# Build then run the agent
agent = SharedEthernetNeutronAgent()
LOG.info(_LI("Shared Ethernet Agent initialized and running"))
agent.rpc_loop()
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging(cfg.CONF)
plugin = HyperVNeutronAgent()
# Start everything.
LOG.info(_("Agent initialized successfully, now running... "))
plugin.daemon_loop()
def main(manager='neutron.services.tunnel.agent.TunnelAgentWithStateReport'):
common_config.init(sys.argv[1:])
config.setup_logging(cfg.CONF)
server = neutron_service.Service.create(
binary='neutron-tunnel-agent',
topic=n_topics.TUNNEL_AGENT,
report_interval=cfg.CONF.tunnel_agent.report_interval,
manager=manager)
service.launch(server).wait()
def main():
config.init(sys.argv[1:])
config.setup_logging()
n_utils.log_opt_values(LOG)
if not CONF.config_file:
sys.exit(_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
run()
def main():
common_config.init(sys.argv[1:])
# the following check is a transitional workaround to make this work
# with different versions of ryu.
# TODO(yamamoto) remove this later
if ryu_cfg.CONF is not cfg.CONF:
ryu_cfg.CONF(project="ryu", args=[])
common_config.setup_logging()
AppManager.run_apps(["neutron.plugins.ofagent.agent.ofa_neutron_agent"])
def config_parse(conf=None, args=None):
"""Create the default configurations."""
if args is None:
args = []
args += ['--config-file', etcdir('neutron.conf')]
if conf is None:
config.init(args=args)
else:
conf(args)
def main():
common_config.init(sys.argv[1:])
driver_name = cfg.CONF.OVS.of_interface
mod_name = _main_modules[driver_name]
mod = importutils.import_module(mod_name)
mod.init_config()
common_config.setup_logging()
n_utils.log_opt_values(LOG)
mod.main()
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
server = neutron_service.Service.create(
binary='neutron-fastpath-agent',
topic="FP_AGENT",
report_interval=30,
manager='networking_6wind.agent.server.NeutronFastPathAgent')
service.launch(cfg.CONF, server).wait()
def _init_configuration():
# the configuration will be read into the cfg.CONF global data structure
config.init(sys.argv[1:])
config.setup_logging()
config.set_config_defaults()
if not cfg.CONF.config_file:
sys.exit(_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
def config_parse(conf=None, args=None):
"""Create the default configurations."""
# neutron.conf.test includes rpc_backend which needs to be cleaned up
if args is None:
args = ['--config-file', etcdir('neutron.conf.test')]
if conf is None:
config.init(args=args)
else:
conf(args)
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
# BGP dynamic route is not a service that needs real time response.
# So disable pubsub here and use period task to do BGP job.
cfg.CONF.set_override('enable_df_pub_sub', False, group='df')
nb_api = api_nb.NbApi.get_instance(False)
server = BGPService(nb_api)
df_service.register_service('df-bgp-service', nb_api, server)
service.launch(cfg.CONF, server).wait()
def launch(binary, manager, topic=None):
cfg.CONF(project='neutron')
common_cfg.init(sys.argv[1:])
config.setup_logging()
report_period = cfg.CONF.ml2_cisco_apic.apic_agent_report_interval
poll_period = cfg.CONF.ml2_cisco_apic.apic_agent_poll_interval
server = service.Service.create(
binary=binary, manager=manager, topic=topic,
report_interval=report_period, periodic_interval=poll_period)
svc.launch(cfg.CONF, server).wait()
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
cumulus_config.register_options()
cumulus_agent = CumulusAgent()
try:
cumulus_agent.start()
except Exception as e:
LOG.exception(_LE("Error in Cumulus agent service."))
sys.exit(_("ERROR: %s.") % e)
def _main():
import sys
common_config.init(sys.argv[1:])
common_config.setup_logging()
agent = DvsNeutronAgent()
# Start everything.
LOG.info(_LI("Agent initialized successfully, now running... "))
agent.daemon_loop()
def main():
cfg.CONF.register_opts(WANTC_OPTS, 'WANTC')
common_config.init(sys.argv[1:])
config.setup_logging()
server = neutron_service.Service.create(
binary='tc_agent2',
topic=topics.TC_AGENT,
report_interval=10,
manager='wan_qos.agent.tc_manager.TcAgentManager')
service.launch(cfg.CONF, server).wait()
def main(manager='neutron.agent.l3.agent.L3NATAgentWithStateReport'):
register_opts(cfg.CONF)
common_config.init(sys.argv[1:])
config.setup_logging()
server = neutron_service.Service.create(
binary='neutron-l3-agent',
topic=topics.L3_AGENT,
report_interval=cfg.CONF.AGENT.report_interval,
manager=manager)
service.launch(cfg.CONF, server).wait()
def _init_configuration():
# the configuration will be read into the cfg.CONF global data structure
config.init(sys.argv[1:]) #初始化CONF，初始化rpc、notification、检验CONF.base_mac
config.setup_logging() #log相关
config.set_config_defaults() #wsgi_middleware cors相关
if not cfg.CONF.config_file:
sys.exit(
_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
def main():
common_config.init(sys.argv[1:])
driver_name = cfg.CONF.OVS.of_interface
mod_name = _main_modules[driver_name]
mod = importutils.import_module(mod_name)
mod.init_config()
common_config.setup_logging()
n_utils.log_opt_values(LOG)
profiler.setup("neutron-ovs-agent", cfg.CONF.host)
mod.main()
def main():
cfg.CONF.register_cli_opts(OPTS)
cfg.CONF.set_override('use_stderr', True)
config.setup_logging()
config.init(sys.argv[1:], default_config_files=[])
if cfg.CONF.config_file:
enable_tests_from_config()
return 0 if all_tests_passed() else 1
def main():
register_options()
common_config.init(sys.argv[1:])
config.setup_logging()
agent = aci_agent.AciNeutronAgent()
# Start everything.
LOG.info(_LI("ACI Agent initialized successfully, now running... "))
agent.daemon_loop()
def config_parse(conf=None, args=None):
"""Create the default configurations."""
# neutron.conf includes rpc_backend which needs to be cleaned up
if args is None:
args = []
args += ['--config-file', etcdir('neutron.conf')]
if conf is None:
config.init(args=args)
else:
conf(args)
def main():
register_options(cfg.CONF)
common_config.init(sys.argv[1:])
config.setup_logging()
server = neutron_service.Service.create(
binary='neutron-dhcp-agent',
topic=topics.DHCP_AGENT,
report_interval=cfg.CONF.AGENT.report_interval,
manager='neutron.agent.dhcp.agent.DhcpAgentWithStateReport')
service.launch(cfg.CONF, server).wait()
def main():
# TODO(hjensas): Imports from neutron in ironic_neutron_agent registers the
# client options. We need to unregister the options we are deprecating
# first to avoid DuplicateOptError. Remove this when dropping deprecations.
_unregiser_deprecated_opts()
common_config.init(sys.argv[1:])
common_config.setup_logging()
agent = BaremetalNeutronAgent()
launcher = service.launch(cfg.CONF, agent, restart_method='mutate')
launcher.wait()
def main():
common_config.init(sys.argv[1:])
# the following check is a transitional workaround to make this work
# with different versions of ryu.
# TODO(yamamoto) remove this later
if ryu_cfg.CONF is not cfg.CONF:
ryu_cfg.CONF(project='ryu', args=[])
common_config.setup_logging()
AppManager.run_apps(
['networking_ofagent.plugins.ofagent.agent.ofa_neutron_agent'])
def set_up_mocks(self):
# Mock the configuration file
args = ['--config-file', base.etcdir('neutron.conf')]
neutron_config.init(args=args)
# Configure the ML2 mechanism drivers and network types
ml2_opts = {
'mechanism_drivers': ['cisco_ucsm'],
'tenant_network_types': ['vlan'],
}
for opt, val in ml2_opts.items():
ml2_config.cfg.CONF.set_override(opt, val, 'ml2')
# Configure the Cisco UCS Manager mechanism driver
ucsm_test_config = {
'ml2_cisco_ucsm_ip: 1.1.1.1': {
'ucsm_username': [UCSM_USERNAME_1],
'ucsm_password': [UCSM_PASSWORD_1],
'ucsm_virtio_eth_ports': UCSM_VIRTIO_ETH_PORTS_1,
'vnic_template_list': ['test-physnet:org-root:Test-VNIC'],
},
'ml2_cisco_ucsm_ip: 2.2.2.2': {
'ucsm_username': [UCSM_USERNAME_2],
'ucsm_password': [UCSM_PASSWORD_2],
'ucsm_virtio_eth_ports': UCSM_VIRTIO_ETH_PORTS_2,
'vnic_template_list': ['physnet2:org-root/org-Test-Sub:Test']
},
}
expected_ucsm_dict = {
'1.1.1.1': [UCSM_PASSWORD_1, UCSM_USERNAME_1],
'2.2.2.2': [UCSM_PASSWORD_2, UCSM_USERNAME_2],
}
expected_ucsm_port_dict = {
'1.1.1.1': [const.ETH_PREFIX + 'eth0', const.ETH_PREFIX + 'eth1'],
'2.2.2.2': [const.ETH_PREFIX + 'eth2', const.ETH_PREFIX + 'eth3'],
}
expected_vnic_template_dict = {
('1.1.1.1', 'test-physnet'): ('org-root', 'Test-VNIC'),
('2.2.2.2', 'physnet2'): ('org-root/org-Test-Sub', 'Test'),
}
self.mocked_parser = mock.patch.object(cfg,
'MultiConfigParser').start()
self.mocked_parser.return_value.read.return_value = [ucsm_test_config]
self.mocked_parser.return_value.parsed = [ucsm_test_config]
ucsm_config.UcsmConfig()
self.assertEqual(expected_ucsm_dict,
ucsm_config.UcsmConfig.ucsm_dict)
self.assertEqual(expected_ucsm_port_dict,
ucsm_config.UcsmConfig.ucsm_port_dict)
self.assertEqual(expected_vnic_template_dict,
ucsm_config.UcsmConfig.vnic_template_dict)
def main():
common_config.init(sys.argv[1:])
common_config.setup_logging()
integ_br = config.AGENT.integration_bridge
polling_interval = config.AGENT.polling_interval
agent = NVSDNeutronAgent(integ_br, polling_interval)
LOG.info(_LI("NVSD Agent initialized successfully, now running... "))
# Start everything.
agent.daemon_loop()
def _init_configuration():
# the configuration will be read into the cfg.CONF global data structure
conf_files = _get_config_files()
config.register_common_config_options()
config.init(sys.argv[1:], default_config_files=conf_files)
config.setup_logging()
config.set_config_defaults()
if not cfg.CONF.config_file:
sys.exit(_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
def setUp(self):
cfg.CONF.register_cli_opts(resources.cli_opts)
super(AbstractTestAdminUtils, self).setUp()
# Init the neutron config
neutron_config.init(args=[
'--config-file', BASE_CONF_PATH, '--config-file', NSX_INI_PATH
])
self._init_mock_plugin()
self._init_resource_plugin()
def main():
meta.register_meta_conf_opts(meta.SHARED_OPTS)
meta.register_meta_conf_opts(meta.UNIX_DOMAIN_METADATA_PROXY_OPTS)
meta.register_meta_conf_opts(meta.METADATA_PROXY_HANDLER_OPTS)
cache.register_oslo_configs(cfg.CONF)
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()
def main():
meta.register_meta_conf_opts(meta.SHARED_OPTS)
meta.register_meta_conf_opts(meta.UNIX_DOMAIN_METADATA_PROXY_OPTS)
meta.register_meta_conf_opts(meta.METADATA_PROXY_HANDLER_OPTS)
meta.register_meta_conf_opts(meta.OVS_OPTS, group='ovs')
config.init(sys.argv[1:])
config.setup_logging()
utils.log_opt_values(LOG)
agt = agent.MetadataAgent(cfg.CONF)
agt.start()
def main():
"""The entry point for the Hyper-V Neutron Agent."""
neutron_config.register_agent_state_opts_helper(CONF)
common_config.init(sys.argv[1:])
neutron_config.setup_logging()
hyperv_agent = HyperVNeutronAgent()
# Start everything.
LOG.info("Agent initialized successfully, now running... ")
hyperv_agent.daemon_loop()
def main():
config.init(sys.argv[1:])
config.setup_logging()
pl_config.register_config()
integ_br = cfg.CONF.RESTPROXYAGENT.integration_bridge
polling_interval = cfg.CONF.RESTPROXYAGENT.polling_interval
bsnagent = RestProxyAgent(integ_br, polling_interval,
cfg.CONF.RESTPROXYAGENT.virtual_switch_type)
bsnagent.daemon_loop()
sys.exit(0)
def main():
register_options()
common_config.init(sys.argv[1:])
config.setup_logging()
server = neutron_service.Service.create(
binary='neutron-bgp-dragent',
topic=bgp_consts.BGP_DRAGENT,
report_interval=cfg.CONF.AGENT.report_interval,
manager='neutron_dynamic_routing.services.bgp.agent.bgp_dragent.'
'BgpDrAgentWithStateReport')
service.launch(cfg.CONF, server).wait()
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()
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()
def main(manager='neutron.agent.l3.agent.L3NATAgentWithStateReport'):
register_opts(cfg.CONF)
common_config.init(sys.argv[1:])
config.setup_logging()
config.setup_privsep()
server = neutron_service.Service.create(
binary=constants.AGENT_PROCESS_L3,
topic=topics.L3_AGENT,
report_interval=cfg.CONF.AGENT.report_interval,
manager=manager)
service.launch(cfg.CONF, server, restart_method='mutate').wait()
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()
def main():
config.init(sys.argv[1:])
if not cfg.CONF.config_file:
sys.exit(_("ERROR: Unable to find configuration file via the default"
" search paths (~/.neutron/, ~/, /etc/neutron/, /etc/) and"
" the '--config-file' option!"))
config.setup_logging()
public_network_id = "00000000-0000-0000-0000-000000000000"
ip_availability = get_ip_availability(network_id=public_network_id,
ip_version=4)
print(json.dumps(ip_availability))
def main(manager='dragonflow.neutron.agent.l3.l3_controller_agent.'
'L3ControllerAgentWithStateReport'):
l3_agent.register_opts(cfg.CONF)
common_config.init(sys.argv[1:])
config.setup_logging()
cfg.CONF.set_override('router_delete_namespaces', True)
server = neutron_service.Service.create(
binary='neutron-l3-controller-agent',
topic=topics.L3_AGENT,
report_interval=cfg.CONF.AGENT.report_interval,
manager=manager)
service.launch(cfg.CONF, server).wait()
def main():
eventlet.monkey_patch()
cfg.CONF(project='neutron')
common_config.init(sys.argv[1:])
common_config.setup_logging()
agent = zvmNeutronAgent()
# Start to query xCAT DB
LOG.info("z/VM agent initialized, now running... ")
agent.xcatdb_daemon_loop()
sys.exit(0)
