def get_patched_multipackager(tc, *args, **kwargs): client_version = get_client_version() extra_init_kwargs = {} if Version("1.11") < Version(client_version) < Version("1.18"): extra_init_kwargs.update({'requester': tc.requester}) elif Version(client_version) >= Version("1.18"): extra_init_kwargs.update({'http_requester': tc.requester}) if Version(client_version) < Version("1.12.0"): cache = tc.client_cache else: cache = tc.cache conan_api = Conan(cache_folder=cache.cache_folder, output=tc.out, **extra_init_kwargs) class Printer(object): def __init__(self, tc): self.tc = tc def __call__(self, contents): if six.PY2: contents = unicode(contents) self.tc.out.write(contents) kwargs["out"] = Printer(tc) kwargs["conan_api"] = conan_api kwargs["cwd"] = tc.current_folder mp = ConanMultiPackager(*args, **kwargs) return mp
def load_cf_class(path, conan_api): client_version = get_client_version() client_version = Version(client_version) if client_version < Version("1.7.0"): from conans.client.loader_parse import load_conanfile_class return load_conanfile_class(path) elif client_version < Version("1.14.0"): return conan_api._loader.load_class(path) elif client_version < Version("1.15.0"): remotes = conan_api._cache.registry.remotes.list for remote in remotes: conan_api.python_requires.enable_remotes(remote_name=remote) return conan_api._loader.load_class(path) elif client_version < Version("1.16.0"): remotes = conan_api._cache.registry.load_remotes() conan_api.python_requires.enable_remotes(remotes=remotes) return conan_api._loader.load_class(path) elif client_version < Version("1.18.0"): remotes = conan_api._cache.registry.load_remotes() conan_api._python_requires.enable_remotes(remotes=remotes) return conan_api._loader.load_class(path) else: if not conan_api.app: conan_api.create_app() remotes = conan_api.app.cache.registry.load_remotes() conan_api.app.python_requires.enable_remotes(remotes=remotes) conan_api.app.pyreq_loader.enable_remotes(remotes=remotes) if client_version < Version("1.20.0"): return conan_api.app.loader.load_class(path) elif client_version < Version("1.21.0"): return conan_api.app.loader.load_basic(path) else: return conan_api.app.loader.load_named(path, None, None, None, None)
def __init__(self, profile_abs_path, reference, conan_api, uploader, exclude_vcvars_precommand=False, build_policy=None, runner=None, cwd=None, printer=None, upload=False, upload_only_recipe=None, test_folder=None, config_url=None, config_args=None, upload_dependencies=None, conanfile=None, skip_recipe_export=False, update_dependencies=False, lockfile=None): self.printer = printer or Printer() self._cwd = cwd or os.getcwd() self._uploader = uploader self._upload = upload self._conan_api = conan_api self._profile_abs_path = profile_abs_path self._reference = reference self._exclude_vcvars_precommand = exclude_vcvars_precommand self._build_policy = build_policy.split(",") if \ isinstance(build_policy, str) else \ build_policy self._runner = PrintRunner(runner or os.system, self.printer) self._test_folder = test_folder self._config_url = config_url self._config_args = config_args self._upload_only_recipe = upload_only_recipe self._conanfile = conanfile self._lockfile = lockfile self._upload_dependencies = upload_dependencies.split(",") if \ isinstance(upload_dependencies, str) else \ upload_dependencies self._upload_dependencies = self._upload_dependencies or [] self.skip_recipe_export = skip_recipe_export self._update_dependencies = update_dependencies self._results = None patch_default_base_profile(conan_api, profile_abs_path) client_version = get_client_version() if client_version < Version("1.12.0"): cache = self._conan_api._client_cache elif client_version < Version("1.18.0"): cache = self._conan_api._cache else: if not conan_api.app: conan_api.create_app() cache = conan_api.app.cache self._profile = load_profile(profile_abs_path, cache)
def run(): conan_version = get_client_version() if conan_version < Version("1.18.0"): conan_api, client_cache, _ = Conan.factory() else: conan_api, _, _ = Conan.factory() conan_api.create_app() client_cache = conan_api.app.cache printer = Printer() remotes_manager = RemotesManager(conan_api, printer) remotes_manager.add_remotes_to_conan() default_username = os.getenv("CONAN_USERNAME") auth_manager = AuthManager(conan_api, printer, default_username=default_username) upload_retry = os.getenv("CPT_UPLOAD_RETRY") upload_only_recipe = os.getenv("CPT_UPLOAD_ONLY_RECIPE") upload_force = os.getenv("CPT_UPLOAD_FORCE") uploader = Uploader(conan_api, remotes_manager, auth_manager, printer, upload_retry, upload_force) build_policy = unscape_env(os.getenv("CPT_BUILD_POLICY")) test_folder = unscape_env(os.getenv("CPT_TEST_FOLDER")) reference = ConanFileReference.loads(os.getenv("CONAN_REFERENCE")) profile_text = unscape_env(os.getenv("CPT_PROFILE")) abs_profile_path = save_profile_to_tmp(profile_text) base_profile_text = unscape_env(os.getenv("CPT_BASE_PROFILE")) config_url = unscape_env(os.getenv("CPT_CONFIG_URL")) config_args = unscape_env(os.getenv("CPT_CONFIG_ARGS")) upload_dependencies = unscape_env(os.getenv("CPT_UPLOAD_DEPENDENCIES")) update_dependencies = unscape_env(os.getenv("CPT_UPDATE_DEPENDENCIES")) conanfile = unscape_env(os.getenv("CPT_CONANFILE")) lockfile = unscape_env(os.getenv("CPT_LOCKFILE")) skip_recipe_export = unscape_env(os.getenv("CPT_SKIP_RECIPE_EXPORT")) if base_profile_text: base_profile_name = unscape_env(os.getenv("CPT_BASE_PROFILE_NAME")) tools.save(os.path.join(client_cache.profiles_path, base_profile_name), base_profile_text) upload = os.getenv("CPT_UPLOAD_ENABLED") runner = CreateRunner(abs_profile_path, reference, conan_api, uploader, build_policy=build_policy, printer=printer, upload=upload, upload_only_recipe=upload_only_recipe, test_folder=test_folder, config_url=config_url, config_args=config_args, upload_dependencies=upload_dependencies, conanfile=conanfile, skip_recipe_export=skip_recipe_export, update_dependencies=update_dependencies, lockfile=lockfile) runner.run()
def get_profile_from_call(self, call): if call.name != "create": raise Exception("Invalid test, not contains a create: %s" % self.calls) from conans.client.profile_loader import read_profile conan_version = get_client_version() if Version(conan_version) < Version("1.12.0"): profile_name = call.kwargs["profile_name"] else: profile_name = call.kwargs["profile_names"][0] tools.replace_in_file(profile_name, "include", "#include") return read_profile(profile_name, os.path.dirname(profile_name), None)[0]
def _upload_artifacts(self, reference, upload, package_id=None): client_version = get_client_version() remote_name = self.remote_manager.upload_remote_name if not remote_name: self.printer.print_message( "Upload skipped, not upload remote available") return if not self.auth_manager.credentials_ready(remote_name): self.printer.print_message( "Upload skipped, credentials for remote '%s' not available" % remote_name) return if upload: self.printer.print_message("Uploading packages for '%s'" % str(reference)) self.auth_manager.login(remote_name) if client_version < Version("1.7.0"): self.conan_api.upload(str(reference), package=package_id, remote=remote_name, force=True, retry=int(self._upload_retry)) elif client_version < Version("1.8.0"): self.conan_api.upload(str(reference), package=package_id, remote_name=remote_name, force=True, retry=int(self._upload_retry)) elif client_version <= Version("1.20.0"): all_packages = package_id != None self.conan_api.upload(str(reference), all_packages=all_packages, remote_name=remote_name, retry=int(self._upload_retry)) else: raise Exception( "Incompatible installed Conan version found: %s" % client_version)
def _upload_artifacts(self, reference, upload, package_id=None): client_version = get_client_version() remote_name = self.remote_manager.upload_remote_name if not remote_name: self.printer.print_message( "Upload skipped, not upload remote available") return if not self.auth_manager.credentials_ready(remote_name): self.printer.print_message( "Upload skipped, credentials for remote '%s' not available" % remote_name) return if upload: self.printer.print_message("Uploading packages for '%s'" % str(reference)) self.auth_manager.login(remote_name) if client_version < Version("1.7.0"): self.conan_api.upload(str(reference), package=package_id, remote=remote_name, force=self._force, retry=int(self._upload_retry)) elif client_version < Version("1.8.0"): self.conan_api.upload(str(reference), package=package_id, remote_name=remote_name, force=self._force, retry=int(self._upload_retry)) else: all_packages = package_id != None policy = UPLOAD_POLICY_FORCE if self._force else None self.conan_api.upload(str(reference), all_packages=all_packages, remote_name=remote_name, policy=policy, retry=int(self._upload_retry))
def patch_default_base_profile(conan_api, profile_abs_path): """If we have a profile including default, but the users default in config is that the default is other, we have to change the include""" text = tools.load(profile_abs_path) if "include(default)" in text: # User didn't specified a custom profile conan_version = get_client_version() if conan_version < Version("1.12.0"): cache = conan_api._client_cache elif conan_version < Version("1.18.0"): cache = conan_api._cache else: if not conan_api.app: conan_api.create_app() cache = conan_api.app.cache default_profile_name = os.path.basename(cache.default_profile_path) if not os.path.exists(cache.default_profile_path): conan_api.create_profile(default_profile_name, detect=True) if default_profile_name != "default": # User have a different default profile name # https://github.com/conan-io/conan-package-tools/issues/121 text = text.replace("include(default)", "include(%s)" % default_profile_name) tools.save(profile_abs_path, text)
def test_docker(self): client_version = get_client_version() ci_manager = MockCIManager() unique_ref = "zlib/%s" % str(time.time()) conanfile = textwrap.dedent(""" from conans import ConanFile import os class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_DOCKER_RUN_OPTIONS": "--network=host -v{}:/tmp/cpt".format( self.root_project_folder), "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_USE_DOCKER": "1", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_LOGIN_USERNAME": "******", "CONAN_USERNAME": "******", "CONAN_UPLOAD": DockerTest.CONAN_SERVER_ADDRESS, "CONAN_PASSWORD": "******" }): self.packager = ConanMultiPackager(channel="mychannel", gcc_versions=["8"], archs=["x86", "x86_64"], build_types=["Release"], reference=unique_ref, ci_manager=ci_manager) self.packager.add_common_builds() self.packager.run() search_pattern = "%s*" % unique_ref ref = ConanFileReference.loads("%s@demo/mychannel" % unique_ref) # Remove from remote if Version(client_version) < Version("1.7"): results = self.api.search_recipes( search_pattern, remote="upload_repo")["results"][0]["items"] self.assertEquals(len(results), 1) packages = self.api.search_packages( ref, remote="upload_repo")["results"][0]["items"][0]["packages"] self.assertEquals(len(packages), 2) self.api.authenticate(name=CONAN_LOGIN_UPLOAD, password=CONAN_UPLOAD_PASSWORD, remote="upload_repo") self.api.remove(search_pattern, remote="upload_repo", force=True) self.assertEquals( self.api.search_recipes(search_pattern)["results"], []) else: results = self.api.search_recipes( search_pattern, remote_name="upload_repo")["results"][0]["items"] self.assertEquals(len(results), 1) if Version(client_version) >= Version("1.12.0"): ref = repr(ref) packages = self.api.search_packages( ref, remote_name="upload_repo" )["results"][0]["items"][0]["packages"] self.assertEquals(len(packages), 2) self.api.authenticate(name="demo", password="******", remote_name="upload_repo") self.api.remove(search_pattern, remote_name="upload_repo", force=True) self.assertEquals( self.api.search_recipes(search_pattern)["results"], []) # Try upload only when stable, shouldn't upload anything with tools.environment_append({ "CONAN_DOCKER_RUN_OPTIONS": "--network=host -v{}:/tmp/cpt".format( self.root_project_folder), "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_USE_DOCKER": "1", "CONAN_LOGIN_USERNAME": "******", "CONAN_USERNAME": "******", "CONAN_PASSWORD": "******", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_UPLOAD_ONLY_WHEN_STABLE": "1" }): self.packager = ConanMultiPackager( channel="mychannel", gcc_versions=["8"], archs=["x86", "x86_64"], build_types=["Release"], reference=unique_ref, upload=DockerTest.CONAN_SERVER_ADDRESS, ci_manager=ci_manager) self.packager.add_common_builds() self.packager.run() if Version(client_version) < Version("1.7"): results = self.api.search_recipes(search_pattern, remote="upload_repo")["results"] self.assertEquals(len(results), 0) self.api.remove(search_pattern, remote="upload_repo", force=True) else: results = self.api.search_recipes( search_pattern, remote_name="upload_repo")["results"] self.assertEquals(len(results), 0) self.api.remove(search_pattern, remote_name="upload_repo", force=True)
def __init__(self, username=None, channel=None, runner=None, gcc_versions=None, visual_versions=None, visual_runtimes=None, visual_toolsets=None, apple_clang_versions=None, archs=None, options=None, use_docker=None, curpage=None, total_pages=None, docker_image=None, reference=None, password=None, remotes=None, upload=None, stable_branch_pattern=None, vs10_x86_64_enabled=False, mingw_configurations=None, stable_channel=None, platform_info=None, upload_retry=None, clang_versions=None, login_username=None, upload_only_when_stable=None, upload_only_when_tag=None, upload_only_recipe=None, build_types=None, cppstds=None, skip_check_credentials=False, allow_gcc_minors=False, exclude_vcvars_precommand=False, docker_run_options=None, docker_image_skip_update=False, docker_image_skip_pull=False, docker_entry_script=None, docker_32_images=None, docker_conan_home=None, docker_shell=None, pip_install=None, build_policy=None, always_update_conan_in_docker=False, conan_api=None, client_cache=None, conanfile=None, ci_manager=None, out=None, test_folder=None, cwd=None, config_url=None, config_args=None, upload_dependencies=None, force_selinux=None, skip_recipe_export=False, update_dependencies=None, lockfile=None): conan_version = get_client_version() self.printer = Printer(out) self.printer.print_rule() self.printer.print_ascci_art() self.cwd = cwd or os.getcwd() if not conan_api: self.conan_api, _, _ = Conan.factory() self.conan_api.create_app() self.client_cache = self.conan_api.app.cache else: self.conan_api = conan_api self.client_cache = client_cache self.ci_manager = ci_manager or CIManager(self.printer) self.remotes_manager = RemotesManager(self.conan_api, self.printer, remotes, upload) self.username = username or os.getenv("CONAN_USERNAME", None) self.skip_check_credentials = skip_check_credentials or get_bool_from_env( "CONAN_SKIP_CHECK_CREDENTIALS") self.auth_manager = AuthManager( self.conan_api, self.printer, login_username, password, default_username=self.username, skip_check_credentials=self.skip_check_credentials) # Upload related variables self.upload_retry = upload_retry or os.getenv("CONAN_UPLOAD_RETRY", 3) if upload_only_when_stable is not None: self.upload_only_when_stable = upload_only_when_stable else: self.upload_only_when_stable = get_bool_from_env( "CONAN_UPLOAD_ONLY_WHEN_STABLE") if upload_only_when_tag is not None: self.upload_only_when_tag = upload_only_when_tag else: self.upload_only_when_tag = get_bool_from_env( "CONAN_UPLOAD_ONLY_WHEN_TAG") self.upload_only_recipe = upload_only_recipe or get_bool_from_env( "CONAN_UPLOAD_ONLY_RECIPE") self.remotes_manager.add_remotes_to_conan() self.uploader = Uploader(self.conan_api, self.remotes_manager, self.auth_manager, self.printer, self.upload_retry) self._builds = [] self._named_builds = {} self._packages_summary = [] self._update_conan_in_docker = always_update_conan_in_docker or get_bool_from_env( "CONAN_ALWAYS_UPDATE_CONAN_DOCKER") self._platform_info = platform_info or PlatformInfo() self.stable_branch_pattern = stable_branch_pattern or \ os.getenv("CONAN_STABLE_BRANCH_PATTERN", None) self.stable_channel = stable_channel or os.getenv( "CONAN_STABLE_CHANNEL", "stable") self.stable_channel = self.stable_channel.rstrip() self.partial_reference = reference or os.getenv( "CONAN_REFERENCE", None) self.channel = self._get_specified_channel(channel, reference) self.conanfile = conanfile or os.getenv("CONAN_CONANFILE", "conanfile.py") if self.partial_reference: if "@" in self.partial_reference: self.reference = ConanFileReference.loads( self.partial_reference) else: name, version = self.partial_reference.split("/") self.reference = ConanFileReference(name, version, self.username, self.channel) else: if not os.path.exists(os.path.join(self.cwd, self.conanfile)): raise Exception("Conanfile not found, specify a 'reference' " "parameter with name and version") conanfile = load_cf_class(os.path.join(self.cwd, self.conanfile), self.conan_api) name, version = conanfile.name, conanfile.version if name and version: self.reference = ConanFileReference(name, version, self.username, self.channel) else: self.reference = None self._docker_image = docker_image or os.getenv("CONAN_DOCKER_IMAGE", None) # If CONAN_DOCKER_IMAGE is specified, then use docker is True self.use_docker = (use_docker or os.getenv("CONAN_USE_DOCKER", False) or self._docker_image is not None) self.docker_conan_home = docker_conan_home or os.getenv( "CONAN_DOCKER_HOME", None) os_name = self._platform_info.system( ) if not self.use_docker else "Linux" self.build_generator = BuildGenerator( reference, os_name, gcc_versions, apple_clang_versions, clang_versions, visual_versions, visual_runtimes, visual_toolsets, vs10_x86_64_enabled, mingw_configurations, archs, allow_gcc_minors, build_types, options, cppstds) self.build_policy = (build_policy or self.ci_manager.get_commit_build_policy() or split_colon_env("CONAN_BUILD_POLICY")) if isinstance(self.build_policy, list): self.build_policy = ",".join(self.build_policy) self.sudo_docker_command = "" if "CONAN_DOCKER_USE_SUDO" in os.environ: self.sudo_docker_command = "sudo -E" if get_bool_from_env( "CONAN_DOCKER_USE_SUDO") else "" elif platform.system() != "Windows": self.sudo_docker_command = "sudo -E" self.sudo_pip_command = "" if "CONAN_PIP_USE_SUDO" in os.environ: self.sudo_pip_command = "sudo -E" if get_bool_from_env( "CONAN_PIP_USE_SUDO") else "" elif platform.system( ) != "Windows" and self._docker_image and 'conanio/' not in str( self._docker_image): self.sudo_pip_command = "sudo -E" self.pip_command = os.getenv("CONAN_PIP_COMMAND", "pip") pip_found = True if tools.os_info.is_windows else tools.which( self.pip_command) if not pip_found or not "pip" in self.pip_command: raise Exception( "CONAN_PIP_COMMAND: '{}' is not a valid pip command.".format( self.pip_command)) self.docker_pip_command = os.getenv("CONAN_DOCKER_PIP_COMMAND", "pip") self.docker_shell = docker_shell or os.getenv("CONAN_DOCKER_SHELL") if self.is_wcow: if self.docker_conan_home is None: self.docker_conan_home = "C:/Users/ContainerAdministrator" self.docker_shell = docker_shell or "cmd /C" else: if self.docker_conan_home is None: self.docker_conan_home = "/home/conan" self.docker_shell = docker_shell or "/bin/sh -c" self.docker_platform_param = "" self.lcow_user_workaround = "" if self.is_lcow: self.docker_platform_param = "--platform=linux" # With LCOW, Docker doesn't respect USER directive in dockerfile yet self.lcow_user_workaround = "sudo su conan && " self.exclude_vcvars_precommand = exclude_vcvars_precommand or \ get_bool_from_env("CONAN_EXCLUDE_VCVARS_PRECOMMAND") self._docker_image_skip_update = docker_image_skip_update or \ get_bool_from_env("CONAN_DOCKER_IMAGE_SKIP_UPDATE") self._docker_image_skip_pull = docker_image_skip_pull or \ get_bool_from_env("CONAN_DOCKER_IMAGE_SKIP_PULL") self.runner = runner or os.system self.output_runner = ConanOutputRunner() self.docker_run_options = docker_run_options or split_colon_env( "CONAN_DOCKER_RUN_OPTIONS") if isinstance(self.docker_run_options, list): self.docker_run_options = " ".join(self.docker_run_options) self.docker_entry_script = docker_entry_script or os.getenv( "CONAN_DOCKER_ENTRY_SCRIPT") self.pip_install = pip_install or split_colon_env("CONAN_PIP_INSTALL") self.upload_dependencies = upload_dependencies or split_colon_env( "CONAN_UPLOAD_DEPENDENCIES") or "" if isinstance(self.upload_dependencies, list): self.upload_dependencies = ",".join(self.upload_dependencies) if "all" in self.upload_dependencies and self.upload_dependencies != "all": raise Exception( "Upload dependencies only accepts or 'all' or package references. Do not mix both!" ) self.update_dependencies = update_dependencies or get_bool_from_env( "CONAN_UPDATE_DEPENDENCIES") if self.channel: os.environ["CONAN_CHANNEL"] = self.channel if docker_32_images is not None: self.docker_32_images = docker_32_images else: self.docker_32_images = os.getenv("CONAN_DOCKER_32_IMAGES", False) self.force_selinux = force_selinux or get_bool_from_env( "CONAN_FORCE_SELINUX") self.curpage = curpage or os.getenv("CONAN_CURRENT_PAGE", 1) self.total_pages = total_pages or os.getenv("CONAN_TOTAL_PAGES", 1) self.conan_pip_package = os.getenv("CONAN_PIP_PACKAGE", "conan==%s" % conan_version) if self.conan_pip_package in ("0", "False"): self.conan_pip_package = "" self.vs10_x86_64_enabled = vs10_x86_64_enabled self.builds_in_current_page = [] self.test_folder = test_folder or os.getenv("CPT_TEST_FOLDER") self.config_url = config_url or os.getenv("CONAN_CONFIG_URL") self.skip_recipe_export = skip_recipe_export or \ get_bool_from_env("CONAN_SKIP_RECIPE_EXPORT") self.config_args = config_args or os.getenv("CONAN_CONFIG_ARGS") self.lockfile = lockfile or os.getenv("CONAN_LOCKFILE") def valid_pair(var, value): return (isinstance(value, six.string_types) or isinstance(value, bool) or isinstance(value, list) ) and not var.startswith("_") and "password" not in var with self.printer.foldable_output("local_vars"): self.printer.print_dict({ var: value for var, value in self.__dict__.items() if valid_pair(var, value) }) self._newest_supported_conan_version = Version( NEWEST_CONAN_SUPPORTED).minor(fill=False) self._client_conan_version = conan_version
def run(self): client_version = get_client_version() if self._config_url: ConfigManager(self._conan_api, self.printer).install(url=self._config_url, args=self._config_args) context = tools.no_op() compiler = self.settings.get("compiler", None) if not self._exclude_vcvars_precommand: if compiler == "Visual Studio" and "compiler.version" in self.settings: compiler_set = namedtuple("compiler", "version")( self.settings["compiler.version"]) mock_sets = namedtuple( "mock_settings", "arch compiler get_safe")( self.settings["arch"], compiler_set, lambda x: self.settings.get(x, None)) context = tools.vcvars(mock_sets) with context: self.printer.print_rule() self.printer.print_profile(tools.load(self._profile_abs_path)) with self.printer.foldable_output("conan_create"): if client_version < Version("1.10.0"): name, version, user, channel = self._reference else: name, version, user, channel, _ = self._reference if self._build_policy: self._build_policy = [] if self._build_policy == "all" else [ self._build_policy ] # https://github.com/conan-io/conan-package-tools/issues/184 with tools.environment_append({"_CONAN_CREATE_COMMAND_": "1"}): params = { "name": name, "version": version, "user": user, "channel": channel, "build_modes": self._build_policy, "profile_name": self._profile_abs_path } self.printer.print_message("Calling 'conan create'") self.printer.print_dict(params) with tools.chdir(self._cwd): if Version(client_version) >= "1.8.0": from conans.errors import ConanInvalidConfiguration exc_class = ConanInvalidConfiguration else: exc_class = None try: if client_version < Version("1.12.0"): self._results = self._conan_api.create( self._conanfile, name=name, version=version, user=user, channel=channel, build_modes=self._build_policy, profile_name=self._profile_abs_path, test_folder=self._test_folder, not_export=self.skip_recipe_export, update=self._update_dependencies) else: self._results = self._conan_api.create( self._conanfile, name=name, version=version, user=user, channel=channel, build_modes=self._build_policy, profile_names=[self._profile_abs_path], test_folder=self._test_folder, not_export=self.skip_recipe_export, update=self._update_dependencies) except exc_class as e: self.printer.print_rule() self.printer.print_message( "Skipped configuration by the recipe: " "%s" % str(e)) self.printer.print_rule() return for installed in self._results['installed']: reference = installed["recipe"]["id"] if client_version >= Version("1.10.0"): reference = ConanFileReference.loads(reference) reference = str(reference.copy_clear_rev()) if ((reference == str(self._reference)) or \ (reference in self._upload_dependencies) or \ ("all" in self._upload_dependencies)) and \ installed['packages']: package_id = installed['packages'][0]['id'] if installed['packages'][0]["built"]: if "@" not in reference: reference += "@" if self._upload_only_recipe: self._uploader.upload_recipe( reference, self._upload) else: self._uploader.upload_packages( reference, self._upload, package_id) else: self.printer.print_message( "Skipping upload for %s, " "it hasn't been built" % package_id)
def run_builds(self, curpage=None, total_pages=None, base_profile_name=None, base_profile_build_name=None): if len(self.named_builds) > 0 and len(self.items) > 0: raise Exception( "Both bulk and named builds are set. Only one is allowed.") self.builds_in_current_page = [] if len(self.items) > 0: curpage = curpage or int(self.curpage) total_pages = total_pages or int(self.total_pages) for index, build in enumerate(self.items): if curpage is None or total_pages is None or ( index % total_pages) + 1 == curpage: self.builds_in_current_page.append(build) elif len(self.named_builds) > 0: curpage = curpage or self.curpage if curpage not in self.named_builds: raise Exception("No builds set for page %s" % curpage) for build in self.named_builds[curpage]: self.builds_in_current_page.append(build) self.printer.print_current_page(curpage, total_pages) self.printer.print_jobs(self.builds_in_current_page) pulled_docker_images = defaultdict(lambda: False) skip_recipe_export = False base_profile_build_name = base_profile_build_name or os.getenv( "CONAN_BASE_PROFILE_BUILD") if base_profile_build_name is not None: if get_client_version() < Version("1.24.0"): raise Exception("Conan Profile Build requires >= 1.24") self.printer.print_message( "**************************************************") self.printer.print_message("Using specified " "build profile: %s" % base_profile_build_name) self.printer.print_message( "**************************************************") # FIXME: Remove in Conan 1.3, https://github.com/conan-io/conan/issues/2787 for index, build in enumerate(self.builds_in_current_page): self.printer.print_message( "Build: %s/%s" % (index + 1, len(self.builds_in_current_page))) base_profile_name = base_profile_name or os.getenv( "CONAN_BASE_PROFILE") if base_profile_name: self.printer.print_message( "**************************************************") self.printer.print_message("Using specified default " "base profile: %s" % base_profile_name) self.printer.print_message( "**************************************************") if self.config_url: ConfigManager(self.conan_api, self.printer).install(url=self.config_url, args=self.config_args) profile_text, base_profile_text = get_profiles( self.client_cache, build, base_profile_name) _, base_profile_build_text = get_profiles(self.client_cache, build, base_profile_build_name) if not self.use_docker: profile_abs_path = save_profile_to_tmp(profile_text) if base_profile_build_text: profile_build_abs_path = save_profile_to_tmp( base_profile_build_text) else: profile_build_abs_path = None r = CreateRunner( profile_abs_path, build.reference, self.conan_api, self.uploader, exclude_vcvars_precommand=self.exclude_vcvars_precommand, build_policy=self.build_policy, runner=self.runner, cwd=self.cwd, printer=self.printer, upload=self._upload_enabled(), upload_only_recipe=self.upload_only_recipe, test_folder=self.test_folder, config_url=self.config_url, config_args=self.config_args, upload_dependencies=self.upload_dependencies, conanfile=self.conanfile, lockfile=self.lockfile, skip_recipe_export=skip_recipe_export, update_dependencies=self.update_dependencies, profile_build_abs_path=profile_build_abs_path) r.run() self._packages_summary.append({ "configuration": build, "package": r.results }) else: docker_image = self._get_docker_image(build) r = DockerCreateRunner( profile_text, base_profile_text, base_profile_name, build.reference, conan_pip_package=self.conan_pip_package, docker_image=docker_image, sudo_docker_command=self.sudo_docker_command, sudo_pip_command=self.sudo_pip_command, docker_image_skip_update=self._docker_image_skip_update, docker_image_skip_pull=self._docker_image_skip_pull, build_policy=self.build_policy, always_update_conan_in_docker=self._update_conan_in_docker, upload=self._upload_enabled(), upload_retry=self.upload_retry, upload_only_recipe=self.upload_only_recipe, upload_force=self.upload_force, runner=self.runner, docker_shell=self.docker_shell, docker_conan_home=self.docker_conan_home, docker_platform_param=self.docker_platform_param, docker_run_options=self.docker_run_options, lcow_user_workaround=self.lcow_user_workaround, test_folder=self.test_folder, pip_install=self.pip_install, docker_pip_command=self.docker_pip_command, config_url=self.config_url, config_args=self.config_args, printer=self.printer, upload_dependencies=self.upload_dependencies, conanfile=self.conanfile, lockfile=self.lockfile, force_selinux=self.force_selinux, skip_recipe_export=skip_recipe_export, update_dependencies=self.update_dependencies, profile_build_text=base_profile_build_text, cwd=self.cwd) r.run(pull_image=not pulled_docker_images[docker_image], docker_entry_script=self.docker_entry_script) pulled_docker_images[docker_image] = True skip_recipe_export = self.skip_recipe_export