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

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

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

{conan-server-2.0.17 → 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.0.17 → conan-server-2.2.0}/conan/api/model.py

@@ -3,24 +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):
-        self._name = name  # Read only, is the key
+    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
-
-    @property
-    def name(self):
-        return self._name
+        self.allowed_packages = allowed_packages
+        self.remote_type = remote_type
 
     def __eq__(self, other):
         if other is None:
@@ -29,8 +30,14 @@ class Remote:
                 self.verify_ssl == other.verify_ssl and self.disabled == other.disabled)
 
     def __str__(self):
-        return "{}: {} [Verify SSL: {}, Enabled: {}]".format(self.name, self.url, self.verify_ssl,
-                                                             not self.disabled)
+        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)
 
     def __repr__(self):
         return str(self)
@@ -128,6 +135,7 @@ class MultiPackagesList:
             if any(b == "*" or b == binary for b in binaries):
                 cache_list.add_refs([ref])  # Binary listed forces recipe listed
                 cache_list.add_prefs(ref, [pref])
+                cache_list.add_configurations({pref: node["info"]})
         return pkglist
 
 
@@ -135,6 +143,25 @@ class PackagesList:
     def __init__(self):
         self.recipes = {}
 
+    def split(self):
+        """
+        Returns a list of PackageList, splitted one per reference.
+        This can be useful to parallelize things like upload, parallelizing per-reference
+        """
+        result = []
+        for r, content in self.recipes.items():
+            subpkglist = PackagesList()
+            subpkglist.recipes[r] = content
+            result.append(subpkglist)
+        return result
+
+    def only_recipes(self):
+        result = {}
+        for ref, ref_dict in self.recipes.items():
+            for rrev_dict in ref_dict.get("revisions", {}).values():
+                rrev_dict.pop("packages", None)
+        return result
+
     def add_refs(self, refs):
         # RREVS alreday come in ASCENDING order, so upload does older revisions first
         for ref in refs:
@@ -258,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.0.17 → conan-server-2.2.0}/conan/api/output.py

@@ -1,5 +1,7 @@
 import fnmatch
 import sys
+import time
+from threading import Lock
 
 from colorama import Fore, Style
 
@@ -53,6 +55,7 @@ class ConanOutput:
     _conan_output_level = LEVEL_STATUS
     _silent_warn_tags = []
     _warnings_as_errors = []
+    lock = Lock()
 
     def __init__(self, scope=""):
         self.stream = sys.stderr
@@ -126,8 +129,11 @@ class ConanOutput:
 
         if newline:
             data = "%s\n" % data
-        self.stream.write(data)
-        self.stream.flush()
+
+        with self.lock:
+            self.stream.write(data)
+            self.stream.flush()
+
         return self
 
     def rewrite_line(self, line):
@@ -161,8 +167,9 @@ class ConanOutput:
         else:
             ret += "{}".format(msg)
 
-        self.stream.write("{}\n".format(ret))
-        self.stream.flush()
+        with self.lock:
+            self.stream.write("{}\n".format(ret))
+            self.stream.flush()
 
     def trace(self, msg):
         if self._conan_output_level <= LEVEL_TRACE:
@@ -252,3 +259,19 @@ def cli_out_write(data, fg=None, bg=None, endline="\n", indentation=0):
         data = f"{' ' * indentation}{data}{endline}"
 
     sys.stdout.write(data)
+
+
+class TimedOutput:
+    def __init__(self, interval, out=None, msg_format=None):
+        self._interval = interval
+        self._msg_format = msg_format
+        self._t = time.time()
+        self._out = out or ConanOutput()
+
+    def info(self, msg, *args, **kwargs):
+        t = time.time()
+        if t - self._t > self._interval:
+            self._t = t
+            if self._msg_format:
+                msg = self._msg_format(msg, *args, **kwargs)
+            self._out.info(msg)

{conan-server-2.0.17 → 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:
@@ -22,66 +24,68 @@ class CacheAPI:
         self.conan_api = conan_api
 
     def export_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         ref.revision = None if ref.revision == "latest" else ref.revision
         ref_layout = app.cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export", ref_layout.export())
 
     def recipe_metadata_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         ref = _resolve_latest_ref(app, ref)
         ref_layout = app.cache.recipe_layout(ref)
         return _check_folder_existence(ref, "metadata", ref_layout.metadata())
 
     def export_source_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         ref.revision = None if ref.revision == "latest" else ref.revision
         ref_layout = app.cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export_sources", ref_layout.export_sources())
 
     def source_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         ref.revision = None if ref.revision == "latest" else ref.revision
         ref_layout = app.cache.recipe_layout(ref)
         return _check_folder_existence(ref, "source", ref_layout.source())
 
     def build_path(self, pref: PkgReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         pref = _resolve_latest_pref(app, pref)
         ref_layout = app.cache.pkg_layout(pref)
         return _check_folder_existence(pref, "build", ref_layout.build())
 
     def package_metadata_path(self, pref: PkgReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         pref = _resolve_latest_pref(app, pref)
         ref_layout = app.cache.pkg_layout(pref)
         return _check_folder_existence(pref, "metadata", ref_layout.metadata())
 
     def package_path(self, pref: PkgReference):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         pref = _resolve_latest_pref(app, pref)
         ref_layout = app.cache.pkg_layout(pref)
         return _check_folder_existence(pref, "package", ref_layout.package())
 
     def check_integrity(self, package_list):
         """Check if the recipes and packages are corrupted (it will raise a ConanExcepcion)"""
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         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:
         """
 
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         if temp:
             rmdir(app.cache.temp_folder)
             # Clean those build folders that didn't succeed to create a package and wont be in DB
@@ -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)
@@ -111,7 +119,7 @@ class CacheAPI:
 
     def save(self, package_list, tgz_path):
         cache_folder = self.conan_api.cache_folder
-        app = ConanApp(cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         out = ConanOutput()
         mkdir(os.path.dirname(tgz_path))
         name = os.path.basename(tgz_path)
@@ -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.0.17 → 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
 
@@ -28,10 +35,69 @@ class ConfigAPI:
                 source_folder=None, target_folder=None):
         # TODO: We probably want to split this into git-folder-http cases?
         from conans.client.conf.config_installer import configuration_install
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        return configuration_install(app, path_or_url, verify_ssl,
-                                     config_type=config_type, args=args,
-                                     source_folder=source_folder, target_folder=target_folder)
+        app = ConanApp(self.conan_api)
+        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)
@@ -62,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.0.17 → conan-server-2.2.0}/conan/api/subapi/download.py

@@ -1,4 +1,8 @@
-from conan.api.model import Remote
+import time
+from multiprocessing.pool import ThreadPool
+from typing import Optional, List
+
+from conan.api.model import Remote, PackagesList
 from conan.api.output import ConanOutput
 from conan.internal.conan_app import ConanApp
 from conans.errors import ConanException
@@ -11,9 +15,12 @@ class DownloadAPI:
     def __init__(self, conan_api):
         self.conan_api = conan_api
 
-    def recipe(self, ref: RecipeReference, remote: Remote, metadata=None):
+    def recipe(self, ref: RecipeReference, remote: Remote, metadata: Optional[List[str]] = None):
+        """Download the recipe specified in the ref from the remote.
+        If the recipe is already in the cache it will be skipped,
+        but the specified metadata will be downloaded."""
         output = ConanOutput()
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         assert ref.revision, f"Reference '{ref}' must have revision"
         try:
             app.cache.recipe_layout(ref)  # raises if not found
@@ -40,9 +47,13 @@ class DownloadAPI:
         app.remote_manager.get_recipe_sources(ref, recipe_layout, remote)
         return True
 
-    def package(self, pref: PkgReference, remote: Remote, metadata=None):
+    def package(self, pref: PkgReference, remote: Remote, metadata: Optional[List[str]] = None):
+        """Download the package specified in the pref from the remote.
+        The recipe for this package binary must already exist in the cache.
+        If the package is already in the cache it will be skipped,
+        but the specified metadata will be downloaded."""
         output = ConanOutput()
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         try:
             app.cache.recipe_layout(pref.ref)  # raises if not found
         except ConanException:
@@ -56,7 +67,7 @@ class DownloadAPI:
                 app.remote_manager.get_package_metadata(pref, remote, metadata)
             return False
 
-        if pref.timestamp is None:  # we didnt obtain the timestamp before (in general it should be)
+        if pref.timestamp is None:  # we didn't obtain the timestamp before (in general it should be)
             # Respect the timestamp of the server
             server_pref = app.remote_manager.get_package_revision_reference(pref, remote)
             assert server_pref == pref
@@ -65,3 +76,29 @@ class DownloadAPI:
         output.info(f"Downloading package '{pref.repr_notime()}'")
         app.remote_manager.get_package(pref, remote, metadata)
         return True
+
+    def download_full(self, package_list: PackagesList, remote: Remote,
+                      metadata: Optional[List[str]] = None):
+        """Download the recipes and packages specified in the package_list from the remote,
+        parallelized based on `core.download:parallel`"""
+        def _download_pkglist(pkglist):
+            for ref, recipe_bundle in pkglist.refs().items():
+                self.recipe(ref, remote, metadata)
+                for pref, _ in pkglist.prefs(ref, recipe_bundle).items():
+                    self.package(pref, remote, metadata)
+
+        t = time.time()
+        parallel = self.conan_api.config.get("core.download:parallel", default=1, check_type=int)
+        thread_pool = ThreadPool(parallel) if parallel > 1 else None
+        if not thread_pool or len(package_list.refs()) <= 1:
+            _download_pkglist(package_list)
+        else:
+            ConanOutput().subtitle(f"Downloading with {parallel} parallel threads")
+            thread_pool.map(_download_pkglist, package_list.split())
+
+        if thread_pool:
+            thread_pool.close()
+            thread_pool.join()
+
+        elapsed = time.time() - t
+        ConanOutput().success(f"Download completed in {int(elapsed)}s\n")

{conan-server-2.0.17 → conan-server-2.2.0}/conan/api/subapi/export.py

@@ -2,7 +2,7 @@ from conan.api.output import ConanOutput
 from conan.internal.conan_app import ConanApp
 from conans.client.cmd.export import cmd_export
 from conans.client.conanfile.package import run_package_method
-from conans.client.graph.graph import BINARY_BUILD
+from conans.client.graph.graph import BINARY_BUILD, RECIPE_INCACHE
 from conans.model.package_ref import PkgReference
 from conans.util.files import mkdir
 
@@ -14,12 +14,12 @@ class ExportAPI:
 
     def export(self, path, name, version, user, channel, lockfile=None, remotes=None):
         ConanOutput().title("Exporting recipe to the cache")
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         return cmd_export(app, self.conan_api.config.global_conf, path, name, version, user, channel,
                           graph_lock=lockfile, remotes=remotes)
 
     def export_pkg(self, deps_graph, source_folder, output_folder):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         cache, hook_manager = app.cache, app.hook_manager
 
         # The graph has to be loaded with build_mode=[ref.name], so that node is not tried
@@ -52,6 +52,7 @@ class ExportAPI:
         cache.assign_prev(pkg_layout)
         pkg_node.prev = prev
         pkg_node.pref_timestamp = pref.timestamp  # assigned by assign_prev
+        pkg_node.recipe = RECIPE_INCACHE
         pkg_node.binary = BINARY_BUILD
         # Make sure folder is updated
         final_folder = pkg_layout.package()

{conan-server-2.0.17 → conan-server-2.2.0}/conan/api/subapi/graph.py

@@ -18,7 +18,7 @@ class GraphAPI:
                                       name=None, version=None, user=None, channel=None,
                                       update=None, remotes=None, lockfile=None,
                                       is_build_require=False):
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
 
         if path.endswith(".py"):
             conanfile = app.loader.load_consumer(path,
@@ -62,7 +62,7 @@ class GraphAPI:
         :return: a graph Node, recipe=RECIPE_CONSUMER
         """
 
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         # necessary for correct resolution and update of remote python_requires
 
         loader = app.loader
@@ -88,7 +88,7 @@ class GraphAPI:
                                      lockfile, remotes, update, check_updates=False, python_requires=None):
         if not python_requires and not requires and not tool_requires:
             raise ConanException("Provide requires or tool_requires")
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
         conanfile = app.loader.load_virtual(requires=requires,
                                             tool_requires=tool_requires,
                                             python_requires=python_requires,
@@ -151,7 +151,7 @@ class GraphAPI:
         return deps_graph
 
     def load_graph(self, root_node, profile_host, profile_build, lockfile=None, remotes=None,
-                   update=False, check_update=False):
+                   update=None, check_update=False):
         """ Compute the dependency graph, starting from a root package, evaluation the graph with
         the provided configuration in profile_build, and profile_host. The resulting graph is a
         graph of recipes, but packages are not computed yet (package_ids) will be empty in the
@@ -169,7 +169,7 @@ class GraphAPI:
         :param check_update: For "graph info" command, check if there are recipe updates
         """
         ConanOutput().title("Computing dependency graph")
-        app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        app = ConanApp(self.conan_api)
 
         assert profile_host is not None
         assert profile_build is not None
@@ -196,7 +196,7 @@ class GraphAPI:
         :param tested_graph: In case of a "test_package", the graph being tested
         """
         ConanOutput().title("Computing necessary packages")
-        conan_app = ConanApp(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        conan_app = ConanApp(self.conan_api)
         binaries_analyzer = GraphBinariesAnalyzer(conan_app, self.conan_api.config.global_conf)
         binaries_analyzer.evaluate_graph(graph, build_mode, lockfile, remotes, update,
                                          build_modes_test, tested_graph)