def create()

in osbenchmark/builder/supplier.py [0:0]

• 87 lines of code
• 16 McCabe index (conditional complexity)

def create(cfg, sources, distribution, provision_config_instance, plugins=None):
    logger = logging.getLogger(__name__)
    if plugins is None:
        plugins = []
    caching_enabled = cfg.opts("source", "cache", mandatory=False, default_value=True)
    revisions = _extract_revisions(cfg.opts("builder", "source.revision", mandatory=sources))
    distribution_version = cfg.opts("builder", "distribution.version", mandatory=False)
    supply_requirements = _supply_requirements(sources, distribution, plugins, revisions, distribution_version)
    build_needed = any([build for _, _, build in supply_requirements.values()])
    os_supplier_type, os_version, _ = supply_requirements["opensearch"]
    src_config = cfg.all_opts("source")
    suppliers = []

    target_os = cfg.opts("builder", "target.os", mandatory=False)
    target_arch = cfg.opts("builder", "target.arch", mandatory=False)

    template_renderer = TemplateRenderer(version=os_version, os_name=target_os, arch=target_arch)

    if build_needed:
        raw_build_jdk = provision_config_instance.mandatory_var("build.jdk")
        try:
            build_jdk = int(raw_build_jdk)
        except ValueError:
            raise exceptions.SystemSetupError(f"ProvisionConfigInstance config key [build.jdk] is invalid: [{raw_build_jdk}] (must be int)")

        os_src_dir = os.path.join(_src_dir(cfg), _config_value(src_config, "opensearch.src.subdir"))
        builder = Builder(os_src_dir, build_jdk, paths.logs())
    else:
        builder = None

    distributions_root = os.path.join(cfg.opts("node", "root.dir"), cfg.opts("source", "distribution.dir"))
    dist_cfg = {}
    # provision_config_instance / plugin defines defaults...
    dist_cfg.update(provision_config_instance.variables)
    for plugin in plugins:
        for k, v in plugin.variables.items():
            dist_cfg["plugin_{}_{}".format(plugin.name, k)] = v
    # ... but the user can override it in benchmark.ini
    dist_cfg.update(cfg.all_opts("distributions"))

    if caching_enabled:
        logger.info("Enabling source artifact caching.")
        max_age_days = int(cfg.opts("source", "cache.days", mandatory=False, default_value=7))
        if max_age_days <= 0:
            raise exceptions.SystemSetupError(f"cache.days must be a positive number but is {max_age_days}")

        source_distributions_root = os.path.join(distributions_root, "src")
        _prune(source_distributions_root, max_age_days)
    else:
        logger.info("Disabling source artifact caching.")
        source_distributions_root = None

    if os_supplier_type == "source":
        os_src_dir = os.path.join(_src_dir(cfg), _config_value(src_config, "opensearch.src.subdir"))

        source_supplier = OpenSearchSourceSupplier(os_version,
                                                      os_src_dir,
                                                      remote_url=cfg.opts("source", "remote.repo.url"),
                                                      provision_config_instance=provision_config_instance,
                                                      builder=builder,
                                                      template_renderer=template_renderer)

        if caching_enabled:
            os_file_resolver = OpenSearchFileNameResolver(dist_cfg, template_renderer)
            source_supplier = CachedSourceSupplier(source_distributions_root,
                                                   source_supplier,
                                                   os_file_resolver)

        suppliers.append(source_supplier)
        repo = None
    else:
        os_src_dir = None
        repo = DistributionRepository(name=cfg.opts("builder", "distribution.repository"),
                                      distribution_config=dist_cfg,
                                      template_renderer=template_renderer)
        suppliers.append(OpenSearchDistributionSupplier(repo, os_version, distributions_root))

    for plugin in plugins:
        supplier_type, plugin_version, _ = supply_requirements[plugin.name]

        if supplier_type == "source":
            if CorePluginSourceSupplier.can_handle(plugin):
                logger.info("Adding core plugin source supplier for [%s].", plugin.name)
                assert os_src_dir is not None, f"Cannot build core plugin {plugin.name} when OpenSearch is not built from source."
                plugin_supplier = CorePluginSourceSupplier(plugin, os_src_dir, builder)
            elif ExternalPluginSourceSupplier.can_handle(plugin):
                logger.info("Adding external plugin source supplier for [%s].", plugin.name)
                plugin_supplier = ExternalPluginSourceSupplier(plugin, plugin_version, _src_dir(cfg, mandatory=False), src_config, builder)
            else:
                raise exceptions.BenchmarkError("Plugin %s can neither be treated as core nor as external plugin. Requirements: %s" %
                                            (plugin.name, supply_requirements[plugin.name]))

            if caching_enabled:
                plugin_file_resolver = PluginFileNameResolver(plugin.name, plugin_version)
                plugin_supplier = CachedSourceSupplier(source_distributions_root,
                                                       plugin_supplier,
                                                       plugin_file_resolver)
            suppliers.append(plugin_supplier)
        else:
            logger.info("Adding plugin distribution supplier for [%s].", plugin.name)
            assert repo is not None, "Cannot benchmark plugin %s from a distribution version but OpenSearch from sources" % plugin.name
            suppliers.append(PluginDistributionSupplier(repo, plugin))

    return CompositeSupplier(suppliers)