# under the License.
import os
+import sys
import eventlet
eventlet.monkey_patch()
from neutron.agent.linux import interface
from neutron.agent.linux import ovs_lib # noqa
from neutron.agent import rpc as agent_rpc
+from neutron.common import config as common_config
from neutron.common import constants
from neutron.common import exceptions
from neutron.common import rpc_compat
def main():
register_options()
- cfg.CONF(project='neutron')
+ common_config.init(sys.argv[1:])
config.setup_logging(cfg.CONF)
server = neutron_service.Service.create(
binary='neutron-dhcp-agent',
# under the License.
#
+import sys
+
import eventlet
eventlet.monkey_patch()
from neutron.agent.linux import iptables_manager
from neutron.agent.linux import ovs_lib # noqa
from neutron.agent import rpc as agent_rpc
+from neutron.common import config as common_config
from neutron.common import constants as l3_constants
from neutron.common import rpc_compat
from neutron.common import topics
config.register_root_helper(conf)
conf.register_opts(interface.OPTS)
conf.register_opts(external_process.OPTS)
- conf(project='neutron')
+ common_config.init(sys.argv[1:])
config.setup_logging(conf)
server = neutron_service.Service.create(
binary='neutron-l3-agent',
import hmac
import os
import socket
+import sys
import eventlet
eventlet.monkey_patch()
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.init(sys.argv[1:])
config.setup_logging(cfg.CONF)
utils.log_opt_values(LOG)
proxy = UnixDomainMetadataProxy(cfg.CONF)
cfg.CONF.register_cli_opts(OPTS)
cfg.CONF.set_override('use_stderr', True)
config.setup_logging(cfg.CONF)
- config.parse(sys.argv[1:], default_config_files=[])
+ config.init(sys.argv[1:], default_config_files=[])
if cfg.CONF.config_file:
enable_tests_from_config()
"""
+import sys
+
from oslo.config import cfg
from neutron.common import config
def main():
- cfg.CONF(project='neutron')
+ config.init(sys.argv[1:])
config.setup_logging(cfg.CONF)
cxt = context.get_admin_context()
max_overflow=20, pool_timeout=10)
-def parse(args, **kwargs):
+def init(args, **kwargs):
cfg.CONF(args=args, project='neutron',
version='%%prog %s' % version.version_info.release_string(),
**kwargs)
def main():
- cfg.CONF(project='neutron')
+ config.init(sys.argv[1:])
config.setup_logging(cfg.CONF)
pl_config.register_config()
import platform
import re
+import sys
import time
import eventlet
from neutron.agent.common import config
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import constants as n_const
from neutron.common import rpc_compat
from neutron.common import topics
def main():
- cfg.CONF(project='neutron')
- logging_config.setup_logging(cfg.CONF)
+ common_config.init(sys.argv[1:])
+ common_config.setup_logging(cfg.CONF)
plugin = HyperVNeutronAgent()
import socket
+import sys
import time
import eventlet
from neutron.agent.linux import ip_lib
from neutron.agent.linux import ovs_lib
from neutron.agent import rpc as agent_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import constants as n_const
from neutron.common import rpc_compat
from neutron.common import topics
def main():
cfg.CONF.register_opts(ip_lib.OPTS)
- cfg.CONF(project='neutron')
- logging_config.setup_logging(cfg.CONF)
+ common_config.init(sys.argv[1:])
+ common_config.setup_logging(cfg.CONF)
try:
agent_config = create_agent_config_map(cfg.CONF)
from neutron.agent.linux import utils
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import constants
from neutron.common import exceptions
from neutron.common import rpc_compat
def main():
- cfg.CONF(project='neutron')
+ common_config.init(sys.argv[1:])
- logging_config.setup_logging(cfg.CONF)
+ common_config.setup_logging(cfg.CONF)
try:
interface_mappings = q_utils.parse_mappings(
cfg.CONF.LINUX_BRIDGE.physical_interface_mappings)
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import constants as q_constants
from neutron.common import rpc_compat
from neutron.common import topics
def main():
- cfg.CONF(project='neutron')
- logging_config.setup_logging(cfg.CONF)
+ common_config.init(sys.argv[1:])
+ common_config.setup_logging(cfg.CONF)
try:
interface_mappings = q_utils.parse_mappings(
# @author: Akihiro MOTOKI
import socket
+import sys
import time
import eventlet
from neutron.agent.linux import ovs_lib
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import constants as q_const
from neutron.common import rpc_compat
from neutron.common import topics
def main():
- config.CONF(project='neutron')
+ common_config.init(sys.argv[1:])
- logging_config.setup_logging(config.CONF)
+ common_config.setup_logging(config.CONF)
# Determine which agent type to use.
integ_br = config.OVS.integration_bridge
"""NVSD agent code for security group events."""
import socket
+import sys
import time
import eventlet
from neutron.agent.linux import ovs_lib
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import rpc_compat
from neutron.common import topics
from neutron import context as n_context
def main():
- config.CONF(project='neutron')
- logging_config.setup_logging(config.CONF)
+ common_config.init(sys.argv[1:])
+ common_config.setup_logging(config.CONF)
integ_br = config.AGENT.integration_bridge
root_helper = config.AGENT.root_helper
from neutron.agent.linux import utils
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import constants as q_const
from neutron.common import rpc_compat
from neutron.common import topics
def main():
cfg.CONF.register_opts(ip_lib.OPTS)
- cfg.CONF(project='neutron')
- logging_config.setup_logging(cfg.CONF)
+ common_config.init(sys.argv[1:])
+ common_config.setup_logging(cfg.CONF)
q_utils.log_opt_values(LOG)
try:
from neutron.agent.linux import ovs_lib
from neutron.agent import rpc as agent_rpc
from neutron.agent import securitygroups_rpc as sg_rpc
-from neutron.common import config as logging_config
+from neutron.common import config as common_config
from neutron.common import exceptions as n_exc
from neutron.common import rpc_compat
from neutron.common import topics
def main():
- cfg.CONF(project='neutron')
+ common_config.init(sys.argv[1:])
- logging_config.setup_logging(cfg.CONF)
+ common_config.setup_logging(cfg.CONF)
integ_br = cfg.CONF.OVS.integration_bridge
polling_interval = cfg.CONF.AGENT.polling_interval
help(sys.argv[0])
args = ['--config-file']
args.append(sys.argv[1])
- config.parse(args)
+ config.init(args)
print("----------------------- Database Options -----------------------")
print("\tconnection: %s" % cfg.CONF.database.connection)
print("\tretry_interval: %d" % cfg.CONF.database.retry_interval)
def main():
# the configuration will be read into the cfg.CONF global data structure
- config.parse(sys.argv[1:])
+ 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"
# @author: Gary Duan, vArmour Networks Inc.
#
+import sys
+
import eventlet
eventlet.monkey_patch()
from neutron.agent.linux import external_process
from neutron.agent.linux import interface
from neutron.agent.linux import ip_lib
+from neutron.common import config as common_config
from neutron.common import constants as l3_constants
from neutron.common import topics
from neutron.openstack.common import log as logging
config.register_root_helper(conf)
conf.register_opts(interface.OPTS)
conf.register_opts(external_process.OPTS)
- conf(project='neutron')
+ common_config.init(sys.argv[1:])
config.setup_logging(conf)
server = neutron_service.Service.create(
binary='neutron-l3-agent',
#
# @author: Mark McClain, DreamHost
+import sys
+
import eventlet
eventlet.monkey_patch()
from neutron.agent.common import config
from neutron.agent.linux import interface
+from neutron.common import config as common_config
from neutron.common import rpc_compat
from neutron.common import topics
from neutron.openstack.common import service
config.register_agent_state_opts_helper(cfg.CONF)
config.register_root_helper(cfg.CONF)
- cfg.CONF(project='neutron')
+ common_config.init(sys.argv[1:])
config.setup_logging(cfg.CONF)
mgr = manager.LbaasAgentManager(cfg.CONF)
# License for the specific language governing permissions and limitations
# under the License.
+import sys
import time
import eventlet
from neutron.agent.common import config
from neutron.agent import rpc as agent_rpc
+from neutron.common import config as common_config
from neutron.common import constants as constants
from neutron.common import rpc_compat
from neutron.common import topics
conf.register_opts(MeteringAgent.Opts)
config.register_agent_state_opts_helper(conf)
config.register_root_helper(conf)
- conf(project='neutron')
+ common_config.init(sys.argv[1:])
config.setup_logging(conf)
server = neutron_service.Service.create(
binary='neutron-metering-agent',
if args is None:
args = ['--config-file', etcdir('neutron.conf.test')]
if conf is None:
- config.parse(args=args)
+ config.init(args=args)
else:
conf(args)
'CONF.AGENT.root_helper': 'helper'}
with contextlib.nested(
mock.patch(AGENTMOD + '.cfg', **cfg_attrs),
+ mock.patch(AGENTMOD + '.config.init'),
mock.patch(NEUTRONCFG),
mock.patch(PLCONFIG),
- ) as (mock_conf, mock_log_conf, mock_pluginconf):
+ ) as (mock_conf, mock_init, mock_log_conf, mock_pluginconf):
self.mod_agent.main()
mock_log_conf.assert_has_calls([
def test_main(self):
with mock.patch.object(hyperv_neutron_agent,
'HyperVNeutronAgent') as plugin:
- with mock.patch.object(hyperv_neutron_agent.cfg, 'CONF') as cfg:
- with mock.patch.object(
- hyperv_neutron_agent,
- 'logging_config') as logging_config:
+ with mock.patch.object(hyperv_neutron_agent,
+ 'common_config') as common_config:
+ hyperv_neutron_agent.main()
- hyperv_neutron_agent.main()
-
- self.assertTrue(cfg.called)
- self.assertTrue(logging_config.setup_logging.called)
- plugin.assert_has_calls([mock.call().daemon_loop()])
+ self.assertTrue(common_config.init.called)
+ self.assertTrue(common_config.setup_logging.called)
+ plugin.assert_has_calls([mock.call().daemon_loop()])
def set_up_mocks(self):
# Mock the configuration file
args = ['--config-file', base.etcdir('neutron.conf.test')]
- neutron_config.parse(args=args)
+ neutron_config.init(args=args)
# Configure the ML2 mechanism drivers and network types
ml2_opts = {
def test_main(self):
with contextlib.nested(
mock.patch.object(nec_neutron_agent, 'NECNeutronAgent'),
- mock.patch.object(nec_neutron_agent, 'logging_config'),
+ mock.patch.object(nec_neutron_agent, 'common_config'),
mock.patch.object(nec_neutron_agent, 'config')
- ) as (agent, logging_config, cfg):
+ ) as (agent, common_config, cfg):
cfg.OVS.integration_bridge = 'br-int-x'
cfg.AGENT.root_helper = 'dummy-helper'
cfg.AGENT.polling_interval = 10
nec_neutron_agent.main()
- self.assertTrue(logging_config.setup_logging.called)
+ self.assertTrue(common_config.setup_logging.called)
agent.assert_has_calls([
mock.call('br-int-x', 'dummy-helper', 10),
mock.call().daemon_loop()
def test_main(self):
with contextlib.nested(
mock.patch.object(nvsd_neutron_agent, 'NVSDNeutronAgent'),
- mock.patch.object(nvsd_neutron_agent, 'logging_config'),
+ mock.patch.object(nvsd_neutron_agent, 'common_config'),
mock.patch.object(nvsd_neutron_agent, 'config')
- ) as (agent, logging_config, config):
+ ) as (agent, common_config, config):
config.AGENT.integration_bridge = 'br-int-dummy'
config.AGENT.root_helper = 'root-helper'
config.AGENT.polling_interval = 5
nvsd_neutron_agent.main()
- self.assertTrue(logging_config.setup_logging.called)
+ self.assertTrue(common_config.setup_logging.called)
agent.assert_has_calls([
mock.call('br-int-dummy', 'root-helper', 5),
mock.call().daemon_loop()
'CONF.AGENT.root_helper': 'helper'}
with contextlib.nested(
mock.patch(self._AGENT_NAME + '.cfg', **cfg_attrs),
- mock.patch(self._AGENT_NAME + '.logging_config'),
+ mock.patch(self._AGENT_NAME + '.common_config'),
mock.patch(self._AGENT_NAME + '._get_tunnel_ip',
return_value='10.0.0.1'),
mock.patch(self._AGENT_NAME + '._get_ovsdb_ip',
return_value='172.16.0.1'),
- ) as (mock_conf, mock_log_conf, _tun, _ovsdb):
+ ) as (mock_conf, mock_common_conf, _tun, _ovsdb):
self.mod_agent.main()
- mock_log_conf.assert_has_calls([
+ mock_common_conf.assert_has_calls([
mock.call(mock_conf)
])
from neutron.agent.common import config
from neutron.agent.linux import interface
+from neutron.common import config as common_config
from neutron.debug import commands
from neutron.debug import debug_agent
from neutron.tests import base
super(TestDebugCommands, self).setUp()
cfg.CONF.register_opts(interface.OPTS)
cfg.CONF.register_opts(debug_agent.NeutronDebugAgent.OPTS)
- cfg.CONF(args=[], project='neutron')
+ common_config.init([])
config.register_interface_driver_opts_helper(cfg.CONF)
config.register_use_namespaces_opts_helper(cfg.CONF)
config.register_root_helper(cfg.CONF)
from neutron.agent import dhcp_agent
from neutron.agent.linux import dhcp
from neutron.agent.linux import interface
+from neutron.common import config as common_config
from neutron.common import constants as const
from neutron.common import exceptions
from neutron.common import rpc_compat
config.register_root_helper(cfg.CONF)
cfg.CONF.register_opts(dhcp.OPTS)
cfg.CONF.register_opts(interface.OPTS)
- cfg.CONF(project='neutron')
+ common_config.init(sys.argv[1:])
agent_mgr = dhcp_agent.DhcpAgentWithStateReport(
'testhost')
eventlet.greenthread.sleep(1)