def get_archs(kwargs):
if "archs" not in kwargs:
archs = os.getenv("CONAN_ARCHS", None)
if archs is None:
# Per default only build 64-bit artifacts
kwargs["archs"] = ["x86_64"]
else:
kwargs["archs"] = split_colon_env("CONAN_ARCHS") if archs else None
return kwargs
def get_env_visual_toolsets():
ret = {}
var = split_colon_env("CONAN_VISUAL_TOOLSETS")
if not var:
return None
for toolset_versions in var:
tmp = toolset_versions.split("=")
if len(tmp) != 2:
raise Exception("Invalid value for CONAN_VISUAL_TOOLSETS env variable, use "
"'14=v140;v140_xp,12=v120_xp'")
visual_version, tmp_toolsets = tmp
toolsets = tmp_toolsets.split(";")
ret[visual_version] = toolsets
return ret
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 add_common_builds(self,
shared_option_name=None,
pure_c=True,
dll_with_static_runtime=False,
reference=None,
header_only=True,
build_all_options_values=None):
if reference:
if "@" in reference:
reference = ConanFileReference.loads(reference)
else:
name, version = reference.split("/")
reference = ConanFileReference(name, version, self.username,
self.channel)
else:
reference = self.reference
if not reference:
raise Exception(
"Specify a CONAN_REFERENCE or name and version fields in the recipe"
)
if shared_option_name is None:
env_shared_option_name = os.getenv("CONAN_SHARED_OPTION_NAME",
None)
shared_option_name = env_shared_option_name if str(
env_shared_option_name).lower() != "false" else False
build_all_options_values = build_all_options_values or split_colon_env(
"CONAN_BUILD_ALL_OPTIONS_VALUES") or []
if not isinstance(build_all_options_values, list):
raise Exception(
"'build_all_options_values' must be a list. e.g. ['foo:opt', 'foo:bar']"
)
conanfile = None
if os.path.exists(os.path.join(self.cwd, self.conanfile)):
conanfile = load_cf_class(os.path.join(self.cwd, self.conanfile),
self.conan_api)
header_only_option = None
if conanfile:
if hasattr(
conanfile, "options"
) and conanfile.options and "header_only" in conanfile.options:
header_only_option = "%s:header_only" % reference.name
if shared_option_name is None:
if conanfile:
if hasattr(
conanfile, "options"
) and conanfile.options and "shared" in conanfile.options:
shared_option_name = "%s:shared" % reference.name
# filter only valid options
raw_options_for_building = [
opt[opt.find(":") + 1:] for opt in build_all_options_values
]
for raw_option in reversed(raw_options_for_building):
if hasattr(conanfile, "options") and conanfile.options and \
not isinstance(conanfile.options.get(raw_option), list):
raw_options_for_building.remove(raw_option)
if raw_options_for_building and conanfile:
# get option and its values
cloned_options = copy.copy(conanfile.options)
for key, value in conanfile.options.items():
if key == "shared" and shared_option_name:
continue
elif key not in raw_options_for_building:
del cloned_options[key]
cloned_options2 = {}
for key, value in cloned_options.items():
# add package reference to the option name
if not key.startswith("{}:".format(reference.name)):
cloned_options2["{}:{}".format(reference.name,
key)] = value
# combine all options x values (cartesian product)
build_all_options_values = [
dict(zip(cloned_options2, v))
for v in product(*cloned_options2.values())
]
builds = self.build_generator.get_builds(pure_c, shared_option_name,
dll_with_static_runtime,
reference,
build_all_options_values)
if header_only_option and header_only:
if conanfile.default_options.get("header_only"):
cloned_builds = copy.deepcopy(builds)
for settings, options, env_vars, build_requires, reference in cloned_builds:
options.update({header_only_option: False})
builds.extend(cloned_builds)
else:
settings, options, env_vars, build_requires, reference = builds[
0]
cloned_options = copy.copy(options)
cloned_options.update({header_only_option: True})
builds.append(
BuildConf(copy.copy(settings), cloned_options,
copy.copy(env_vars), copy.copy(build_requires),
reference))
self._builds.extend(builds)
def __init__(self, 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._visual_toolsets = visual_toolsets
self._os_name = os_name
self._reference = reference
self._vs10_x86_64_enabled = vs10_x86_64_enabled
self._allow_gcc_minors = allow_gcc_minors or os.getenv("CONAN_ALLOW_GCC_MINORS", False)
self._clang_versions = clang_versions or split_colon_env("CONAN_CLANG_VERSIONS")
self._gcc_versions = gcc_versions or split_colon_env("CONAN_GCC_VERSIONS")
# If there are some GCC versions declared then we don't default the clang
# versions
if self._clang_versions is None:
if not self._gcc_versions:
self._clang_versions = default_clang_versions
else:
self._clang_versions = []
# If there are some CLANG versions declared then we don't default the gcc
# versions
if self._gcc_versions is None:
if self._clang_versions == default_clang_versions:
self._gcc_versions = default_gcc_versions
else:
self._gcc_versions = []
if self._gcc_versions and not self._allow_gcc_minors:
for a_version in self._gcc_versions:
if Version(str(a_version)) >= Version("5") and "." in str(a_version):
raise Exception("""
******************* DEPRECATED GCC MINOR VERSIONS! ***************************************
- The use of gcc versions >= 5 and specifying the minor version (e.j "5.4") is deprecated.
- The ABI of gcc >= 5 (5, 6, and 7) is compatible between minor versions (e.j 5.3 is compatible with 5.4)
- Specify only the major in your script:
- CONAN_GCC_VERSIONS="5,6,7" if you are using environment variables.
- gcc_versions=["5", "6", "7"] if you are using the constructor parameter.
You can still keep using the same docker images, or use the new "conanio/gcc5", "conanio/gcc6", "conanio/gcc7"
If you still want to keep the old behavior, set the environment var CONAN_ALLOW_GCC_MINORS or pass the
"allow_gcc_minors=True" parameter. But it is not recommended, if your packages are public most users
won't be able to use them.
******************************************************************************************
""")
self._visual_versions = visual_versions or split_colon_env("CONAN_VISUAL_VERSIONS")
if self._visual_versions is None:
if not mingw_configurations and not get_mingw_config_from_env():
self._visual_versions = default_visual_versions
else:
self._visual_versions = []
elif mingw_configurations or get_mingw_config_from_env():
self._visual_versions = []
self._visual_runtimes = visual_runtimes or split_colon_env("CONAN_VISUAL_RUNTIMES")
if self._visual_runtimes is None:
self._visual_runtimes = default_visual_runtimes
self._apple_clang_versions = apple_clang_versions or split_colon_env("CONAN_APPLE_CLANG_VERSIONS")
if self._apple_clang_versions is None:
self._apple_clang_versions = default_apple_clang_versions
self._mingw_configurations = mingw_configurations or get_mingw_config_from_env()
_default_archs = ["x86_64"] if self._os_name == "Darwin" else default_archs
self._archs = archs or split_colon_env("CONAN_ARCHS")
if self._archs is None:
self._archs = _default_archs
self._build_types = build_types or split_colon_env("CONAN_BUILD_TYPES")
if self._build_types is None:
self._build_types = default_build_types
self._cppstds = cppstds or split_colon_env("CONAN_CPPSTDS")
if self._cppstds is None:
self._cppstds = default_cppstds
options = options or split_colon_env("CONAN_OPTIONS")
if options is None:
options = []
self._options = transform_list_options_to_dict(options)
def get_archs():
archs = os.getenv("CONAN_ARCHS", None)
if get_os() == "Macos" and archs is None:
return ["x86_64"]
return split_colon_env("CONAN_ARCHS") if archs else None
