Python utils.itersubclasses函数代码示例

 def get_runner(task, endpoint, config):
     """Returns instance of a scenario runner for execution type."""
     execution_type = config.get('execution', 'continuous')
     for runner in rutils.itersubclasses(ScenarioRunner):
         if execution_type == runner.__execution_type__:
             new_runner = runner(task, endpoint)
             return new_runner

def find_resource_managers(names=None, admin_required=None):
    """Returns resource managers.

    :param names: List of names in format <service> or <service>.<resource>
                  that is used for filtering resource manager classes
    :param admin_required: None -> returns all ResourceManagers
                           True -> returns only admin ResourceManagers
                           False -> returns only non admin ResourceManagers
    """
    names = set(names or [])

    resource_managers = []
    for manager in rutils.itersubclasses(base.ResourceManager):
        if admin_required is not None:
            if admin_required != manager._admin_required:
                continue

        if (manager._service in names
           or "%s.%s" % (manager._service, manager._resource) in names):
            resource_managers.append(manager)

    resource_managers.sort(key=lambda x: x._order)

    found_names = set()
    for mgr in resource_managers:
        found_names.add(mgr._service)
        found_names.add("%s.%s" % (mgr._service, mgr._resource))

    missing = names - found_names
    if missing:
        LOG.warning("Missing resource managers: %s" % ", ".join(missing))

    return resource_managers

def find_benchmark_scenario(query):
    """Find a scenario method by query.

    :param query: string with the name of the benchmark scenario being
                  searched. It can be either a full name (e.g,
                  'NovaServers.boot_server') or just a method name (e.g.,
                  'boot_server')
    :returns: method object or None if the query doesn't match any
              scenario method.
    """
    if "." in query:
        scenario_group, scenario_name = query.split(".", 1)
    else:
        scenario_group = None
        scenario_name = query

    if scenario_group:
        scenario_cls = find_benchmark_scenario_group(scenario_group)
        if hasattr(scenario_cls, scenario_name):
            return getattr(scenario_cls, scenario_name)
        else:
            return None
    else:
        for scenario_cls in utils.itersubclasses(scenarios_base.Scenario):
            if scenario_name in dir(scenario_cls):
                return getattr(scenario_cls, scenario_name)
        return None

 def get_provider(config, deployment):
     """Returns instance of vm provider by name."""
     name = config['type']
     for provider in utils.itersubclasses(ProviderFactory):
         if name == provider.__name__:
             return provider(deployment, config)
     raise exceptions.NoSuchVMProvider(vm_provider_name=name)

 def _get_descriptions(self, base_cls):
     descriptions = []
     for entity in utils.itersubclasses(base_cls):
         name = entity.__name__
         doc = utils.parse_docstring(entity.__doc__)
         description = doc["short_description"] or ""
         descriptions.append((name, description))
     return descriptions

 def get_by_name(name):
     """Returns Scenario class by name."""
     # TODO(msdubov): support approximate string matching
     #                (here and in other base classes).
     for scenario in utils.itersubclasses(Scenario):
         if name == scenario.__name__:
             return scenario
     raise exceptions.NoSuchScenario(name=name)

 def _find_substitution(self, query):
     max_distance = min(3, len(query) / 4)
     scenarios = scenario_base.Scenario.list_benchmark_scenarios()
     scenario_groups = list(set(s.split(".")[0] for s in scenarios))
     scenario_methods = list(set(s.split(".")[1] for s in scenarios))
     deploy_engines = [cls.__name__ for cls in utils.itersubclasses(
                       deploy.EngineFactory)]
     server_providers = [cls.__name__ for cls in utils.itersubclasses(
                         serverprovider.ProviderFactory)]
     candidates = (scenarios + scenario_groups + scenario_methods +
                   deploy_engines + server_providers)
     suggestions = []
     # NOTE(msdubov): Incorrect query may either have typos or be truncated.
     for candidate in candidates:
         if ((utils.distance(query, candidate) <= max_distance or
              candidate.startswith(query))):
             suggestions.append(candidate)
     return suggestions

 def validate(config):
     properties = dict([(c.OPTION_NAME, c.CONFIG_SCHEMA)
                        for c in utils.itersubclasses(SLA)])
     schema = {
         "type": "object",
         "properties": properties,
         "additionalProperties": False,
     }
     jsonschema.validate(config, schema)

 def get_provider(config, task):
     """Returns instance of vm provider by name."""
     name = config['name']
     for provider in utils.itersubclasses(ProviderFactory):
         if name == provider.__name__:
             provider = provider(config)
             provider.task = task
             return provider
     raise exceptions.NoSuchVMProvider(vm_provider_name=name)

 def get_engine(name, deployment):
     """Returns instance of a deploy engine with corresponding name."""
     for engine in utils.itersubclasses(EngineFactory):
         if name == engine.__name__:
             new_engine = engine(deployment)
             return new_engine
     LOG.error(_('Deployment %(uuid)s: Deploy engine for %(name)s '
                 'does not exist.') %
               {'uuid': deployment['uuid'], 'name': name})
     deployment.update_status(consts.DeployStatus.DEPLOY_FAILED)
     raise exceptions.NoSuchEngine(engine_name=name)

 def _get_descriptions(self, base_cls, subclass_filter=None):
     descriptions = []
     subclasses = utils.itersubclasses(base_cls)
     if subclass_filter:
         subclasses = filter(subclass_filter, subclasses)
     for entity in subclasses:
         name = entity.__name__
         doc = utils.parse_docstring(entity.__doc__)
         description = doc["short_description"] or ""
         descriptions.append((name, description))
     descriptions.sort(key=lambda d: d[0])
     return descriptions

    def test_itersubclasses(self):
        class A(object):
            pass

        class B(A):
            pass

        class C(A):
            pass

        class D(C):
            pass

        self.assertEqual([B, C, D], list(utils.itersubclasses(A)))

    def list_benchmark_scenarios():
        """Lists all the existing methods in the benchmark scenario classes.

        Returns the method names in format <Class name>.<Method name>, which
        is used in the test config.

        :returns: List of strings
        """
        utils.import_modules_from_package("rally.benchmark.scenarios")
        benchmark_scenarios = [
            ["%s.%s" % (scenario.__name__, method) for method in dir(scenario) if not method.startswith("_")]
            for scenario in utils.itersubclasses(Scenario)
        ]
        benchmark_scenarios_flattened = list(itertools.chain.from_iterable(benchmark_scenarios))
        return benchmark_scenarios_flattened

    def list_benchmark_scenarios():
        """Lists all the existing methods in the benchmark scenario classes.

        Returns the method names in format <Class name>.<Method name>, which
        is used in the test config.

        :returns: List of strings
        """
        benchmark_scenarios = [
            ["%s.%s" % (scenario.__name__, func)
             for func in dir(scenario) if Scenario.is_scenario(scenario, func)]
            for scenario in utils.itersubclasses(Scenario)
        ]
        benchmark_scenarios_flattened = list(itertools.chain.from_iterable(
                                                        benchmark_scenarios))
        return benchmark_scenarios_flattened

    def get_scenario_by_name(name):
        """Return benchmark scenario method by name.

        :param name: name of the benchmark scenario being searched for (either
                     a full name (e.g, 'NovaServers.boot_server') or just
                     a method name (e.g., 'boot_server')
        :returns: function object
        """
        if "." in name:
            scenario_group, scenario_name = name.split(".", 1)
            scenario_cls = Scenario.get_by_name(scenario_group)
            if Scenario.is_scenario(scenario_cls, scenario_name):
                return getattr(scenario_cls, scenario_name)
        else:
            for scenario_cls in utils.itersubclasses(Scenario):
                if Scenario.is_scenario(scenario_cls, name):
                    return getattr(scenario_cls, name)
        raise exceptions.NoSuchScenario(name=name)