conan-server 2.1.0__tar.gz → 2.2.0__tar.gz

{conan-server-2.1.0 → conan-server-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.1.0
+Version: 2.2.0
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/conan_api.py

@@ -1,6 +1,7 @@
 import sys
 
 from conan.api.subapi.cache import CacheAPI
+from conan.api.subapi.command import CommandAPI
 from conan.api.subapi.local import LocalAPI
 from conan.api.subapi.lockfile import LockfileAPI
 from conans import __version__ as client_version
@@ -39,6 +40,7 @@ class ConanAPI(object):
         migrator = ClientMigrator(self.cache_folder, Version(client_version))
         migrator.migrate()
 
+        self.command = CommandAPI(self)
         self.remotes = RemotesAPI(self)
         # Search recipes by wildcard and packages filtering by configuracion
         self.search = SearchAPI(self)

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/model.py

@@ -3,21 +3,25 @@ import json
 
 from conans.client.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
     RECIPE_VIRTUAL, BINARY_SKIP, BINARY_MISSING, BINARY_INVALID
-from conans.errors import ConanException
+from conans.errors import ConanException, NotFoundException
 from conans.model.package_ref import PkgReference
 from conans.model.recipe_ref import RecipeReference
 from conans.util.files import load
 from conans.model.version_range import VersionRange
 
+LOCAL_RECIPES_INDEX = "local-recipes-index"
+
 
 class Remote:
 
-    def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None):
+    def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None,
+                 remote_type=None):
         self.name = name  # Read only, is the key
         self.url = url
         self.verify_ssl = verify_ssl
         self.disabled = disabled
         self.allowed_packages = allowed_packages
+        self.remote_type = remote_type
 
     def __eq__(self, other):
         if other is None:
@@ -29,6 +33,9 @@ class Remote:
         allowed_msg = ""
         if self.allowed_packages:
             allowed_msg = ", Allowed packages: {}".format(", ".join(self.allowed_packages))
+        if self.remote_type == LOCAL_RECIPES_INDEX:
+            return "{}: {} [{}, Enabled: {}{}]".format(self.name, self.url, LOCAL_RECIPES_INDEX,
+                                                       not self.disabled, allowed_msg)
         return "{}: {} [Verify SSL: {}, Enabled: {}{}]".format(self.name, self.url, self.verify_ssl,
                                                                not self.disabled, allowed_msg)
 
@@ -278,7 +285,7 @@ class ListPattern:
 
     def check_refs(self, refs):
         if not refs and self.ref and "*" not in self.ref:
-            raise ConanException(f"Recipe '{self.ref}' not found")
+            raise NotFoundException(f"Recipe '{self.ref}' not found")
 
     def filter_rrevs(self, rrevs):
         if self._only_latest(self.rrev):

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/cache.py

@@ -6,14 +6,16 @@ from io import BytesIO
 
 from conan.api.model import PackagesList
 from conan.api.output import ConanOutput
+from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.integrity_check import IntegrityChecker
 from conans.client.cache.cache import ClientCache
+from conans.client.downloaders.download_cache import DownloadCache
 from conans.errors import ConanException
 from conans.model.package_ref import PkgReference
 from conans.model.recipe_ref import RecipeReference
 from conans.util.dates import revision_timestamp_now
-from conans.util.files import rmdir, gzopen_without_timestamps, mkdir
+from conans.util.files import rmdir, gzopen_without_timestamps, mkdir, remove
 
 
 class CacheAPI:
@@ -69,15 +71,17 @@ class CacheAPI:
         checker = IntegrityChecker(app)
         checker.check(package_list)
 
-    def clean(self, package_list, source=True, build=True, download=True, temp=True):
+    def clean(self, package_list, source=True, build=True, download=True, temp=True,
+              backup_sources=False):
         """
         Remove non critical folders from the cache, like source, build and download (.tgz store)
         folders.
         :param package_list: the package lists that should be cleaned
         :param source: boolean, remove the "source" folder if True
         :param build: boolean, remove the "build" folder if True
-        :param download: boolen, remove the "download (.tgz)" folder if True
+        :param download: boolean, remove the "download (.tgz)" folder if True
         :param temp: boolean, remove the temporary folders
+        :param backup_sources: boolean, remove the "source" folder if True
         :return:
         """
 
@@ -93,6 +97,10 @@ class CacheAPI:
                     info = os.path.join(folder, "p", "conaninfo.txt")
                     if not os.path.exists(manifest) or not os.path.exists(info):
                         rmdir(folder)
+        if backup_sources:
+            backup_files = self.conan_api.cache.get_backup_sources(package_list, exclude=False, only_upload=False)
+            for f in backup_files:
+                remove(f)
 
         for ref, ref_bundle in package_list.refs().items():
             ref_layout = app.cache.recipe_layout(ref)
@@ -183,6 +191,22 @@ class CacheAPI:
 
         return package_list
 
+    def get_backup_sources(self, package_list=None, exclude=True, only_upload=True):
+        """Get list of backup source files currently present in the cache,
+        either all of them if no argument, or filtered by those belonging to the references in the package_list
+
+        @param package_list: a PackagesList object to filter backup files from (The files should have been downloaded form any of the references in the package_list)
+        @param exclude: if True, exclude the sources that come from URLs present the core.sources:exclude_urls global conf
+        @param only_upload: if True, only return the files for packages that are set to be uploaded
+        """
+        config = self.conan_api.config.global_conf
+        download_cache_path = config.get("core.sources:download_cache")
+        download_cache_path = download_cache_path or HomePaths(
+            self.conan_api.cache_folder).default_sources_backup_folder
+        excluded_urls = config.get("core.sources:exclude_urls", check_type=list, default=[]) if exclude else []
+        download_cache = DownloadCache(download_cache_path)
+        return download_cache.get_backup_sources_files(excluded_urls, package_list, only_upload)
+
 
 def _resolve_latest_ref(app, ref):
     if ref.revision is None or ref.revision == "latest":

conan-server-2.2.0/conan/api/subapi/command.py

@@ -0,0 +1,24 @@
+from conans.errors import ConanException
+
+
+class CommandAPI:
+
+    def __init__(self, conan_api):
+        self.conan_api = conan_api
+        self.cli = None
+
+    def run(self, cmd):
+        if isinstance(cmd, str):
+            cmd = cmd.split()
+        if isinstance(cmd, list):
+            current_cmd = cmd[0]
+            args = cmd[1:]
+        else:
+            raise ConanException("Input of conan_api.command.run() should be a list or a string")
+        commands = getattr(self.cli, "_commands")  # to no make it public to users of Cli class
+        try:
+            command = commands[current_cmd]
+        except KeyError:
+            raise ConanException(f"Command {current_cmd} does not exist")
+
+        return command.run_cli(self.conan_api, args)

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/config.py

@@ -1,3 +1,4 @@
+import json
 import os
 import platform
 import textwrap
@@ -5,12 +6,18 @@ import yaml
 from jinja2 import Environment, FileSystemLoader
 
 from conan import conan_version
+from conan.api.output import ConanOutput
 from conans.client.conf import default_settings_yml
 from conan.internal.api import detect_api
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
+from conans.client.graph.graph import CONTEXT_HOST, RECIPE_VIRTUAL, Node
+from conans.client.graph.graph_builder import DepsGraphBuilder
+from conans.client.graph.profile_node_definer import consumer_definer
 from conans.errors import ConanException
 from conans.model.conf import ConfDefinition, BUILT_IN_CONFS
+from conans.model.pkg_type import PackageType
+from conans.model.recipe_ref import RecipeReference
 from conans.model.settings import Settings
 from conans.util.files import load, save
 
@@ -32,6 +39,66 @@ class ConfigAPI:
         configuration_install(app, path_or_url, verify_ssl, config_type=config_type, args=args,
                               source_folder=source_folder, target_folder=target_folder)
 
+    def install_pkg(self, ref, lockfile=None, force=False):
+        ConanOutput().warning("The 'conan config install-pkg' is experimental",
+                              warn_tag="experimental")
+        conan_api = self.conan_api
+        remotes = conan_api.remotes.list()  # ready to use remotes arguments
+        # Ready to use profiles as inputs, but NOT using profiles yet, empty ones
+        profile_host = profile_build = conan_api.profiles.get_profile([])
+
+        app = ConanApp(self.conan_api)
+
+        # Computation of a very simple graph that requires "ref"
+        conanfile = app.loader.load_virtual(requires=[RecipeReference.loads(ref)])
+        consumer_definer(conanfile, profile_build, profile_host)
+        root_node = Node(ref=None, conanfile=conanfile, context=CONTEXT_HOST, recipe=RECIPE_VIRTUAL)
+        root_node.is_conf = True
+        update = ["*"]
+        builder = DepsGraphBuilder(app.proxy, app.loader, app.range_resolver, app.cache, remotes,
+                                   update, update, self.conan_api.config.global_conf)
+        deps_graph = builder.load_graph(root_node, profile_host, profile_build, lockfile)
+
+        # Basic checks of the package: correct package_type and no-dependencies
+        deps_graph.report_graph_error()
+        pkg = deps_graph.root.dependencies[0].dst
+        ConanOutput().info(f"Configuration from package: {pkg}")
+        if pkg.conanfile.package_type is not PackageType.CONF:
+            raise ConanException(f'{pkg.conanfile} is not of package_type="configuration"')
+        if pkg.dependencies:
+            raise ConanException(f"Configuration package {pkg.ref} cannot have dependencies")
+
+        # The computation of the "package_id" and the download of the package is done as usual
+        # By default we allow all remotes, and build_mode=None, always updating
+        conan_api.graph.analyze_binaries(deps_graph, None, remotes, update=update, lockfile=lockfile)
+        conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
+
+        # We check if this specific version is already installed
+        config_pref = pkg.pref.repr_notime()
+        config_versions = []
+        config_version_file = HomePaths(conan_api.home_folder).config_version_path
+        if os.path.exists(config_version_file):
+            config_versions = json.loads(load(config_version_file))
+            config_versions = config_versions["config_version"]
+            if config_pref in config_versions:
+                if force:
+                    ConanOutput().info(f"Package '{pkg}' already configured, "
+                                       "but re-installation forced")
+                else:
+                    ConanOutput().info(f"Package '{pkg}' already configured, "
+                                       "skipping configuration install")
+                    return pkg.pref  # Already installed, we can skip repeating the install
+
+        from conans.client.conf.config_installer import configuration_install
+        configuration_install(app, uri=pkg.conanfile.package_folder, verify_ssl=False,
+                              config_type="dir", ignore=["conaninfo.txt", "conanmanifest.txt"])
+        # We save the current package full reference in the file for future
+        # And for ``package_id`` computation
+        config_versions = {ref.split("/", 1)[0]: ref for ref in config_versions}
+        config_versions[pkg.pref.ref.name] = pkg.pref.repr_notime()
+        save(config_version_file, json.dumps({"config_version": list(config_versions.values())}))
+        return pkg.pref
+
     def get(self, name, default=None, check_type=None):
         return self.global_conf.get(name, default=default, check_type=check_type)
 
@@ -61,6 +128,7 @@ class ConfigAPI:
             if platform.system() in ["Linux", "FreeBSD"]:
                 import distro
             template = Environment(loader=FileSystemLoader(home_folder)).from_string(text)
+            home_folder = home_folder.replace("\\", "/")
             content = template.render({"platform": platform, "os": os, "distro": distro,
                                        "conan_version": conan_version,
                                        "conan_home_folder": home_folder,

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/list.py

@@ -6,7 +6,7 @@ from conan.internal.conan_app import ConanApp
 from conans.errors import ConanException, NotFoundException
 from conans.model.info import load_binary_info
 from conans.model.package_ref import PkgReference
-from conans.model.recipe_ref import RecipeReference
+from conans.model.recipe_ref import RecipeReference, ref_matches
 from conans.search.search import get_cache_packages_binary_info, filter_packages
 from conans.util.dates import timelimit
 
@@ -87,7 +87,35 @@ class ListAPI:
         """
         return filter_packages(query, pkg_configurations)
 
-    def select(self, pattern, package_query=None, remote=None, lru=None):
+    @staticmethod
+    def filter_packages_profile(packages, profile, ref):
+        result = {}
+        profile_settings = profile.processed_settings.serialize()
+        # Options are those for dependencies, like *:shared=True
+        profile_options = profile.options._deps_package_options
+        for pref, data in packages.items():
+            settings = data.get("settings", {})
+            settings_match = options_match = True
+            for k, v in settings.items():  # Only the defined settings that don't match
+                value = profile_settings.get(k)
+                if value is not None and value != v:
+                    settings_match = False
+                    break
+            options = data.get("options", {})
+            for k, v in options.items():
+                for pattern, pattern_options in profile_options.items():
+                    if ref_matches(ref, pattern, None):
+                        value = pattern_options.get_safe(k)
+                        if value is not None and value != v:
+                            options_match = False
+                            break
+
+            if settings_match and options_match:
+                result[pref] = data
+
+        return result
+
+    def select(self, pattern, package_query=None, remote=None, lru=None, profile=None):
         if package_query and pattern.package_id and "*" not in pattern.package_id:
             raise ConanException("Cannot specify '-p' package queries, "
                                  "if 'package_id' is not a pattern")
@@ -150,6 +178,8 @@ class ListAPI:
                     packages = self.packages_configurations(rrev, remote)
                     if package_query is not None:
                         packages = self.filter_packages_configurations(packages, package_query)
+                    if profile is not None:
+                        packages = self.filter_packages_profile(packages, profile, rrev)
                     prefs = packages.keys()
                     prefs = pattern.filter_prefs(prefs)
                     packages = {pref: conf for pref, conf in packages.items() if pref in prefs}
@@ -193,7 +223,6 @@ class ListAPI:
                 ConanOutput().info(f"Finding binaries in remote {remote.name}")
                 pkg_configurations = self.packages_configurations(ref, remote=remote)
             except Exception as e:
-                pass
                 ConanOutput(f"ERROR IN REMOTE {remote.name}: {e}")
             else:
                 candidates.extend(_BinaryDistance(pref, data, conaninfo, remote)
@@ -202,8 +231,7 @@ class ListAPI:
         candidates.sort()
         pkglist = PackagesList()
         pkglist.add_refs([ref])
-        # If there are exact matches, only return the matches
-        # else, limit to the number specified
+        # Return the closest matches, stop adding when distance is increased
         candidate_distance = None
         for candidate in candidates:
             if candidate_distance and candidate.distance != candidate_distance:

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/lockfile.py

@@ -79,19 +79,21 @@ class LockfileAPI:
         return lockfile
 
     @staticmethod
-    def add_lockfile(lockfile=None, requires=None, build_requires=None, python_requires=None):
+    def add_lockfile(lockfile=None, requires=None, build_requires=None, python_requires=None,
+                     config_requires=None):
         if lockfile is None:
             lockfile = Lockfile()  # create a new lockfile
             lockfile.partial = True
 
         lockfile.add(requires=requires, build_requires=build_requires,
-                     python_requires=python_requires)
+                     python_requires=python_requires, config_requires=config_requires)
         return lockfile
 
     @staticmethod
-    def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None):
+    def remove_lockfile(lockfile, requires=None, build_requires=None, python_requires=None,
+                        config_requires=None):
         lockfile.remove(requires=requires, build_requires=build_requires,
-                        python_requires=python_requires)
+                        python_requires=python_requires, config_requires=config_requires)
         return lockfile
 
     @staticmethod

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/new.py

@@ -28,6 +28,7 @@ class NewAPI:
         from conan.internal.api.new.bazel_exe import bazel_exe_files
         from conan.internal.api.new.autotools_lib import autotools_lib_files
         from conan.internal.api.new.autoools_exe import autotools_exe_files
+        from conan.internal.api.new.local_recipes_index import local_recipes_index_files
         new_templates = {"basic": basic_file,
                          "cmake_lib": cmake_lib_files,
                          "cmake_exe": cmake_exe_files,
@@ -39,7 +40,8 @@ class NewAPI:
                          "bazel_exe": bazel_exe_files,
                          "autotools_lib": autotools_lib_files,
                          "autotools_exe": autotools_exe_files,
-                         "alias": alias_file}
+                         "alias": alias_file,
+                         "local_recipes_index": local_recipes_index_files}
         template_files = new_templates.get(template_name)
         return template_files
 

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/remotes.py

@@ -3,11 +3,12 @@ import json
 import os
 from urllib.parse import urlparse
 
-from conan.api.model import Remote
+from conan.api.model import Remote, LOCAL_RECIPES_INDEX
 from conan.api.output import ConanOutput
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
-
+from conans.client.rest_client_local_recipe_index import add_local_recipes_index_remote, \
+    remove_local_recipes_index_remote
 from conans.errors import ConanException
 from conans.util.files import save, load
 
@@ -99,13 +100,16 @@ class RemotesAPI:
         """
         Add a new ``Remote`` object to the existing ones
 
+
         :param remote: a ``Remote`` object to be added
         :param force: do not fail if the remote already exist (but default it failes)
         :param index: if not defined, the new remote will be last one. Pass an integer to insert
           the remote in that position instead of the last one
         """
+        add_local_recipes_index_remote(self.conan_api, remote)
         remotes = _load(self._remotes_file)
-        _validate_url(remote.url)
+        if remote.remote_type != LOCAL_RECIPES_INDEX:
+            _validate_url(remote.url)
         current = {r.name: r for r in remotes}.get(remote.name)
         if current:  # same name remote existing!
             if not force:
@@ -139,6 +143,7 @@ class RemotesAPI:
         _save(self._remotes_file, remotes)
         app = ConanApp(self.conan_api)
         for remote in removed:
+            remove_local_recipes_index_remote(self.conan_api, remote)
             app.cache.localdb.clean(remote_url=remote.url)
         return removed
 
@@ -160,7 +165,8 @@ class RemotesAPI:
         except KeyError:
             raise ConanException(f"Remote '{remote_name}' doesn't exist")
         if url is not None:
-            _validate_url(url)
+            if remote.remote_type != LOCAL_RECIPES_INDEX:
+                _validate_url(url)
             _check_urls(remotes, url, force=False, current=remote)
             remote.url = url
         if secure is not None:
@@ -255,7 +261,7 @@ def _load(remotes_file):
     result = []
     for r in data.get("remotes", []):
         remote = Remote(r["name"], r["url"], r["verify_ssl"], r.get("disabled", False),
-                        r.get("allowed_packages"))
+                        r.get("allowed_packages"), r.get("remote_type"))
         result.append(remote)
     return result
 
@@ -268,6 +274,8 @@ def _save(remotes_file, remotes):
             remote["disabled"] = True
         if r.allowed_packages:
             remote["allowed_packages"] = r.allowed_packages
+        if r.remote_type:
+            remote["remote_type"] = r.remote_type
         remote_list.append(remote)
     save(remotes_file, json.dumps({"remotes": remote_list}, indent=True))
 

{conan-server-2.1.0 → conan-server-2.2.0}/conan/api/subapi/upload.py

@@ -3,11 +3,9 @@ import time
 from multiprocessing.pool import ThreadPool
 
 from conan.api.output import ConanOutput
-from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.upload_metadata import gather_metadata
 from conans.client.cmd.uploader import PackagePreparator, UploadExecutor, UploadUpstreamChecker
-from conans.client.downloaders.download_cache import DownloadCache
 from conans.client.pkg_sign import PkgSignaturesPlugin
 from conans.client.rest.file_uploader import FileUploader
 from conans.errors import ConanException, AuthenticationException, ForbiddenException
@@ -83,7 +81,7 @@ class UploadAPI:
             if not dry_run:
                 subtitle("Uploading artifacts")
                 self.upload(pkglist, remote)
-                backup_files = self.get_backup_sources(pkglist)
+                backup_files = self.conan_api.cache.get_backup_sources(pkglist)
                 self.upload_backup_sources(backup_files)
 
         t = time.time()
@@ -101,17 +99,6 @@ class UploadAPI:
         elapsed = time.time() - t
         ConanOutput().success(f"Upload completed in {int(elapsed)}s\n")
 
-    def get_backup_sources(self, package_list=None):
-        """Get list of backup source files currently present in the cache,
-        either all of them if no argument, else filter by those belonging to the references in the package_list"""
-        config = self.conan_api.config.global_conf
-        download_cache_path = config.get("core.sources:download_cache")
-        download_cache_path = download_cache_path or HomePaths(
-            self.conan_api.cache_folder).default_sources_backup_folder
-        excluded_urls = config.get("core.sources:exclude_urls", check_type=list, default=[])
-        download_cache = DownloadCache(download_cache_path)
-        return download_cache.get_backup_sources_files_to_upload(excluded_urls, package_list)
-
     def upload_backup_sources(self, files):
         config = self.conan_api.config.global_conf
         url = config.get("core.sources:upload_url", check_type=str)

{conan-server-2.1.0 → conan-server-2.2.0}/conan/cli/args.py

@@ -130,8 +130,6 @@ def validate_common_graph_args(args):
     if args.requires and (args.name or args.version or args.user or args.channel):
         raise ConanException("Can't use --name, --version, --user or --channel arguments with "
                              "--requires")
-    if args.channel and not args.user:
-        raise ConanException("Can't specify --channel without --user")
     if not args.path and not args.requires and not args.tool_requires:
         raise ConanException("Please specify a path to a conanfile or a '--requires=<ref>'")
     if args.path and (args.requires or args.tool_requires):

{conan-server-2.1.0 → conan-server-2.2.0}/conan/cli/cli.py

@@ -22,6 +22,7 @@ from conans.util.files import exception_message_safe
 
 _CONAN_INTERNAL_CUSTOM_COMMANDS_PATH = "_CONAN_INTERNAL_CUSTOM_COMMANDS_PATH"
 
+
 class Cli:
     """A single command of the conan application, with all the first level commands. Manages the
     parsing of parameters and delegates functionality to the conan python api. It can also show the
@@ -33,6 +34,7 @@ class Cli:
         assert isinstance(conan_api, ConanAPI), \
             "Expected 'Conan' type, got '{}'".format(type(conan_api))
         self._conan_api = conan_api
+        self._conan_api.command.cli = self
         self._groups = defaultdict(list)
         self._commands = {}
 

{conan-server-2.1.0 → conan-server-2.2.0}/conan/cli/command.py

@@ -132,6 +132,28 @@ class ConanCommand(BaseConanCommand):
         subcommand.set_name(self.name)
         self._subcommands[subcommand.name] = subcommand
 
+    def run_cli(self, conan_api, *args):
+        parser = ConanArgumentParser(conan_api, description=self._doc,
+                                     prog="conan {}".format(self._name),
+                                     formatter_class=SmartFormatter)
+        self._init_log_levels(parser)
+        self._init_formatters(parser)
+        info = self._method(conan_api, parser, *args)
+        if not self._subcommands:
+            return info
+
+        subcommand_parser = parser.add_subparsers(dest='subcommand', help='sub-command help')
+        subcommand_parser.required = True
+
+        subcmd = args[0][0]
+        try:
+            sub = self._subcommands[subcmd]
+        except (KeyError, IndexError):  # display help
+            raise ConanException(f"Sub command {subcmd} does not exist")
+        else:
+            sub.set_parser(subcommand_parser, conan_api)
+            return sub.run_cli(conan_api, parser, *args)
+
     def run(self, conan_api, *args):
         parser = ConanArgumentParser(conan_api, description=self._doc,
                                      prog="conan {}".format(self._name),
@@ -168,6 +190,9 @@ class ConanSubCommand(BaseConanCommand):
         self._parser = None
         self._subcommand_name = method.__name__.replace('_', '-')
 
+    def run_cli(self, conan_api, parent_parser, *args):
+        return self._method(conan_api, parent_parser, self._parser, *args)
+
     def run(self, conan_api, parent_parser, *args):
         info = self._method(conan_api, parent_parser, self._parser, *args)
         # It is necessary to do it after calling the "method" otherwise parser not complete

{conan-server-2.1.0 → conan-server-2.2.0}/conan/cli/commands/cache.py

@@ -79,6 +79,8 @@ def cache_clean(conan_api: ConanAPI, parser, subparser, *args):
                            help="Clean download and metadata folders")
     subparser.add_argument("-t", "--temp", action='store_true', default=False,
                            help="Clean temporary folders")
+    subparser.add_argument("-bs", "--backup-sources", action='store_true', default=False,
+                           help="Clean backup sources")
     subparser.add_argument('-p', '--package-query', action=OnceArgument,
                            help="Remove only the packages matching a specific query, e.g., "
                                 "os=Windows AND (arch=x86 OR compiler=gcc)")
@@ -86,9 +88,10 @@ def cache_clean(conan_api: ConanAPI, parser, subparser, *args):
 
     ref_pattern = ListPattern(args.pattern or "*", rrev="*", package_id="*", prev="*")
     package_list = conan_api.list.select(ref_pattern, package_query=args.package_query)
-    if args.build or args.source or args.download or args.temp:
+    if args.build or args.source or args.download or args.temp or args.backup_sources:
         conan_api.cache.clean(package_list, source=args.source, build=args.build,
-                              download=args.download, temp=args.temp)
+                              download=args.download, temp=args.temp,
+                              backup_sources=args.backup_sources)
     else:
         conan_api.cache.clean(package_list)
 
@@ -159,5 +162,5 @@ def cache_backup_upload(conan_api: ConanAPI, parser, subparser, *args):
     """
     Upload all the source backups present in the cache
     """
-    files = conan_api.upload.get_backup_sources()
+    files = conan_api.cache.get_backup_sources()
     conan_api.upload.upload_backup_sources(files)

{conan-server-2.1.0 → conan-server-2.2.0}/conan/cli/commands/config.py

@@ -1,5 +1,5 @@
 from conan.api.output import cli_out_write
-from conan.cli.command import conan_command, conan_subcommand
+from conan.cli.command import conan_command, conan_subcommand, OnceArgument
 from conan.cli.formatters import default_json_formatter
 from conans.util.config_parser import get_bool_from_text
 
@@ -37,13 +37,39 @@ def config_install(conan_api, parser, subparser, *args):
                                 'specified origin')
     subparser.add_argument("-tf", "--target-folder",
                            help='Install to that path in the conan cache')
+
     args = parser.parse_args(*args)
-    verify_ssl = args.verify_ssl if isinstance(args.verify_ssl, bool) else get_bool_from_text(args.verify_ssl)
+    verify_ssl = args.verify_ssl if isinstance(args.verify_ssl, bool) \
+        else get_bool_from_text(args.verify_ssl)
     conan_api.config.install(args.item, verify_ssl, args.type, args.args,
                              source_folder=args.source_folder,
                              target_folder=args.target_folder)
 
 
+@conan_subcommand()
+def config_install_pkg(conan_api, parser, subparser, *args):
+    """
+    (Experimental) Install the configuration (remotes, profiles, conf), from a Conan package
+    """
+    subparser.add_argument("item", help="Conan require")
+    subparser.add_argument("-l", "--lockfile", action=OnceArgument,
+                           help="Path to a lockfile. Use --lockfile=\"\" to avoid automatic use of "
+                                "existing 'conan.lock' file")
+    subparser.add_argument("--lockfile-partial", action="store_true",
+                           help="Do not raise an error if some dependency is not found in lockfile")
+    subparser.add_argument("--lockfile-out", action=OnceArgument,
+                           help="Filename of the updated lockfile")
+    subparser.add_argument("-f", "--force", action='store_true',
+                           help="Force the re-installation of configuration")
+    args = parser.parse_args(*args)
+
+    lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile,
+                                               partial=args.lockfile_partial)
+    config_pref = conan_api.config.install_pkg(args.item, lockfile=lockfile, force=args.force)
+    lockfile = conan_api.lockfile.add_lockfile(lockfile, config_requires=[config_pref.ref])
+    conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out)
+
+
 def list_text_formatter(confs):
     for k, v in confs.items():
         cli_out_write(f"{k}: {v}")