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

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

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

{conan-server-2.0.16 → conan-server-2.0.17}/conan/api/subapi/cache.py

@@ -13,7 +13,7 @@ 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
+from conans.util.files import rmdir, gzopen_without_timestamps, mkdir
 
 
 class CacheAPI:
@@ -113,6 +113,7 @@ class CacheAPI:
         cache_folder = self.conan_api.cache_folder
         app = ConanApp(cache_folder, self.conan_api.config.global_conf)
         out = ConanOutput()
+        mkdir(os.path.dirname(tgz_path))
         name = os.path.basename(tgz_path)
         with open(tgz_path, "wb") as tgz_handle:
             tgz = gzopen_without_timestamps(name, mode="w", fileobj=tgz_handle)

{conan-server-2.0.16 → conan-server-2.0.17}/conan/cli/cli.py

@@ -47,35 +47,43 @@ class Cli:
             for k, v in self._commands.items():  # Fill groups data too
                 self._groups[v.group].append(k)
 
-        custom_commands_path = HomePaths(self._conan_api.cache_folder).custom_commands_path
-        if not os.path.isdir(custom_commands_path):
-            return
+        conan_custom_commands_path = HomePaths(self._conan_api.cache_folder).custom_commands_path
+        # Important! This variable should be only used for testing/debugging purpose
+        developer_custom_commands_path = os.getenv("_CONAN_INTERNAL_CUSTOM_COMMANDS_PATH")
+        # Notice that in case of having same custom commands file names, the developer one has
+        # preference over the Conan default location because of the sys.path.append(xxxx)
+        custom_commands_folders = [developer_custom_commands_path, conan_custom_commands_path] \
+            if developer_custom_commands_path else [conan_custom_commands_path]
+
+        for custom_commands_path in custom_commands_folders:
+            if not os.path.isdir(custom_commands_path):
+                return
 
-        sys.path.append(custom_commands_path)
-        for module in pkgutil.iter_modules([custom_commands_path]):
-            module_name = module[1]
-            if module_name.startswith("cmd_"):
-                try:
-                    self._add_command(module_name, module_name.replace("cmd_", ""))
-                except Exception as e:
-                    ConanOutput().error(f"Error loading custom command '{module_name}.py': {e}",
-                                        error_type="exception")
-        # layers
-        for folder in os.listdir(custom_commands_path):
-            layer_folder = os.path.join(custom_commands_path, folder)
-            sys.path.append(layer_folder)
-            if not os.path.isdir(layer_folder):
-                continue
-            for module in pkgutil.iter_modules([layer_folder]):
+            sys.path.append(custom_commands_path)
+            for module in pkgutil.iter_modules([custom_commands_path]):
                 module_name = module[1]
                 if module_name.startswith("cmd_"):
-                    module_path = f"{folder}.{module_name}"
                     try:
-                        self._add_command(module_path, module_name.replace("cmd_", ""),
-                                          package=folder)
+                        self._add_command(module_name, module_name.replace("cmd_", ""))
                     except Exception as e:
-                        ConanOutput().error(f"Error loading custom command {module_path}: {e}",
+                        ConanOutput().error(f"Error loading custom command '{module_name}.py': {e}",
                                             error_type="exception")
+            # layers
+            for folder in os.listdir(custom_commands_path):
+                layer_folder = os.path.join(custom_commands_path, folder)
+                sys.path.append(layer_folder)
+                if not os.path.isdir(layer_folder):
+                    continue
+                for module in pkgutil.iter_modules([layer_folder]):
+                    module_name = module[1]
+                    if module_name.startswith("cmd_"):
+                        module_path = f"{folder}.{module_name}"
+                        try:
+                            self._add_command(module_path, module_name.replace("cmd_", ""),
+                                              package=folder)
+                        except Exception as e:
+                            ConanOutput().error(f"Error loading custom command {module_path}: {e}",
+                                                error_type="exception")
 
     def _add_command(self, import_path, method_name, package=None):
         try:
@@ -84,7 +92,9 @@ class Cli:
             if command_wrapper.doc:
                 name = f"{package}:{command_wrapper.name}" if package else command_wrapper.name
                 self._commands[name] = command_wrapper
-                self._groups[command_wrapper.group].append(name)
+                # Avoiding duplicated command help messages
+                if name not in self._groups[command_wrapper.group]:
+                    self._groups[command_wrapper.group].append(name)
             for name, value in getmembers(imported_module):
                 if isinstance(value, ConanSubCommand):
                     if name.startswith("{}_".format(method_name)):

{conan-server-2.0.16 → conan-server-2.0.17}/conan/cli/commands/list.py

@@ -109,7 +109,7 @@ def prepare_pkglist_compact(pkglist):
             new_rrev = f"{ref}#{rrev}"
             timestamp = rrev_info.pop("timestamp", None)
             if timestamp:
-                new_rrev += f" ({timestamp_to_str(timestamp)})"
+                new_rrev += f"%{timestamp} ({timestamp_to_str(timestamp)})"
 
             packages = rrev_info.pop("packages", None)
             if packages:

{conan-server-2.0.16 → conan-server-2.0.17}/conan/internal/api/detect_api.py

@@ -122,7 +122,7 @@ def _get_e2k_architecture():
     }.get(platform.processor())
 
 
-def detect_libcxx(compiler, version):
+def detect_libcxx(compiler, version, compiler_exe=None):
     assert isinstance(version, Version)
 
     def _detect_gcc_libcxx(version_, executable):
@@ -166,7 +166,7 @@ def detect_libcxx(compiler, version):
     if compiler == "apple-clang":
         return "libc++"
     elif compiler == "gcc":
-        libcxx = _detect_gcc_libcxx(version, "g++")
+        libcxx = _detect_gcc_libcxx(version, compiler_exe or "g++")
         return libcxx
     elif compiler == "cc":
         if platform.system() == "SunOS":
@@ -179,7 +179,7 @@ def detect_libcxx(compiler, version):
         elif platform.system() == "Windows":
             return  # by default windows will assume LLVM/Clang with VS backend
         else:  # Linux
-            libcxx = _detect_gcc_libcxx(version, "clang++")
+            libcxx = _detect_gcc_libcxx(version, compiler_exe or "clang++")
             return libcxx
     elif compiler == "sun-cc":
         return "libCstd"
@@ -243,17 +243,17 @@ def detect_cppstd(compiler, compiler_version):
     return cppstd
 
 
-def detect_compiler():
-    """
-    find the default compiler on the build machine
-    search order and priority:
-    1. CC and CXX environment variables are always top priority
-    2. Visual Studio detection (Windows only) via vswhere or registry or environment variables
-    3. Apple Clang (Mac only)
-    4. cc executable
-    5. gcc executable
-    6. clang executable
+def detect_default_compiler():
     """
+        find the default compiler on the build machine
+        search order and priority:
+        1. CC and CXX environment variables are always top priority
+        2. Visual Studio detection (Windows only) via vswhere or registry or environment variables
+        3. Apple Clang (Mac only)
+        4. cc executable
+        5. gcc executable
+        6. clang executable
+        """
     output = ConanOutput(scope="detect_api")
     cc = os.environ.get("CC", "")
     cxx = os.environ.get("CXX", "")
@@ -263,11 +263,11 @@ def detect_compiler():
         if "clang" in command.lower():
             return _clang_compiler(command)
         if "gcc" in command or "g++" in command or "c++" in command:
-            gcc, gcc_version = _gcc_compiler(command)
+            gcc, gcc_version, compiler_exe = _gcc_compiler(command)
             if platform.system() == "Darwin" and gcc is None:
                 output.error("%s detected as a frontend using apple-clang. "
                              "Compiler not supported" % command)
-            return gcc, gcc_version
+            return gcc, gcc_version, compiler_exe
         if platform.system() == "SunOS" and command.lower() == "cc":
             return _sun_cc_compiler(command)
         if (platform.system() == "Windows" and command.rstrip('"').endswith(("cl", "cl.exe"))
@@ -276,28 +276,28 @@ def detect_compiler():
 
         # I am not able to find its version
         output.error("Not able to automatically detect '%s' version" % command)
-        return None, None
+        return None, None, None
 
     if platform.system() == "Windows":
         version = _detect_vs_ide_version()
         version = {"17": "193", "16": "192", "15": "191"}.get(str(version))  # Map to compiler
         if version:
-            return 'msvc', Version(version)
+            return 'msvc', Version(version), None
 
     if platform.system() == "SunOS":
-        sun_cc, sun_cc_version = _sun_cc_compiler()
+        sun_cc, sun_cc_version, compiler_exe = _sun_cc_compiler()
         if sun_cc:
-            return sun_cc, sun_cc_version
+            return sun_cc, sun_cc_version, compiler_exe
 
     if platform.system() in ["Darwin", "FreeBSD"]:
-        clang, clang_version = _clang_compiler()  # prioritize clang
+        clang, clang_version, compiler_exe = _clang_compiler()  # prioritize clang
         if clang:
-            return clang, clang_version
+            return clang, clang_version, compiler_exe
         return
     else:
-        gcc, gcc_version = _gcc_compiler()
+        gcc, gcc_version, compiler_exe = _gcc_compiler()
         if gcc:
-            return gcc, gcc_version
+            return gcc, gcc_version, compiler_exe
         return _clang_compiler()
 
 
@@ -326,11 +326,11 @@ def _gcc_compiler(compiler_exe="gcc"):
             _, out = detect_runner("%s --version" % compiler_exe)
             out = out.lower()
             if "clang" in out:
-                return None, None
+                return None, None, None
 
         ret, out = detect_runner('%s -dumpversion' % compiler_exe)
         if ret != 0:
-            return None, None
+            return None, None, None
         compiler = "gcc"
         installed_version = re.search(r"([0-9]+(\.[0-9])?)", out).group()
         # Since GCC 7.1, -dumpversion return the major version number
@@ -338,9 +338,15 @@ def _gcc_compiler(compiler_exe="gcc"):
         # number ("7.1.1").
         if installed_version:
             ConanOutput(scope="detect_api").info("Found %s %s" % (compiler, installed_version))
-            return compiler, Version(installed_version)
+            return compiler, Version(installed_version), compiler_exe
     except (Exception,):  # to disable broad-except
-        return None, None
+        return None, None, None
+
+
+def detect_compiler():
+    ConanOutput(scope="detect_api").warning("detect_compiler() is deprecated, use detect_default_compiler()", warn_tag="deprecated")
+    compiler, version, _ = detect_default_compiler()
+    return compiler, version
 
 
 def _sun_cc_compiler(compiler_exe="cc"):
@@ -354,28 +360,28 @@ def _sun_cc_compiler(compiler_exe="cc"):
             installed_version = re.search(r"([0-9]+\.[0-9]+)", out).group()
         if installed_version:
             ConanOutput(scope="detect_api").info("Found %s %s" % (compiler, installed_version))
-            return compiler, Version(installed_version)
+            return compiler, Version(installed_version), compiler_exe
     except (Exception,):  # to disable broad-except
-        return None, None
+        return None, None, None
 
 
 def _clang_compiler(compiler_exe="clang"):
     try:
         ret, out = detect_runner('%s --version' % compiler_exe)
         if ret != 0:
-            return None, None
+            return None, None, None
         if "Apple" in out:
             compiler = "apple-clang"
         elif "clang version" in out:
             compiler = "clang"
         else:
-            return None, None
+            return None, None, None
         installed_version = re.search(r"([0-9]+\.[0-9])", out).group()
         if installed_version:
             ConanOutput(scope="detect_api").info("Found %s %s" % (compiler, installed_version))
-            return compiler, Version(installed_version)
+            return compiler, Version(installed_version), compiler_exe
     except (Exception,):  # to disable broad-except
-        return None, None
+        return None, None, None
 
 
 def _msvc_cl_compiler(compiler_exe="cl"):
@@ -386,20 +392,20 @@ def _msvc_cl_compiler(compiler_exe="cl"):
         compiler_exe = compiler_exe.strip('"')
         ret, out = detect_runner(f'"{compiler_exe}" /?')
         if ret != 0:
-            return None, None
+            return None, None, None
         first_line = out.splitlines()[0]
         if "Microsoft" not in first_line:
-            return None, None
+            return None, None, None
         compiler = "msvc"
         version_regex = re.search(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)\.([0-9]+)\.?([0-9]+)?",
                                   first_line)
         if not version_regex:
-            return None, None
+            return None, None, None
         # 19.36.32535 -> 193
         version = f"{version_regex.group('major')}{version_regex.group('minor')[0]}"
-        return compiler, Version(version)
+        return compiler, Version(version), compiler_exe
     except (Exception,):  # to disable broad-except
-        return None, None
+        return None, None, None
 
 
 def default_compiler_version(compiler, version):

{conan-server-2.0.16 → conan-server-2.0.17}/conan/tools/cmake/toolchain/blocks.py

@@ -826,7 +826,7 @@ class GenericSystemBlock(Block):
         cmake_sysroot = self._conanfile.conf.get("tools.build:sysroot")
         cmake_sysroot = cmake_sysroot.replace("\\", "/") if cmake_sysroot is not None else None
 
-        result = self._get_winsdk_version(system_version, generator)
+        result = self._get_winsdk_version(system_version, generator_platform)
         system_version, winsdk_version, gen_platform_sdk_version = result
 
         return {"toolset": toolset,

{conan-server-2.0.16 → conan-server-2.0.17}/conan/tools/gnu/pkgconfigdeps.py

@@ -286,7 +286,7 @@ class _PCGenerator:
         requires = self._get_cpp_info_requires_names(self._dep.cpp_info)
         # If we have found some component requires it would be enough
         if not requires:
-            # If no requires were found, let's try to get all the direct dependencies,
+            # If no requires were found, let's try to get all the direct visible dependencies,
             # e.g., requires = "other_pkg/1.0"
             requires = [_get_package_name(req, self._build_context_suffix)
                         for req in self._transitive_reqs.values()]

{conan-server-2.0.16 → conan-server-2.0.17}/conan/tools/google/bazeldeps.py

@@ -117,15 +117,16 @@ def _get_libs(dep, cpp_info=None) -> list:
             full_path = os.path.join(libdir, f)
             if not os.path.isfile(full_path):  # Make sure that directories are excluded
                 continue
+            name, ext = os.path.splitext(f)
             # Users may not name their libraries in a conventional way. For example, directly
-            # use the basename of the lib file as lib name.
-            if f in libs:
+            # use the basename of the lib file as lib name, e.g., cpp_info.libs = ["liblib1.a"]
+            # Issue related: https://github.com/conan-io/conan/issues/11331
+            if ext and f in libs:  # let's ensure that it has any extension
                 _save_lib_path(f, full_path)
                 continue
-            name, ext = os.path.splitext(f)
             if name not in libs and name.startswith("lib"):
                 name = name[3:]  # libpkg -> pkg
-             # FIXME: Should it read a conf variable to know unexpected extensions?
+            # FIXME: Should it read a conf variable to know unexpected extensions?
             if (is_shared and ext in (".so", ".dylib", ".lib", ".dll")) or \
                (not is_shared and ext in (".a", ".lib")):
                 if name in libs:

{conan-server-2.0.16 → conan-server-2.0.17}/conan_server.egg-info/PKG-INFO

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

{conan-server-2.0.16 → conan-server-2.0.17}/conans/__init__.py

@@ -2,4 +2,4 @@ CHECKSUM_DEPLOY = "checksum_deploy"  # Only when v2
 REVISIONS = "revisions"  # Only when enabled in config, not by default look at server_launcher.py
 OAUTH_TOKEN = "oauth_token"
 
-__version__ = '2.0.16'
+__version__ = '2.0.17'

{conan-server-2.0.16 → conan-server-2.0.17}/conans/client/conf/detect.py

@@ -1,6 +1,6 @@
 from conan.api.output import ConanOutput
 from conan.internal.api.detect_api import detect_os, detect_arch, default_msvc_runtime, \
-    detect_libcxx, detect_cppstd, detect_compiler, default_compiler_version
+    detect_libcxx, detect_cppstd, detect_default_compiler, default_compiler_version
 
 
 def detect_defaults_settings():
@@ -14,7 +14,7 @@ def detect_defaults_settings():
     arch = detect_arch()
     if arch:
         result.append(("arch", arch))
-    compiler, version = detect_compiler()
+    compiler, version, compiler_exe = detect_default_compiler()
     if not compiler:
         result.append(("build_type", "Release"))
         ConanOutput().warning("No compiler was detected (one may not be needed)")
@@ -28,7 +28,7 @@ def detect_defaults_settings():
         result.append(("compiler.runtime", runtime))
     if runtime_version:
         result.append(("compiler.runtime_version", runtime_version))
-    libcxx = detect_libcxx(compiler, version)
+    libcxx = detect_libcxx(compiler, version, compiler_exe)
     if libcxx:
         result.append(("compiler.libcxx", libcxx))
     cppstd = detect_cppstd(compiler, version)

{conan-server-2.0.16 → conan-server-2.0.17}/conans/client/graph/graph_builder.py

@@ -1,6 +1,5 @@
 import copy
 import os
-import re
 from collections import deque
 
 from conans.client.conanfile.configure import run_configure_method
@@ -14,7 +13,6 @@ from conans.client.graph.provides import check_graph_provides
 from conans.errors import ConanException
 from conans.model.conan_file import ConanFile
 from conans.model.options import Options
-from conans.model.package_ref import PkgReference
 from conans.model.recipe_ref import RecipeReference, ref_matches
 from conans.model.requires import Requirement
 
@@ -280,11 +278,12 @@ class DepsGraphBuilder(object):
             tracking_ref = require_version.split(':', 1)
             ref = require.ref
             if len(tracking_ref) > 1:
-                ref = RecipeReference.loads(str(node.ref))
+                ref = RecipeReference.loads(str(require.ref))
                 ref.name = tracking_ref[1][:-1]  # Remove the trailing >
             req = Requirement(ref, headers=True, libs=True, visible=True)
             transitive = node.transitive_deps.get(req)
-            if transitive is None:
+            if transitive is None or transitive.require.ref.user != ref.user \
+                    or transitive.require.ref.channel != ref.channel:
                 raise ConanException(f"{node.ref} require '{ref}': didn't find a matching "
                                      "host dependency")
             require.ref.version = transitive.require.ref.version

{conan-server-2.0.16 → conan-server-2.0.17}/conans/client/migrations.py

@@ -58,11 +58,13 @@ class ClientMigrator(Migrator):
 
 
 def _migrate_pkg_db_lru(cache_folder, old_version):
-    ConanOutput().warning(f"Upgrade cache from Conan version '{old_version}'")
-    ConanOutput().warning("Running 2.0.14 Cache DB migration to add LRU column")
     config = ConfigAPI.load_config(cache_folder)
     storage = config.get("core.cache:storage_path") or os.path.join(cache_folder, "p")
     db_filename = os.path.join(storage, 'cache.sqlite3')
+    if not os.path.exists(db_filename):
+        return
+    ConanOutput().warning(f"Upgrade cache from Conan version '{old_version}'")
+    ConanOutput().warning("Running 2.0.14 Cache DB migration to add LRU column")
     connection = sqlite3.connect(db_filename, isolation_level=None,
                                  timeout=1, check_same_thread=False)
     try:

{conan-server-2.0.16 → conan-server-2.0.17}/conans/client/profile_loader.py

@@ -126,8 +126,14 @@ class ProfileLoader:
                    "profile_name": file_path,
                    "conan_version": conan_version,
                    "detect_api": detect_api}
+
         rtemplate = Environment(loader=FileSystemLoader(base_path)).from_string(text)
-        text = rtemplate.render(context)
+
+        try:
+            text = rtemplate.render(context)
+        except Exception as e:
+            raise ConanException(f"Error while rendering the profile template file '{profile_path}'. "
+                                 f"Check your Jinja2 syntax: {str(e)}")
 
         try:
             return self._recurse_load_profile(text, profile_path)

{conan-server-2.0.16 → conan-server-2.0.17}/conans/model/conf.py

@@ -347,7 +347,7 @@ class Conf:
         """
         Returns a string with the format ``name=conf-value``
         """
-        return "\n".join([v.dumps() for v in reversed(self._values.values())])
+        return "\n".join([v.dumps() for v in sorted(self._values.values(), key=lambda x: x._name)])
 
     def serialize(self):
         """

{conan-server-2.0.16 → conan-server-2.0.17}/conans/model/requires.py

@@ -268,7 +268,7 @@ class Requirement:
         if require.build:  # public!
             # TODO: To discuss if this way of conflicting build_requires is actually useful or not
             downstream_require = Requirement(require.ref, headers=False, libs=False, build=True,
-                                             run=False, visible=True, direct=False)
+                                             run=False, visible=self.visible, direct=False)
             return downstream_require
 
         if self.build:  # Build-requires

{conan-server-2.0.16 → conan-server-2.0.17}/conans/test/conftest.py

@@ -91,6 +91,9 @@ tools_locations = {
             "path": {'Windows': 'C:/cmake/cmake-3.23.1-win64-x64/bin',
                      'Darwin': '/Users/jenkins/cmake/cmake-3.23.1/bin',
                      'Linux': "/usr/share/cmake-3.23.5/bin"}
+        },
+        "3.28": {
+            "disabled": True  # TODO: Still not in CI
         }
     },
     'ninja': {