def main(): """Parse options and call the appropriate class/method.""" CONF.register_cli_opt(category_opt) script_name = sys.argv[0] if len(sys.argv) < 2: print(_("\nOpenStack manila version: %(version)s\n") % {"version": version.version_string()}) print(script_name + " category action [<args>]") print(_("Available categories:")) for category in CATEGORIES: print("\t%s" % category) sys.exit(2) try: log.register_options(CONF) CONF(sys.argv[1:], project="manila", version=version.version_string()) log.setup(CONF, "manila") except cfg.ConfigFilesNotFoundError: cfgfile = CONF.config_file[-1] if CONF.config_file else None if cfgfile and not os.access(cfgfile, os.R_OK): st = os.stat(cfgfile) print(_("Could not read %s. Re-running with sudo") % cfgfile) try: os.execvp("sudo", ["sudo", "-u", "#%s" % st.st_uid] + sys.argv) except Exception: print(_("sudo failed, continuing as if nothing happened")) print(_("Please re-run manila-manage as root.")) sys.exit(2) fn = CONF.category.action_fn fn_args = fetch_func_args(fn) fn(*fn_args)
def parse_args(args=None, usage=None, default_config_files=None): logging.register_options(CONF) CONF(args=args, project='murano', version=version.version_string, usage=usage, default_config_files=default_config_files)
def main(args=sys.argv[1:]): # pragma: no cover log.register_options(CONF) CONF(args, project='ironic-inspector') debug = CONF.debug log.set_defaults(default_log_levels=[ 'urllib3.connectionpool=WARN', 'keystonemiddleware.auth_token=WARN', 'requests.packages.urllib3.connectionpool=WARN', ('ironicclient.common.http=INFO' if debug else 'ironicclient.common.http=ERROR')]) log.setup(CONF, 'ironic_inspector') app_kwargs = {'host': CONF.listen_address, 'port': CONF.listen_port} context = create_ssl_context() if context: app_kwargs['ssl_context'] = context init() try: app.run(**app_kwargs) finally: firewall.clean_up()
def prepare_service(argv=[], conf=cfg.CONF): log.register_options(conf) config.parse_args(argv) cfg.set_defaults(_options.log_opts, default_log_levels=_DEFAULT_LOG_LEVELS) log.setup(conf, 'python-watcher') conf.log_opt_values(LOG, logging.DEBUG)
def main(): CONF.register_cli_opt(category_opt) try: log.register_options(CONF) CONF(sys.argv[1:], project='rumster', version=version.version_info.version_string()) log.setup(CONF, "rumster") except cfg.ConfigFilesNotFoundError: cfgfile = CONF.config_file[-1] if CONF.config_file else None if cfgfile and not os.access(cfgfile, os.R_OK): st = os.stat(cfgfile) print(_LI("Could not read %s. Re-running with sudo") % cfgfile) try: os.execvp('sudo', ['sudo', '-u', '#%s' % st.st_uid] + sys.argv) except Exception: print(_LI('sudo failed, continuing as if nothing happened')) print(_LI('Please re-run rumster-manage as root.')) sys.exit(2) fn = CONF.category.action_fn fn_args = fetch_func_args(fn) fn(*fn_args)
def new_config(): conf = cfg.ConfigOpts() log.register_options(conf) conf.register_opts(context_opts) conf.register_opts(common_opts) conf.register_opts(host_opts) conf.register_opts(db_opts) conf.register_opts(_options.eventlet_backdoor_opts) conf.register_opts(_options.periodic_opts) conf.register_opts(_options.ssl_opts, "ssl") conf.register_group(retry_opt_group) conf.register_opts(retry_opts, group=retry_opt_group) conf.register_group(queue_opt_group) conf.register_opts(queue_opts, group=queue_opt_group) conf.register_group(ks_queue_opt_group) conf.register_opts(ks_queue_opts, group=ks_queue_opt_group) conf.register_group(quota_opt_group) conf.register_opts(quota_opts, group=quota_opt_group) return conf
def prepare_service(argv=None): if argv is None: argv = [] log.register_options(CONF) config.parse_args(argv) config.set_config_defaults() log.setup(CONF, 'zun')
def _get_config_opts(self): config = cfg.ConfigOpts() config.register_opts(common_config.core_opts) config.register_opts(common_config.core_cli_opts) logging.register_options(config) agent_config.register_process_monitor_opts(config) return config
def prepare_service(argv=None, config_files=None, share=False): conf = cfg.ConfigOpts() for group, options in opts.list_opts(): conf.register_opts(list(options), group=None if group == "DEFAULT" else group) db_options.set_defaults(conf) if profiler_opts: profiler_opts.set_defaults(conf) if not share: defaults.set_cors_middleware_defaults() oslo_i18n.enable_lazy() log.register_options(conf) if argv is None: argv = sys.argv conf(argv[1:], project='panko', validate_default_values=True, version=version.version_info.version_string(), default_config_files=config_files) if not share: log.setup(conf, 'panko') profiler.setup(conf) # NOTE(liusheng): guru cannot run with service under apache daemon, so when # panko-api running with mod_wsgi, the argv is [], we don't start # guru. if argv: gmr.TextGuruMeditation.setup_autorun(version) return conf
def prepare_service(argv=None, config_files=None, conf=None): if argv is None: argv = sys.argv if conf is None: conf = cfg.ConfigOpts() oslo_i18n.enable_lazy() for group, options in opts.list_opts(): conf.register_opts(list(options), group=None if group == "DEFAULT" else group) keystone_client.register_keystoneauth_opts(conf) log.register_options(conf) log_levels = (conf.default_log_levels + ['futurist=INFO', 'neutronclient=INFO', 'keystoneclient=INFO']) log.set_defaults(default_log_levels=log_levels) conf(argv[1:], project='ceilometer', validate_default_values=True, version=version.version_info.version_string(), default_config_files=config_files) keystone_client.post_register_keystoneauth_opts(conf) log.setup(conf, 'ceilometer') utils.setup_root_helper(conf) sample.setup(conf) gmr.TextGuruMeditation.setup_autorun(version) messaging.setup() return conf
def _log_setup(self): CONF = cfg.CONF self.set_request_context() DOMAIN = "masakari" CONF.log_file = self.conf_log.get("log_file") CONF.use_stderr = False logging.register_options(CONF) logging.setup(CONF, DOMAIN) log_dir = os.path.dirname(self.conf_log.get("log_file")) # create log dir if not created try: os.makedirs(log_dir) except OSError as exc: if exc.errno == errno.EEXIST and os.path.isdir(log_dir): pass else: raise return
def parse_args_with_log(project, argv=None, version=None, conf=None, log=True, default_config_files=None, default_log_format=None, default_log_levels=None): conf = conf if conf else cfg.CONF argv = argv if argv else sys.argv[1:] if not log: conf(argv, project=project, version=version, default_config_files=default_config_files) return from oslo_log import log if project not in _ROOTS: _DEFAULT_LOG_LEVELS.append('%s=INFO' % project) _ROOTS.append(project) log_fmt = default_log_format if default_log_format else _DEFAULT_LOG_FORMAT log_lvl = default_log_levels if default_log_levels else _DEFAULT_LOG_LEVELS log.set_defaults(log_fmt, log_lvl) log.register_options(conf) # (TODO): Configure the options of the other libraries, which must be called # before parsing the configuration file. conf(argv, project=project, version=version, default_config_files=default_config_files) log.setup(conf, project, version)
def new_config(): conf = cfg.ConfigOpts() log.register_options(conf) conf.register_opts(context_opts) conf.register_opts(common_opts) conf.register_opts(host_opts) conf.register_opts(db_opts) conf.register_opts(_options.eventlet_backdoor_opts) conf.register_opts(_options.periodic_opts) conf.register_opts(_options.ssl_opts, "ssl") conf.register_group(retry_opt_group) conf.register_opts(retry_opts, group=retry_opt_group) conf.register_group(queue_opt_group) conf.register_opts(queue_opts, group=queue_opt_group) conf.register_group(ks_queue_opt_group) conf.register_opts(ks_queue_opts, group=ks_queue_opt_group) conf.register_group(quota_opt_group) conf.register_opts(quota_opts, group=quota_opt_group) # Update default values from libraries that carry their own oslo.config # initialization and configuration. set_middleware_defaults() return conf
def api_app(conf): log.set_defaults(constant.KILOEYES_LOGGING_CONTEXT_FORMAT, constant.KILOEYES_LOG_LEVELS) log.register_options(cfg.CONF) if conf.get('name'): name = conf.get('name') else: name = 'kiloeyes' cfg.CONF(args=[], project=name) log.setup(cfg.CONF, name) dispatcher_manager = named.NamedExtensionManager( namespace=namespace.DISPATCHER_NS, names=cfg.CONF.dispatcher, invoke_on_load=True, invoke_args=[cfg.CONF]) if not list(dispatcher_manager): LOG.error('Failed to load any dispatchers for %s' % namespace.DISPATCHER_NS) return None # Create the application app = resource_api.ResourceAPI() # add each dispatcher to the application to serve requests offered by # each dispatcher for driver in dispatcher_manager: app.add_route(None, driver.obj) LOG.debug('Dispatcher drivers have been added to the routes!') return app
def prepare_service(argv=None, config_files=None, conf=None): if argv is None: argv = sys.argv # FIXME(sileht): Use ConfigOpts() instead if conf is None: conf = cfg.CONF oslo_i18n.enable_lazy() log.register_options(conf) log_levels = (conf.default_log_levels + ['futurist=INFO', 'neutronclient=INFO', 'keystoneclient=INFO']) log.set_defaults(default_log_levels=log_levels) defaults.set_cors_middleware_defaults() policy_opts.set_defaults(conf) conf(argv[1:], project='ceilometer', validate_default_values=True, version=version.version_info.version_string(), default_config_files=config_files) ka_loading.load_auth_from_conf_options(conf, "service_credentials") log.setup(conf, 'ceilometer') # NOTE(liusheng): guru cannot run with service under apache daemon, so when # ceilometer-api running with mod_wsgi, the argv is [], we don't start # guru. if argv: gmr.TextGuruMeditation.setup_autorun(version) messaging.setup() return conf
def launch(conf, config_file="/etc/monasca/events_api.conf"): log.register_options(cfg.CONF) log.set_defaults() cfg.CONF(args=[], project='monasca_events_api', default_config_files=[config_file]) log.setup(cfg.CONF, 'monasca_events_api') app = falcon.API() versions = simport.load(cfg.CONF.dispatcher.versions)() app.add_route("/", versions) app.add_route("/{version_id}", versions) events = simport.load(cfg.CONF.dispatcher.events)() app.add_route("/v2.0/events", events) app.add_route("/v2.0/events/{event_id}", events) streams = simport.load(cfg.CONF.dispatcher.stream_definitions)() app.add_route("/v2.0/stream-definitions/", streams) app.add_route("/v2.0/stream-definitions/{stream_id}", streams) transforms = simport.load(cfg.CONF.dispatcher.transforms)() app.add_route("/v2.0/transforms", transforms) app.add_route("/v2.0/transforms/{transform_id}", transforms) LOG.debug('Dispatcher drivers have been added to the routes!') return app
def parse_args(argv, default_config_files=None, configure_db=True, init_rpc=True): log.register_options(CONF) # We use the oslo.log default log levels which includes suds=INFO # and add only the extra levels that Nova needs if CONF.glance.debug: extra_default_log_levels = ['glanceclient=DEBUG'] else: extra_default_log_levels = ['glanceclient=WARN'] log.set_defaults(default_log_levels=log.get_default_log_levels() + extra_default_log_levels) rpc.set_defaults(control_exchange='nova') if profiler: profiler.set_defaults(CONF) config.set_middleware_defaults() CONF(argv[1:], project='nova', version=version.version_string(), default_config_files=default_config_files) if init_rpc: rpc.init(CONF) if configure_db: sqlalchemy_api.configure(CONF)
def main(): logging.register_options(cfg.CONF) cfg.CONF(project='heat', prog='heat-engine', version=version.version_info.version_string()) logging.setup(cfg.CONF, 'heat-engine') logging.set_defaults() messaging.setup() config.startup_sanity_check() mgr = None try: mgr = template._get_template_extension_manager() except template.TemplatePluginNotRegistered as ex: LOG.critical(_LC("%s"), ex) if not mgr or not mgr.names(): sys.exit("ERROR: No template format plugins registered") from heat.engine import service as engine # noqa profiler.setup('heat-engine', cfg.CONF.host) gmr.TextGuruMeditation.setup_autorun(version) srv = engine.EngineService(cfg.CONF.host, rpc_api.ENGINE_TOPIC) workers = cfg.CONF.num_engine_workers if not workers: workers = max(4, processutils.get_worker_count()) launcher = service.launch(cfg.CONF, srv, workers=workers) if cfg.CONF.enable_cloud_watch_lite: # We create the periodic tasks here, which mean they are created # only in the parent process when num_engine_workers>1 is specified srv.create_periodic_tasks() launcher.wait()
def main(): try: logging.register_options(cfg.CONF) cfg.CONF(project='heat', prog='heat-api-cloudwatch', version=version.version_info.version_string()) logging.setup(cfg.CONF, 'heat-api-cloudwatch') logging.set_defaults() messaging.setup() app = config.load_paste_app() port = cfg.CONF.heat_api_cloudwatch.bind_port host = cfg.CONF.heat_api_cloudwatch.bind_host LOG.info(_LI('Starting Heat CloudWatch API on %(host)s:%(port)s'), {'host': host, 'port': port}) profiler.setup('heat-api-cloudwatch', host) gmr.TextGuruMeditation.setup_autorun(version) server = wsgi.Server('heat-api-cloudwatch', cfg.CONF.heat_api_cloudwatch) server.start(app, default_port=port) systemd.notify_once() server.wait() except RuntimeError as e: msg = six.text_type(e) sys.exit("ERROR: %s" % msg)
def main(): logging.register_options(cfg.CONF) cfg.CONF(sys.argv[1:], project='magnum') logging.setup(cfg.CONF, 'magnum') LOG.info(_LI('Starting server in PID %s') % os.getpid()) LOG.debug("Configuration:") cfg.CONF.log_opt_values(LOG, std_logging.DEBUG) cfg.CONF.import_opt('topic', 'magnum.conductor.config', group='conductor') conductor_id = short_id.generate_id() endpoints = [ docker_conductor.Handler(), k8s_conductor.Handler(), bay_conductor.Handler(), conductor_listener.Handler(), ] if (not os.path.isfile(cfg.CONF.bay.k8s_atomic_template_path) and not os.path.isfile(cfg.CONF.bay.k8s_coreos_template_path)): LOG.error(_LE("The Heat template can not be found for either k8s " "atomic %(atomic_template)s or coreos " "(coreos_template)%s. Install template first if you " "want to create bay.") % {'atomic_template': cfg.CONF.bay.k8s_atomic_template_path, 'coreos_template': cfg.CONF.bay.k8s_coreos_template_path}) server = service.Service(cfg.CONF.conductor.topic, conductor_id, endpoints) server.serve()
def _setUp(self): log.register_options(cfg.CONF) CONF.set_default('host', 'fake-mini') CONF.set_default('connection', "sqlite://", group='database') CONF.set_default('sqlite_synchronous', False, group='database') config.parse_args([], default_config_files=[]) self.addCleanup(CONF.reset)
def main(): CONF.register_cli_opt(command_opt) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='glance', prog='glance-registry') cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-api')) cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-manage')) config.parse_args(default_config_files=cfg_files, usage="%(prog)s [options] <cmd>") logging.setup(CONF, 'glance') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: if CONF.command.action.startswith('db'): return CONF.command.action_fn() else: func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [encodeutils.safe_decode(arg) for arg in CONF.command.action_args] return CONF.command.action_fn(*func_args, **func_kwargs) except exception.GlanceException as e: sys.exit("ERROR: %s" % utils.exception_to_str(e))
def parse_args(argv=None, config_file=None): """Loads application configuration. Loads entire application configuration just once. """ global _CONF_LOADED if _CONF_LOADED: LOG.debug('Configuration has been already loaded') return log.set_defaults() log.register_options(CONF) argv = (argv if argv is not None else sys.argv[1:]) args = ([] if _is_running_under_gunicorn() else argv or []) config_file = (_get_deprecated_config_file() if config_file is None else config_file) CONF(args=args, prog='api', project='monasca', version=version.version_str, default_config_files=[config_file] if config_file else None, description='RESTful API for alarming in the cloud') log.setup(CONF, product_name='monasca-api', version=version.version_str) conf.register_opts() _CONF_LOADED = True
def main(): CONF.register_cli_opts([ cfg.Opt('os-username'), cfg.Opt('os-password'), cfg.Opt('os-auth-url'), cfg.Opt('os-tenant-name'), ]) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='glance', prog='glance-api') cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-search')) config.parse_args(default_config_files=cfg_files) logging.setup(CONF, 'glance') namespace = 'glance.search.index_backend' ext_manager = stevedore.extension.ExtensionManager( namespace, invoke_on_load=True) for ext in ext_manager.extensions: try: ext.obj.setup() except Exception as e: LOG.error(_LE("Failed to setup index extension " "%(ext)s: %(e)s") % {'ext': ext.name, 'e': e}) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def set_default_for_default_log_levels(): extra_log_level_defaults = [ ] log.register_options(CONF) CONF.set_default("default_log_levels", CONF.default_log_levels + extra_log_level_defaults)
def launch_engine(setup_logging=True): if setup_logging: logging.register_options(cfg.CONF) cfg.CONF(project='heat', prog='heat-engine', version=version.version_info.version_string()) if setup_logging: logging.setup(cfg.CONF, 'heat-engine') logging.set_defaults() messaging.setup() config.startup_sanity_check() mgr = None try: mgr = template._get_template_extension_manager() except template.TemplatePluginNotRegistered as ex: LOG.critical("%s", ex) if not mgr or not mgr.names(): sys.exit("ERROR: No template format plugins registered") from heat.engine import service as engine # noqa profiler.setup('heat-engine', cfg.CONF.host) gmr.TextGuruMeditation.setup_autorun(version) srv = engine.EngineService(cfg.CONF.host, rpc_api.ENGINE_TOPIC) workers = cfg.CONF.num_engine_workers if not workers: workers = max(4, processutils.get_worker_count()) launcher = service.launch(cfg.CONF, srv, workers=workers, restart_method='mutate') return launcher
def main(): CONF.register_cli_opts(IMPORT_OPTS) try: log.register_options(CONF) except cfg.ArgsAlreadyParsedError: pass log.setup(CONF, 'storyboard') CONF(project='storyboard') # only_tags and exclude_tags are mutually exclusive if CONF.only_tags and CONF.exclude_tags: print('ERROR: only-tags and exclude-tags are mutually exclusive', file=sys.stderr) exit(1) # If the user requested an autoincrement value, set that before we start # importing things. Note that mysql will automatically set the # autoincrement to the next-available id equal to or larger than the # requested one. auto_increment = CONF.auto_increment if auto_increment: print('Setting stories.AUTO_INCREMENT to %d' % (auto_increment,)) session = db_api.get_session(in_request=False) session.execute('ALTER TABLE stories AUTO_INCREMENT = %d;' % (auto_increment,)) if CONF.origin is 'launchpad': loader = LaunchpadLoader(CONF.from_project, CONF.to_project, set(CONF.only_tags), set(CONF.exclude_tags)) loader.run() else: print('Unsupported import origin: %s' % CONF.origin) return
def subscribe(): try: log.register_options(CONF) except cfg.ArgsAlreadyParsedError: pass log.setup(CONF, 'storyboard') CONF(project='storyboard') CONF.register_opts(NOTIFICATION_OPTS, "notifications") subscriber = Subscriber(CONF.notifications) subscriber.start() manager = enabled.EnabledExtensionManager( namespace='storyboard.plugin.worker', check_func=check_enabled, invoke_on_load=True, invoke_args=(CONF,) ) while subscriber.started: (method, properties, body) = subscriber.get() if not method or not properties: LOG.debug(_("No messages available, sleeping for 5 seconds.")) time.sleep(5) continue manager.map(handle_event, body) # Ack the message subscriber.ack(method.delivery_tag)
def main(): """Parse options and call the appropriate class/method.""" CONF.register_cli_opt(category_opt) script_name = sys.argv[0] if len(sys.argv) < 2: print(_("\nOpenStack manila version: %(version)s\n") % {'version': version.version_string()}) print(script_name + " category action [<args>]") print(_("Available categories:")) for category in CATEGORIES: print("\t%s" % category) sys.exit(2) try: log.register_options(CONF) CONF(sys.argv[1:], project='manila', version=version.version_string()) log.setup(CONF, "manila") except cfg.ConfigFilesNotFoundError as e: cfg_files = e.config_files print(_("Failed to read configuration file(s): %s") % cfg_files) sys.exit(2) fn = CONF.category.action_fn fn_args = fetch_func_args(fn) fn(*fn_args)
def __init__(self, parse_conf=True, config_path=None): """Initialize a configuration from a conf directory and conf file.""" super(TempestConfigPrivate, self).__init__() config_files = [] failsafe_path = "/etc/tempest/" + self.DEFAULT_CONFIG_FILE if config_path: path = config_path else: # 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): path = failsafe_path # only parse the config file if we expect one to exist. This is needed # to remove an issue with the config file up to date checker. if parse_conf: config_files.append(path) logging.register_options(_CONF) if os.path.isfile(path): _CONF([], project="tempest", default_config_files=config_files) else: _CONF([], project="tempest") logging.setup(_CONF, "tempest") LOG = logging.getLogger("tempest") LOG.info("Using tempest config file %s" % path) register_opts() self._set_attrs() if parse_conf: _CONF.log_opt_values(LOG, std_logging.DEBUG)
def register_cli_opts(): cfg.CONF.register_cli_opts(core_cli_opts) logging.register_options(cfg.CONF)
def setUp(self): super(TestDvrRouterOperations, self).setUp() mock.patch('eventlet.spawn').start() self.conf = agent_config.setup_conf() self.conf.register_opts(base_config.core_opts) log.register_options(self.conf) self.conf.register_opts(agent_config.AGENT_STATE_OPTS, 'AGENT') self.conf.register_opts(l3_config.OPTS) self.conf.register_opts(ha.OPTS) agent_config.register_interface_driver_opts_helper(self.conf) agent_config.register_use_namespaces_opts_helper(self.conf) agent_config.register_process_monitor_opts(self.conf) self.conf.register_opts(interface.OPTS) self.conf.register_opts(external_process.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.set_override('state_path', '') self.device_exists_p = mock.patch( 'neutron.agent.linux.ip_lib.device_exists') self.device_exists = self.device_exists_p.start() self.ensure_dir = mock.patch('neutron.agent.linux.utils' '.ensure_dir').start() mock.patch('neutron.agent.linux.keepalived.KeepalivedManager' '.get_full_config_file_path').start() self.utils_exec_p = mock.patch('neutron.agent.linux.utils.execute') self.utils_exec = self.utils_exec_p.start() self.utils_replace_file_p = mock.patch( 'neutron.agent.linux.utils.replace_file') self.utils_replace_file = self.utils_replace_file_p.start() self.external_process_p = mock.patch( 'neutron.agent.linux.external_process.ProcessManager') self.external_process = self.external_process_p.start() self.process_monitor = mock.patch( 'neutron.agent.linux.external_process.ProcessMonitor').start() self.send_adv_notif_p = mock.patch( 'neutron.agent.linux.ip_lib.send_ip_addr_adv_notif') self.send_adv_notif = self.send_adv_notif_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 ip_rule = mock.patch('neutron.agent.linux.ip_lib.IPRule').start() self.mock_rule = mock.MagicMock() ip_rule.return_value = self.mock_rule ip_dev = mock.patch('neutron.agent.linux.ip_lib.IPDevice').start() self.mock_ip_dev = mock.MagicMock() ip_dev.return_value = self.mock_ip_dev self.l3pluginApi_cls_p = mock.patch( 'neutron.agent.l3.agent.L3PluginApi') l3pluginApi_cls = self.l3pluginApi_cls_p.start() self.plugin_api = mock.MagicMock() l3pluginApi_cls.return_value = self.plugin_api self.looping_call_p = mock.patch( 'neutron.openstack.common.loopingcall.FixedIntervalLoopingCall') self.looping_call_p.start() subnet_id_1 = _uuid() subnet_id_2 = _uuid() self.snat_ports = [{ 'subnets': [{ 'cidr': '152.2.0.0/16', 'gateway_ip': '152.2.0.1', 'id': subnet_id_1 }], 'network_id': _uuid(), 'device_owner': 'network:router_centralized_snat', 'mac_address': 'fa:16:3e:80:8d:80', 'fixed_ips': [{ 'subnet_id': subnet_id_1, 'ip_address': '152.2.0.13', 'prefixlen': 16 }], 'id': _uuid(), 'device_id': _uuid() }, { 'subnets': [{ 'cidr': '152.10.0.0/16', 'gateway_ip': '152.10.0.1', 'id': subnet_id_2 }], 'network_id': _uuid(), 'device_owner': 'network:router_centralized_snat', 'mac_address': 'fa:16:3e:80:8d:80', 'fixed_ips': [{ 'subnet_id': subnet_id_2, 'ip_address': '152.10.0.13', 'prefixlen': 16 }], 'id': _uuid(), 'device_id': _uuid() }] self.ri_kwargs = { 'agent_conf': self.conf, 'interface_driver': self.mock_driver } self._callback_manager = manager.CallbacksManager() mock.patch.object(registry, '_get_callback_manager', return_value=self._callback_manager).start()
ks_loading.register_auth_conf_options(cfg.CONF, NOVA_CONF_SECTION) ks_loading.register_session_conf_options(cfg.CONF, NOVA_CONF_SECTION) # Register the nova configuration options common_config.register_nova_opts() ks_loading.register_auth_conf_options(cfg.CONF, common_config.PLACEMENT_CONF_SECTION) ks_loading.register_session_conf_options(cfg.CONF, common_config.PLACEMENT_CONF_SECTION) # Register the placement configuration options common_config.register_placement_opts() logging.register_options(cfg.CONF) def init(args, default_config_files=None, **kwargs): cfg.CONF(args=args, project='neutron', version='%%(prog)s %s' % version.version_info.release_string(), default_config_files=default_config_files, **kwargs) n_rpc.init(cfg.CONF) # Validate that the base_mac is of the correct format msg = validators.validate_regex(cfg.CONF.base_mac, validators.MAC_PATTERN) if msg: msg = _("Base MAC: %s") % msg
def register_reconn_opts(): '''Register oslo logger opts & cli opts and reconn default opts & cli opts ''' global _default_action_message_format _default_message_format_help = "Default format of message for all " \ "survey action group. Message will be composed " \ "of this format on matched pattern. " \ "Variables within {} will be substituted " \ "with its value. These variables should " \ "be part of msg_user_data option. Fields " \ "{timestamp}, {line} and {matched_pattern} " \ "are computed. Field {name} is substituted " \ "by the value defined for parameter name " \ "of matching survey config group. " \ "Rest all characters will be sent as it is in message. " \ "Logging { or } requires escape by doubling " \ "{{, }}. Defaults to :" + _default_action_message_format logging.register_options(CONF) reconn_opts = [ cfg.StrOpt('target_file', required=True, default=None, help='Absolute file path of console.log ' 'of a VM instance, RECONN is supposed ' 'to stream read and look out for VM ' 'boot up stage'), cfg.IntOpt('timeout', default=20, help='terminate reconn after timeout minutes. ' 'Defaults to 20 minutes'), cfg.StrOpt('survey_action_message_format', default=_default_action_message_format, help=_default_message_format_help), cfg.DictOpt('msg_user_data', default={}, help="User data is a set of key:value pairs, where the " "key is looked up in survey_action_message_format " "string within {} and it is substituted with the " "value. This helps in forming " "custom message to be sent to RMQ"), cfg.StrOpt('end_reconn', default=None, help='A [CONFIG] group name that defines a ' 'parameter called "pattern" which is an ' 'regular expression that will be looked ' 'out in file. On encountering end reconn ' 'pattern, reconn will be stopped'), cfg.StrOpt('survey_group', required=True, default=None, help='Survey pattern groups name'), ] CONF.register_opts(reconn_opts) CONF.register_cli_opts(reconn_opts[:-2])
$ gunicorn zaqar.transport.wsgi.app:app NOTE: As for external containers, it is necessary to put config files in the standard paths. There's no common way to specify / pass configuration files to the WSGI app when it is called from other apps. """ from oslo_config import cfg from oslo_log import log from oslo_reports import guru_meditation_report as gmr from oslo_reports import opts as gmr_opts from zaqar import bootstrap from zaqar import version # Use the global CONF instance conf = cfg.CONF gmr_opts.set_defaults(conf) log.register_options(conf) conf(project='zaqar', prog='zaqar-queues', args=[]) log.setup(conf, 'zaqar') gmr.TextGuruMeditation.setup_autorun(version, conf=conf) boot = bootstrap.Bootstrap(conf) conf.drivers.transport = 'wsgi' application = boot.transport.app # Keep the old name for compatibility app = application
def parse_args(argv, default_config_files=None): log.register_options(CONF) CONF(argv[1:], project='prometheus-alertmanager-dingtalk', version='0.1', default_config_files=default_config_files)
def setUp(self): super(TestDvrRouterOperations, self).setUp() mock.patch('eventlet.spawn').start() self.conf = agent_config.setup_conf() self.conf.register_opts(base_config.core_opts) log.register_options(self.conf) self.conf.register_opts(agent_config.AGENT_STATE_OPTS, 'AGENT') l3_config.register_l3_agent_config_opts(l3_config.OPTS, self.conf) ha_conf.register_l3_agent_ha_opts(self.conf) agent_config.register_interface_driver_opts_helper(self.conf) agent_config.register_process_monitor_opts(self.conf) agent_config.register_interface_opts(self.conf) agent_config.register_external_process_opts(self.conf) self.conf.set_override('interface_driver', 'neutron.agent.linux.interface.NullDriver') self.conf.set_override('state_path', cfg.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.ensure_dir = mock.patch( 'oslo_utils.fileutils.ensure_tree').start() mock.patch('neutron.agent.linux.keepalived.KeepalivedManager' '.get_full_config_file_path').start() self.utils_exec_p = mock.patch('neutron.agent.linux.utils.execute') self.utils_exec = self.utils_exec_p.start() self.utils_replace_file_p = mock.patch( 'neutron_lib.utils.file.replace_file') self.utils_replace_file = self.utils_replace_file_p.start() self.external_process_p = mock.patch( 'neutron.agent.linux.external_process.ProcessManager') self.external_process = self.external_process_p.start() self.process_monitor = mock.patch( 'neutron.agent.linux.external_process.ProcessMonitor').start() self.send_adv_notif_p = mock.patch( 'neutron.agent.linux.ip_lib.send_ip_addr_adv_notif') self.send_adv_notif = self.send_adv_notif_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.mock_delete_ip_rule = mock.patch.object(ip_lib, 'delete_ip_rule').start() ip_dev = mock.patch('neutron.agent.linux.ip_lib.IPDevice').start() self.mock_ip_dev = mock.MagicMock() ip_dev.return_value = self.mock_ip_dev self.l3pluginApi_cls_p = mock.patch( 'neutron.agent.l3.agent.L3PluginApi') l3pluginApi_cls = self.l3pluginApi_cls_p.start() self.plugin_api = mock.MagicMock() l3pluginApi_cls.return_value = self.plugin_api self.looping_call_p = mock.patch( 'oslo_service.loopingcall.FixedIntervalLoopingCall') self.looping_call_p.start() subnet_id_1 = _uuid() subnet_id_2 = _uuid() self.snat_ports = [{ 'subnets': [{ 'cidr': '152.2.0.0/16', 'gateway_ip': '152.2.0.1', 'id': subnet_id_1 }], 'network_id': _uuid(), 'device_owner': lib_constants.DEVICE_OWNER_ROUTER_SNAT, 'mac_address': 'fa:16:3e:80:8d:80', 'fixed_ips': [{ 'subnet_id': subnet_id_1, 'ip_address': '152.2.0.13', 'prefixlen': 16 }], 'id': _uuid(), 'device_id': _uuid() }, { 'subnets': [{ 'cidr': '152.10.0.0/16', 'gateway_ip': '152.10.0.1', 'id': subnet_id_2 }], 'network_id': _uuid(), 'device_owner': lib_constants.DEVICE_OWNER_ROUTER_SNAT, 'mac_address': 'fa:16:3e:80:8d:80', 'fixed_ips': [{ 'subnet_id': subnet_id_2, 'ip_address': '152.10.0.13', 'prefixlen': 16 }], 'id': _uuid(), 'device_id': _uuid() }] self.ri_kwargs = { 'agent_conf': self.conf, 'interface_driver': self.mock_driver }
def setUp(self): super(FaultMiddlewareTest, self).setUp() log.register_options(cfg.CONF)
def setup(self): logging.register_options(CONF) CONF(sys.argv[1:], version=self.version) logging.setup(CONF, self.name)
def launch(conf, config_file="/etc/monasca/api-config.conf"): log.register_options(cfg.CONF) log.set_defaults() cfg.CONF(args=[], project='monasca_api', default_config_files=[config_file]) log.setup(cfg.CONF, 'monasca_api') app = falcon.API() versions = simport.load(cfg.CONF.dispatcher.versions)() app.add_route("/", versions) app.add_route("/{version_id}", versions) # The following resource is a workaround for a regression in falcon 0.3 # which causes the path '/v2.0' to not route to the versions resource version_2_0 = simport.load(cfg.CONF.dispatcher.version_2_0)() app.add_route("/v2.0", version_2_0) metrics = simport.load(cfg.CONF.dispatcher.metrics)() app.add_route("/v2.0/metrics", metrics) metrics_measurements = simport.load( cfg.CONF.dispatcher.metrics_measurements)() app.add_route("/v2.0/metrics/measurements", metrics_measurements) metrics_statistics = simport.load(cfg.CONF.dispatcher.metrics_statistics)() app.add_route("/v2.0/metrics/statistics", metrics_statistics) metrics_names = simport.load(cfg.CONF.dispatcher.metrics_names)() app.add_route("/v2.0/metrics/names", metrics_names) alarm_definitions = simport.load(cfg.CONF.dispatcher.alarm_definitions)() app.add_route("/v2.0/alarm-definitions/", alarm_definitions) app.add_route("/v2.0/alarm-definitions/{alarm_definition_id}", alarm_definitions) alarms = simport.load(cfg.CONF.dispatcher.alarms)() app.add_route("/v2.0/alarms", alarms) app.add_route("/v2.0/alarms/{alarm_id}", alarms) alarm_count = simport.load(cfg.CONF.dispatcher.alarms_count)() app.add_route("/v2.0/alarms/count/", alarm_count) alarms_state_history = simport.load( cfg.CONF.dispatcher.alarms_state_history)() app.add_route("/v2.0/alarms/state-history", alarms_state_history) app.add_route("/v2.0/alarms/{alarm_id}/state-history", alarms_state_history) notification_methods = simport.load( cfg.CONF.dispatcher.notification_methods)() app.add_route("/v2.0/notification-methods", notification_methods) app.add_route("/v2.0/notification-methods/{notification_method_id}", notification_methods) dimension_values = simport.load(cfg.CONF.dispatcher.dimension_values)() app.add_route("/v2.0/metrics/dimensions/names/values", dimension_values) dimension_names = simport.load(cfg.CONF.dispatcher.dimension_names)() app.add_route("/v2.0/metrics/dimensions/names", dimension_names) notification_method_types = simport.load( cfg.CONF.dispatcher.notification_method_types)() app.add_route("/v2.0/notification-methods/types", notification_method_types) LOG.debug('Dispatcher drivers have been added to the routes!') return app
def config(args=[]): CONF.register_opts(_COMMON) CONF.register_cli_opts(_COMMON) log.register_options(CONF) CONF(args=args, project='freezer', version=FREEZER_VERSION)
def _setup_logger(args=None): args = [] if args is None else args log.register_options(CONF) opts.set_config_defaults() opts.parse_args(args) log.setup(CONF, 'ironic_inspector')
def _setup_logging(): # TODO(aznashwan): setup logging for OpenStack client libs too: logging.register_options(conf.CONF) logging.setup(conf.CONF, 'coriolis')
# Copyright 2018 Cloudbase Solutions Srl # All Rights Reserved. import argparse from oslo_log import log as logging from coriolis_openstack_utils import actions from coriolis_openstack_utils import conf from coriolis_openstack_utils import constants # Setup logging: logging.register_options(conf.CONF) logging.setup(conf.CONF, 'coriolis') LOG = logging.getLogger(__name__) # Setup argument parsing: PARSER = argparse.ArgumentParser(description="Coriolis Openstack utils.") PARSER.add_argument("-v", "--verbose", action="store_true", help="Increase log verbosity") PARSER.add_argument("--config-file", metavar="CONF_FILE", dest="conf_file", help="Path to the config file.") PARSER.add_argument( "--dont-recreate-tenants", dest="dont_recreate_tenants", default=False, action="store_true",
def main(): if len(sys.argv) == 1: print('Error: Config file must be specified.') print('a10_nlbaas2oct --config-file <filename>') return 1 logging.register_options(cfg.CONF) cfg.CONF(args=sys.argv[1:], project='a10_nlbaas2oct', version='a10_nlbaas2oct 1.0') logging.set_defaults() logging.setup(cfg.CONF, 'a10_nlbaas2oct') LOG = logging.getLogger('a10_nlbaas2oct') CONF.log_opt_values(LOG, logging.DEBUG) XOR_CLI_COMMANDS = (CONF.all, CONF.lb_id, CONF.project_id) if CONF.flavor_id and not CONF.lb_id: print('Error: --lb-id should be specified with --flavor-id') return 1 if not any(XOR_CLI_COMMANDS) and not CONF.migration.lb_id_list: print('Error: One of --all, --lb-id, --project-id must be ' 'specified or lb_id_list must be set in the config file.') return 1 if CONF.flavor_id and (XOR_CLI_COMMANDS[0] or XOR_CLI_COMMANDS[2]): print( 'Error: --flavor-id can only be used in conjunction with --lb-id') return 1 if CONF.migration.flavor_id_list and CONF.migration.lb_id_list: if len(CONF.migration.flavor_id_list) > len(CONF.migration.lb_id_list): print('Error: flavor_id_list cannot be mapped with lb_id_list ' 'as flavor_id_list holds more entries than lb_id_list') return 1 check_multi = lambda x: bool(x) commands = list(filter(check_multi, XOR_CLI_COMMANDS)) if len(commands) > 1: print('Error: Only one of --all, --lb-id, --project-id allowed.') return 1 elif len(commands) == 1: if CONF.migration.lb_id_list and not (CONF.lb_id or CONF.cleanup): print( 'Error: Only --lb-id and --cleanup are allowed with lb_id_list set in the config file.' ) return CLEANUP_ONLY = False if CONF.cleanup: full_success_msg, lb_success_msg = _cleanup_confirmation(LOG) if full_success_msg and lb_success_msg: CLEANUP_ONLY = True else: print('Exiting...') return else: LOG.info('=== Starting migration ===') full_success_msg = '\n\nMigration completed successfully' lb_success_msg = 'migration of loadbalancer %s' db_sessions = _setup_db_sessions() n_session = db_sessions['n_session'] o_session = db_sessions['o_session'] a10_config = a10_cfg.A10Config(config_path=CONF.migration.a10_config_path, provider=CONF.migration.provider_name) conf_lb_id_list = CONF.migration.lb_id_list if not conf_lb_id_list: conf_lb_id_list = [] if CONF.lb_id and CONF.lb_id not in conf_lb_id_list: conf_lb_id_list.append(CONF.lb_id) if CONF.project_id and db_sessions.get('k_session'): if not db_utils.get_project_entry(db_sessions['k_session'], CONF.project_id): print('Error: Provide valid --project-id value.') return lb_id_list = db_utils.get_loadbalancer_ids(n_session, conf_lb_id_list=conf_lb_id_list, conf_project_id=CONF.project_id, conf_all=CONF.all) conf_flavor_id_list = [] flavor_map = {} if CONF.migration.flavor_id_list and CONF.migration.lb_id_list: conf_flavor_id_list.extend(CONF.migration.flavor_id_list) fl_list_length = len(CONF.migration.flavor_id_list) lb_list_length = len(CONF.migration.lb_id_list) if fl_list_length < lb_list_length: if CONF.migration.default_flavor_id: for flavor_id in range(fl_list_length, lb_list_length): conf_flavor_id_list.insert( flavor_id, CONF.migration.default_flavor_id) fl_id = None fl_id_list = [] failure_count = 0 tenant_bindings = [] curr_device_name = None lb_idx = 0 for lb_id in lb_id_list: lb_id = lb_id[0] try: LOG.info('Locking Neutron LBaaS load balancer: %s', lb_id) db_utils.lock_loadbalancer(n_session, lb_id) n_lb = db_utils.get_loadbalancer_entry(n_session, lb_id) provider = n_lb[0] tenant_id = n_lb[1] tenant_name = None if not db_utils.get_project_entry(db_sessions['k_session'], tenant_id): LOG.info( 'Tenant with id %s does not exist. Attempting to lookup ' 'the tenant using %s as the name instead of id.', tenant_id, tenant_id) tenant_id = db_utils.get_tenant_by_name( db_sessions['k_session'], tenant_id) if not tenant_id: LOG.warning( 'Skipping loadbalancer with id %s. It is owned by a tenant with id ' 'or name %s that does not exist.', lb_id, n_lb[1]) continue elif len(tenant_id) > 1: LOG.warning( 'Skipping loadbalancer with id %s. It was created with the tenant name %s ' 'instead of tenant id. This tenant name is used by multiple projects so it ' 'cannot be looked up. Please update the loadbalancer tenant_id in the db to' 'match the intended tenant.', lb_id, n_lb[1]) continue else: tenant_name = n_lb[1] tenant_id = tenant_id[0][0] if provider != CONF.migration.provider_name: LOG.info( 'Skipping loadbalancer with provider %s. ' 'Does not match specified provider %s.', provider, CONF.migration.provider_name) continue tenant_device_binding = tenant_name if tenant_name else tenant_id tenant_bindings.append(tenant_device_binding) if not CLEANUP_ONLY: device_info = _migrate_device(LOG, a10_config, db_sessions, lb_id, tenant_id, tenant_device_binding) if not device_info: continue device_name = device_info['name'] fl_id = _flavor_selection(LOG, a10_config, o_session, lb_id, conf_flavor_id_list, lb_idx, flavor_map, device_name) _migrate_slb(LOG, n_session, o_session, lb_id, fl_id, tenant_id, n_lb, CONF.migration.ignore_l7rule_status) lb_idx = lb_idx + 1 _cleanup_slb(LOG, n_session, lb_id, CLEANUP_ONLY) # Rollback everything if we are in a trial run otherwise commit if CONF.migration.trial_run: o_session.rollback() n_session.rollback() LOG.info('Simulated ' + lb_success_msg + ' successful', lb_id) else: o_session.commit() n_session.commit() LOG.info('Successful ' + lb_success_msg, lb_id) except Exception as e: n_session.rollback() o_session.rollback() LOG.exception("Skipping load balancer %s due to: %s.", lb_id, str(e)) failure_count += 1 finally: # Attempt to unlock the loadbalancer even if an error occured or it was deleted. # This ensures we don't get stuck in pending states LOG.info('Unlocking Neutron LBaaS load balancer: %s', lb_id) db_utils.unlock_loadbalancer(n_session, lb_id) n_session.commit() failure_count += _cleanup_tenant_bindings( LOG, db_sessions['a10_nlbaas_session'], a10_config, tenant_bindings, CLEANUP_ONLY) if failure_count: LOG.warning("%d failures were detected", failure_count) sys.exit(1) print(full_success_msg)
def prepare_service(argv=None): if argv is None: argv = [] logging.register_options(cfg.CONF) cfg.CONF(argv[1:], project='magnum') logging.setup(cfg.CONF, 'magnum')
def main(): """Executes model's methods with corresponding parameters""" # we may add deepaas config, but then too many options... # config.config_and_logging(sys.argv) log.register_options(CONF) log.set_defaults(default_log_levels=log.get_default_log_levels()) CONF(sys.argv[1:], project='deepaas', version=deepaas.__version__) log.setup(CONF, "deepaas-cli") LOG.info("[INFO, Method] {} was called.".format(CONF.methods.name)) # put all variables in dict, makes life easier... conf_vars = vars(CONF._namespace) if CONF.deepaas_with_multiprocessing: mp.set_start_method('spawn', force=True) # TODO(multi-file): change to many files ('for' itteration) if CONF.methods.__contains__('files'): if CONF.methods.files: # create tmp file as later it supposed # to be deleted by the application temp = tempfile.NamedTemporaryFile() temp.close() # copy original file into tmp file with open(conf_vars['files'], "rb") as f: with open(temp.name, "wb") as f_tmp: for line in f: f_tmp.write(line) # create file object file_type = mimetypes.MimeTypes().guess_type(conf_vars['files'])[0] file_obj = v2_wrapper.UploadedFile( name="data", filename=temp.name, content_type=file_type, original_filename=conf_vars['files']) # re-write 'files' parameter in conf_vars conf_vars['files'] = file_obj # debug of input parameters LOG.debug("[DEBUG provided options, conf_vars]: {}".format(conf_vars)) if CONF.methods.name == 'get_metadata': meta = model_obj.get_metadata() meta_json = json.dumps(meta) LOG.debug("[DEBUG, get_metadata, Output]: {}".format(meta_json)) if CONF.deepaas_method_output: _store_output(meta_json, CONF.deepaas_method_output) return meta_json elif CONF.methods.name == 'warm': # await model_obj.warm() model_obj.warm() LOG.info("[INFO, warm] Finished warm() method") elif CONF.methods.name == 'predict': # call predict method predict_vars = _get_subdict(conf_vars, predict_args) task = model_obj.predict(**predict_vars) if CONF.deepaas_method_output: out_file = CONF.deepaas_method_output out_path = os.path.dirname(os.path.abspath(out_file)) if not os.path.exists(out_path): # Create path if does not exist os.makedirs(out_path) # check extension of the output file out_filename, out_extension = os.path.splitext(out_file) # set default extension for the data returned # by the application to .json extension = ".json" # check what is asked to return by the application (if --accept) if CONF.methods.__contains__('accept'): if CONF.methods.accept: extension = mimetypes.guess_extension(CONF.methods.accept) if (extension is not None and out_extension is not None and extension != out_extension): # noqa: W503 out_file = out_file + extension LOG.warn("[WARNING] You are trying to store {} " "type data in the file " "with {} extension!\n" "===================> " "New output is {}".format(extension, out_extension, out_file)) if extension == ".json" or extension is None: results_json = json.dumps(task) LOG.debug("[DEBUG, predict, Output]: {}".format(results_json)) f = open(out_file, "w+") f.write(results_json) f.close() else: out_results = task.name shutil.copy(out_results, out_file) LOG.info("[INFO, Output] Output is saved in {}".format(out_file)) return task elif CONF.methods.name == 'train': train_vars = _get_subdict(conf_vars, train_args) start = time.time() task = model_obj.train(**train_vars) LOG.info("[INFO] Elapsed time: %s", str(time.time() - start)) # we assume that train always returns JSON results_json = json.dumps(task) LOG.debug("[DEBUG, train, Output]: {}".format(results_json)) if CONF.deepaas_method_output: _store_output(results_json, CONF.deepaas_method_output) return results_json else: LOG.warn("[WARNING] No Method was requested! Return get_metadata()") meta = model_obj.get_metadata() meta_json = json.dumps(meta) LOG.debug("[DEBUG, get_metadata, Output]: {}".format(meta_json)) return meta_json
def read_config(prog, argv): logging.register_options(cfg.CONF) config_files = find_config('%s.conf' % prog) cfg.CONF(argv[1:], project='designate', prog=prog, default_config_files=config_files) config.set_defaults()
def init(args, **kwargs): # Register the configuration options logging.register_options(cfg.CONF) cfg.CONF(args=args, project='valence', **kwargs)
# under the License. import eventlet eventlet.monkey_patch() import argparse import ConfigParser from gbpservice.nfp.core import log as nfp_logging import os from oslo_config import cfg from oslo_log import log as oslo_logging import socket import sys import time oslo_logging.register_options(cfg.CONF) LOG = nfp_logging.getLogger(__name__) # Queue of proxy connections which workers will handle ConnQ = eventlet.queue.Queue(maxsize=0) tcp_open_connection_count = 0 tcp_close_connection_count = 0 class ConnectionIdleTimeOut(Exception): ''' Exception raised when connection is idle for configured timeout ''' pass
def log_file(self, file_dir): logging.register_options(self.CONF) self.CONF(default_config_files=[file_dir]) logging.setup(self.CONF, __name__)
def parse_args(argv, default_config_files=None): logging.register_options(CONF) CONF(argv[1:], project='smart_proj', version='smart_ver 0.0.1', default_config_files=default_config_files)
# License for the specific language governing permissions and limitations # under the License. import eventlet eventlet.monkey_patch() from gbpservice._i18n import _ from gbpservice.nfp.core import log as nfp_logging import os from oslo_config import cfg as oslo_config from oslo_log import log as oslo_logging import socket import sys import time oslo_logging.register_options(oslo_config.CONF) if not hasattr(oslo_config.CONF, 'module'): module_opts = [ oslo_config.StrOpt('module', default='proxy', help='component name for logging.') ] oslo_config.CONF.register_opts(module_opts) LOG = nfp_logging.getLogger(__name__) # Queue of proxy connections which workers will handle ConnQ = eventlet.queue.Queue(maxsize=0) tcp_open_connection_count = 0
def init_log(self): logging.register_options(self.CONF) logging.setup(self.CONF, __name__)
def init(__file__, OPTS, argv=None): """ 标准的init, 初始化CONF和LOG :param __file__: :param OPTS: :return: """ self_package_name = get_package_name(__file__) # print self_package_name self_package_folder = get_script_location(__file__) # print self_package_folder SELF_PACKAGE_OPTS = [ cfg.StrOpt('self_package_name', default=self_package_name, help='the self package name'), cfg.StrOpt('self_package_folder', default=self_package_folder, help='the self package folder'), ] # done: important! 这里暂时设置为空, oslo.config强制检查argv, 最好是让他不检查 # done: 暂时使用backup_argv过后再还原的方式. backup_argv = [] backup_argv[:] = sys.argv sys.argv[1:] = [] CONF_FILE = self_package_name + '.conf' global get_logger # print __file__ CONF.register_opts(SELF_PACKAGE_OPTS) CONF.register_opts(OPTS) which_log = 'oslo' # which_log='smartlog' if which_log == 'smartlog': OPTS = [ # DEBUG False的时候会计算all. cfg.BoolOpt('debug', default=True, help='debug toggle') ] CONF.register_opts(OPTS) # todo: root level改了没用, 另外这一段需要在configfile之后才好. if CONF.debug: log_level = "DEBUG" else: log_level = "WARNING" # log的名字空间是全局的, 只根据名字来分级. 因此根log只要建立一下就行了. # LOG=get_logger(name=CONF.self_package_name,level=log_level,console=True) # 直接用root, 不然捕获不了general的信息. 默认的format在smartlg里面有. 需要的时候再在这里设置. set_root_logger(level=log_level) elif which_log == 'oslo': oslo_i18n.enable_lazy() log.register_options(CONF) log_levels = (CONF.default_log_levels + ['loader=ERROR']) # todo: oslo log格式如何调整. 以及如何设置各个log的级别. # done: 暂时使用自己的log log.set_defaults(default_log_levels=log_levels) log.setup(CONF, CONF.self_package_name) get_logger = log.getLogger else: print("please set which log system to use") exit(0) script_location = get_script_location(__file__) # Path configuration of labkit packages and config. # labkit 的 packages 和 config 的路径配置 config_file_location = os.path.join(os.environ['HOME'], '.labkit', 'config', self_package_name) config_folder = os.path.join(os.environ['HOME'], '.labkit', 'config') local_packages_folder = os.path.join(os.environ['HOME'], '.labkit', 'packages') packages_folder = os.path.dirname(os.path.dirname(self_package_folder)) OPTS = [ cfg.StrOpt('config_file_location', default=config_file_location, help='config file location'), cfg.StrOpt('local_packages_folder', default=local_packages_folder, help='local packages folder'), cfg.StrOpt('config_folder', default=config_folder, help='config folder'), cfg.StrOpt('packages_folder', default=packages_folder, help='labkit packages folder') ] CONF.register_opts(OPTS) config_files = [os.path.join(config_file_location, CONF_FILE)] # version=importlib.import_module(CONF.self_package_name+'.version') if argv is None: argv = sys.argv CONF(args=None, project=CONF.self_package_name, validate_default_values=False, # version=version.version_info.version_string(), default_config_files=config_files) sys.argv[:] = backup_argv[:]
def __init__(self): self.logger = LOG logging.register_options(CONF) logging.set_defaults(default_log_levels=CONF.default_log_levels) logging.setup(CONF, 'armada')
help=("Pass in your authentication token if you have " "one. This is the token used for the master.")), cfg.StrOpt('slavetoken', short='S', default='', help=("Pass in your authentication token if you have " "one. This is the token used for the slave.")), cfg.StrOpt('command', positional=True, help="Command to be given to replicator"), cfg.ListOpt('args', positional=True, help="Arguments for the command"), ] CONF = cfg.CONF CONF.register_cli_opts(cli_opts) logging.register_options(CONF) # If ../glance/__init__.py exists, add ../ to Python search path, so that # it will override what happens to be installed in /usr/(local/)lib/python... possible_topdir = os.path.normpath( os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)) if os.path.exists(os.path.join(possible_topdir, 'glance', '__init__.py')): sys.path.insert(0, possible_topdir) COMMANDS = """Commands: help <command> Output help for one of the commands below compare What is missing from the slave glance? dump Dump the contents of a glance instance to local disk. livecopy Load the contents of one glance instance into another.
def setUp(self): super(TestApp, self).setUp() self.CONF = self.useFixture(fixture_config.Config()).conf log.register_options(cfg.CONF)
def parse_args(argv, default_config_files=None): log.register_options(CONF) CONF(argv[1:], project='hagent', version='0.1', default_config_files=default_config_files)
def setUp(self): super(TestEvent, self).setUp() logging.register_options(cfg.CONF)