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
