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