Python Config.get方法代码示例

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
    def init():

        global log
        global kafka_producer

        if not log:
            log = create_logger(Config().get("logging"))

        if kafka_producer:
            raise Exception("XOSKafkaProducer already initialized")

        else:
            log.info(
                "Connecting to Kafka with bootstrap servers: %s"
                % Config.get("kafka_bootstrap_servers")
            )

            try:
                producer_config = {
                    "bootstrap.servers": ",".join(Config.get("kafka_bootstrap_servers"))
                }

                kafka_producer = confluent_kafka.Producer(**producer_config)

                log.info("Connected to Kafka: %s" % kafka_producer)

            except confluent_kafka.KafkaError as e:
                log.exception("Kafka Error: %s" % e)

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
 def test_config_not_initialized(self):
     """
     [XOS-Config] Raise if accessing properties without initialization
     """
     with self.assertRaises(Exception) as e:
         Config.get("database")
     self.assertEqual(e.exception.message, "[XOS-Config] Module has not been initialized")

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
def config_accessor_grpcapi():
    global orig_sigint

    grpcapi_endpoint = Config.get("accessor.endpoint")
    grpcapi_username = Config.get("accessor.username")
    grpcapi_password = Config.get("accessor.password")

    # if password starts with "@", then retreive the password from a file
    if grpcapi_password.startswith("@"):
        fn = grpcapi_password[1:]
        if not os.path.exists(fn):
            raise Exception("%s does not exist" % fn)
        grpcapi_password = open(fn).readline().strip()

    from xosapi.xos_grpc_client import SecureClient
    from twisted.internet import reactor

    grpcapi_client = SecureClient(endpoint=grpcapi_endpoint, username=grpcapi_username, password=grpcapi_password)
    grpcapi_client.set_reconnect_callback(functools.partial(grpcapi_reconnect, grpcapi_client, reactor))
    grpcapi_client.start()

    # Start reactor. This will cause the client to connect and then execute
    # grpcapi_callback().

    # Reactor will take over SIGINT during reactor.run(), but does not return it when reactor.stop() is called.

    orig_sigint = signal.getsignal(signal.SIGINT)

    # Start reactor. This will cause the client to connect and then execute
    # grpcapi_callback().

    reactor.run()

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
 def test_config_override(self):
     """
     [XOS-Config] If an override is provided for the config, it should return the overridden value
     """
     Config.init(sample_conf, "xos-config-schema.yaml", override_conf)
     res = Config.get("logging.level")
     self.assertEqual(res, "info")
     res = Config.get("database.password")
     self.assertEqual(res, "overridden_password")

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
    def test_config_extend(self):
        """
        [XOS-Config] If an override is provided for the config, it should
        return the overridden value (also if not defined in the base one)
        """

        Config.init(sample_conf, "xos-config-schema.yaml", extend_conf)
        res = Config.get("xos_dir")
        self.assertEqual(res, "/opt/xos")
        res = Config.get("database.password")
        self.assertEqual(res, "safe")

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
    def __init__(self,user=None,clientid=None):

        user = Config.get("feefie.client_user")

        try:
            clid = Config.get("feefie.client_id")
        except:
            clid = get_random_client_id()
            print "EventSender: no feefie_client_id configured. Using random id %s" % clid

        if fofum_enabled:
            self.fofum = Fofum(user=user)
            self.fofum.make(clid)

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
def config_accessor():
    accessor_kind = Config.get("accessor.kind")

    if accessor_kind == "testframework":
        config_accessor_mock()
    elif accessor_kind == "grpcapi":
        config_accessor_grpcapi()
    else:
        raise Exception("Unknown accessor kind %s" % accessor_kind)

    # now import any wrappers that the synchronizer needs to add to the ORM
    if Config.get("wrappers"):
        for wrapper_name in Config.get("wrappers"):
            importlib.import_module(wrapper_name)

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
    def load_dependency_graph(self):

        try:
            if Config.get("dependency_graph"):
                self.log.debug(
                    "Loading model dependency graph",
                    path=Config.get("dependency_graph"),
                )
                dep_graph_str = open(Config.get("dependency_graph")).read()
            else:
                self.log.debug("Using default model dependency graph", graph={})
                dep_graph_str = "{}"

            # joint_dependencies is of the form { Model1 -> [(Model2, src_port, dst_port), ...] }
            # src_port is the field that accesses Model2 from Model1
            # dst_port is the field that accesses Model1 from Model2
            static_dependencies = json.loads(dep_graph_str)
            dynamic_dependencies = (
                []
            )  # Dropped Service and ServiceInstance dynamic dependencies

            joint_dependencies = dict(
                list(static_dependencies.items()) + dynamic_dependencies
            )

            model_dependency_graph = DiGraph()
            for src_model, deps in joint_dependencies.items():
                for dep in deps:
                    dst_model, src_accessor, dst_accessor = dep
                    if src_model != dst_model:
                        edge_label = {
                            "src_accessor": src_accessor,
                            "dst_accessor": dst_accessor,
                        }
                        model_dependency_graph.add_edge(
                            src_model, dst_model, **edge_label
                        )

            model_dependency_graph_rev = model_dependency_graph.reverse(copy=True)
            self.model_dependency_graph = {
                # deletion
                True: model_dependency_graph_rev,
                False: model_dependency_graph,
            }
            self.log.debug("Loaded dependencies", edges=model_dependency_graph.edges())
        except Exception as e:
            self.log.exception("Error loading dependency graph", e=e)
            raise e

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
 def _test_get_child_level(self):
     """
     [XOS-Config] Should return a child level param
     """
     Config.init(sample_conf)
     res = Config.get("nested.parameter.for")
     self.assertEqual(res, "testing")

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
def run_playbook(ansible_hosts, ansible_config, fqp, opts):
    args = {"ansible_hosts": ansible_hosts,
            "ansible_config": ansible_config,
            "fqp": fqp,
            "opts": opts,
            "config_file": Config.get_config_file()}

    keep_temp_files = Config.get("keep_temp_files")

    dir = tempfile.mkdtemp()
    args_fn = None
    result_fn = None
    try:
        log.info("creating args file",dir = dir)

        args_fn = os.path.join(dir, "args")
        result_fn = os.path.join(dir, "result")

        open(args_fn, "w").write(pickle.dumps(args))

        ansible_main_fn = os.path.join(os.path.dirname(__file__), "ansible_main.py")

        os.system("python %s %s %s" % (ansible_main_fn, args_fn, result_fn))

        result = pickle.loads(open(result_fn).read())

        if hasattr(result, "exception"):
            log.error("Exception in playbook",exception = result["exception"])

        stats = result.get("stats", None)
        aresults = result.get("aresults", None)
    except Exception,e:
        log.exception("Exception running ansible_main")
        stats = None
        aresults = None

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
 def setUp(self):
     b = backend.Backend()
     steps_dir = Config.get("steps_dir")
     self.steps = b.load_sync_step_modules(steps_dir)
     self.synchronizer = event_loop.XOSObserver(self.steps)
     os.remove('/tmp/sync_ports')
     os.remove('/tmp/delete_ports')

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
def unload_models(client, reactor, version):
    # This function is called by a timer until it succeeds.
    log.info("unload_models initiated by timer")

    try:
        result = ModelLoadClient(client).unload_models(
            Config.get("name"),
            version=version,
            cleanup_behavior=ModelLoadClient.AUTOMATICALLY_CLEAN)

        log.debug("Unload response", result=result)

        if result.status in [result.SUCCESS, result.SUCCESS_NOTHING_CHANGED]:
            log.info("Models successfully unloaded. Exiting with status", code=0)
            sys.exit(0)

        if result.status == result.TRYAGAIN:
            log.info("TRYAGAIN received. Expect to try again in 30 seconds.")

    except Exception:
        # If the synchronizer is operational, then assume the ORM's restart_on_disconnect will deal with the
        # connection being lost.
        log.exception("Error while unloading. Expect to try again in 30 seconds.")

    Timer(30, functools.partial(unload_models, client, reactor, version)).start()

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
    def load_dependency_graph(self):
        dep_path = Config.get("dependency_graph")
        self.log.info('Loading model dependency graph', path = dep_path)

        try:
            dep_graph_str = open(dep_path).read()

            # joint_dependencies is of the form { Model1 -> [(Model2, src_port, dst_port), ...] }
            # src_port is the field that accesses Model2 from Model1
            # dst_port is the field that accesses Model1 from Model2
            joint_dependencies = json.loads(dep_graph_str)

            model_dependency_graph = DiGraph()
            for src_model, deps in joint_dependencies.items():
                for dep in deps:
                    dst_model, src_accessor, dst_accessor = dep
                    if src_model != dst_model:
                        edge_label = {'src_accessor': src_accessor,
                                      'dst_accessor': dst_accessor}
                        model_dependency_graph.add_edge(
                            src_model, dst_model, edge_label)

            model_dependency_graph_rev = model_dependency_graph.reverse(
                copy=True)
            self.model_dependency_graph = {
                # deletion
                True: model_dependency_graph_rev,
                False: model_dependency_graph
            }
            self.log.info("Loaded dependencies", edges = model_dependency_graph.edges())
        except Exception as e:
            self.log.exception("Error loading dependency graph", e = e)
            raise e

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
    def __init__(self, username=None, password=None, tenant=None, url=None, token=None, endpoint=None, controller=None,
                 cacert=None, admin=True, *args, **kwds):

        self.has_openstack = has_openstack
        self.url = controller.auth_url
        if admin:
            self.username = controller.admin_user
            self.password = controller.admin_password
            self.tenant = controller.admin_tenant
        else:
            self.username = None
            self.password = None
            self.tenant = None

        if username:
            self.username = username
        if password:
            self.password = password
        if tenant:
            self.tenant = tenant
        if url:
            self.url = url
        if token:
            self.token = token
        if endpoint:
            self.endpoint = endpoint

        if cacert:
            self.cacert = cacert
        else:
            self.cacert = Config.get("nova.ca_ssl_cert")

# 需要导入模块: from xosconfig import Config [as 别名]
# 或者: from xosconfig.Config import get [as 别名]
def update_diag(diag_class, loop_end=None, loop_start=None, syncrecord_start=None, sync_start=None,
                backend_status=None, backend_code=0):
    observer_name = Config.get("name")

    try:
        diag = diag_class.objects.filter(name=observer_name).first()
        if (not diag):
            if hasattr(diag_class.objects, "new"):
                # api style
                diag = diag_class.objects.new(name=observer_name)
            else:
                # django style
                diag = diag_class(name=observer_name)
        br_str = diag.backend_register
        if br_str:
            br = json.loads(br_str)
        else:
            br = {}
        if loop_end:
            br['last_run'] = loop_end
        if loop_end and loop_start:
            br['last_duration'] = loop_end - loop_start
        if syncrecord_start:
            br['last_syncrecord_start'] = syncrecord_start
        if sync_start:
            br['last_synchronizer_start'] = sync_start
        if backend_status:
            diag.backend_status = backend_status
        diag.backend_register = json.dumps(br)
        diag.save()
    except:
        log.exception("Exception in update_diag")
        traceback.print_exc()