def prepare_service(argv=[]):
rpc.set_defaults(control_exchange='ironic')
cfg.set_defaults(log.log_opts,
default_log_levels=['amqplib=WARN',
'qpid.messaging=INFO',
'sqlalchemy=WARN',
'keystoneclient=INFO',
'stevedore=INFO',
'eventlet.wsgi.server=WARN'
])
cfg.CONF(argv[1:], project='ironic')
log.setup('ironic')
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='')
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()
def main():
eventlet.monkey_patch()
register_options()
cfg.CONF(project='neutron')
config.setup_logging(cfg.CONF)
legacy.modernize_quantum_config(cfg.CONF)
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(server).wait()
def __init__(self):
"""Initialize a configuration from a conf directory and conf file."""
config_files = []
failsafe_path = "/etc/fuel/" + self.DEFAULT_CONFIG_FILE
# Environment variables override defaults...
custom_config = os.environ.get('CUSTOM_FUEL_CONFIG')
LOG.info('CUSTOM CONFIG PATH %s' % custom_config)
if custom_config:
path = custom_config
else:
conf_dir = os.environ.get('FUEL_CONFIG_DIR',
self.DEFAULT_CONFIG_DIR)
conf_file = os.environ.get('FUEL_CONFIG', self.DEFAULT_CONFIG_FILE)
path = os.path.join(conf_dir, conf_file)
if not (os.path.isfile(path) or 'FUEL_CONFIG_DIR' in os.environ
or 'FUEL_CONFIG' in os.environ):
path = failsafe_path
LOG.info("Using fuel config file %s" % path)
if not os.path.exists(path):
msg = "Config file {0} not found".format(path)
print(RuntimeError(msg), file=sys.stderr)
else:
config_files.append(path)
cfg.CONF([], project='fuel', default_config_files=config_files)
register_compute_opts(cfg.CONF)
register_identity_opts(cfg.CONF)
register_network_opts(cfg.CONF)
register_master_opts(cfg.CONF)
register_volume_opts(cfg.CONF)
register_murano_opts(cfg.CONF)
register_heat_opts(cfg.CONF)
register_sahara_opts(cfg.CONF)
register_fuel_opts(cfg.CONF)
register_ironic_opts(cfg.CONF)
self.compute = cfg.CONF.compute
self.identity = cfg.CONF.identity
self.network = cfg.CONF.network
self.master = cfg.CONF.master
self.volume = cfg.CONF.volume
self.murano = cfg.CONF.murano
self.heat = cfg.CONF.heat
self.sahara = cfg.CONF.sahara
self.fuel = cfg.CONF.fuel
self.ironic = cfg.CONF.ironic
def main():
eventlet.monkey_patch()
cfg.CONF(project='neutron')
config.setup_logging(cfg.CONF)
pl_config.register_config()
integ_br = cfg.CONF.RESTPROXYAGENT.integration_bridge
polling_interval = cfg.CONF.RESTPROXYAGENT.polling_interval
root_helper = cfg.CONF.AGENT.root_helper
bsnagent = RestProxyAgent(integ_br, polling_interval, root_helper,
cfg.CONF.RESTPROXYAGENT.virtual_switch_type)
bsnagent.daemon_loop()
sys.exit(0)
def prepare_service(argv=[]):
eventlet.monkey_patch()
utils.read_config('billingstack', sys.argv)
rpc.set_defaults(control_exchange='billingstack')
cfg.set_defaults(log.log_opts,
default_log_levels=[
'amqplib=WARN', 'qpid.messaging=INFO',
'sqlalchemy=WARN', 'keystoneclient=INFO',
'stevedore=INFO', 'eventlet.wsgi.server=WARN'
])
cfg.CONF(argv[1:], project='billingstack')
log.setup('billingstack')
def prepare_service(argv=[]):
cfg.set_defaults(log.log_opts,
default_log_levels=['amqp=WARN',
'amqplib=WARN',
'qpid.messaging=INFO',
'sqlalchemy=WARN',
'keystoneclient=INFO',
'stevedore=INFO',
'eventlet.wsgi.server=WARN',
'iso8601=WARN'
])
cfg.CONF(argv[1:], project='tuskar')
log.setup('tuskar')
def __init__(self):
self.handlers = named.NamedExtensionManager(
namespace='dnh.handler',
names=cfg.CONF[CFG_GRP].handlers,
invoke_on_load=True)
# Some handlers may have required options. They're loaded by stevedore
# after the initial config parsing, so we reparse the config file here
# to make sure handlers get all their (required) options parsed.
cfg.CONF()
self.connection = kombu.Connection(
'amqp://%s:%d' % (cfg.CONF[CFG_GRP].host, cfg.CONF[CFG_GRP].port))
signal.signal(signal.SIGTERM, self.on_signal_stop)
signal.signal(signal.SIGINT, self.on_signal_stop)
def main():
cfg.CONF([], project='ceilometer')
parser = argparse.ArgumentParser(description='generate event data', )
parser.add_argument(
'--interval',
default=10,
type=int,
help='The period between events, in minutes.',
)
parser.add_argument(
'--start',
default=31,
type=int,
help='The number of days in the past to start timestamps.',
)
parser.add_argument(
'--end',
default=2,
type=int,
help='The number of days into the future to continue timestamps.',
)
parser.add_argument(
'--event_types',
default=3,
type=int,
help='The number of unique event_types.',
)
args = parser.parse_args()
# Set up logging to use the console
console = logging.StreamHandler(sys.stderr)
console.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(message)s')
console.setFormatter(formatter)
root_logger = logging.getLogger('')
root_logger.addHandler(console)
root_logger.setLevel(logging.DEBUG)
# Connect to the event database
conn = storage.get_connection_from_config(cfg.CONF, 'event')
# Compute the correct time span
start = datetime.datetime.utcnow() - datetime.timedelta(days=args.start)
end = datetime.datetime.utcnow() + datetime.timedelta(days=args.end)
make_test_data(conn=conn,
start=start,
end=end,
interval=args.interval,
event_types=args.event_types)
def prepare_service(argv=None):
#
gettextutils.install('volt', lazy=True)
cfg.set_defaults(log.log_opts,
default_log_levels=[
'amqplib=WARN', 'qpid.messaging=INFO',
'sqlalchemy=WARN', 'keystoneclient=INFO',
'stevedore=INFO', 'eventlet.wsgi.server=WARN',
'iso8601=WARN'
])
if argv is None:
argv = sys.argv
cfg.CONF(argv[1:], project='volt', version=version.version_string())
log.setup('volt')
def prepare_service(argv=None):
eventlet.monkey_patch()
gettextutils.install('ceilometer')
rpc.set_defaults(control_exchange='ceilometer')
cfg.set_defaults(log.log_opts,
default_log_levels=[
'amqplib=WARN', 'qpid.messaging=INFO',
'sqlalchemy=WARN', 'keystoneclient=INFO',
'stevedore=INFO', 'eventlet.wsgi.server=WARN'
])
if argv is None:
argv = sys.argv
cfg.CONF(argv[1:], project='ceilometer')
log.setup('ceilometer')
def test_boot_strap_successful(self):
tests_path = os.path.abspath(os.path.dirname(
os.path.dirname(__file__)))
conf_path = os.path.join(tests_path, 'etc', 'default_functional.conf')
cfg.CONF(args=[], default_config_files=[conf_path])
bootstrap_obj = bootstrap.Bootstrap(cfg.CONF)
mock_path = 'poppy.transport.pecan.driver.simple_server'
with mock.patch(mock_path) as mocked_module:
mock_server = mock.Mock()
mocked_module.make_server = mock.Mock(return_value=mock_server)
bootstrap_obj.run()
self.assertTrue(mock_server.serve_forever.called)
def parse_args(argv, default_config_files=None):
options.set_defaults(sql_connection=_DEFAULT_SQL_CONNECTION,
sqlite_db='nova.sqlite')
rpc.set_defaults(control_exchange='nova')
nova_default_log_levels = (
log.DEFAULT_LOG_LEVELS +
["keystonemiddleware=WARN", "routes.middleware=WARN"])
log.set_defaults(default_log_levels=nova_default_log_levels)
debugger.register_cli_opts()
cfg.CONF(argv[1:],
project='nova',
version=version.version_string(),
default_config_files=default_config_files)
rpc.init(cfg.CONF)
def initialize_app(self, argv):
super(QuantumDebugShell, 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[QUANTUM_TEST_CONFIG_FILE]"))
client = self.client_manager.quantum
cfg.CONF.register_opts(interface.OPTS)
cfg.CONF.register_opts(QuantumDebugAgent.OPTS)
config.register_root_helper(cfg.CONF)
cfg.CONF(['--config-file', self.options.config_file])
config.setup_logging(cfg.CONF)
driver = importutils.import_object(cfg.CONF.interface_driver, cfg.CONF)
self.debug_agent = QuantumDebugAgent(cfg.CONF, client, driver)
def test_listen(self):
tests_path = os.path.abspath(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
conf_path = os.path.join(tests_path, 'etc', 'default_functional.conf')
cfg.CONF(args=[], default_config_files=[conf_path])
mock_path = 'poppy.transport.pecan.driver.simple_server'
with mock.patch(mock_path) as mocked_module:
mock_server = mock.Mock()
mocked_module.make_server = mock.Mock(return_value=mock_server)
driver = pecan.Driver(cfg.CONF, None)
driver.listen()
self.assertTrue(mock_server.serve_forever.called)
def main(argv):
cfg.CONF([], project='ceilometer')
if os.getenv("CEILOMETER_TEST_HBASE_URL"):
url = ("%s?table_prefix=%s" %
(os.getenv("CEILOMETER_TEST_HBASE_URL"),
os.getenv("CEILOMETER_TEST_HBASE_TABLE_PREFIX", "test")))
conn = storage.get_connection(url, 'ceilometer.metering.storage')
alarm_conn = storage.get_connection(url, 'ceilometer.alarm.storage')
for arg in argv:
if arg == "--upgrade":
conn.upgrade()
alarm_conn.upgrade()
if arg == "--clear":
conn.clear()
alarm_conn.clear()
def setUp(self):
super(TestCase, self).setUp()
self.mox = mox.Mox()
self.stubs = stubout.StubOutForTesting()
self.tempdir = self.useFixture(fixtures.TempDir())
self.useFixture(fixtures.FakeLogger())
cfg.CONF([], project='ceilometer')
# Set a default location for the pipeline config file so the
# tests work even if ceilometer is not installed globally on
# the system.
cfg.CONF.set_override(
'pipeline_cfg_file',
self.path_get('etc/ceilometer/pipeline.yaml'),
)
def init(args, **kwargs):
cfg.CONF(args=args,
project='neutron',
version='%%prog %s' % version.version_info.release_string(),
**kwargs)
# FIXME(ihrachys): if import is put in global, circular import
# failure occurs
from neutron.common import rpc as n_rpc
n_rpc.init(cfg.CONF)
# Validate that the base_mac is of the correct format
msg = attributes._validate_regex(cfg.CONF.base_mac, attributes.MAC_PATTERN)
if msg:
msg = _("Base MAC: %s") % msg
raise Exception(msg)
def main():
cfg.CONF.register_opts(ip_lib.OPTS)
cfg.CONF(project='neutron')
logging_config.setup_logging(cfg.CONF)
try:
agent_config = create_agent_config_map(cfg.CONF)
except ValueError as e:
LOG.exception(_("%s Agent terminated!"), e)
raise SystemExit(1)
plugin = SdnveNeutronAgent(**agent_config)
# Start everything.
LOG.info(_("Agent initialized successfully, now running... "))
plugin.daemon_loop()
def init_config():
"""Initialize configuration for this script"""
logging.setup("sync_network")
cfgfile = get_config_files()
cfg.CONF(
args=[
j for i in zip(["--config-file"] * len(cfgfile), cfgfile)
for j in i
],
project="neutron",
)
cfg.CONF.set_override('control_exchange', '')
cfg.CONF.set_override('rpc_backend',
'neutron.openstack.common.rpc.impl_fake')
cfg.CONF.set_override('verbose', True)
cfg.CONF.set_override('debug', True)
def start():
"""Starts Kwapi drivers."""
cfg.CONF(sys.argv[1:],
project='kwapi',
default_config_files=['/etc/kwapi/drivers.conf'])
log.setup('kwapi')
start_zmq_server()
load_all_drivers()
check_drivers_alive()
signal.signal(signal.SIGTERM, signal_handler)
try:
signal.pause()
except KeyboardInterrupt:
terminate()
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_root_helper(cfg.CONF)
cfg.CONF(project='quantum')
config.setup_logging(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()
def main():
cfg.CONF(sys.argv[1:], project='solum')
logging.setup('solum')
LOG.info(_('Starting server in PID %s') % os.getpid())
LOG.debug("Configuration:")
cfg.CONF.log_opt_values(LOG, std_logging.DEBUG)
cfg.CONF.import_opt('topic', 'solum.conductor.config', group='conductor')
cfg.CONF.import_opt('host', 'solum.conductor.config', group='conductor')
endpoints = [
default_handler.Handler(),
]
server = service.Service(cfg.CONF.conductor.topic, cfg.CONF.conductor.host,
endpoints)
server.serve()
def __init__(self):
"""Initialize a configuration from a conf directory and conf file."""
# Environment variables override defaults...
conf_dir = os.environ.get('TEMPEST_CONFIG_DIR',
self.DEFAULT_CONFIG_DIR)
conf_file = os.environ.get('TEMPEST_CONFIG', self.DEFAULT_CONFIG_FILE)
path = os.path.join(conf_dir, conf_file)
if not (os.path.isfile(path) or 'TEMPEST_CONFIG_DIR' in os.environ
or 'TEMPEST_CONFIG' in os.environ):
path = "/etc/tempest/" + self.DEFAULT_CONFIG_FILE
LOG.info("Using tempest config file %s" % path)
if not os.path.exists(path):
msg = "Config file %(path)s not found" % locals()
print >> sys.stderr, RuntimeError(msg)
sys.exit(os.EX_NOINPUT)
cfg.CONF([], project='tempest', default_config_files=[path])
register_compute_opts(cfg.CONF)
register_identity_opts(cfg.CONF)
register_whitebox_opts(cfg.CONF)
register_image_opts(cfg.CONF)
register_network_opts(cfg.CONF)
register_volume_opts(cfg.CONF)
register_object_storage_opts(cfg.CONF)
register_boto_opts(cfg.CONF)
register_compute_admin_opts(cfg.CONF)
register_stress_opts(cfg.CONF)
self.compute = cfg.CONF.compute
self.whitebox = cfg.CONF.whitebox
self.identity = cfg.CONF.identity
self.images = cfg.CONF.image
self.network = cfg.CONF.network
self.volume = cfg.CONF.volume
self.object_storage = cfg.CONF['object-storage']
self.boto = cfg.CONF.boto
self.compute_admin = cfg.CONF['compute-admin']
self.stress = cfg.CONF.stress
if not self.compute_admin.username:
self.compute_admin.username = self.identity.admin_username
self.compute_admin.password = self.identity.admin_password
self.compute_admin.tenant_name = self.identity.admin_tenant_name
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()
def main():
eventlet.monkey_patch()
cfg.CONF(project='quantum')
logging_config.setup_logging(cfg.CONF)
try:
agent_config = create_agent_config_map(cfg.CONF)
except ValueError as e:
LOG.error(_('%s Agent terminated!'), e)
sys.exit(1)
plugin = OVSQuantumAgent(**agent_config)
# Start everything.
LOG.info(_("Agent initialized successfully, now running... "))
plugin.daemon_loop()
sys.exit(0)
def main():
cfg.CONF(default_config_files=([NUAGE_CONFIG_FILE]))
config.nuage_register_cfg_opts()
server = cfg.CONF.RESTPROXY.server
serverauth = cfg.CONF.RESTPROXY.serverauth
serverssl = cfg.CONF.RESTPROXY.serverssl
base_uri = cfg.CONF.RESTPROXY.base_uri
auth_resource = cfg.CONF.RESTPROXY.auth_resource
organization = cfg.CONF.RESTPROXY.organization
fipquota = str(cfg.CONF.RESTPROXY.default_floatingip_quota)
logging = importutils.import_module('logging')
nuageclientinst = importutils.import_module('nuagenetlib.nuageclient')
nuageclient = nuageclientinst.NuageClient(server, base_uri, serverssl,
serverauth, auth_resource,
organization)
logging.basicConfig(level=logging.DEBUG)
SyncManager(nuageclient).synchronize(fipquota)
def prepare_service(argv=None):
gettextutils.install('ceilometer', lazy=True)
gettextutils.enable_lazy()
cfg.set_defaults(log.log_opts,
default_log_levels=['amqplib=WARN',
'qpid.messaging=INFO',
'sqlalchemy=WARN',
'keystoneclient=INFO',
'stevedore=INFO',
'eventlet.wsgi.server=WARN',
'iso8601=WARN'
])
if argv is None:
argv = sys.argv
cfg.CONF(argv[1:], project='ceilometer')
log.setup('ceilometer')
messaging.setup()
def main():
opts = [
cfg.StrOpt('network_id',
help=_('Network that will have instance metadata '
'proxied.')),
cfg.StrOpt('router_id',
help=_('Router that will have connected instances\' '
'metadata proxied.')),
cfg.StrOpt('pid_file',
help=_('Location of pid file of this process.')),
cfg.BoolOpt('daemonize', default=True, help=_('Run as daemon.')),
cfg.IntOpt('metadata_port',
default=9697,
help=_("TCP Port to listen for metadata server "
"requests.")),
cfg.StrOpt('metadata_proxy_socket',
default='$state_path/metadata_proxy',
help=_('Location of Metadata Proxy UNIX domain '
'socket')),
cfg.StrOpt('metadata_proxy_user',
default=None,
help=_("User (uid or name) running metadata proxy after "
"its initialization")),
cfg.StrOpt('metadata_proxy_group',
default=None,
help=_("Group (gid or name) running metadata proxy after "
"its initialization")),
]
cfg.CONF.register_cli_opts(opts)
# Don't get the default configuration file
cfg.CONF(project='neutron', default_config_files=[])
config.setup_logging()
utils.log_opt_values(LOG)
proxy = ProxyDaemon(cfg.CONF.pid_file,
cfg.CONF.metadata_port,
network_id=cfg.CONF.network_id,
router_id=cfg.CONF.router_id,
user=cfg.CONF.metadata_proxy_user,
group=cfg.CONF.metadata_proxy_group)
if cfg.CONF.daemonize:
proxy.start()
else:
proxy.run()
def main():
cfg.CONF(args=['--config-file', 'example_conf.ini'],
project='neutron',
version='1')
plugin = nodemanager.NodeManager()
#device1 = plugin.get_device_by_file("Device - Nexus-1000v(2).xml")
isolation = isolationprovider.IsolationProvider()
#validator1 = validator.Validator(isolation.get_all_instances_names())
#validator1.validate_all()
#service = isolation.get_service('Vlan Access')
#device = plugin.applicable_service_by_device('VlanProfile','Nexus-1000v(2)')
devices = ['R2', 'SW1', 'SW2']
services = ['Vlan', 'VPLS', 'Trunk']
#print plugin.list_services_by_devices(services, devices)
devices_ports = {"R1": "FastEthernet0-0", "R2": "Fastethernet0-1"}
print plugin.discover_all_services("R1")
