def __init__(self, client_cache, user_io, runner, remote_manager, search_manager): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager)
def __init__(self, paths, user_io, runner, remote_manager): assert isinstance(user_io, UserIO) assert isinstance(paths, ConanPaths) self._conan_paths = paths self._user_io = user_io self._runner = runner self._manager = ConanManager(paths, user_io, runner, remote_manager)
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager, settings_preprocessor): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager, settings_preprocessor) # Patch the tools module with a good requester and user_io set_global_instances(self._user_io.out, get_basic_requester(self._client_cache))
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager, _settings_preprocessor, interactive=True): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._remote_manager = remote_manager self.recorder = ActionRecorder() self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager, _settings_preprocessor, self.recorder) if not interactive: self._user_io.disable_input()
def get_command(): def instance_remote_manager(client_cache): requester = requests.Session() requester.proxies = client_cache.conan_config.proxies # Verify client version against remotes version_checker_requester = VersionCheckerRequester( requester, Version(CLIENT_VERSION), Version(MIN_SERVER_COMPATIBLE_VERSION), out) # To handle remote connections rest_api_client = RestApiClient(out, requester=version_checker_requester) # To store user and token localdb = LocalDB(client_cache.localdb) # Wraps RestApiClient to add authentication support (same interface) auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb) # Handle remote connections remote_manager = RemoteManager(client_cache, auth_manager, out) return remote_manager use_color = get_env("CONAN_COLOR_DISPLAY", 1) if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): import colorama colorama.init() color = True else: color = False out = ConanOutput(sys.stdout, color) user_io = UserIO(out=out) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: # To capture exceptions in conan.conf parsing client_cache = ClientCache(user_folder, None, out) # obtain a temp ConanManager instance to execute the migrations remote_manager = instance_remote_manager(client_cache) # Get a DiskSearchManager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) manager = ConanManager(client_cache, user_io, ConanRunner(), remote_manager, search_manager) client_cache = migrate_and_get_client_cache(user_folder, out, manager) except Exception as e: out.error(str(e)) sys.exit(True) # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) command = Command(client_cache, user_io, ConanRunner(), remote_manager, search_manager) return command
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager) # Patch the tools module with a good requester and user_io tools._global_requester = get_basic_requester(self._client_cache) tools._global_output = self._user_io.out
class Command(object): """ A single command of the conans application, with all the first level commands. Manages the parsing of parameters and delegates functionality in collaborators. It can also show help of the tool """ def __init__(self, paths, user_io, runner, remote_manager, localdb): assert isinstance(user_io, UserIO) assert isinstance(paths, ConanPaths) self._conan_paths = paths self._user_io = user_io self._runner = runner self._manager = ConanManager(paths, user_io, runner, remote_manager, localdb) self._localdb = localdb def _parse_args(self, parser): parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument( "--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument( "--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument( "--build", "-b", action=Extender, nargs="*", help='''Optional, use it to choose if you want to build from sources: --build Build all from sources, do not use binary packages. --build=never Default option. Never build, use binary packages or fail if a binary package is not found. --build=missing Build from code if a binary package is not found. --build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters. ''') def _detect_tested_library_name(self): conanfile_content = load(CONANFILE) match = re.search('^\s*name\s*=\s*"(.*)"', conanfile_content, re.MULTILINE) if match: return "%s*" % match.group(1) self._user_io.out.warn( "Cannot detect a valid conanfile in current directory") return None def _get_build_sources_parameter(self, build_param): # returns True if we want to build the missing libraries # False if building is forbidden # A list with patterns: Will force build matching libraries, # will look for the package for the rest if isinstance(build_param, list): if len(build_param) == 0: # All packages from source return ["*"] elif len(build_param) == 1 and build_param[0] == "never": return False # Default elif len(build_param) == 1 and build_param[0] == "missing": return True else: # A list of expressions to match (if matches, will build from source) return ["%s*" % ref_expr for ref_expr in build_param] else: return False # Nothing is built def test(self, *args): """ build and run your package test. Must have conanfile.py with "test" method and "test" subfolder with package consumer test project """ parser = argparse.ArgumentParser(description=self.test.__doc__, prog="conan", formatter_class=RawTextHelpFormatter) parser.add_argument( "path", nargs='?', default="", help='path to conanfile file, ' 'e.g., openssl/1.0.2@lasote/testing or ./my_project/') self._parse_args(parser) args = parser.parse_args(*args) folder = os.path.normpath(os.path.join(os.getcwd(), args.path)) test_folder = os.path.join(folder, "test") if not os.path.exists(test_folder): raise ConanException("test folder not available") lib_to_test = self._detect_tested_library_name() # Get False or a list of patterns to check if args.build is None and lib_to_test: # Not specified, force build the tested library args.build = [lib_to_test] else: args.build = self._get_build_sources_parameter(args.build) options = args.options or [] settings = args.settings or [] sha = hashlib.sha1("".join(options + settings)).hexdigest() build_folder = os.path.join(folder, "build", sha) rmdir(build_folder) shutil.copytree(test_folder, build_folder) self._manager.install(reference=build_folder, remote=args.remote, options=options, settings=settings, build_mode=args.build) self._manager.build(build_folder, test=True) def install(self, *args): """ install in the local store the given requirements. Requirements can be defined in the command line or in a conanfile. EX: conans install opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan", formatter_class=RawTextHelpFormatter) parser.add_argument( "reference", nargs='?', default="", help='reference name or path to conanfile file, ' 'e.g., openssl/1.0.2@lasote/testing or ./my_project/') self._parse_args(parser) args = parser.parse_args(*args) # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) option_dict = args.options or [] settings_dict = args.settings or [] try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath( os.path.join(os.getcwd(), args.reference)) self._manager.install(reference=reference, remote=args.remote, options=option_dict, settings=settings_dict, build_mode=args.build) def build(self, *args): """ calls your project conanfile.py "build" method. EX: conans build ./my_project Intended for package creators, requires a conanfile.py. """ parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan") parser.add_argument( "path", nargs="?", help='path to user conanfile.py, e.g., conans build .', default="") args = parser.parse_args(*args) root_path = os.path.normpath(os.path.join(os.getcwd(), args.path)) self._manager.build(root_path) def export(self, *args): """ copies a conanfile.py and associated (export) files to your local store, where it can be shared and reused in other projects. From that store, it can be uploaded to any remote with "upload" command. """ parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan") parser.add_argument("user", help='user_name[/channel]. By default, channel is ' '"testing", e.g., phil or phil/stable') parser.add_argument( '--path', '-p', default=None, help='Optional. Folder with a %s. Default current directory.' % CONANFILE) args = parser.parse_args(*args) self._manager.export(args.user, args.path) def remove(self, *args): """ Remove any folder from your local/remote store """ parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan") parser.add_argument('pattern', help='Pattern name, e.g., openssl/*') parser.add_argument( '-p', '--packages', const=[], nargs='?', help='By default, remove all the packages or select one, ' 'specifying the SHA key') parser.add_argument( '-b', '--builds', const=[], nargs='?', help='By default, remove all the build folders or select one, ' 'specifying the SHA key') parser.add_argument('-s', '--src', default=False, action="store_true", help='Remove source folders') parser.add_argument('-f', '--force', default=False, action='store_true', help='Remove without requesting a confirmation') parser.add_argument('-r', '--remote', help='Remote origin') args = parser.parse_args(*args) if args.packages: args.packages = args.packages.split(",") if args.builds: args.builds = args.builds.split(",") self._manager.remove(args.pattern, package_ids_filter=args.packages, build_ids=args.builds, src=args.src, force=args.force, remote=args.remote) def user(self, *parameters): """ shows or change the current user """ parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan") parser.add_argument( "name", nargs='?', default=None, help='Username you want to use. ' 'If no name is provided it will show the current user.') parser.add_argument("-p", "--password", help='User password') parser.add_argument("--remote", "-r", help='look for in the remote storage') args = parser.parse_args(*parameters) # To enable -h self._manager.user(args.remote, args.name, args.password) def search(self, *args): """ show local/remote packages """ parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan") parser.add_argument('pattern', nargs='?', help='Pattern name, e.g., openssl/*') parser.add_argument('--case-sensitive', default=False, action='store_true', help='Make a case-sensitive search') parser.add_argument('-r', '--remote', help='Remote origin') parser.add_argument('-v', '--verbose', default=False, action='store_true', help='Show packages options and settings') parser.add_argument('-p', '--package', help='Package ID pattern. EX: 23*', default=None) args = parser.parse_args(*args) self._manager.search(args.pattern, args.remote, ignorecase=not args.case_sensitive, verbose=args.verbose, package_pattern=args.package) def upload(self, *args): """ uploads a conanfile or binary packages from the local store to any remote. To upload something, it should be "exported" first. """ parser = argparse.ArgumentParser(description=self.upload.__doc__, prog="conan") parser.add_argument( "reference", help='conan reference, e.g., openssl/1.0.2@lasote/testing') # TODO: packageparser.add_argument('package', help='user name') parser.add_argument("--package", "-p", default=None, help='package ID to upload') parser.add_argument("--remote", "-r", help='upload to this specific remote') parser.add_argument("--all", action='store_true', default=False, help='Upload both conans sources and packages') parser.add_argument( "--force", action='store_true', default=False, help='Do not check conans date, override remote with local') args = parser.parse_args(*args) conan_ref = ConanFileReference.loads(args.reference) package_id = args.package if not conan_ref and not package_id: raise ConanException("Enter conans or package id") self._manager.upload(conan_ref, package_id, args.remote, all_packages=args.all, force=args.force) def _show_help(self): """ prints a summary of all commands """ self._user_io.out.writeln( 'Conan commands. Type $conan "command" -h for help', Color.BRIGHT_YELLOW) commands = self._commands() for name in sorted(self._commands()): self._user_io.out.write(' %-10s' % name, Color.GREEN) self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0]) def _commands(self): """ returns a list of available commands """ result = {} for m in inspect.getmembers(self, predicate=inspect.ismethod): method_name = m[0] if not method_name.startswith('_'): method = m[1] if method.__doc__ and not method.__doc__.startswith('HIDDEN'): result[method_name] = method return result def run(self, *args): """HIDDEN: entry point for executing commands, dispatcher to class methods """ errors = False try: try: command = args[0][0] commands = self._commands() method = commands[command] except KeyError as exc: if command in ["-v", "--version"]: self._user_io.out.success("Conan version %s" % CLIENT_VERSION) return False self._show_help() if command in ["-h", "--help"]: return False raise ConanException("Unknown command %s" % str(exc)) except IndexError as exc: # No parameters self._show_help() return False method(args[0][1:]) except (KeyboardInterrupt, SystemExit) as exc: logger.error(exc) errors = True except ConanException as exc: logger.error(exc) # logger.debug(traceback.format_exc()) errors = True self._user_io.out.error(str(exc)) return errors
class ConanAPIV1(object): @staticmethod def instance_remote_manager(requester, client_cache, user_io, _client_version, min_server_compatible_version): # Verify client version against remotes version_checker_req = VersionCheckerRequester(requester, _client_version, min_server_compatible_version, user_io.out) # To handle remote connections put_headers = client_cache.read_put_headers() rest_api_client = RestApiClient(user_io.out, requester=version_checker_req, put_headers=put_headers) # To store user and token localdb = LocalDB(client_cache.localdb) # Wraps RestApiClient to add authentication support (same interface) auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb) # Handle remote connections remote_manager = RemoteManager(client_cache, auth_manager, user_io.out) return localdb, rest_api_client, remote_manager @staticmethod def factory(interactive=None): """Factory""" use_color = get_env("CONAN_COLOR_DISPLAY", 1) if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): import colorama colorama.init() color = True else: color = False out = ConanOutput(sys.stdout, color) user_io = UserIO(out=out) try: user_home = get_conan_user_home() client_cache = migrate_and_get_client_cache(user_home, out) sys.path.append(os.path.join(user_home, "python")) except Exception as e: out.error(str(e)) raise with tools.environment_append(client_cache.conan_config.env_vars): # Adjust CONAN_LOGGING_LEVEL with the env readed conans.util.log.logger = configure_logger() # Get the new command instance after migrations have been done requester = get_basic_requester(client_cache) _, _, remote_manager = ConanAPIV1.instance_remote_manager( requester, client_cache, user_io, Version(client_version), Version(MIN_SERVER_COMPATIBLE_VERSION)) # Adjust global tool variables set_global_instances(out, requester) # Get a search manager search_manager = DiskSearchManager(client_cache) # Settings preprocessor if interactive is None: interactive = not get_env("CONAN_NON_INTERACTIVE", False) conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager, settings_preprocessor, interactive=interactive) return conan, client_cache, user_io def __init__(self, client_cache, user_io, runner, remote_manager, search_manager, _settings_preprocessor, interactive=True): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._remote_manager = remote_manager self.recorder = ActionRecorder() self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager, _settings_preprocessor, self.recorder) if not interactive: self._user_io.disable_input() @api_method def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None, visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None, shared=None, upload_url=None, gitignore=None, gitlab_gcc_versions=None, gitlab_clang_versions=None): from conans.client.cmd.new import cmd_new cwd = os.path.abspath(cwd or os.getcwd()) files = cmd_new(name, header=header, pure_c=pure_c, test=test, exports_sources=exports_sources, bare=bare, visual_versions=visual_versions, linux_gcc_versions=linux_gcc_versions, linux_clang_versions=linux_clang_versions, osx_clang_versions=osx_clang_versions, shared=shared, upload_url=upload_url, gitignore=gitignore, gitlab_gcc_versions=gitlab_gcc_versions, gitlab_clang_versions=gitlab_clang_versions) save_files(cwd, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) @api_method def test(self, path, reference, profile_name=None, settings=None, options=None, env=None, remote=None, update=False, build_modes=None, cwd=None, test_build_folder=None): settings = settings or [] options = options or [] env = env or [] conanfile_path = _get_conanfile_path(path, cwd, py=True) cwd = cwd or os.getcwd() profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) reference = ConanFileReference.loads(reference) pt = PackageTester(self._manager, self._user_io) pt.install_build_and_test(conanfile_path, reference, profile, remote, update, build_modes=build_modes, test_build_folder=test_build_folder) @api_method def create(self, conanfile_path, name=None, version=None, user=None, channel=None, profile_name=None, settings=None, options=None, env=None, test_folder=None, not_export=False, build_modes=None, keep_source=False, keep_build=False, verify=None, manifests=None, manifests_interactive=None, remote=None, update=False, cwd=None, test_build_folder=None): """ API method to create a conan package :param test_folder: default None - looks for default 'test' or 'test_package' folder), string - test_folder path False - disabling tests """ settings = settings or [] options = options or [] env = env or [] cwd = cwd or os.getcwd() conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) if not name or not version: conanfile = load_conanfile_class(conanfile_path) name, version = conanfile.name, conanfile.version if not name or not version: raise ConanException("conanfile.py doesn't declare package name or version") reference = ConanFileReference(name, version, user, channel) scoped_output = ScopedOutput(str(reference), self._user_io.out) # Make sure keep_source is set for keep_build if keep_build: keep_source = True # Forcing an export! if not not_export: scoped_output.highlight("Exporting package recipe") self._manager.export(conanfile_path, name, version, user, channel, keep_source) if build_modes is None: # Not specified, force build the tested library build_modes = [name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) def get_test_conanfile_path(tf): """Searches in the declared test_folder or in the standard locations""" if tf is False: # Look up for testing conanfile can be disabled if tf (test folder) is False return None test_folders = [tf] if tf else ["test_package", "test"] base_folder = os.path.dirname(conanfile_path) for test_folder_name in test_folders: test_folder = os.path.join(base_folder, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): return test_conanfile_path else: if tf: raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % tf) test_conanfile_path = get_test_conanfile_path(test_folder) if test_conanfile_path: pt = PackageTester(self._manager, self._user_io) pt.install_build_and_test(test_conanfile_path, reference, profile, remote, update, build_modes=build_modes, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, keep_build=keep_build, test_build_folder=test_build_folder) else: self._manager.install(reference=reference, install_folder=None, # Not output anything manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build_modes, update=update, keep_build=keep_build) @api_method def export_pkg(self, conanfile_path, name, channel, source_folder=None, build_folder=None, package_folder=None, install_folder=None, profile_name=None, settings=None, options=None, env=None, force=False, user=None, version=None, cwd=None): settings = settings or [] options = options or [] env = env or [] cwd = cwd or os.getcwd() # Checks that info files exists if the install folder is specified if install_folder and not existing_info_files(_make_abs_path(install_folder, cwd)): raise ConanException("The specified install folder doesn't contain '%s' and '%s' " "files" % (CONANINFO, BUILD_INFO)) conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) if package_folder: if build_folder or source_folder: raise ConanException("package folder definition incompatible with build and source folders") package_folder = _make_abs_path(package_folder, cwd) build_folder = _make_abs_path(build_folder, cwd) install_folder = _make_abs_path(install_folder, cwd, default=build_folder) source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path)) # Checks that no both settings and info files are specified if install_folder and existing_info_files(install_folder) and \ (profile_name or settings or options or env): raise ConanException("%s and %s are found, at '%s' folder, so specifying profile, " "settings, options or env is not allowed" % (CONANINFO, BUILD_INFO, install_folder)) infos_present = existing_info_files(install_folder) if not infos_present: profile = profile_from_args(profile_name, settings, options, env=env, cwd=cwd, client_cache=self._client_cache) else: profile = read_conaninfo_profile(install_folder) conanfile = load_conanfile_class(conanfile_path) if (name and conanfile.name and conanfile.name != name) or \ (version and conanfile.version and conanfile.version != version): raise ConanException("Specified name/version doesn't match with the " "name/version in the conanfile") self._manager.export(conanfile_path, name, version, user, channel) if not (name and version): name = conanfile.name version = conanfile.version reference = ConanFileReference(name, version, user, channel) self._manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder, package_folder=package_folder, install_folder=install_folder, profile=profile, force=force) @api_method def download(self, reference, remote=None, package=None, recipe=False): if package and recipe: raise ConanException("recipe parameter cannot be used together with package") # Install packages without settings (fixed ids or all) conan_ref = ConanFileReference.loads(reference) self._manager.download(conan_ref, package, remote=remote, recipe=recipe) @api_method def install_reference(self, reference, settings=None, options=None, env=None, remote=None, verify=None, manifests=None, manifests_interactive=None, build=None, profile_name=None, update=False, generators=None, install_folder=None, cwd=None): cwd = cwd or os.getcwd() install_folder = _make_abs_path(install_folder, cwd) manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) if not generators: # We don't want the default txt generators = False mkdir(install_folder) self._manager.install(reference=reference, install_folder=install_folder, remote=remote, profile=profile, build_modes=build, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generators, install_reference=True) @api_method def install(self, path="", settings=None, options=None, env=None, remote=None, verify=None, manifests=None, manifests_interactive=None, build=None, profile_name=None, update=False, generators=None, no_imports=False, install_folder=None, cwd=None): cwd = cwd or os.getcwd() install_folder = _make_abs_path(install_folder, cwd) conanfile_path = _get_conanfile_path(path, cwd, py=None) manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) self._manager.install(reference=conanfile_path, install_folder=install_folder, remote=remote, profile=profile, build_modes=build, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generators, no_imports=no_imports) @api_method def config_get(self, item): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) self._user_io.out.info(config_parser.get_item(item)) return config_parser.get_item(item) @api_method def config_set(self, item, value): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) config_parser.set_item(item, value) self._client_cache.invalidate() @api_method def config_rm(self, item): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) config_parser.rm_item(item) self._client_cache.invalidate() @api_method def config_install(self, item, verify_ssl): from conans.client.conf.config_installer import configuration_install return configuration_install(item, self._client_cache, self._user_io.out, verify_ssl) def _info_get_profile(self, reference, install_folder, profile_name, settings, options, env): cwd = os.getcwd() try: reference = ConanFileReference.loads(reference) except ConanException: reference = _get_conanfile_path(reference, cwd=None, py=None) if install_folder or not (profile_name or settings or options or env): # When not install folder is specified but neither any setting, we try to read the # info from cwd install_folder = _make_abs_path(install_folder, cwd) if existing_info_files(install_folder): return reference, read_conaninfo_profile(install_folder) return reference, profile_from_args(profile_name, settings, options, env=env, cwd=cwd, client_cache=self._client_cache) @api_method def info_build_order(self, reference, settings=None, options=None, env=None, profile_name=None, remote=None, build_order=None, check_updates=None, install_folder=None): reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings, options, env) graph = self._manager.info_build_order(reference, profile, build_order, remote, check_updates) return graph @api_method def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, profile_name=None, remote=None, check_updates=None, install_folder=None): reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings, options, env) ret = self._manager.info_nodes_to_build(reference, profile, build_modes, remote, check_updates) ref_list, project_reference = ret return ref_list, project_reference @api_method def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, profile_name=None, update=False, install_folder=None): reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings, options, env) ret = self._manager.info_get_graph(reference, remote=remote, profile=profile, check_updates=update) deps_graph, graph_updates_info, project_reference = ret return deps_graph, graph_updates_info, project_reference @api_method def build(self, conanfile_path, source_folder=None, package_folder=None, build_folder=None, install_folder=None, should_configure=True, should_build=True, should_install=True, cwd=None): cwd = cwd or os.getcwd() conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) build_folder = _make_abs_path(build_folder, cwd) install_folder = _make_abs_path(install_folder, cwd, default=build_folder) source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path)) default_pkg_folder = os.path.join(build_folder, "package") package_folder = _make_abs_path(package_folder, cwd, default=default_pkg_folder) self._manager.build(conanfile_path, source_folder, build_folder, package_folder, install_folder, should_configure=should_configure, should_build=should_build, should_install=should_install) @api_method def package(self, path, build_folder, package_folder, source_folder=None, install_folder=None, cwd=None): cwd = cwd or os.getcwd() conanfile_path = _get_conanfile_path(path, cwd, py=True) build_folder = _make_abs_path(build_folder, cwd) install_folder = _make_abs_path(install_folder, cwd, default=build_folder) source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path)) default_pkg_folder = os.path.join(build_folder, "package") package_folder = _make_abs_path(package_folder, cwd, default=default_pkg_folder) self._manager.local_package(package_folder, conanfile_path, build_folder, source_folder, install_folder) @api_method def source(self, path, source_folder=None, info_folder=None, cwd=None): cwd = cwd or os.getcwd() conanfile_path = _get_conanfile_path(path, cwd, py=True) source_folder = _make_abs_path(source_folder, cwd) info_folder = _make_abs_path(info_folder, cwd) mkdir(source_folder) if not os.path.exists(info_folder): raise ConanException("Specified info-folder doesn't exist") self._manager.source(conanfile_path, source_folder, info_folder) @api_method def imports(self, path, dest=None, info_folder=None, cwd=None): """ :param path: Path to the conanfile :param dest: Dir to put the imported files. (Abs path or relative to cwd) :param info_folder: Dir where the conaninfo.txt and conanbuildinfo.txt files are :param cwd: Current working directory :return: None """ cwd = cwd or os.getcwd() info_folder = _make_abs_path(info_folder, cwd) dest = _make_abs_path(dest, cwd) mkdir(dest) conanfile_abs_path = _get_conanfile_path(path, cwd, py=None) self._manager.imports(conanfile_abs_path, dest, info_folder) @api_method def imports_undo(self, manifest_path): cwd = os.getcwd() manifest_path = _make_abs_path(manifest_path, cwd) self._manager.imports_undo(manifest_path) @api_method def export(self, path, name, version, user, channel, keep_source=False, cwd=None): conanfile_path = _get_conanfile_path(path, cwd, py=True) self._manager.export(conanfile_path, name, version, user, channel, keep_source) @api_method def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False, remote=None, outdated=False): self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds, src=src, force=force, remote=remote, packages_query=query, outdated=outdated) @api_method def copy(self, reference, user_channel, force=False, packages=None): """ param packages: None=No binaries, True=All binaries, else list of IDs """ from conans.client.cmd.copy import cmd_copy # FIXME: conan copy does not support short-paths in Windows cmd_copy(reference, user_channel, packages, self._client_cache, self._user_io, self._remote_manager, self.recorder, force=force) @api_method def authenticate(self, name, password, remote=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) if not remote: remote = registry.default_remote else: remote = registry.remote(remote) if password == "": name, password = self._user_io.request_login(remote_name=remote.name, username=name) self._remote_manager.authenticate(remote, name, password) @api_method def user_set(self, user, remote_name=None): return user_set(self._client_cache, self._user_io.out, user, remote_name) @api_method def users_clean(self): return users_clean(self._client_cache) @api_method def users_list(self, remote=None): users = users_list(self._client_cache, self._user_io.out, remote) for remote_name, username in users: self._user_io.out.info("Current '%s' user: %s" % (remote_name, username)) @api_method def search_recipes(self, pattern, remote=None, case_sensitive=False): search = Search(self._client_cache, self._remote_manager, self._user_io) return search.search_recipes(pattern, remote, case_sensitive) @api_method def search_packages(self, reference, query=None, remote=None, outdated=False): search = Search(self._client_cache, self._remote_manager, self._user_io) return search.search_packages(reference, remote, query=query, outdated=outdated) @api_method def upload(self, pattern, package=None, remote=None, all_packages=False, force=False, confirm=False, retry=2, retry_wait=5, skip_upload=False, integrity_check=False, no_overwrite=None): """ Uploads a package recipe and the generated binary packages to a specified remote """ if force and no_overwrite: raise ConanException("'no_overwrite' argument cannot be used together with 'force'") uploader = CmdUpload(self._client_cache, self._user_io, self._remote_manager, remote, self.recorder) return uploader.upload(pattern, package, all_packages, force, confirm, retry, retry_wait, skip_upload, integrity_check, no_overwrite) @api_method def remote_list(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remotes @api_method def remote_add(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add(remote, url, verify_ssl, insert) @api_method def remote_remove(self, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove(remote) @api_method def remote_update(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update(remote, url, verify_ssl, insert) @api_method def remote_list_ref(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.refs @api_method def remote_add_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add_ref(reference, remote) @api_method def remote_remove_ref(self, reference): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove_ref(reference) @api_method def remote_update_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update_ref(reference, remote) @api_method def profile_list(self): return cmd_profile_list(self._client_cache.profiles_path, self._user_io.out) @api_method def create_profile(self, profile_name, detect=False): return cmd_profile_create(profile_name, self._client_cache.profiles_path, self._user_io.out, detect) @api_method def update_profile(self, profile_name, key, value): return cmd_profile_update(profile_name, key, value, self._client_cache.profiles_path) @api_method def get_profile_key(self, profile_name, key): return cmd_profile_get(profile_name, key, self._client_cache.profiles_path) @api_method def delete_profile_key(self, profile_name, key): return cmd_profile_delete_key(profile_name, key, self._client_cache.profiles_path) @api_method def read_profile(self, profile=None): p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path) return p @api_method def get_path(self, reference, package_id=None, path=None, remote=None): reference = ConanFileReference.loads(str(reference)) return self._manager.get_path(reference, package_id, path, remote) @api_method def export_alias(self, reference, target_reference): reference = ConanFileReference.loads(str(reference)) target_reference = ConanFileReference.loads(str(target_reference)) return self._manager.export_alias(reference, target_reference)
def _init_manager(self, action_recorder): """Every api call gets a new recorder and new manager""" return ConanManager(self._client_cache, self._user_io, self._runner, self._remote_manager, self._search_manager, self._settings_preprocessor, action_recorder, self._registry)
class Command(object): """ A single command of the conans application, with all the first level commands. Manages the parsing of parameters and delegates functionality in collaborators. It can also show help of the tool """ def __init__(self, paths, user_io, runner, remote_manager, localdb): assert isinstance(user_io, UserIO) assert isinstance(paths, ConanPaths) self._conan_paths = paths self._user_io = user_io self._runner = runner self._manager = ConanManager(paths, user_io, runner, remote_manager, localdb) self._localdb = localdb def _parse_args(self, parser): parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--build", "-b", action=Extender, nargs="*", help='''Optional, use it to choose if you want to build from sources: --build Build all from sources, do not use binary packages. --build=never Default option. Never build, use binary packages or fail if a binary package is not found. --build=missing Build from code if a binary package is not found. --build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters. ''') def _detect_tested_library_name(self): conanfile_content = load(CONANFILE) match = re.search('^\s*name\s*=\s*"(.*)"', conanfile_content, re.MULTILINE) if match: return "%s*" % match.group(1) self._user_io.out.warn("Cannot detect a valid conanfile in current directory") return None def _get_build_sources_parameter(self, build_param): # returns True if we want to build the missing libraries # False if building is forbidden # A list with patterns: Will force build matching libraries, # will look for the package for the rest if isinstance(build_param, list): if len(build_param) == 0: # All packages from source return ["*"] elif len(build_param) == 1 and build_param[0] == "never": return False # Default elif len(build_param) == 1 and build_param[0] == "missing": return True else: # A list of expressions to match (if matches, will build from source) return ["%s*" % ref_expr for ref_expr in build_param] else: return False # Nothing is built def test(self, *args): """ build and run your package test. Must have conanfile.py with "test" method and "test" subfolder with package consumer test project """ parser = argparse.ArgumentParser(description=self.test.__doc__, prog="conan test", formatter_class=RawTextHelpFormatter) parser.add_argument("path", nargs='?', default="", help='path to conanfile file, ' 'e.g. /my_project/') self._parse_args(parser) args = parser.parse_args(*args) root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path)) test_folder = os.path.join(root_folder, "test") if not os.path.exists(test_folder): raise ConanException("test folder not available") lib_to_test = self._detect_tested_library_name() # Get False or a list of patterns to check if args.build is None and lib_to_test: # Not specified, force build the tested library args.build = [lib_to_test] else: args.build = self._get_build_sources_parameter(args.build) options = args.options or [] settings = args.settings or [] sha = hashlib.sha1("".join(options + settings)).hexdigest() build_folder = os.path.join(root_folder, "build", sha) rmdir(build_folder) shutil.copytree(test_folder, build_folder) self._manager.install(reference=build_folder, current_path=build_folder, remote=args.remote, options=options, settings=settings, build_mode=args.build) self._manager.build(build_folder, build_folder, test=True) def install(self, *args): """ install in the local store the given requirements. Requirements can be defined in the command line or in a conanfile. EX: conans install opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='reference' 'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='Force install specified package ID (ignore settings/options)') parser.add_argument("--all", action='store_true', default=False, help='Install all packages from the specified reference') parser.add_argument("--file", "-f", help="specify conanfile filename") self._parse_args(parser) args = parser.parse_args(*args) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) if args.all or args.package: # Install packages without settings (fixed ids or all) if args.all: args.package = [] if not args.reference or not isinstance(reference, ConanFileReference): raise ConanException("Invalid conanfile reference. e.g., OpenSSL/1.0.2e@lasote/stable") self._manager.download(reference, args.package, remote=args.remote) else: # Classic install, package chosen with settings and options # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) option_dict = args.options or [] settings_dict = args.settings or [] self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=option_dict, settings=settings_dict, build_mode=args.build, filename=args.file) def info(self, *args): """ Prints information about the requirements. Requirements can be defined in the command line or in a conanfile. EX: conans info opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='reference name or path to conanfile file, ' 'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/') parser.add_argument("--file", "-f", help="specify conanfile filename") self._parse_args(parser) args = parser.parse_args(*args) # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) option_dict = args.options or [] settings_dict = args.settings or [] current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=option_dict, settings=settings_dict, build_mode=args.build, info=True, filename=args.file) def build(self, *args): """ calls your project conanfile.py "build" method. EX: conans build ./my_project Intended for package creators, requires a conanfile.py. """ parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build") parser.add_argument("path", nargs="?", help='path to user conanfile.py, e.g., conans build .', default="") parser.add_argument("--file", "-f", help="specify conanfile filename") args = parser.parse_args(*args) current_path = os.getcwd() if args.path: root_path = os.path.abspath(args.path) else: root_path = current_path self._manager.build(root_path, current_path, filename=args.file) def package(self, *args): """ calls your conanfile.py "package" method for a specific package or regenerates the existing package's manifest. Intended for package creators, for regenerating a package without recompiling the source. e.g. conan package OpenSSL/1.0.2e@lasote/stable 9cf83afd07b678d38a9c1645f605875400847ff3 """ parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package") parser.add_argument("reference", help='reference name. e.g., openssl/1.0.2@lasote/testing') parser.add_argument("package", nargs="?", default="", help='Package ID to regenerate. e.g., ' '9cf83afd07b678d38a9c1645f605875400847ff3') parser.add_argument("-o", "--only-manifest", default=False, action='store_true', help='Just regenerate manifest for the existing package.' 'If True conan won\'t call your conanfile\'s package method.') parser.add_argument("--all", action='store_true', default=False, help='Package all packages from specified reference') args = parser.parse_args(*args) try: reference = ConanFileReference.loads(args.reference) except: raise ConanException("Invalid conanfile reference. e.g., OpenSSL/1.0.2e@lasote/stable") if not args.all and not args.package: raise ConanException("'conan package': Please specify --all or a package ID") self._manager.package(reference, args.package, args.only_manifest, args.all) def export(self, *args): """ copies a conanfile.py and associated (export) files to your local store, where it can be shared and reused in other projects. From that store, it can be uploaded to any remote with "upload" command. """ parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export") parser.add_argument("user", help='user_name[/channel]. By default, channel is ' '"testing", e.g., phil or phil/stable') parser.add_argument('--path', '-p', default=None, help='Optional. Folder with a %s. Default current directory.' % CONANFILE) parser.add_argument('--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') args = parser.parse_args(*args) current_path = args.path or os.getcwd() keep_source = args.keep_source self._manager.export(args.user, current_path, keep_source) def remove(self, *args): """ Remove any folder from your local/remote store """ parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove") parser.add_argument('pattern', help='Pattern name, e.g., openssl/*') parser.add_argument('-p', '--packages', const=[], nargs='?', help='By default, remove all the packages or select one, ' 'specifying the SHA key') parser.add_argument('-b', '--builds', const=[], nargs='?', help='By default, remove all the build folders or select one, ' 'specifying the SHA key') parser.add_argument('-s', '--src', default=False, action="store_true", help='Remove source folders') parser.add_argument('-f', '--force', default=False, action='store_true', help='Remove without requesting a confirmation') parser.add_argument('-r', '--remote', help='Remote origin') args = parser.parse_args(*args) if args.packages: args.packages = args.packages.split(",") if args.builds: args.builds = args.builds.split(",") self._manager.remove(args.pattern, package_ids_filter=args.packages, build_ids=args.builds, src=args.src, force=args.force, remote=args.remote) def copy(self, *args): """ Copy packages to another user/channel """ parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy") parser.add_argument("reference", default="", help='reference' 'e.g., OpenSSL/1.0.2e@lasote/stable') parser.add_argument("user_channel", default="", help='Destination user/channel' 'e.g., lasote/testing') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='copy specified package ID') parser.add_argument("--all", action='store_true', default=False, help='Copy all packages from the specified reference') parser.add_argument("--force", action='store_true', default=False, help='Override destination packages and conanfile') args = parser.parse_args(*args) reference = ConanFileReference.loads(args.reference) new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name, reference.version, args.user_channel)) if args.all: args.package = [] self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force) def user(self, *parameters): """ shows or change the current user """ parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user") parser.add_argument("name", nargs='?', default=None, help='Username you want to use. ' 'If no name is provided it will show the current user.') parser.add_argument("-p", "--password", help='User password') parser.add_argument("--remote", "-r", help='look for in the remote storage') args = parser.parse_args(*parameters) # To enable -h self._manager.user(args.remote, args.name, args.password) def search(self, *args): """ show local/remote packages """ parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search") parser.add_argument('pattern', nargs='?', help='Pattern name, e.g., openssl/*') parser.add_argument('--case-sensitive', default=False, action='store_true', help='Make a case-sensitive search') parser.add_argument('-r', '--remote', help='Remote origin') parser.add_argument('-v', '--verbose', default=False, action='store_true', help='Show packages options and settings') parser.add_argument('-p', '--package', help='Package ID pattern. EX: 23*', default=None) args = parser.parse_args(*args) self._manager.search(args.pattern, args.remote, ignorecase=not args.case_sensitive, verbose=args.verbose, package_pattern=args.package) def upload(self, *args): """ uploads a conanfile or binary packages from the local store to any remote. To upload something, it should be "exported" first. """ parser = argparse.ArgumentParser(description=self.upload.__doc__, prog="conan upload") parser.add_argument("reference", help='conan reference, e.g., OpenSSL/1.0.2e@lasote/stable') # TODO: packageparser.add_argument('package', help='user name') parser.add_argument("--package", "-p", default=None, help='package ID to upload') parser.add_argument("--remote", "-r", help='upload to this specific remote') parser.add_argument("--all", action='store_true', default=False, help='Upload both conans sources and packages') parser.add_argument("--force", action='store_true', default=False, help='Do not check conans date, override remote with local') args = parser.parse_args(*args) conan_ref = ConanFileReference.loads(args.reference) package_id = args.package if not conan_ref and not package_id: raise ConanException("Enter conans or package id") self._manager.upload(conan_ref, package_id, args.remote, all_packages=args.all, force=args.force) def _show_help(self): """ prints a summary of all commands """ self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help', Color.BRIGHT_YELLOW) commands = self._commands() for name in sorted(self._commands()): self._user_io.out.write(' %-10s' % name, Color.GREEN) self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0]) def _commands(self): """ returns a list of available commands """ result = {} for m in inspect.getmembers(self, predicate=inspect.ismethod): method_name = m[0] if not method_name.startswith('_'): method = m[1] if method.__doc__ and not method.__doc__.startswith('HIDDEN'): result[method_name] = method return result def run(self, *args): """HIDDEN: entry point for executing commands, dispatcher to class methods """ errors = False try: try: command = args[0][0] commands = self._commands() method = commands[command] except KeyError as exc: if command in ["-v", "--version"]: self._user_io.out.success("Conan version %s" % CLIENT_VERSION) return False self._show_help() if command in ["-h", "--help"]: return False raise ConanException("Unknown command %s" % str(exc)) except IndexError as exc: # No parameters self._show_help() return False method(args[0][1:]) except (KeyboardInterrupt, SystemExit) as exc: logger.error(exc) errors = True except ConanException as exc: logger.error(exc) # logger.debug(traceback.format_exc()) errors = True self._user_io.out.error(str(exc)) return errors
def _init_manager(self, action_recorder): """Every api call gets a new recorder and new manager""" return ConanManager(self._client_cache, self._user_io, self._runner, self._remote_manager, action_recorder, self._registry, self._graph_manager)
class Command(object): """ A single command of the conans application, with all the first level commands. Manages the parsing of parameters and delegates functionality in collaborators. It can also show help of the tool """ def __init__(self, paths, user_io, runner, remote_manager): assert isinstance(user_io, UserIO) assert isinstance(paths, ConanPaths) self._conan_paths = paths self._user_io = user_io self._runner = runner self._manager = ConanManager(paths, user_io, runner, remote_manager) def _parse_args(self, parser): parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--build", "-b", action=Extender, nargs="*", help='''Optional, use it to choose if you want to build from sources: --build Build all from sources, do not use binary packages. --build=never Default option. Never build, use binary packages or fail if a binary package is not found. --build=missing Build from code if a binary package is not found. --build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters. ''') def _get_tuples_list_from_extender_arg(self, items): if not items: return [] # Validate the pairs for item in items: chunks = item.split("=") if len(chunks) != 2: raise ConanException("Invalid input '%s', use 'name=value'" % item) return [(item[0], item[1]) for item in [item.split("=") for item in items]] def _detect_tested_library_name(self): conanfile_content = load(CONANFILE) match = re.search('^\s*name\s*=\s*[\'"](.*)[\'"]', conanfile_content, re.MULTILINE) if match: return "%s*" % match.group(1) self._user_io.out.warn("Cannot detect a valid conanfile in current directory") return None def _get_build_sources_parameter(self, build_param): # returns True if we want to build the missing libraries # False if building is forbidden # A list with patterns: Will force build matching libraries, # will look for the package for the rest if isinstance(build_param, list): if len(build_param) == 0: # All packages from source return ["*"] elif len(build_param) == 1 and build_param[0] == "never": return False # Default elif len(build_param) == 1 and build_param[0] == "missing": return True else: # A list of expressions to match (if matches, will build from source) return ["%s*" % ref_expr for ref_expr in build_param] else: return False # Nothing is built def _test_check(self, test_folder, test_folder_name): """ To ensure that the 0.9 version new layout is detected and users warned """ # Check old tests, format test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("Test conanfile.py does not exist") test_conanfile_content = load(test_conanfile) if ".conanfile_directory" not in test_conanfile_content: self._user_io.out.error("""******* conan test command layout has changed ******* In your "%s" folder 'conanfile.py' you should use the path to the conanfile_directory, something like: self.run('cmake %%s %%s' %% (self.conanfile_directory, cmake.command_line)) """ % (test_folder_name)) # Test the CMakeLists, if existing test_cmake = os.path.join(test_folder, "CMakeLists.txt") if os.path.exists(test_cmake): test_cmake_content = load(test_cmake) if "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake" not in test_cmake_content: self._user_io.out.error("""******* conan test command layout has changed ******* In your "%s" folder 'CMakeLists.txt' you should use the path to the CMake binary directory, like this: include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) """ % (test_folder_name)) def new(self, *args): """ create a new package template conanfile.py and other optional files """ parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new", formatter_class=RawTextHelpFormatter) parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing') parser.add_argument("-t", "--test", action='store_true', default=False, help='Create test_package skeleton to test package') parser.add_argument("-i", "--header", action='store_true', default=False, help='Create a headers only package') parser.add_argument("-c", "--pure_c", action='store_true', default=False, help='Create a C language package only package (non-headers)') args = parser.parse_args(*args) root_folder = os.getcwd() try: name, version, user, channel = ConanFileReference.loads(args.name) except: raise ConanException("Bad parameter, please use full package name," "e.g: MyLib/1.2.3@user/testing") from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake, test_main) if args.header: files = {"conanfile.py": conanfile_header.format(name=name, version=version)} else: files = {"conanfile.py": conanfile.format(name=name, version=version)} if args.pure_c: config = "\n def config(self):\n del self.settings.compiler.libcxx" files["conanfile.py"] = files["conanfile.py"] + config if args.test: files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version, user=user, channel=channel) files["test_package/CMakeLists.txt"] = test_cmake files["test_package/example.cpp"] = test_main save_files(root_folder, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) def test_package(self, *args): """ build and run your package test. Must have conanfile.py with "test" method and "test_package" subfolder with package consumer test project """ parser = argparse.ArgumentParser(description=self.test_package.__doc__, prog="conan test", formatter_class=RawTextHelpFormatter) parser.add_argument("path", nargs='?', default="", help='path to conanfile file, ' 'e.g. /my_project/') parser.add_argument("-f", "--folder", help='alternative test folder name') parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') self._parse_args(parser) args = parser.parse_args(*args) root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path)) if args.folder: test_folder_name = args.folder test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % args.folder) else: for name in ["test_package", "test"]: test_folder_name = name test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile): break else: raise ConanException("test folder 'test_package' not available, " "or it doesn't have a conanfile.py") lib_to_test = self._detect_tested_library_name() # Get False or a list of patterns to check if args.build is None and lib_to_test: # Not specified, force build the tested library args.build = [lib_to_test] else: args.build = self._get_build_sources_parameter(args.build) options = args.options or [] settings = args.settings or [] sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) scopes = Scopes.from_list(args.scope) if args.scope else None self._manager.install(reference=test_folder, current_path=build_folder, remote=args.remote, options=options, settings=settings, build_mode=args.build, scopes=scopes) self._test_check(test_folder, test_folder_name) self._manager.build(test_folder, build_folder, test=True) # Alias to test def test(self, *args): """ (deprecated). Alias to test_package, use it instead """ self.test_package(*args) def install(self, *args): """ install in the local store the given requirements. Requirements can be defined in the command line or in a conanfile. EX: conans install opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='package recipe reference' 'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='Force install specified package ID (ignore settings/options)') parser.add_argument("--all", action='store_true', default=False, help='Install all packages from the specified package recipe') parser.add_argument("--integrity", "-i", action='store_true', default=False, help='Check that the stored recipe or package manifests are correct') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("--update", "-u", action='store_true', default=False, help="update with new upstream packages") parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') self._parse_args(parser) args = parser.parse_args(*args) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) if args.all or args.package: # Install packages without settings (fixed ids or all) if args.all: args.package = [] if not args.reference or not isinstance(reference, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., OpenSSL/1.0.2e@lasote/stable") self._manager.download(reference, args.package, remote=args.remote) else: # Classic install, package chosen with settings and options # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) scopes = Scopes.from_list(args.scope) if args.scope else None self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, build_mode=args.build, filename=args.file, update=args.update, integrity=args.integrity, scopes=scopes) def info(self, *args): """ Prints information about the requirements. Requirements can be defined in the command line or in a conanfile. EX: conans info opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='reference name or path to conanfile file, ' 'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--only", "-n", help='show fields only') parser.add_argument("--integrity", "-i", action='store_true', default=False, help='Check that the stored recipe or package manifests are correct') parser.add_argument("--update", "-u", action='store_true', default=False, help="check updates exist from upstream remotes") args = parser.parse_args(*args) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, build_mode=False, info=args.only or True, check_updates=args.update, integrity=args.integrity, filename=args.file) def build(self, *args): """ calls your project conanfile.py "build" method. EX: conans build ./my_project Intended for package creators, requires a conanfile.py. """ parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build") parser.add_argument("path", nargs="?", help='path to user conanfile.py, e.g., conans build .', default="") parser.add_argument("--file", "-f", help="specify conanfile filename") args = parser.parse_args(*args) current_path = os.getcwd() if args.path: root_path = os.path.abspath(args.path) else: root_path = current_path self._manager.build(root_path, current_path, filename=args.file) def package(self, *args): """ calls your conanfile.py "package" method for a specific package or regenerates the existing package's manifest. Intended for package creators, for regenerating a package without recompiling the source. e.g. conan package OpenSSL/1.0.2e@lasote/stable 9cf83afd07b678da9c1645f605875400847ff3 """ parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package") parser.add_argument("reference", help='package recipe reference name. e.g., openssl/1.0.2@lasote/testing') parser.add_argument("package", nargs="?", default="", help='Package ID to regenerate. e.g., ' '9cf83afd07b678d38a9c1645f605875400847ff3') parser.add_argument("-o", "--only-manifest", default=False, action='store_true', help='Just regenerate manifest for the existing package.' 'If True conan won\'t call your conanfile\'s package method.') parser.add_argument("--all", action='store_true', default=False, help='Package all packages from specified reference') args = parser.parse_args(*args) try: reference = ConanFileReference.loads(args.reference) except: raise ConanException("Invalid package recipe reference. e.g., OpenSSL/1.0.2e@lasote/stable") if not args.all and not args.package: raise ConanException("'conan package': Please specify --all or a package ID") self._manager.package(reference, args.package, args.only_manifest, args.all) def export(self, *args): """ copies the package recipe (conanfile.py and associated files) to your local store, where it can be shared and reused in other projects. From that store, it can be uploaded to any remote with "upload" command. """ parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export") parser.add_argument("user", help='user_name[/channel]. By default, channel is ' '"testing", e.g., phil or phil/stable') parser.add_argument('--path', '-p', default=None, help='Optional. Folder with a %s. Default current directory.' % CONANFILE) parser.add_argument('--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') args = parser.parse_args(*args) current_path = args.path or os.getcwd() keep_source = args.keep_source self._manager.export(args.user, current_path, keep_source) def remove(self, *args): """ Remove any package recipe or package from your local/remote store """ parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove") parser.add_argument('pattern', help='Pattern name, e.g., openssl/*') parser.add_argument('-p', '--packages', const=[], nargs='?', help='By default, remove all the packages or select one, ' 'specifying the SHA key') parser.add_argument('-b', '--builds', const=[], nargs='?', help='By default, remove all the build folders or select one, ' 'specifying the SHA key') parser.add_argument('-s', '--src', default=False, action="store_true", help='Remove source folders') parser.add_argument('-f', '--force', default=False, action='store_true', help='Remove without requesting a confirmation') parser.add_argument('-r', '--remote', help='Remote origin') args = parser.parse_args(*args) if args.packages: args.packages = args.packages.split(",") if args.builds: args.builds = args.builds.split(",") self._manager.remove(args.pattern, package_ids_filter=args.packages, build_ids=args.builds, src=args.src, force=args.force, remote=args.remote) def copy(self, *args): """ Copy package recipe and packages to another user/channel """ parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy") parser.add_argument("reference", default="", help='package recipe reference' 'e.g., OpenSSL/1.0.2e@lasote/stable') parser.add_argument("user_channel", default="", help='Destination user/channel' 'e.g., lasote/testing') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='copy specified package ID') parser.add_argument("--all", action='store_true', default=False, help='Copy all packages from the specified package recipe') parser.add_argument("--force", action='store_true', default=False, help='Override destination packages and the package recipe') args = parser.parse_args(*args) reference = ConanFileReference.loads(args.reference) new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name, reference.version, args.user_channel)) if args.all: args.package = [] self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force) def user(self, *parameters): """ shows or change the current user """ parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user") parser.add_argument("name", nargs='?', default=None, help='Username you want to use. ' 'If no name is provided it will show the current user.') parser.add_argument("-p", "--password", help='User password. Use double quotes ' 'if password with spacing, and escape quotes if existing') parser.add_argument("--remote", "-r", help='look for in the remote storage') parser.add_argument('-c', '--clean', default=False, action='store_true', help='Remove user and tokens for all remotes') args = parser.parse_args(*parameters) # To enable -h if args.clean: localdb = LocalDB(self._conan_paths.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(args.remote, args.name, args.password) def search(self, *args): """ show local/remote packages """ parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search") parser.add_argument('pattern', nargs='?', help='Pattern name, e.g., openssl/*') parser.add_argument('--case-sensitive', default=False, action='store_true', help='Make a case-sensitive search') parser.add_argument('-r', '--remote', help='Remote origin') parser.add_argument('-v', '--verbose', default=False, action='store_true', help='Show packages') parser.add_argument('-x', '--extra-verbose', default=False, action='store_true', help='Show packages options and settings') parser.add_argument('-p', '--package', help='Package ID pattern. EX: 23*', default=None) args = parser.parse_args(*args) self._manager.search(args.pattern, args.remote, ignorecase=not args.case_sensitive, verbose=args.verbose, extra_verbose=args.extra_verbose, package_pattern=args.package) def upload(self, *args): """ uploads a conanfile or binary packages from the local store to any remote. To upload something, it should be "exported" first. """ parser = argparse.ArgumentParser(description=self.upload.__doc__, prog="conan upload") parser.add_argument("reference", help='package recipe reference, e.g., OpenSSL/1.0.2e@lasote/stable') # TODO: packageparser.add_argument('package', help='user name') parser.add_argument("--package", "-p", default=None, help='package ID to upload') parser.add_argument("--remote", "-r", help='upload to this specific remote') parser.add_argument("--all", action='store_true', default=False, help='Upload both package recipe and packages') parser.add_argument("--force", action='store_true', default=False, help='Do not check conans date, override remote with local') args = parser.parse_args(*args) conan_ref = ConanFileReference.loads(args.reference) package_id = args.package if not conan_ref and not package_id: raise ConanException("Enter conans or package id") self._manager.upload(conan_ref, package_id, args.remote, all_packages=args.all, force=args.force) def remote(self, *args): """ manage remotes """ parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote") subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help') # create the parser for the "a" command subparsers.add_parser('list', help='list current remotes') parser_add = subparsers.add_parser('add', help='add a remote') parser_add.add_argument('remote', help='name of the remote') parser_add.add_argument('url', help='url of the remote') parser_rm = subparsers.add_parser('remove', help='remove a remote') parser_rm.add_argument('remote', help='name of the remote') parser_upd = subparsers.add_parser('update', help='update the remote url') parser_upd.add_argument('remote', help='name of the remote') parser_upd.add_argument('url', help='url') subparsers.add_parser('list_ref', help='list the package recipes and its associated remotes') parser_padd = subparsers.add_parser('add_ref', help="associate a recipe's reference to a remote") parser_padd.add_argument('reference', help='package recipe reference') parser_padd.add_argument('remote', help='name of the remote') parser_prm = subparsers.add_parser('remove_ref', help="dissociate a recipe's reference and its remote") parser_prm.add_argument('reference', help='package recipe reference') parser_pupd = subparsers.add_parser('update_ref', help="update the remote associated with a package recipe") parser_pupd.add_argument('reference', help='package recipe reference') parser_pupd.add_argument('remote', help='name of the remote') args = parser.parse_args(*args) registry = RemoteRegistry(self._conan_paths.registry, self._user_io.out) if args.subcommand == "list": for r in registry.remotes: self._user_io.out.info("%s: %s" % (r.name, r.url)) elif args.subcommand == "add": registry.add(args.remote, args.url) elif args.subcommand == "remove": registry.remove(args.remote) elif args.subcommand == "update": registry.update(args.remote, args.url) elif args.subcommand == "list_ref": for ref, remote in registry.refs.items(): self._user_io.out.info("%s: %s" % (ref, remote)) elif args.subcommand == "add_ref": registry.add_ref(args.reference, args.remote) elif args.subcommand == "remove_ref": registry.remove_ref(args.reference) elif args.subcommand == "update_ref": registry.update_ref(args.reference, args.remote) def _show_help(self): """ prints a summary of all commands """ self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help', Color.BRIGHT_YELLOW) commands = self._commands() for name in sorted(self._commands()): self._user_io.out.write(' %-10s' % name, Color.GREEN) self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0]) def _commands(self): """ returns a list of available commands """ result = {} for m in inspect.getmembers(self, predicate=inspect.ismethod): method_name = m[0] if not method_name.startswith('_'): method = m[1] if method.__doc__ and not method.__doc__.startswith('HIDDEN'): result[method_name] = method return result def run(self, *args): """HIDDEN: entry point for executing commands, dispatcher to class methods """ errors = False try: try: command = args[0][0] commands = self._commands() method = commands[command] except KeyError as exc: if command in ["-v", "--version"]: self._user_io.out.success("Conan version %s" % CLIENT_VERSION) return False self._show_help() if command in ["-h", "--help"]: return False raise ConanException("Unknown command %s" % str(exc)) except IndexError as exc: # No parameters self._show_help() return False method(args[0][1:]) except (KeyboardInterrupt, SystemExit) as exc: logger.error(exc) errors = True except ConanException as exc: logger.error(exc) # import traceback # logger.debug(traceback.format_exc()) errors = True self._user_io.out.error(str(exc)) return errors
class Command(object): """ A single command of the conan application, with all the first level commands. Manages the parsing of parameters and delegates functionality in collaborators. It can also show help of the tool """ def __init__(self, client_cache, user_io, runner, remote_manager, search_manager): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager) def _parse_args(self, parser): parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--build", "-b", action=Extender, nargs="*", help='''Optional, use it to choose if you want to build from sources: --build Build all from sources, do not use binary packages. --build=never Default option. Never build, use binary packages or fail if a binary package is not found. --build=missing Build from code if a binary package is not found. --build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters. ''') def _get_tuples_list_from_extender_arg(self, items): if not items: return [] # Validate the pairs for item in items: chunks = item.split("=") if len(chunks) != 2: raise ConanException("Invalid input '%s', use 'name=value'" % item) return [(item[0], item[1]) for item in [item.split("=") for item in items]] def _get_build_sources_parameter(self, build_param): # returns True if we want to build the missing libraries # False if building is forbidden # A list with patterns: Will force build matching libraries, # will look for the package for the rest if isinstance(build_param, list): if len(build_param) == 0: # All packages from source return ["*"] elif len(build_param) == 1 and build_param[0] == "never": return False # Default elif len(build_param) == 1 and build_param[0] == "missing": return True else: # A list of expressions to match (if matches, will build from source) return ["%s*" % ref_expr for ref_expr in build_param] else: return False # Nothing is built def _test_check(self, test_folder, test_folder_name): """ To ensure that the 0.9 version new layout is detected and users warned """ # Check old tests, format test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("Test conanfile.py does not exist") test_conanfile_content = load(test_conanfile) if ".conanfile_directory" not in test_conanfile_content: self._user_io.out.error("""******* conan test command layout has changed ******* In your "%s" folder 'conanfile.py' you should use the path to the conanfile_directory, something like: self.run('cmake %%s %%s' %% (self.conanfile_directory, cmake.command_line)) """ % (test_folder_name)) # Test the CMakeLists, if existing test_cmake = os.path.join(test_folder, "CMakeLists.txt") if os.path.exists(test_cmake): test_cmake_content = load(test_cmake) if "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake" not in test_cmake_content: self._user_io.out.error("""******* conan test command layout has changed ******* In your "%s" folder 'CMakeLists.txt' you should use the path to the CMake binary directory, like this: include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) """ % (test_folder_name)) def new(self, *args): """ create a new package template conanfile.py and other optional files """ parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new", formatter_class=RawTextHelpFormatter) parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing') parser.add_argument("-t", "--test", action='store_true', default=False, help='Create test_package skeleton to test package') parser.add_argument("-i", "--header", action='store_true', default=False, help='Create a headers only package') parser.add_argument("-c", "--pure_c", action='store_true', default=False, help='Create a C language package only package (non-headers)') args = parser.parse_args(*args) root_folder = os.getcwd() try: name, version, user, channel = ConanFileReference.loads(args.name) pattern = re.compile('[\W_]+') package_name = pattern.sub('', name).capitalize() except: raise ConanException("Bad parameter, please use full package name," "e.g: MyLib/1.2.3@user/testing") from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake, test_main) if args.header: files = {"conanfile.py": conanfile_header.format(name=name, version=version, package_name=package_name)} else: files = {"conanfile.py": conanfile.format(name=name, version=version, package_name=package_name)} if args.pure_c: config = "\n def config(self):\n del self.settings.compiler.libcxx" files["conanfile.py"] = files["conanfile.py"] + config if args.test: files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version, user=user, channel=channel, package_name=package_name) files["test_package/CMakeLists.txt"] = test_cmake files["test_package/example.cpp"] = test_main save_files(root_folder, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) def test_package(self, *args): """ build and run your package test. Must have conanfile.py with "test" method and "test_package" subfolder with package consumer test project """ parser = argparse.ArgumentParser(description=self.test_package.__doc__, prog="conan test_package", formatter_class=RawTextHelpFormatter) parser.add_argument("path", nargs='?', default="", help='path to conanfile file, ' 'e.g. /my_project/') parser.add_argument("-ne", "--not-export", default=False, action='store_true', help='Do not export the conanfile before test execution') parser.add_argument("-f", "--folder", help='alternative test folder name') parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') parser.add_argument('--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') parser.add_argument("--update", "-u", action='store_true', default=False, help="update with new upstream packages") parser.add_argument("--profile", "-pr", default=None, help='Define a profile') self._parse_args(parser) args = parser.parse_args(*args) root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path)) if args.folder: test_folder_name = args.folder test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % args.folder) else: for name in ["test_package", "test"]: test_folder_name = name test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile): break else: raise ConanException("test folder 'test_package' not available, " "or it doesn't have a conanfile.py") options = args.options or [] settings = args.settings or [] sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) scopes = Scopes.from_list(args.scope) if args.scope else None manager = self._manager loader = manager._loader(None, settings, options, scopes) conanfile = loader.load_conan(test_conanfile, self._user_io.out, consumer=True) try: # convert to list from ItemViews required for python3 reqs = list(conanfile.requires.items()) first_dep = reqs[0][1].conan_reference except Exception: raise ConanException("Unable to retrieve first requirement of test conanfile.py") # Forcing an export! if not args.not_export: self._user_io.out.info("Exporting package recipe") user_channel = "%s/%s" % (first_dep.user, first_dep.channel) self._manager.export(user_channel, root_folder, keep_source=args.keep_source) lib_to_test = first_dep.name + "*" # Get False or a list of patterns to check if args.build is None and lib_to_test: # Not specified, force build the tested library args.build = [lib_to_test] else: args.build = self._get_build_sources_parameter(args.build) self._manager.install(reference=test_folder, current_path=build_folder, remote=args.remote, options=options, settings=settings, build_mode=args.build, scopes=scopes, update=args.update, profile_name=args.profile) self._test_check(test_folder, test_folder_name) self._manager.build(test_folder, build_folder, test=True, profile_name=args.profile) # Alias to test def test(self, *args): """ (deprecated). Alias to test_package, use it instead """ self.test_package(*args) def install(self, *args): """ install in the local store the given requirements. Requirements can be defined in the command line or in a conanfile. EX: conan install opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='package recipe reference' 'e.g., MyPackage/1.2@user/channel or ./my_project/') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='Force install specified package ID (ignore settings/options)') parser.add_argument("--all", action='store_true', default=False, help='Install all packages from the specified package recipe') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("--update", "-u", action='store_true', default=False, help="update with new upstream packages") parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') parser.add_argument("--profile", "-pr", default=None, help='Define a profile') parser.add_argument("--generator", "-g", nargs=1, action=Extender, help='Generators to use') parser.add_argument("--werror", action='store_true', default=False, help='Error instead of warnings for graph inconsistencies') # Manifests arguments default_manifest_folder = '.conan_manifests' parser.add_argument("--manifests", "-m", const=default_manifest_folder, nargs="?", help='Install dependencies manifests in folder for later verify.' ' Default folder is .conan_manifests, but can be changed') parser.add_argument("--manifests-interactive", "-mi", const=default_manifest_folder, nargs="?", help='Install dependencies manifests in folder for later verify, ' 'asking user for confirmation. ' 'Default folder is .conan_manifests, but can be changed') parser.add_argument("--verify", "-v", const=default_manifest_folder, nargs="?", help='Verify dependencies manifests against stored ones') self._parse_args(parser) args = parser.parse_args(*args) self._user_io.out.werror_active = args.werror current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) if args.all or args.package: # Install packages without settings (fixed ids or all) if args.all: args.package = [] if not args.reference or not isinstance(reference, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.download(reference, args.package, remote=args.remote) else: # Classic install, package chosen with settings and options # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) scopes = Scopes.from_list(args.scope) if args.scope else None if args.manifests and args.manifests_interactive: raise ConanException("Do not specify both manifests and " "manifests-interactive arguments") if args.verify and (args.manifests or args.manifests_interactive): raise ConanException("Do not specify both 'verify' and " "'manifests' or 'manifests-interactive' arguments") manifest_folder = args.verify or args.manifests or args.manifests_interactive if manifest_folder: if not os.path.isabs(manifest_folder): if isinstance(reference, ConanFileReference): manifest_folder = os.path.join(current_path, manifest_folder) else: manifest_folder = os.path.join(reference, manifest_folder) manifest_verify = args.verify is not None manifest_interactive = args.manifests_interactive is not None else: manifest_verify = manifest_interactive = False self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, build_mode=args.build, filename=args.file, update=args.update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, scopes=scopes, generators=args.generator, profile_name=args.profile) def info(self, *args): """ Prints information about the requirements. Requirements can be defined in the command line or in a conanfile. EX: conan info opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='reference name or path to conanfile file, ' 'e.g., MyPackage/1.2@user/channel or ./my_project/') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--only", "-n", help='show fields only') parser.add_argument("--update", "-u", action='store_true', default=False, help="check updates exist from upstream remotes") parser.add_argument("--build_order", "-bo", help='given a modified reference, return ordered list to build (CI)', nargs=1, action=Extender) parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') args = parser.parse_args(*args) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) scopes = Scopes.from_list(args.scope) if args.scope else None self._manager.info(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, info=args.only or True, check_updates=args.update, filename=args.file, build_order=args.build_order, scopes=scopes) def build(self, *args): """ calls your project conanfile.py "build" method. EX: conan build ./my_project Intended for package creators, requires a conanfile.py. """ parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build") parser.add_argument("path", nargs="?", help='path to user conanfile.py, e.g., conan build .', default="") parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("--profile", "-pr", default=None, help='Define a profile') args = parser.parse_args(*args) current_path = os.getcwd() if args.path: root_path = os.path.abspath(args.path) else: root_path = current_path self._manager.build(root_path, current_path, filename=args.file, profile_name=args.profile) def package(self, *args): """ calls your conanfile.py "package" method for a specific package or regenerates the existing package's manifest. It will not create a new package, use 'install' or 'test_package' instead. Intended for package creators, for regenerating a package without recompiling the source, i.e. for troubleshooting, and fixing the package() method, not normal operation. It requires the package has been built locally, it will not re-package otherwise. e.g. conan package MyPackage/1.2@user/channel 9cf83afd07b678da9c1645f605875400847ff3 """ parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package") parser.add_argument("reference", help='package recipe reference name. ' 'e.g., MyPackage/1.2@user/channel') parser.add_argument("package", nargs="?", default="", help='Package ID to regenerate. e.g., ' '9cf83afd07b678d38a9c1645f605875400847ff3' ' If not specified, ALL binaries for this recipe are re-packaged') args = parser.parse_args(*args) try: reference = ConanFileReference.loads(args.reference) except: raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.package(reference, args.package) def source(self, *args): """ Calls your conanfile.py "source" method to configure the source directory. I.e., downloads and unzip the package source. """ parser = argparse.ArgumentParser(description=self.source.__doc__, prog="conan source") parser.add_argument("reference", help="package recipe reference name. e.g., zlib-ng/1.2.8@plex/stable") parser.add_argument("-f", "--force", default=False, action="store_true", help="force remove the source directory and run again.") args = parser.parse_args(*args) try: reference = ConanFileReference.loads(args.reference) except: raise ConanException("Invalid package recipe reference. e.g., zlib-ng/1.2.8@plex/stable") self._manager.source(reference, args.force) def export(self, *args): """ copies the package recipe (conanfile.py and associated files) to your local store, where it can be shared and reused in other projects. From that store, it can be uploaded to any remote with "upload" command. """ parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export") parser.add_argument("user", help='user_name[/channel]. By default, channel is ' '"testing", e.g., phil or phil/stable') parser.add_argument('--path', '-p', default=None, help='Optional. Folder with a %s. Default current directory.' % CONANFILE) parser.add_argument('--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') args = parser.parse_args(*args) current_path = os.path.abspath(args.path or os.getcwd()) keep_source = args.keep_source self._manager.export(args.user, current_path, keep_source) def remove(self, *args): """ Remove any package recipe or package from your local/remote store """ parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove") parser.add_argument('pattern', help='Pattern name, e.g., openssl/*') parser.add_argument('-p', '--packages', const=[], nargs='?', help='By default, remove all the packages or select one, ' 'specifying the SHA key') parser.add_argument('-b', '--builds', const=[], nargs='?', help='By default, remove all the build folders or select one, ' 'specifying the SHA key') parser.add_argument('-s', '--src', default=False, action="store_true", help='Remove source folders') parser.add_argument('-f', '--force', default=False, action='store_true', help='Remove without requesting a confirmation') parser.add_argument('-r', '--remote', help='Remote origin') args = parser.parse_args(*args) if args.packages: args.packages = args.packages.split(",") if args.builds: args.builds = args.builds.split(",") self._manager.remove(args.pattern, package_ids_filter=args.packages, build_ids=args.builds, src=args.src, force=args.force, remote=args.remote) def copy(self, *args): """ Copy package recipe and packages to another user/channel """ parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy") parser.add_argument("reference", default="", help='package recipe reference' 'e.g., MyPackage/1.2@user/channel') parser.add_argument("user_channel", default="", help='Destination user/channel' 'e.g., lasote/testing') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='copy specified package ID') parser.add_argument("--all", action='store_true', default=False, help='Copy all packages from the specified package recipe') parser.add_argument("--force", action='store_true', default=False, help='Override destination packages and the package recipe') args = parser.parse_args(*args) reference = ConanFileReference.loads(args.reference) new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name, reference.version, args.user_channel)) if args.all: args.package = [] self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force) def user(self, *parameters): """ shows or change the current user """ parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user") parser.add_argument("name", nargs='?', default=None, help='Username you want to use. ' 'If no name is provided it will show the current user.') parser.add_argument("-p", "--password", help='User password. Use double quotes ' 'if password with spacing, and escape quotes if existing') parser.add_argument("--remote", "-r", help='look for in the remote storage') parser.add_argument('-c', '--clean', default=False, action='store_true', help='Remove user and tokens for all remotes') args = parser.parse_args(*parameters) # To enable -h if args.clean: localdb = LocalDB(self._client_cache.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(args.remote, args.name, args.password) def search(self, *args): """ show local/remote packages """ parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search") parser.add_argument('pattern', nargs='?', help='Pattern name, e.g. openssl/* or package recipe reference if "-q" is used. e.g. MyPackage/1.2@user/channel') parser.add_argument('--case-sensitive', default=False, action='store_true', help='Make a case-sensitive search') parser.add_argument('-r', '--remote', help='Remote origin') parser.add_argument('-q', '--query', default=None, help='Packages query: "os=Windows AND arch=x86". The "pattern" parameter has to be a package recipe reference: MyPackage/1.2@user/channel') args = parser.parse_args(*args) reference = None if args.pattern: try: reference = ConanFileReference.loads(args.pattern) except ConanException: if args.query is not None: raise ConanException("-q parameter only allowed with a valid recipe " "reference as search pattern. e.j conan search " "MyPackage/1.2@user/channel -q \"os=Windows\"") self._manager.search(reference or args.pattern, args.remote, ignorecase=not args.case_sensitive, packages_query=args.query) def upload(self, *args): """ uploads a conanfile or binary packages from the local store to any remote. To upload something, it should be "exported" first. """ parser = argparse.ArgumentParser(description=self.upload.__doc__, prog="conan upload") parser.add_argument("reference", help='package recipe reference, e.g., MyPackage/1.2@user/channel') # TODO: packageparser.add_argument('package', help='user name') parser.add_argument("--package", "-p", default=None, help='package ID to upload') parser.add_argument("--remote", "-r", help='upload to this specific remote') parser.add_argument("--all", action='store_true', default=False, help='Upload both package recipe and packages') parser.add_argument("--force", action='store_true', default=False, help='Do not check conan recipe date, override remote with local') args = parser.parse_args(*args) conan_ref = ConanFileReference.loads(args.reference) package_id = args.package if not conan_ref and not package_id: raise ConanException("Enter conan reference or package id") self._manager.upload(conan_ref, package_id, args.remote, all_packages=args.all, force=args.force) def remote(self, *args): """ manage remotes """ parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote") subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help') # create the parser for the "a" command subparsers.add_parser('list', help='list current remotes') parser_add = subparsers.add_parser('add', help='add a remote') parser_add.add_argument('remote', help='name of the remote') parser_add.add_argument('url', help='url of the remote') parser_rm = subparsers.add_parser('remove', help='remove a remote') parser_rm.add_argument('remote', help='name of the remote') parser_upd = subparsers.add_parser('update', help='update the remote url') parser_upd.add_argument('remote', help='name of the remote') parser_upd.add_argument('url', help='url') subparsers.add_parser('list_ref', help='list the package recipes and its associated remotes') parser_padd = subparsers.add_parser('add_ref', help="associate a recipe's reference to a remote") parser_padd.add_argument('reference', help='package recipe reference') parser_padd.add_argument('remote', help='name of the remote') parser_prm = subparsers.add_parser('remove_ref', help="dissociate a recipe's reference and its remote") parser_prm.add_argument('reference', help='package recipe reference') parser_pupd = subparsers.add_parser('update_ref', help="update the remote associated " "with a package recipe") parser_pupd.add_argument('reference', help='package recipe reference') parser_pupd.add_argument('remote', help='name of the remote') args = parser.parse_args(*args) registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) if args.subcommand == "list": for r in registry.remotes: self._user_io.out.info("%s: %s" % (r.name, r.url)) elif args.subcommand == "add": registry.add(args.remote, args.url) elif args.subcommand == "remove": registry.remove(args.remote) elif args.subcommand == "update": registry.update(args.remote, args.url) elif args.subcommand == "list_ref": for ref, remote in registry.refs.items(): self._user_io.out.info("%s: %s" % (ref, remote)) elif args.subcommand == "add_ref": registry.add_ref(args.reference, args.remote) elif args.subcommand == "remove_ref": registry.remove_ref(args.reference) elif args.subcommand == "update_ref": registry.update_ref(args.reference, args.remote) def _show_help(self): """ prints a summary of all commands """ self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help', Color.BRIGHT_YELLOW) commands = self._commands() for name in sorted(self._commands()): self._user_io.out.write(' %-10s' % name, Color.GREEN) self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0]) def _commands(self): """ returns a list of available commands """ result = {} for m in inspect.getmembers(self, predicate=inspect.ismethod): method_name = m[0] if not method_name.startswith('_'): method = m[1] if method.__doc__ and not method.__doc__.startswith('HIDDEN'): result[method_name] = method return result def run(self, *args): """HIDDEN: entry point for executing commands, dispatcher to class methods """ errors = False try: try: command = args[0][0] commands = self._commands() method = commands[command] except KeyError as exc: if command in ["-v", "--version"]: self._user_io.out.success("Conan version %s" % CLIENT_VERSION) return False self._show_help() if command in ["-h", "--help"]: return False raise ConanException("Unknown command %s" % str(exc)) except IndexError as exc: # No parameters self._show_help() return False method(args[0][1:]) except (KeyboardInterrupt, SystemExit) as exc: logger.error(exc) errors = True except ConanException as exc: try: msg = unicode(exc) except: msg = str(exc) # import traceback # logger.debug(traceback.format_exc()) errors = True self._user_io.out.error(msg) return errors
class ConanAPIV1(object): @staticmethod def factory(): """Factory""" def instance_remote_manager(client_cache): requester = get_basic_requester(client_cache) # Verify client version against remotes version_checker_requester = VersionCheckerRequester( requester, Version(CLIENT_VERSION), Version(MIN_SERVER_COMPATIBLE_VERSION), out) # To handle remote connections put_headers = client_cache.read_put_headers() rest_api_client = RestApiClient( out, requester=version_checker_requester, put_headers=put_headers) # To store user and token localdb = LocalDB(client_cache.localdb) # Wraps RestApiClient to add authentication support (same interface) auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb) # Handle remote connections remote_manager = RemoteManager(client_cache, auth_manager, out) return remote_manager use_color = get_env("CONAN_COLOR_DISPLAY", 1) if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): import colorama colorama.init() color = True else: color = False out = ConanOutput(sys.stdout, color) user_io = UserIO(out=out) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: client_cache = migrate_and_get_client_cache(user_folder, out) except Exception as e: out.error(str(e)) raise with tools.environment_append(client_cache.conan_config.env_vars): # Adjust CONAN_LOGGING_LEVEL with the env readed conans.util.log.logger = configure_logger() # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager) return conan def __init__(self, client_cache, user_io, runner, remote_manager, search_manager): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager) # Patch the tools module with a good requester and user_io tools._global_requester = get_basic_requester(self._client_cache) tools._global_output = self._user_io.out @api_method def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None, visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None, shared=None, upload_url=None, gitignore=None): from conans.client.new import get_files cwd = prepare_cwd(cwd) files = get_files(name, header=header, pure_c=pure_c, test=test, exports_sources=exports_sources, bare=bare, visual_versions=visual_versions, linux_gcc_versions=linux_gcc_versions, linux_clang_versions=linux_clang_versions, osx_clang_versions=osx_clang_versions, shared=shared, upload_url=upload_url, gitignore=gitignore) save_files(cwd, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) @api_method def test_package(self, path=None, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build=None, keep_source=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, remote=None, update=False, cwd=None): settings = settings or [] options = options or [] env = env or [] cwd = prepare_cwd(cwd) root_folder = os.path.normpath(os.path.join(cwd, path)) if test_folder: test_folder_name = test_folder test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % test_folder) else: for name in ["test_package", "test"]: test_folder_name = name test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile): break else: raise ConanException( "test folder 'test_package' not available, " "or it doesn't have a conanfile.py") options = options or [] settings = settings or [] sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) conanfile = load_consumer_conanfile(test_conanfile, "", self._client_cache.settings, self._runner, self._user_io.out) try: # convert to list from ItemViews required for python3 if hasattr(conanfile, "requirements"): conanfile.requirements() reqs = list(conanfile.requires.items()) first_dep = reqs[0][1].conan_reference except Exception: raise ConanException( "Unable to retrieve first requirement of test conanfile.py") # Forcing an export! if not not_export: self._user_io.out.info("Exporting package recipe") user_channel = "%s/%s" % (first_dep.user, first_dep.channel) self._manager.export(user_channel, root_folder, keep_source=keep_source) lib_to_test = first_dep.name # Get False or a list of patterns to check if build is None and lib_to_test: # Not specified, force build the tested library build = [lib_to_test] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, root_folder, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests self._manager.install(reference=test_folder, current_path=build_folder, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build, update=update, generators=["txt"]) test_conanfile = os.path.join(test_folder, CONANFILE) self._manager.build(test_conanfile, test_folder, build_folder, test=True) # Alias to test @api_method def test(self, *args): self.test_package(*args) @api_method def package_files(self, reference, package_folder=None, profile_name=None, force=False, settings=None, options=None, cwd=None): cwd = prepare_cwd(cwd) reference = ConanFileReference.loads(reference) package_folder = package_folder or cwd if not os.path.isabs(package_folder): package_folder = os.path.join(cwd, package_folder) profile = profile_from_args( profile_name, settings, options, env=None, scope=None, cwd=cwd, default_folder=self._client_cache.profiles_path) self._manager.package_files(reference=reference, package_folder=package_folder, profile=profile, force=force) @api_method def install(self, reference="", package=None, settings=None, options=None, env=None, scope=None, all=False, remote=None, werror=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, build=None, profile_name=None, update=False, generator=None, no_imports=False, filename=None, cwd=None): self._user_io.out.werror_active = werror cwd = prepare_cwd(cwd) try: ref = ConanFileReference.loads(reference) except: ref = os.path.normpath(os.path.join(cwd, reference)) if all or package: # Install packages without settings (fixed ids or all) if all: package = [] if not reference or not isinstance(ref, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.download(ref, package, remote=remote) else: # Classic install, package chosen with settings and options manifests = _parse_manifests_arguments( verify, manifests, manifests_interactive, cwd, self._client_cache.profiles_path) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) self._manager.install(reference=ref, current_path=cwd, remote=remote, profile=profile, build_modes=build, filename=filename, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generator, no_imports=no_imports) @api_method def config_get(self, item): config_parser = ConanClientConfigParser( self._client_cache.conan_conf_path) self._user_io.out.info(config_parser.get_item(item)) return config_parser.get_item(item) @api_method def config_set(self, item, value): config_parser = ConanClientConfigParser( self._client_cache.conan_conf_path) config_parser.set_item(item, value) @api_method def config_rm(self, item): config_parser = ConanClientConfigParser( self._client_cache.conan_conf_path) config_parser.rm_item(item) @api_method def info_build_order(self, reference, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, build_order=None, check_updates=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) graph = self._manager.info_build_order(reference, profile, filename, build_order, remote, check_updates, cwd=cwd) return graph @api_method def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, check_updates=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) ret = self._manager.info_nodes_to_build(reference, profile, filename, build_modes, remote, check_updates, cwd) ref_list, project_reference = ret return ref_list, project_reference @api_method def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, scope=None, profile_name=None, update=False, filename=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, current_path, self._client_cache.profiles_path) ret = self._manager.info_get_graph(reference=reference, current_path=current_path, remote=remote, profile=profile, check_updates=update, filename=filename) deps_graph, graph_updates_info, project_reference = ret return deps_graph, graph_updates_info, project_reference @api_method def build(self, path="", source_folder=None, filename=None, cwd=None): current_path = prepare_cwd(cwd) if path: root_path = os.path.abspath(path) else: root_path = current_path build_folder = current_path source_folder = source_folder or root_path if not os.path.isabs(source_folder): source_folder = os.path.normpath( os.path.join(current_path, source_folder)) if filename and filename.endswith(".txt"): raise ConanException( "A conanfile.py is needed to call 'conan build'") conanfile_path = os.path.join(root_path, filename or CONANFILE) self._manager.build(conanfile_path, source_folder, build_folder) @api_method def package(self, reference="", package=None, build_folder=None, source_folder=None, cwd=None): current_path = prepare_cwd(cwd) try: self._manager.package(ConanFileReference.loads(reference), package) except: if "@" in reference: raise recipe_folder = reference if not os.path.isabs(recipe_folder): recipe_folder = os.path.normpath( os.path.join(current_path, recipe_folder)) build_folder = build_folder or current_path if not os.path.isabs(build_folder): build_folder = os.path.normpath( os.path.join(current_path, build_folder)) package_folder = current_path source_folder = source_folder or recipe_folder self._manager.local_package(package_folder, recipe_folder, build_folder, source_folder) @api_method def source(self, reference, force=False, cwd=None): cwd = prepare_cwd(cwd) current_path, reference = _get_reference(reference, cwd) self._manager.source(current_path, reference, force) @api_method def imports(self, reference, undo=False, dest=None, filename=None, cwd=None): cwd = prepare_cwd(cwd) if undo: if not os.path.isabs(reference): current_path = os.path.normpath(os.path.join(cwd, reference)) else: current_path = reference self._manager.imports_undo(current_path) else: cwd = prepare_cwd(cwd) current_path, reference = _get_reference(reference, cwd) self._manager.imports(current_path, reference, filename, dest) @api_method def export(self, user, path=None, keep_source=False, filename=None, cwd=None): cwd = prepare_cwd(cwd) current_path = os.path.abspath(path or cwd) self._manager.export(user, current_path, keep_source, filename=filename) @api_method def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False, remote=None): self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds, src=src, force=force, remote=remote, packages_query=query) @api_method def copy(self, reference="", user_channel="", force=False, all=False, package=None): reference = ConanFileReference.loads(reference) new_ref = ConanFileReference.loads( "%s/%s@%s" % (reference.name, reference.version, user_channel)) if all: package = [] self._manager.copy(reference, package, new_ref.user, new_ref.channel, force) @api_method def user(self, name=None, clean=False, remote=None, password=None): if clean: localdb = LocalDB(self._client_cache.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(remote, name, password) @api_method def search_recipes(self, pattern, remote=None, case_sensitive=False): refs = self._manager.search_recipes(pattern, remote, ignorecase=not case_sensitive) return refs @api_method def search_packages(self, reference, query=None, remote=None): ret = self._manager.search_packages(reference, remote, packages_query=query) return ret @api_method def upload(self, pattern, package=None, remote=None, all=False, force=False, confirm=False, retry=2, retry_wait=5, skip_upload=False): """ Uploads a package recipe and the generated binary packages to a specified remote """ if package and not is_a_reference(pattern): raise ConanException( "-p parameter only allowed with a valid recipe reference, " "not with a pattern") self._manager.upload(pattern, package, remote, all_packages=all, force=force, confirm=confirm, retry=retry, retry_wait=retry_wait, skip_upload=skip_upload) @api_method def remote_list(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) for r in registry.remotes: self._user_io.out.info("%s: %s [Verify SSL: %s]" % (r.name, r.url, r.verify_ssl)) @api_method def remote_add(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add(remote, url, verify_ssl, insert) @api_method def remote_remove(self, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove(remote) @api_method def remote_update(self, remote, url, verify_ssl=True): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update(remote, url, verify_ssl) @api_method def remote_list_ref(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) for ref, remote in registry.refs.items(): self._user_io.out.info("%s: %s" % (ref, remote)) @api_method def remote_add_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add_ref(reference, remote) @api_method def remote_remove_ref(self, reference): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove_ref(reference) @api_method def remote_update_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update_ref(reference, remote) @api_method def profile(self, subcommand, profile=None, cwd=None): cwd = prepare_cwd(cwd) if subcommand == "list": folder = self._client_cache.profiles_path if os.path.exists(folder): profiles = [ name for name in os.listdir(folder) if not os.path.isdir(name) ] for p in sorted(profiles): self._user_io.out.info(p) else: self._user_io.out.info("No profiles defined") elif subcommand == "show": p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path) Printer(self._user_io.out).print_profile(profile, p)
class ConanAPIV1(object): @staticmethod def factory(): """Factory""" def instance_remote_manager(client_cache): requester = get_basic_requester(client_cache) # Verify client version against remotes version_checker_requester = VersionCheckerRequester(requester, Version(CLIENT_VERSION), Version(MIN_SERVER_COMPATIBLE_VERSION), out) # To handle remote connections put_headers = client_cache.read_put_headers() rest_api_client = RestApiClient(out, requester=version_checker_requester, put_headers=put_headers) # To store user and token localdb = LocalDB(client_cache.localdb) # Wraps RestApiClient to add authentication support (same interface) auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb) # Handle remote connections remote_manager = RemoteManager(client_cache, auth_manager, out) return remote_manager use_color = get_env("CONAN_COLOR_DISPLAY", 1) if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): import colorama colorama.init() color = True else: color = False out = ConanOutput(sys.stdout, color) user_io = UserIO(out=out) try: client_cache = migrate_and_get_client_cache(get_conan_user_home(), out) except Exception as e: out.error(str(e)) raise with tools.environment_append(client_cache.conan_config.env_vars): # Adjust CONAN_LOGGING_LEVEL with the env readed conans.util.log.logger = configure_logger() # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) # Settings preprocessor conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager, settings_preprocessor) return conan def __init__(self, client_cache, user_io, runner, remote_manager, search_manager, settings_preprocessor): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager, settings_preprocessor) # Patch the tools module with a good requester and user_io tools._global_requester = get_basic_requester(self._client_cache) tools._global_output = self._user_io.out @api_method def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None, visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None, shared=None, upload_url=None, gitignore=None, gitlab_gcc_versions=None, gitlab_clang_versions=None): from conans.client.new import get_files cwd = prepare_cwd(cwd) files = get_files(name, header=header, pure_c=pure_c, test=test, exports_sources=exports_sources, bare=bare, visual_versions=visual_versions, linux_gcc_versions=linux_gcc_versions, linux_clang_versions=linux_clang_versions, osx_clang_versions=osx_clang_versions, shared=shared, upload_url=upload_url, gitignore=gitignore, gitlab_gcc_versions=gitlab_gcc_versions, gitlab_clang_versions=gitlab_clang_versions) save_files(cwd, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) @api_method def test_package(self, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build=None, keep_source=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, remote=None, update=False, cwd=None, user=None, channel=None, name=None, version=None): settings = settings or [] options = options or [] env = env or [] cwd = prepare_cwd(cwd) if name and version: package_name = name package_version = version else: conanfile_path = os.path.join(cwd, "conanfile.py") conanfile = load_conanfile_class(conanfile_path) package_name = getattr(conanfile, "name", None) package_version = getattr(conanfile, "version", None) if not package_name or not package_version: raise ConanException("conanfile.py doesn't declare package name or version") test_folders = [test_folder] if test_folder else ["test_package", "test"] for test_folder_name in test_folders: test_folder = os.path.join(cwd, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): break else: raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % test_folder_name) sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) loader = self._manager.get_loader(profile) test_conanfile = loader.load_conan(test_conanfile_path, self._user_io.out, consumer=True) try: if hasattr(test_conanfile, "requirements"): test_conanfile.requirements() except Exception as e: raise ConanException("Error in test_package/conanfile.py requirements(). %s" % str(e)) requirement = test_conanfile.requires.get(package_name) if requirement: if requirement.conan_reference.version != package_version: raise ConanException("package version is '%s', but test_package/conanfile " "is requiring version '%s'\n" "You can remove this requirement and use " "'conan test_package user/channel' instead" % (package_version, requirement.conan_reference.version)) user = user or requirement.conan_reference.user channel = channel or requirement.conan_reference.channel if not user or not channel: raise ConanException("Please specify user and channel") conanfile_reference = ConanFileReference(package_name, package_version, user, channel) # Forcing an export! if not not_export: self._user_io.out.info("Exporting package recipe") self._manager.export(user, channel, cwd, keep_source=keep_source) if build is None: # Not specified, force build the tested library build = [package_name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests self._manager.install(inject_require=conanfile_reference, reference=test_folder, current_path=build_folder, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build, update=update, generators=["txt"] ) test_conanfile = os.path.join(test_folder, CONANFILE) self._manager.build(test_conanfile, test_folder, build_folder, package_folder=None, test=str(conanfile_reference)) @api_method def create(self, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build=None, keep_source=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, remote=None, update=False, cwd=None, user=None, channel=None, name=None, version=None): settings = settings or [] options = options or [] env = env or [] cwd = prepare_cwd(cwd) if not name or not version: conanfile_path = os.path.join(cwd, "conanfile.py") conanfile = load_conanfile_class(conanfile_path) name, version = conanfile.name, conanfile.version if not name or not version: raise ConanException("conanfile.py doesn't declare package name or version") reference = ConanFileReference(name, version, user, channel) scoped_output = ScopedOutput(str(reference), self._user_io.out) # Forcing an export! if not not_export: scoped_output.highlight("Exporting package recipe") self._manager.export(user, channel, cwd, keep_source=keep_source, name=name, version=version) if build is None: # Not specified, force build the tested library build = [name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) self._manager.install(reference=reference, current_path=cwd, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build, update=update ) test_folders = [test_folder] if test_folder else ["test_package", "test"] for test_folder_name in test_folders: test_folder = os.path.join(cwd, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): break else: self._user_io.out.warn("test package folder not available, or it doesn't have " "a conanfile.py\nIt is recommended to set a 'test_package' " "while creating packages") return scoped_output.highlight("Testing with 'test_package'") sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) test_conanfile = os.path.join(test_folder, CONANFILE) self._manager.install(inject_require=reference, reference=test_folder, current_path=build_folder, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, update=update, generators=["txt"] ) self._manager.build(test_conanfile, test_folder, build_folder, package_folder=None, test=str(reference)) @api_method def package_files(self, reference, source_folder=None, build_folder=None, package_folder=None, profile_name=None, force=False, settings=None, options=None, cwd=None): cwd = prepare_cwd(cwd) reference = ConanFileReference.loads(reference) profile = profile_from_args(profile_name, settings, options, env=None, scope=None, cwd=cwd, default_folder=self._client_cache.profiles_path) package_folder = package_folder or cwd if not source_folder and build_folder: source_folder = build_folder if not os.path.isabs(package_folder): package_folder = os.path.join(cwd, package_folder) if source_folder and not os.path.isabs(source_folder): source_folder = os.path.normpath(os.path.join(cwd, source_folder)) if build_folder and not os.path.isabs(build_folder): build_folder = os.path.normpath(os.path.join(cwd, build_folder)) self._manager.package_files(reference=reference, source_folder=source_folder, build_folder=build_folder, package_folder=package_folder, profile=profile, force=force) @api_method def install(self, reference="", package=None, settings=None, options=None, env=None, scope=None, all=False, remote=None, werror=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, build=None, profile_name=None, update=False, generator=None, no_imports=False, filename=None, cwd=None): self._user_io.out.werror_active = werror cwd = prepare_cwd(cwd) try: ref = ConanFileReference.loads(reference) except: ref = os.path.normpath(os.path.join(cwd, reference)) if all or package: # Install packages without settings (fixed ids or all) if all: package = [] if not reference or not isinstance(ref, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.download(ref, package, remote=remote) else: # Classic install, package chosen with settings and options manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) self._manager.install(reference=ref, current_path=cwd, remote=remote, profile=profile, build_modes=build, filename=filename, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generator, no_imports=no_imports) @api_method def config_get(self, item): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) self._user_io.out.info(config_parser.get_item(item)) return config_parser.get_item(item) @api_method def config_set(self, item, value): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) config_parser.set_item(item, value) @api_method def config_rm(self, item): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) config_parser.rm_item(item) @api_method def info_build_order(self, reference, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, build_order=None, check_updates=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) graph = self._manager.info_build_order(reference, profile, filename, build_order, remote, check_updates, cwd=cwd) return graph @api_method def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, check_updates=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) ret = self._manager.info_nodes_to_build(reference, profile, filename, build_modes, remote, check_updates, cwd) ref_list, project_reference = ret return ref_list, project_reference @api_method def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, scope=None, profile_name=None, update=False, filename=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, current_path, self._client_cache.profiles_path) ret = self._manager.info_get_graph(reference=reference, current_path=current_path, remote=remote, profile=profile, check_updates=update, filename=filename) deps_graph, graph_updates_info, project_reference = ret return deps_graph, graph_updates_info, project_reference @api_method def build(self, path="", source_folder=None, package_folder=None, filename=None, cwd=None): current_path = prepare_cwd(cwd) if path: root_path = os.path.abspath(path) else: root_path = current_path build_folder = current_path source_folder = source_folder or root_path if not os.path.isabs(source_folder): source_folder = os.path.normpath(os.path.join(current_path, source_folder)) if package_folder and not os.path.isabs(package_folder): package_folder = os.path.normpath(os.path.join(current_path, package_folder)) if filename and filename.endswith(".txt"): raise ConanException("A conanfile.py is needed to call 'conan build'") conanfile_path = os.path.join(root_path, filename or CONANFILE) self._manager.build(conanfile_path, source_folder, build_folder, package_folder) @api_method def package(self, reference="", package_id=None, build_folder=None, source_folder=None, cwd=None): try: ref = ConanFileReference.loads(reference) except: if "@" in reference: raise ref = None if ref: # cache packaging # TODO: other args are unused. Either raise, or split API in two methods self._manager.package(ref, package_id) else: # local packaging current_path = prepare_cwd(cwd) recipe_folder = reference if not os.path.isabs(recipe_folder): recipe_folder = os.path.join(current_path, recipe_folder) recipe_folder = os.path.normpath(recipe_folder) build_folder = build_folder or recipe_folder if not os.path.isabs(build_folder): build_folder = os.path.join(current_path, build_folder) build_folder = os.path.normpath(build_folder) package_folder = current_path source_folder = source_folder or recipe_folder self._manager.local_package(package_folder, recipe_folder, build_folder, source_folder) @api_method def source(self, reference, force=False, cwd=None): cwd = prepare_cwd(cwd) current_path, reference = _get_reference(reference, cwd) self._manager.source(current_path, reference, force) @api_method def imports(self, reference, undo=False, dest=None, filename=None, cwd=None): cwd = prepare_cwd(cwd) if undo: if not os.path.isabs(reference): current_path = os.path.normpath(os.path.join(cwd, reference)) else: current_path = reference self._manager.imports_undo(current_path) else: cwd = prepare_cwd(cwd) current_path, reference = _get_reference(reference, cwd) self._manager.imports(current_path, reference, filename, dest) @api_method def export(self, user, channel, path=None, keep_source=False, filename=None, cwd=None, name=None, version=None): cwd = prepare_cwd(cwd) current_path = os.path.abspath(path or cwd) self._manager.export(user, channel, current_path, keep_source, filename=filename, name=name, version=version) @api_method def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False, remote=None, outdated=False): self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds, src=src, force=force, remote=remote, packages_query=query, outdated=outdated) @api_method def copy(self, reference="", user_channel="", force=False, all=False, package=None): reference = ConanFileReference.loads(reference) new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name, reference.version, user_channel)) if all: package = [] self._manager.copy(reference, package, new_ref.user, new_ref.channel, force) @api_method def user(self, name=None, clean=False, remote=None, password=None): if clean: localdb = LocalDB(self._client_cache.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(remote, name, password) @api_method def search_recipes(self, pattern, remote=None, case_sensitive=False): refs = self._manager.search_recipes(pattern, remote, ignorecase=not case_sensitive) return refs @api_method def search_packages(self, reference, query=None, remote=None, outdated=False): ret = self._manager.search_packages(reference, remote, packages_query=query, outdated=outdated) return ret @api_method def upload(self, pattern, package=None, remote=None, all=False, force=False, confirm=False, retry=2, retry_wait=5, skip_upload=False, integrity_check=False): """ Uploads a package recipe and the generated binary packages to a specified remote """ if package and not is_a_reference(pattern): raise ConanException("-p parameter only allowed with a valid recipe reference, " "not with a pattern") self._manager.upload(pattern, package, remote, all_packages=all, force=force, confirm=confirm, retry=retry, retry_wait=retry_wait, skip_upload=skip_upload, integrity_check=integrity_check) @api_method def remote_list(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remotes @api_method def remote_add(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add(remote, url, verify_ssl, insert) @api_method def remote_remove(self, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove(remote) @api_method def remote_update(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update(remote, url, verify_ssl, insert) @api_method def remote_list_ref(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.refs @api_method def remote_add_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add_ref(reference, remote) @api_method def remote_remove_ref(self, reference): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove_ref(reference) @api_method def remote_update_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update_ref(reference, remote) @api_method def profile_list(self): folder = self._client_cache.profiles_path if os.path.exists(folder): return [name for name in os.listdir(folder) if not os.path.isdir(name)] else: self._user_io.out.info("No profiles defined") return [] @api_method def create_profile(self, profile_name, detect=False): profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd()) if os.path.exists(profile_path): raise ConanException("Profile already exists") profile = Profile() if detect: settings = detect_defaults_settings(self._user_io.out) for name, value in settings: profile.settings[name] = value contents = profile.dumps() save(profile_path, contents) self._user_io.out.info("Empty profile created: %s" % profile_path) return profile_path @staticmethod def _get_profile_keys(key): # settings.compiler.version => settings, compiler.version tmp = key.split(".") first_key = tmp[0] rest_key = ".".join(tmp[1:]) if len(tmp) > 1 else None if first_key not in ("build_requires", "settings", "options", "scopes", "env"): raise ConanException("Invalid specified key: %s" % key) return first_key, rest_key @api_method def update_profile(self, profile_name, key, value): first_key, rest_key = self._get_profile_keys(key) profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path) if first_key == "settings": profile.settings[rest_key] = value elif first_key == "options": tmp = OptionsValues([(rest_key, value)]) profile.options.update(tmp) elif first_key == "env": profile.env_values.update(EnvValues.loads("%s=%s" % (rest_key, value))) elif first_key == "scopes": profile.update_scopes(Scopes.from_list(["%s=%s" % (rest_key, value)])) elif first_key == "build_requires": raise ConanException("Edit the profile manually to change the build_requires") contents = profile.dumps() profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd()) save(profile_path, contents) @api_method def delete_profile_key(self, profile_name, key): first_key, rest_key = self._get_profile_keys(key) profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path) # For options, scopes, env vars try: package, name = rest_key.split(":") except ValueError: package = None name = rest_key try: if first_key == "settings": del profile.settings[rest_key] elif first_key == "options": profile.options.remove(name, package) elif first_key == "env": profile.env_values.remove(name, package) elif first_key == "scopes": profile.scopes.remove(name, package) elif first_key == "build_requires": raise ConanException("Edit the profile manually to delete a build_require") except KeyError: raise ConanException("Profile key '%s' doesn't exist" % key) contents = profile.dumps() profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd()) save(profile_path, contents) @api_method def read_profile(self, profile=None): p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path) return p @api_method def get_path(self, reference, package_id=None, path=None, remote=None): reference = ConanFileReference.loads(str(reference)) return self._manager.get_path(reference, package_id, path, remote) @api_method def export_alias(self, reference, target_reference): reference = ConanFileReference.loads(str(reference)) target_reference = ConanFileReference.loads(str(target_reference)) return self._manager.export_alias(reference, target_reference)
class Command(object): """ A single command of the conan application, with all the first level commands. Manages the parsing of parameters and delegates functionality in collaborators. It can also show help of the tool """ def __init__(self, client_cache, user_io, runner, remote_manager, search_manager): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager) def _parse_args(self, parser): parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--env", "-e", help='set environment variables to build the package, -e CXX=/usr/bin/clang++', nargs=1, action=Extender) parser.add_argument("--build", "-b", action=Extender, nargs="*", help='''Optional, use it to choose if you want to build from sources: --build Build all from sources, do not use binary packages. --build=never Default option. Never build, use binary packages or fail if a binary package is not found. --build=missing Build from code if a binary package is not found. --build=outdated Build from code if the binary is not built with the current recipe or when missing binary package. --build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters. ''') def _get_tuples_list_from_extender_arg(self, items): if not items: return [] # Validate the pairs for item in items: chunks = item.split("=") if len(chunks) != 2: raise ConanException("Invalid input '%s', use 'name=value'" % item) return [(item[0], item[1]) for item in [item.split("=") for item in items]] def _get_simple_and_package_tuples(self, items): ''' Parse items like "thing:item=value or item2=value2 and returns a tuple list for the simple items (name, value) and a dict for the package items {package: [(item, value)...)], ...} ''' simple_items = [] package_items = defaultdict(list) tuples = self._get_tuples_list_from_extender_arg(items) for name, value in tuples: if ":" in name: # Scoped items tmp = name.split(":", 1) ref_name = tmp[0] name = tmp[1] package_items[ref_name].append((name, value)) else: simple_items.append((name, value)) return simple_items, package_items def _get_build_sources_parameter(self, build_param): # returns True if we want to build the missing libraries # False if building is forbidden # A list with patterns: Will force build matching libraries, # will look for the package for the rest # "outdated" if will build when the package is not generated with # the current exported recipe if isinstance(build_param, list): if len(build_param) == 0: # All packages from source return ["*"] elif len(build_param) == 1 and build_param[0] == "never": return False # Default elif len(build_param) == 1 and build_param[0] == "missing": return True elif len(build_param) == 1 and build_param[0] == "outdated": return "outdated" else: # A list of expressions to match (if matches, will build from source) return ["%s*" % ref_expr for ref_expr in build_param] else: return False # Nothing is built def _test_check(self, test_folder, test_folder_name): """ To ensure that the 0.9 version new layout is detected and users warned """ # Check old tests, format test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("Test conanfile.py does not exist") test_conanfile_content = load(test_conanfile) if ".conanfile_directory" not in test_conanfile_content: self._user_io.out.error("""******* conan test command layout has changed ******* In your "%s" folder 'conanfile.py' you should use the path to the conanfile_directory, something like: self.run('cmake %%s %%s' %% (self.conanfile_directory, cmake.command_line)) """ % (test_folder_name)) # Test the CMakeLists, if existing test_cmake = os.path.join(test_folder, "CMakeLists.txt") if os.path.exists(test_cmake): test_cmake_content = load(test_cmake) if "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake" not in test_cmake_content: self._user_io.out.error("""******* conan test command layout has changed ******* In your "%s" folder 'CMakeLists.txt' you should use the path to the CMake binary directory, like this: include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) """ % (test_folder_name)) def new(self, *args): """ create a new package template conanfile.py and other optional files """ parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new", formatter_class=RawTextHelpFormatter) parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing') parser.add_argument("-t", "--test", action='store_true', default=False, help='Create test_package skeleton to test package') parser.add_argument("-i", "--header", action='store_true', default=False, help='Create a headers only package') parser.add_argument("-c", "--pure_c", action='store_true', default=False, help='Create a C language package only package (non-headers)') args = parser.parse_args(*args) root_folder = os.getcwd() try: name, version, user, channel = ConanFileReference.loads(args.name) pattern = re.compile('[\W_]+') package_name = pattern.sub('', name).capitalize() except: raise ConanException("Bad parameter, please use full package name," "e.g: MyLib/1.2.3@user/testing") from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake, test_main) if args.header: files = {"conanfile.py": conanfile_header.format(name=name, version=version, package_name=package_name)} else: files = {"conanfile.py": conanfile.format(name=name, version=version, package_name=package_name)} if args.pure_c: config = "\n def config(self):\n del self.settings.compiler.libcxx" files["conanfile.py"] = files["conanfile.py"] + config if args.test: files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version, user=user, channel=channel, package_name=package_name) files["test_package/CMakeLists.txt"] = test_cmake files["test_package/example.cpp"] = test_main save_files(root_folder, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) def test_package(self, *args): """ build and run your package test. Must have conanfile.py with "test" method and "test_package" subfolder with package consumer test project """ parser = argparse.ArgumentParser(description=self.test_package.__doc__, prog="conan test_package", formatter_class=RawTextHelpFormatter) parser.add_argument("path", nargs='?', default="", help='path to conanfile file, ' 'e.g. /my_project/') parser.add_argument("-ne", "--not-export", default=False, action='store_true', help='Do not export the conanfile before test execution') parser.add_argument("-f", "--folder", help='alternative test folder name') parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') parser.add_argument('--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') parser.add_argument("--update", "-u", action='store_true', default=False, help="update with new upstream packages") parser.add_argument("--profile", "-pr", default=None, help='Define a profile') self._parse_args(parser) args = parser.parse_args(*args) current_path = os.getcwd() root_folder = os.path.normpath(os.path.join(current_path, args.path)) if args.folder: test_folder_name = args.folder test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % args.folder) else: for name in ["test_package", "test"]: test_folder_name = name test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile): break else: raise ConanException("test folder 'test_package' not available, " "or it doesn't have a conanfile.py") options = args.options or [] settings = args.settings or [] sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) options = self._get_tuples_list_from_extender_arg(args.options) env, package_env = self._get_simple_and_package_tuples(args.env) settings, package_settings = self._get_simple_and_package_tuples(args.settings) scopes = Scopes.from_list(args.scope) if args.scope else None manager = self._manager # Read profile environment and mix with the command line parameters if args.profile: try: profile = manager.read_profile(args.profile, current_path) except ConanException as exc: raise ConanException("Error reading '%s' profile: %s" % (args.profile, exc)) else: profile.update_env(env) profile.update_packages_env(package_env) env = profile.env package_env = profile.package_env loader = manager._loader(current_path=None, user_settings_values=settings, user_options_values=options, scopes=scopes, package_settings=package_settings, env=env, package_env=package_env) conanfile = loader.load_conan(test_conanfile, self._user_io.out, consumer=True) try: # convert to list from ItemViews required for python3 conanfile.requirements() reqs = list(conanfile.requires.items()) first_dep = reqs[0][1].conan_reference except Exception: raise ConanException("Unable to retrieve first requirement of test conanfile.py") # Forcing an export! if not args.not_export: self._user_io.out.info("Exporting package recipe") user_channel = "%s/%s" % (first_dep.user, first_dep.channel) self._manager.export(user_channel, root_folder, keep_source=args.keep_source) lib_to_test = first_dep.name + "*" # Get False or a list of patterns to check if args.build is None and lib_to_test: # Not specified, force build the tested library args.build = [lib_to_test] else: args.build = self._get_build_sources_parameter(args.build) self._manager.install(reference=test_folder, current_path=build_folder, remote=args.remote, options=options, settings=settings, package_settings=package_settings, build_mode=args.build, scopes=scopes, update=args.update, generators=["env", "txt"], profile_name=args.profile, env=env, package_env=package_env ) self._test_check(test_folder, test_folder_name) self._manager.build(test_folder, build_folder, test=True, profile_name=args.profile, env=env, package_env=package_env) # Alias to test def test(self, *args): """ (deprecated). Alias to test_package, use it instead """ self.test_package(*args) def install(self, *args): """ install in the local store the given requirements. Requirements can be defined in the command line or in a conanfile. EX: conan install opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='package recipe reference' 'e.g., MyPackage/1.2@user/channel or ./my_project/') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='Force install specified package ID (ignore settings/options)') parser.add_argument("--all", action='store_true', default=False, help='Install all packages from the specified package recipe') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("--update", "-u", action='store_true', default=False, help="update with new upstream packages") parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') parser.add_argument("--profile", "-pr", default=None, help='Define a profile') parser.add_argument("--generator", "-g", nargs=1, action=Extender, help='Generators to use') parser.add_argument("--werror", action='store_true', default=False, help='Error instead of warnings for graph inconsistencies') # Manifests arguments default_manifest_folder = '.conan_manifests' parser.add_argument("--manifests", "-m", const=default_manifest_folder, nargs="?", help='Install dependencies manifests in folder for later verify.' ' Default folder is .conan_manifests, but can be changed') parser.add_argument("--manifests-interactive", "-mi", const=default_manifest_folder, nargs="?", help='Install dependencies manifests in folder for later verify, ' 'asking user for confirmation. ' 'Default folder is .conan_manifests, but can be changed') parser.add_argument("--verify", "-v", const=default_manifest_folder, nargs="?", help='Verify dependencies manifests against stored ones') parser.add_argument("--no-imports", action='store_true', default=False, help='Install specified packages but avoid running imports') self._parse_args(parser) args = parser.parse_args(*args) self._user_io.out.werror_active = args.werror current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) if args.all or args.package: # Install packages without settings (fixed ids or all) if args.all: args.package = [] if not args.reference or not isinstance(reference, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.download(reference, args.package, remote=args.remote) else: # Classic install, package chosen with settings and options # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) options = self._get_tuples_list_from_extender_arg(args.options) settings, package_settings = self._get_simple_and_package_tuples(args.settings) env, package_env = self._get_simple_and_package_tuples(args.env) scopes = Scopes.from_list(args.scope) if args.scope else None if args.manifests and args.manifests_interactive: raise ConanException("Do not specify both manifests and " "manifests-interactive arguments") if args.verify and (args.manifests or args.manifests_interactive): raise ConanException("Do not specify both 'verify' and " "'manifests' or 'manifests-interactive' arguments") manifest_folder = args.verify or args.manifests or args.manifests_interactive if manifest_folder: if not os.path.isabs(manifest_folder): if isinstance(reference, ConanFileReference): manifest_folder = os.path.join(current_path, manifest_folder) else: manifest_folder = os.path.join(reference, manifest_folder) manifest_verify = args.verify is not None manifest_interactive = args.manifests_interactive is not None else: manifest_verify = manifest_interactive = False self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, build_mode=args.build, filename=args.file, update=args.update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, scopes=scopes, generators=args.generator, profile_name=args.profile, package_settings=package_settings, env=env, package_env=package_env, no_imports=args.no_imports) def info(self, *args): """ Prints information about the requirements. Requirements can be defined in the command line or in a conanfile. EX: conan info opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info", formatter_class=RawTextHelpFormatter) parser.add_argument("reference", nargs='?', default="", help='reference name or path to conanfile file, ' 'e.g., MyPackage/1.2@user/channel or ./my_project/') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument("--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument("--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument("--only", "-n", help='show fields only') parser.add_argument("--update", "-u", action='store_true', default=False, help="check updates exist from upstream remotes") parser.add_argument("--build_order", "-bo", help='given a modified reference, return ordered list to build (CI)', nargs=1, action=Extender) parser.add_argument("--scope", "-sc", nargs=1, action=Extender, help='Define scopes for packages') args = parser.parse_args(*args) options = self._get_tuples_list_from_extender_arg(args.options) settings, package_settings = self._get_simple_and_package_tuples(args.settings) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath(os.path.join(current_path, args.reference)) scopes = Scopes.from_list(args.scope) if args.scope else None self._manager.info(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, package_settings=package_settings, info=args.only or True, check_updates=args.update, filename=args.file, build_order=args.build_order, scopes=scopes) def build(self, *args): """ Calls your project conanfile.py "build" method. E.g. conan build ./my_project Intended for package creators, requires a conanfile.py. """ parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build") parser.add_argument("path", nargs="?", help='path to user conanfile.py, e.g., conan build .', default="") parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("--profile", "-pr", default=None, help='Define a profile') args = parser.parse_args(*args) current_path = os.getcwd() if args.path: root_path = os.path.abspath(args.path) else: root_path = current_path self._manager.build(root_path, current_path, filename=args.file, profile_name=args.profile) def package(self, *args): """ Calls your conanfile.py "package" method for a specific package recipe. It will not create a new package, use 'install' or 'test_package' instead for packages in the conan local cache, or `build' for conanfile.py in user space. Intended for package creators, for regenerating a package without recompiling the source, i.e. for troubleshooting, and fixing the package() method, not normal operation. It requires the package has been built locally, it will not re-package otherwise. E.g. conan package MyPackage/1.2@user/channel 9cf83afd07b678da9c1645f605875400847ff3 When used in a user space project, it will execute from the build folder specified as parameter, and the current directory. This is useful while creating package recipes or just for extracting artifacts from the current project, without even being a package """ parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package") parser.add_argument("reference", help='package recipe reference ' 'e.g. MyPkg/0.1@user/channel, or local path to the build folder' ' (relative or absolute)') parser.add_argument("package", nargs="?", default="", help='Package ID to regenerate. e.g., ' '9cf83afd07b678d38a9c1645f605875400847ff3' ' If not specified, ALL binaries for this recipe are re-packaged') args = parser.parse_args(*args) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) self._manager.package(reference, args.package) except: if "@" in args.reference: raise build_folder = args.reference if not os.path.isabs(build_folder): build_folder = os.path.normpath(os.path.join(current_path, build_folder)) self._manager.local_package(current_path, build_folder) def _get_reference(self, args): current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: if "@" in args.reference: raise if not os.path.isabs(args.reference): reference = os.path.normpath(os.path.join(current_path, args.reference)) else: reference = args.reference return current_path, reference def source(self, *args): """ Calls your conanfile.py "source" method to configure the source directory. I.e., downloads and unzip the package source. """ parser = argparse.ArgumentParser(description=self.source.__doc__, prog="conan source") parser.add_argument("reference", nargs='?', default="", help="package recipe reference. e.g., MyPackage/1.2@user/channel or ./my_project/") parser.add_argument("-f", "--force", default=False, action="store_true", help="force remove the source directory and run again.") args = parser.parse_args(*args) current_path, reference = self._get_reference(args) self._manager.source(current_path, reference, args.force) def imports(self, *args): """ Executes only the import functionality of the conanfile (txt or py). It requires to have been previously installed and have a conanbuildinfo.txt generated file """ parser = argparse.ArgumentParser(description=self.imports.__doc__, prog="conan imports") parser.add_argument("reference", nargs='?', default="", help="package recipe reference. e.g., MyPackage/1.2@user/channel or ./my_project/") parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("-d", "--dest", help="optional destination base directory, current dir by default") parser.add_argument("-u", "--undo", default=False, action="store_true", help="Undo the imports, remove files copied to project or user space") args = parser.parse_args(*args) if args.undo: if not os.path.isabs(args.reference): current_path = os.path.normpath(os.path.join(os.getcwd(), args.reference)) else: current_path = args.reference self._manager.imports_undo(current_path) else: dest_folder = args.dest current_path, reference = self._get_reference(args) self._manager.imports(current_path, reference, args.file, dest_folder) def export(self, *args): """ Copies the package recipe (conanfile.py and associated files) to your local store, where it can be shared and reused in other projects. From that store, it can be uploaded to any remote with "upload" command. """ parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export") parser.add_argument("user", help='user_name[/channel]. By default, channel is ' '"testing", e.g., phil or phil/stable') parser.add_argument('--path', '-p', default=None, help='Optional. Folder with a %s. Default current directory.' % CONANFILE) parser.add_argument('--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') args = parser.parse_args(*args) current_path = os.path.abspath(args.path or os.getcwd()) keep_source = args.keep_source self._manager.export(args.user, current_path, keep_source) def remove(self, *args): """ Remove any package recipe or package from your local/remote store """ parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove") parser.add_argument('pattern', help='Pattern name, e.g., openssl/*') parser.add_argument('-p', '--packages', const=[], nargs='?', help='By default, remove all the packages or select one, ' 'specifying the SHA key') parser.add_argument('-b', '--builds', const=[], nargs='?', help='By default, remove all the build folders or select one, ' 'specifying the SHA key') parser.add_argument('-s', '--src', default=False, action="store_true", help='Remove source folders') parser.add_argument('-f', '--force', default=False, action='store_true', help='Remove without requesting a confirmation') parser.add_argument('-r', '--remote', help='Remote origin') args = parser.parse_args(*args) if args.packages: args.packages = args.packages.split(",") if args.builds: args.builds = args.builds.split(",") self._manager.remove(args.pattern, package_ids_filter=args.packages, build_ids=args.builds, src=args.src, force=args.force, remote=args.remote) def copy(self, *args): """ Copy package recipe and packages to another user/channel """ parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy") parser.add_argument("reference", default="", help='package recipe reference' 'e.g., MyPackage/1.2@user/channel') parser.add_argument("user_channel", default="", help='Destination user/channel' 'e.g., lasote/testing') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='copy specified package ID') parser.add_argument("--all", action='store_true', default=False, help='Copy all packages from the specified package recipe') parser.add_argument("--force", action='store_true', default=False, help='Override destination packages and the package recipe') args = parser.parse_args(*args) reference = ConanFileReference.loads(args.reference) new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name, reference.version, args.user_channel)) if args.all: args.package = [] self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force) def user(self, *parameters): """ shows or change the current user """ parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user") parser.add_argument("name", nargs='?', default=None, help='Username you want to use. ' 'If no name is provided it will show the current user.') parser.add_argument("-p", "--password", help='User password. Use double quotes ' 'if password with spacing, and escape quotes if existing') parser.add_argument("--remote", "-r", help='look for in the remote storage') parser.add_argument('-c', '--clean', default=False, action='store_true', help='Remove user and tokens for all remotes') args = parser.parse_args(*parameters) # To enable -h if args.clean: localdb = LocalDB(self._client_cache.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(args.remote, args.name, args.password) def search(self, *args): """ show local/remote packages """ parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search") parser.add_argument('pattern', nargs='?', help='Pattern name, e.g. openssl/* or package recipe reference if "-q" is used. e.g. MyPackage/1.2@user/channel') parser.add_argument('--case-sensitive', default=False, action='store_true', help='Make a case-sensitive search') parser.add_argument('-r', '--remote', help='Remote origin') parser.add_argument('-q', '--query', default=None, help='Packages query: "os=Windows AND arch=x86". The "pattern" parameter has to be a package recipe reference: MyPackage/1.2@user/channel') args = parser.parse_args(*args) reference = None if args.pattern: try: reference = ConanFileReference.loads(args.pattern) except ConanException: if args.query is not None: raise ConanException("-q parameter only allowed with a valid recipe " "reference as search pattern. e.j conan search " "MyPackage/1.2@user/channel -q \"os=Windows\"") self._manager.search(reference or args.pattern, args.remote, ignorecase=not args.case_sensitive, packages_query=args.query) def upload(self, *args): """ uploads a conanfile or binary packages from the local store to any remote. To upload something, it should be "exported" first. """ parser = argparse.ArgumentParser(description=self.upload.__doc__, prog="conan upload") parser.add_argument("reference", help='package recipe reference, e.g., MyPackage/1.2@user/channel') # TODO: packageparser.add_argument('package', help='user name') parser.add_argument("--package", "-p", default=None, help='package ID to upload') parser.add_argument("--remote", "-r", help='upload to this specific remote') parser.add_argument("--all", action='store_true', default=False, help='Upload both package recipe and packages') parser.add_argument("--force", action='store_true', default=False, help='Do not check conan recipe date, override remote with local') args = parser.parse_args(*args) conan_ref = ConanFileReference.loads(args.reference) package_id = args.package if not conan_ref and not package_id: raise ConanException("Enter conan reference or package id") self._manager.upload(conan_ref, package_id, args.remote, all_packages=args.all, force=args.force) def remote(self, *args): """ manage remotes """ parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote") subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help') # create the parser for the "a" command subparsers.add_parser('list', help='list current remotes') parser_add = subparsers.add_parser('add', help='add a remote') parser_add.add_argument('remote', help='name of the remote') parser_add.add_argument('url', help='url of the remote') parser_add.add_argument('verify_ssl', help='Verify SSL certificated. Default True', default="True", nargs="?") parser_rm = subparsers.add_parser('remove', help='remove a remote') parser_rm.add_argument('remote', help='name of the remote') parser_upd = subparsers.add_parser('update', help='update the remote url') parser_upd.add_argument('remote', help='name of the remote') parser_upd.add_argument('url', help='url') parser_upd.add_argument('verify_ssl', help='Verify SSL certificated. Default True', default="True", nargs="?") subparsers.add_parser('list_ref', help='list the package recipes and its associated remotes') parser_padd = subparsers.add_parser('add_ref', help="associate a recipe's reference to a remote") parser_padd.add_argument('reference', help='package recipe reference') parser_padd.add_argument('remote', help='name of the remote') parser_prm = subparsers.add_parser('remove_ref', help="dissociate a recipe's reference and its remote") parser_prm.add_argument('reference', help='package recipe reference') parser_pupd = subparsers.add_parser('update_ref', help="update the remote associated " "with a package recipe") parser_pupd.add_argument('reference', help='package recipe reference') parser_pupd.add_argument('remote', help='name of the remote') args = parser.parse_args(*args) registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) if args.subcommand == "list": for r in registry.remotes: self._user_io.out.info("%s: %s [Verify SSL: %s]" % (r.name, r.url, r.verify_ssl)) elif args.subcommand == "add": verify = get_bool_from_text_value(args.verify_ssl) registry.add(args.remote, args.url, args.verify_ssl) elif args.subcommand == "remove": registry.remove(args.remote) elif args.subcommand == "update": verify = get_bool_from_text_value(args.verify_ssl) registry.update(args.remote, args.url, verify) elif args.subcommand == "list_ref": for ref, remote in registry.refs.items(): self._user_io.out.info("%s: %s" % (ref, remote)) elif args.subcommand == "add_ref": registry.add_ref(args.reference, args.remote) elif args.subcommand == "remove_ref": registry.remove_ref(args.reference) elif args.subcommand == "update_ref": registry.update_ref(args.reference, args.remote) def profile(self, *args): """ manage profiles """ parser = argparse.ArgumentParser(description=self.profile.__doc__, prog="conan profile") subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help') # create the parser for the "profile" command subparsers.add_parser('list', help='list current profiles') parser_show = subparsers.add_parser('show', help='show the values defined for a profile') parser_show.add_argument('profile', help='name of the profile') args = parser.parse_args(*args) if args.subcommand == "list": folder = self._client_cache.profiles_path if os.path.exists(folder): profiles = [name for name in os.listdir(folder) if not os.path.isdir(name)] for p in profiles: self._user_io.out.info(p) else: self._user_io.out.info("No profiles defined") elif args.subcommand == "show": p = self._manager.read_profile(args.profile, os.getcwd()) Printer(self._user_io.out).print_profile(args.profile, p) def _show_help(self): """ prints a summary of all commands """ self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help', Color.BRIGHT_YELLOW) commands = self._commands() for name in sorted(self._commands()): self._user_io.out.write(' %-10s' % name, Color.GREEN) self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0]) def _commands(self): """ returns a list of available commands """ result = {} for m in inspect.getmembers(self, predicate=inspect.ismethod): method_name = m[0] if not method_name.startswith('_'): method = m[1] if method.__doc__ and not method.__doc__.startswith('HIDDEN'): result[method_name] = method return result def run(self, *args): """HIDDEN: entry point for executing commands, dispatcher to class methods """ errors = False try: try: command = args[0][0] commands = self._commands() method = commands[command] except KeyError as exc: if command in ["-v", "--version"]: self._user_io.out.success("Conan version %s" % CLIENT_VERSION) return False self._show_help() if command in ["-h", "--help"]: return False raise ConanException("Unknown command %s" % str(exc)) except IndexError as exc: # No parameters self._show_help() return False method(args[0][1:]) except (KeyboardInterrupt, SystemExit) as exc: logger.error(exc) errors = True except ConanException as exc: msg = str(exc) # import traceback # logger.debug(traceback.format_exc()) errors = True self._user_io.out.error(msg) return errors
class ConanAPIV1(object): @staticmethod def factory(): """Factory""" def instance_remote_manager(client_cache): requester = get_basic_requester(client_cache) # Verify client version against remotes version_checker_req = VersionCheckerRequester( requester, Version(client_version), Version(MIN_SERVER_COMPATIBLE_VERSION), out) # To handle remote connections put_headers = client_cache.read_put_headers() rest_api_client = RestApiClient(out, requester=version_checker_req, put_headers=put_headers) # To store user and token localdb = LocalDB(client_cache.localdb) # Wraps RestApiClient to add authentication support (same interface) auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb) # Handle remote connections remote_manager = RemoteManager(client_cache, auth_manager, out) return remote_manager use_color = get_env("CONAN_COLOR_DISPLAY", 1) if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): import colorama colorama.init() color = True else: color = False out = ConanOutput(sys.stdout, color) user_io = UserIO(out=out) try: client_cache = migrate_and_get_client_cache( get_conan_user_home(), out) except Exception as e: out.error(str(e)) raise with tools.environment_append(client_cache.conan_config.env_vars): # Adjust CONAN_LOGGING_LEVEL with the env readed conans.util.log.logger = configure_logger() # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) # Settings preprocessor conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager, settings_preprocessor) return conan, client_cache, user_io def __init__(self, client_cache, user_io, runner, remote_manager, search_manager, settings_preprocessor): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager, settings_preprocessor) # Patch the tools module with a good requester and user_io set_global_instances(self._user_io.out, get_basic_requester(self._client_cache)) @api_method def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None, visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None, shared=None, upload_url=None, gitignore=None, gitlab_gcc_versions=None, gitlab_clang_versions=None): from conans.client.new import get_files cwd = prepare_cwd(cwd) files = get_files(name, header=header, pure_c=pure_c, test=test, exports_sources=exports_sources, bare=bare, visual_versions=visual_versions, linux_gcc_versions=linux_gcc_versions, linux_clang_versions=linux_clang_versions, osx_clang_versions=osx_clang_versions, shared=shared, upload_url=upload_url, gitignore=gitignore, gitlab_gcc_versions=gitlab_gcc_versions, gitlab_clang_versions=gitlab_clang_versions) save_files(cwd, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) @api_method def test(self, path, profile_name=None, settings=None, options=None, env=None, remote=None, update=False, user=None, channel=None, name=None, version=None, build_modes=None): settings = settings or [] options = options or [] env = env or [] cwd = os.getcwd() base_folder = self._abs_relative_to(path, cwd, default=cwd) conanfile_abs_path = self._get_conanfile_path(base_folder, "conanfile.py") profile = profile_from_args(profile_name, settings, options, env, None, cwd, self._client_cache) pt = PackageTester(self._manager, self._user_io) pt.install_build_and_test(conanfile_abs_path, profile, name, version, user, channel, remote, update, build_modes=build_modes) @api_method def test_package(self, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build=None, keep_source=False, verify=None, manifests=None, manifests_interactive=None, remote=None, update=False, cwd=None, user=None, channel=None, name=None, version=None): self._user_io.out.warn( "THIS METHOD IS DEPRECATED and will be removed. " "Use 'conan create' to generate binary packages for a " "recipe. If you want to test a package you can use 'conan test' " "command.") settings = settings or [] options = options or [] env = env or [] cwd = prepare_cwd(cwd) if name and version: package_name = name package_version = version else: conanfile_path = os.path.join(cwd, "conanfile.py") conanfile = load_conanfile_class(conanfile_path) package_name = getattr(conanfile, "name", None) package_version = getattr(conanfile, "version", None) if not package_name or not package_version: raise ConanException( "conanfile.py doesn't declare package name or version") test_folders = [test_folder ] if test_folder else ["test_package", "test"] for test_folder_name in test_folders: test_folder = os.path.join(cwd, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): break else: raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % test_folder_name) sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache) loader = self._manager.get_loader(profile) test_conanfile = loader.load_conan(test_conanfile_path, self._user_io.out, consumer=True) try: if hasattr(test_conanfile, "requirements"): test_conanfile.requirements() except Exception as e: raise ConanException( "Error in test_package/conanfile.py requirements(). %s" % str(e)) requirement = test_conanfile.requires.get(package_name) if requirement: if requirement.conan_reference.version != package_version: raise ConanException( "package version is '%s', but test_package/conanfile " "is requiring version '%s'\n" "You can remove this requirement and use " "'conan test_package user/channel' instead" % (package_version, requirement.conan_reference.version)) user = user or requirement.conan_reference.user channel = channel or requirement.conan_reference.channel if not user or not channel: raise ConanException("Please specify user and channel") conanfile_reference = ConanFileReference(package_name, package_version, user, channel) # Forcing an export! if not not_export: self._user_io.out.info("Exporting package recipe") self._manager.export(user, channel, cwd, keep_source=keep_source) if build is None: # Not specified, force build the tested library build = [package_name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests self._manager.install(inject_require=conanfile_reference, reference=test_folder, install_folder=build_folder, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build, update=update, generators=["txt"]) test_conanfile = os.path.join(test_folder, CONANFILE) self._manager.build(test_conanfile, test_folder, build_folder, package_folder=None, install_folder=build_folder, test=str(conanfile_reference)) @api_method def create(self, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build_modes=None, keep_source=False, verify=None, manifests=None, manifests_interactive=None, remote=None, update=False, conan_file_path=None, filename=None, user=None, channel=None, name=None, version=None, werror=False): settings = settings or [] options = options or [] env = env or [] self._user_io.out.werror_active = werror cwd = os.getcwd() conanfile_folder = self._abs_relative_to(conan_file_path, cwd, default=cwd) if not name or not version: conanfile_abs_path = self._get_conanfile_path( conanfile_folder, filename or CONANFILE) conanfile = load_conanfile_class(conanfile_abs_path) name, version = conanfile.name, conanfile.version if not name or not version: raise ConanException( "conanfile.py doesn't declare package name or version") reference = ConanFileReference(name, version, user, channel) scoped_output = ScopedOutput(str(reference), self._user_io.out) # Forcing an export! if not not_export: scoped_output.highlight("Exporting package recipe") self._manager.export(user, channel, conanfile_folder, keep_source=keep_source, name=name, version=version, filename=filename) if build_modes is None: # Not specified, force build the tested library build_modes = [name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache) self._manager.install( reference=reference, install_folder=None, # Not output anything manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build_modes, update=update, filename=filename) base_folder = self._abs_relative_to(conan_file_path, cwd, default=cwd) def get_test_conanfile_path(tf): """Searchs in the declared test_folder or in the standard locations""" test_folders = [tf] if tf else ["test_package", "test"] for test_folder_name in test_folders: test_folder = os.path.join(base_folder, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): return test_conanfile_path else: if tf: raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % tf) test_conanfile_path = get_test_conanfile_path(test_folder) if test_conanfile_path: pt = PackageTester(self._manager, self._user_io) scoped_output.highlight("Testing with 'test_package'") pt.install_build_and_test(test_conanfile_path, profile, name, version, user, channel, remote, update) def _get_profile(self, profile_name, settings, options, env, cwd, install_folder): infos_present = existing_info_files(install_folder) if not infos_present: profile = profile_from_args(profile_name, settings, options, env=env, scope=None, cwd=cwd, client_cache=self._client_cache) else: profile = read_conaninfo_profile(install_folder) return profile def _validate_can_read_infos(self, install_folder, cwd): if install_folder and not existing_info_files( self._abs_relative_to(install_folder, cwd)): raise ConanException( "The specified --install-folder doesn't contain '%s' and '%s' " "files" % (CONANINFO, BUILD_INFO)) @staticmethod def _validate_one_settings_source(install_folder, profile_name, settings, options, env): if install_folder and existing_info_files(install_folder) and \ (profile_name or settings or options or env): raise ConanException( "%s and %s are found, at '%s' folder, so specifying profile, " "settings, options or env is not allowed" % (CONANINFO, BUILD_INFO, install_folder)) @api_method def export_pkg(self, path, name, channel, source_folder=None, build_folder=None, install_folder=None, profile_name=None, settings=None, options=None, env=None, force=False, user=None, version=None): settings = settings or [] options = options or [] env = env or [] cwd = os.getcwd() # Checks that info files exists if the install folder is specified self._validate_can_read_infos(install_folder, cwd) path = self._abs_relative_to(path, cwd) build_folder = self._abs_relative_to(build_folder, cwd, default=cwd) install_folder = self._abs_relative_to(install_folder, cwd, default=build_folder) source_folder = self._abs_relative_to(source_folder, cwd, default=build_folder) # Checks that no both settings and info files are specified self._validate_one_settings_source(install_folder, profile_name, settings, options, env) profile = self._get_profile(profile_name, settings, options, env, cwd, install_folder) conanfile_abs_path = self._get_conanfile_path(path, "conanfile.py") conanfile = load_conanfile_class(conanfile_abs_path) if (name and conanfile.name and conanfile.name != name) or \ (version and conanfile.version and conanfile.version != version): raise ConanException( "Specified name/version doesn't match with the " "name/version in the conanfile") self._manager.export(user, channel, path, name=name, version=version) if not (name and version): name = conanfile.name version = conanfile.version reference = ConanFileReference(name, version, user, channel) self._manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder, install_folder=install_folder, profile=profile, force=force) @api_method def download(self, reference, remote=None, package=None): # Install packages without settings (fixed ids or all) if not reference or not isinstance(reference, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.download(reference, package, remote=remote) @api_method def install_reference(self, reference, settings=None, options=None, env=None, scope=None, remote=None, werror=False, verify=None, manifests=None, manifests_interactive=None, build=None, profile_name=None, update=False, generators=None, install_folder=None): self._user_io.out.werror_active = werror cwd = os.getcwd() install_folder = self._abs_relative_to(install_folder, cwd, default=cwd) manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache) if not generators: # We don't want the default txt generators = False self._manager.install(reference=reference, install_folder=install_folder, remote=remote, profile=profile, build_modes=build, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generators, cwd=cwd, deploy=True) @api_method def install(self, path="", settings=None, options=None, env=None, scope=None, remote=None, werror=False, verify=None, manifests=None, manifests_interactive=None, build=None, profile_name=None, update=False, generators=None, no_imports=False, filename=None, install_folder=None): self._user_io.out.werror_active = werror cwd = os.getcwd() install_folder = self._abs_relative_to(install_folder, cwd, default=cwd) conanfile_folder = self._abs_relative_to(path, cwd, default=cwd) manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache) self._manager.install(reference=conanfile_folder, install_folder=install_folder, remote=remote, profile=profile, build_modes=build, filename=filename, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generators, no_imports=no_imports) @api_method def config_get(self, item): config_parser = ConanClientConfigParser( self._client_cache.conan_conf_path) self._user_io.out.info(config_parser.get_item(item)) return config_parser.get_item(item) @api_method def config_set(self, item, value): config_parser = ConanClientConfigParser( self._client_cache.conan_conf_path) config_parser.set_item(item, value) @api_method def config_rm(self, item): config_parser = ConanClientConfigParser( self._client_cache.conan_conf_path) config_parser.rm_item(item) @api_method def config_install(self, item): from conans.client.conf.config_installer import configuration_install return configuration_install(item, self._client_cache, self._user_io.out, self._runner) @api_method def info_build_order(self, reference, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, build_order=None, check_updates=None, build_folder=None): current_path = os.getcwd() try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, build_folder, self._client_cache) graph = self._manager.info_build_order(reference, profile, filename, build_order, remote, check_updates) return graph @api_method def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, check_updates=None, build_folder=None): current_path = os.getcwd() try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, build_folder, self._client_cache) ret = self._manager.info_nodes_to_build(reference, profile, filename, build_modes, remote, check_updates) ref_list, project_reference = ret return ref_list, project_reference @api_method def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, scope=None, profile_name=None, update=False, filename=None, build_folder=None): current_path = os.getcwd() try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, build_folder, self._client_cache) ret = self._manager.info_get_graph(reference=reference, remote=remote, profile=profile, check_updates=update, filename=filename) deps_graph, graph_updates_info, project_reference = ret return deps_graph, graph_updates_info, project_reference @api_method def build(self, path, source_folder=None, package_folder=None, filename=None, build_folder=None, install_folder=None): cwd = os.getcwd() conanfile_folder = self._abs_relative_to(path, cwd) build_folder = self._abs_relative_to(build_folder, cwd, default=cwd) install_folder = self._abs_relative_to(install_folder, cwd, default=build_folder) source_folder = self._abs_relative_to(source_folder, cwd, default=conanfile_folder) default_pkg_folder = os.path.join(build_folder, "package") package_folder = self._abs_relative_to(package_folder, cwd, default=default_pkg_folder) conanfile_abs_path = self._get_conanfile_path(conanfile_folder, filename) if conanfile_abs_path.endswith(".txt"): raise ConanException( "A conanfile.py is needed to call 'conan build' " "(not valid conanfile.txt)") self._manager.build(conanfile_abs_path, source_folder, build_folder, package_folder, install_folder) @api_method def package(self, path, build_folder, package_folder, source_folder=None, install_folder=None): cwd = os.getcwd() conanfile_folder = self._abs_relative_to(path, cwd) build_folder = self._abs_relative_to(build_folder, cwd, default=cwd) install_folder = self._abs_relative_to(install_folder, cwd, default=build_folder) source_folder = self._abs_relative_to(source_folder, cwd, default=conanfile_folder) default_pkg = os.path.join(build_folder, "package") package_folder = self._abs_relative_to(package_folder, cwd, default=default_pkg) self._manager.local_package(package_folder, conanfile_folder, build_folder, source_folder, install_folder) @api_method def source(self, path, source_folder=None, info_folder=None): cwd = os.getcwd() path = self._abs_relative_to(path, cwd) source_folder = self._abs_relative_to(source_folder, cwd, default=cwd) info_folder = self._abs_relative_to(info_folder, cwd, default=cwd) mkdir(source_folder) if not os.path.exists(info_folder): raise ConanException("Specified info-folder doesn't exist") conanfile_abs_path = self._get_conanfile_path(path, CONANFILE) self._manager.source(conanfile_abs_path, source_folder, info_folder) @staticmethod def _abs_relative_to(path, base_relative, default=None): """Gets an absolute path from "path" parameter, prepending base_relative if not abs yet. If path is none, will return the 'default'""" if not path: return default if not os.path.isabs(path): return os.path.normpath(os.path.join(base_relative, path)) else: return path @staticmethod def _get_conanfile_path(conanfile_folder, the_filename=None): def raise_if_not_exists(some_path): if not os.path.exists(some_path): raise ConanException("Conanfile not found: %s" % some_path) if the_filename: conanfile_path = os.path.join(conanfile_folder, the_filename) raise_if_not_exists(conanfile_path) else: conanfile_path = os.path.join(conanfile_folder, CONANFILE) if not os.path.exists(conanfile_path): conanfile_path = os.path.join(conanfile_folder, CONANFILE_TXT) raise_if_not_exists(conanfile_path) return conanfile_path @api_method def imports(self, path, dest=None, filename=None, info_folder=None): """ :param path: Path to the conanfile :param dest: Dir to put the imported files. (Abs path or relative to cwd) :param filename: Alternative name of the conanfile. Default: conanfile.py or conanfile.txt :param build_folder: Dir where the conaninfo.txt and conanbuildinfo.txt files are :return: None """ cwd = os.getcwd() conanfile_folder = self._abs_relative_to(path, cwd) info_folder = self._abs_relative_to(info_folder, cwd, default=cwd) dest = self._abs_relative_to(dest, cwd, default=cwd) mkdir(dest) conanfile_abs_path = self._get_conanfile_path(conanfile_folder, filename) self._manager.imports(conanfile_abs_path, dest, info_folder) @api_method def imports_undo(self, manifest_path): manifest_path = self._abs_relative_to(manifest_path, os.getcwd()) self._manager.imports_undo(manifest_path) @api_method def export(self, user, channel, path=None, keep_source=False, filename=None, cwd=None, name=None, version=None): cwd = prepare_cwd(cwd) current_path = os.path.abspath(path or cwd) self._manager.export(user, channel, current_path, keep_source, filename=filename, name=name, version=version) @api_method def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False, remote=None, outdated=False): self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds, src=src, force=force, remote=remote, packages_query=query, outdated=outdated) @api_method def copy(self, reference="", user_channel="", force=False, all=False, package=None): reference = ConanFileReference.loads(reference) new_ref = ConanFileReference.loads( "%s/%s@%s" % (reference.name, reference.version, user_channel)) if all: package = [] self._manager.copy(reference, package, new_ref.user, new_ref.channel, force) @api_method def user(self, name=None, clean=False, remote=None, password=None): if clean: localdb = LocalDB(self._client_cache.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(remote, name, password) @api_method def search_recipes(self, pattern, remote=None, case_sensitive=False): refs = self._manager.search_recipes(pattern, remote, ignorecase=not case_sensitive) return refs @api_method def search_packages(self, reference, query=None, remote=None, outdated=False): ret = self._manager.search_packages(reference, remote, packages_query=query, outdated=outdated) return ret @api_method def upload(self, pattern, package=None, remote=None, all=False, force=False, confirm=False, retry=2, retry_wait=5, skip_upload=False, integrity_check=False): """ Uploads a package recipe and the generated binary packages to a specified remote """ if package and not is_a_reference(pattern): raise ConanException( "-p parameter only allowed with a valid recipe reference, " "not with a pattern") self._manager.upload(pattern, package, remote, all_packages=all, force=force, confirm=confirm, retry=retry, retry_wait=retry_wait, skip_upload=skip_upload, integrity_check=integrity_check) @api_method def remote_list(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remotes @api_method def remote_add(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add(remote, url, verify_ssl, insert) @api_method def remote_remove(self, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove(remote) @api_method def remote_update(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update(remote, url, verify_ssl, insert) @api_method def remote_list_ref(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.refs @api_method def remote_add_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add_ref(reference, remote) @api_method def remote_remove_ref(self, reference): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove_ref(reference) @api_method def remote_update_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update_ref(reference, remote) @api_method def profile_list(self): folder = self._client_cache.profiles_path if os.path.exists(folder): return [ name for name in os.listdir(folder) if not os.path.isdir(os.path.join(folder, name)) ] else: self._user_io.out.info("No profiles defined") return [] @api_method def create_profile(self, profile_name, detect=False): profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd()) if os.path.exists(profile_path): raise ConanException("Profile already exists") profile = Profile() if detect: settings = detect_defaults_settings(self._user_io.out) for name, value in settings: profile.settings[name] = value contents = profile.dumps() save(profile_path, contents) self._user_io.out.info("Empty profile created: %s" % profile_path) return profile_path @staticmethod def _get_profile_keys(key): # settings.compiler.version => settings, compiler.version tmp = key.split(".") first_key = tmp[0] rest_key = ".".join(tmp[1:]) if len(tmp) > 1 else None if first_key not in ("build_requires", "settings", "options", "scopes", "env"): raise ConanException("Invalid specified key: %s" % key) return first_key, rest_key @api_method def update_profile(self, profile_name, key, value): first_key, rest_key = self._get_profile_keys(key) profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path) if first_key == "settings": profile.settings[rest_key] = value elif first_key == "options": tmp = OptionsValues([(rest_key, value)]) profile.options.update(tmp) elif first_key == "env": profile.env_values.update( EnvValues.loads("%s=%s" % (rest_key, value))) elif first_key == "scopes": profile.update_scopes( Scopes.from_list(["%s=%s" % (rest_key, value)])) elif first_key == "build_requires": raise ConanException( "Edit the profile manually to change the build_requires") contents = profile.dumps() profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd()) save(profile_path, contents) @api_method def get_profile_key(self, profile_name, key): first_key, rest_key = self._get_profile_keys(key) profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path) try: if first_key == "settings": return profile.settings[rest_key] elif first_key == "options": return dict(profile.options.as_list())[rest_key] elif first_key == "env": package = None var = rest_key if ":" in rest_key: package, var = rest_key.split(":") return profile.env_values.data[package][var] elif first_key == "build_requires": raise ConanException( "List the profile manually to see the build_requires") except KeyError: raise ConanException("Key not found: '%s'" % key) @api_method def delete_profile_key(self, profile_name, key): first_key, rest_key = self._get_profile_keys(key) profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path) # For options, scopes, env vars try: package, name = rest_key.split(":") except ValueError: package = None name = rest_key try: if first_key == "settings": del profile.settings[rest_key] elif first_key == "options": profile.options.remove(name, package) elif first_key == "env": profile.env_values.remove(name, package) elif first_key == "scopes": profile.scopes.remove(name, package) elif first_key == "build_requires": raise ConanException( "Edit the profile manually to delete a build_require") except KeyError: raise ConanException("Profile key '%s' doesn't exist" % key) contents = profile.dumps() profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd()) save(profile_path, contents) @api_method def read_profile(self, profile=None): p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path) return p @api_method def get_path(self, reference, package_id=None, path=None, remote=None): reference = ConanFileReference.loads(str(reference)) return self._manager.get_path(reference, package_id, path, remote) @api_method def export_alias(self, reference, target_reference): reference = ConanFileReference.loads(str(reference)) target_reference = ConanFileReference.loads(str(target_reference)) return self._manager.export_alias(reference, target_reference)
class Command(object): """ A single command of the conans application, with all the first level commands. Manages the parsing of parameters and delegates functionality in collaborators. It can also show help of the tool """ def __init__(self, paths, user_io, runner, remote_manager): assert isinstance(user_io, UserIO) assert isinstance(paths, ConanPaths) self._conan_paths = paths self._user_io = user_io self._runner = runner self._manager = ConanManager(paths, user_io, runner, remote_manager) def _parse_args(self, parser): parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument( "--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument( "--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) parser.add_argument( "--build", "-b", action=Extender, nargs="*", help='''Optional, use it to choose if you want to build from sources: --build Build all from sources, do not use binary packages. --build=never Default option. Never build, use binary packages or fail if a binary package is not found. --build=missing Build from code if a binary package is not found. --build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters. ''') def _get_tuples_list_from_extender_arg(self, items): if not items: return [] # Validate the pairs for item in items: chunks = item.split("=") if len(chunks) != 2: raise ConanException("Invalid input '%s', use 'name=value'" % item) return [(item[0], item[1]) for item in [item.split("=") for item in items]] def _detect_tested_library_name(self): conanfile_content = load(CONANFILE) match = re.search('^\s*name\s*=\s*"(.*)"', conanfile_content, re.MULTILINE) if match: return "%s*" % match.group(1) self._user_io.out.warn( "Cannot detect a valid conanfile in current directory") return None def _get_build_sources_parameter(self, build_param): # returns True if we want to build the missing libraries # False if building is forbidden # A list with patterns: Will force build matching libraries, # will look for the package for the rest if isinstance(build_param, list): if len(build_param) == 0: # All packages from source return ["*"] elif len(build_param) == 1 and build_param[0] == "never": return False # Default elif len(build_param) == 1 and build_param[0] == "missing": return True else: # A list of expressions to match (if matches, will build from source) return ["%s*" % ref_expr for ref_expr in build_param] else: return False # Nothing is built def test(self, *args): """ build and run your package test. Must have conanfile.py with "test" method and "test" subfolder with package consumer test project """ parser = argparse.ArgumentParser(description=self.test.__doc__, prog="conan test", formatter_class=RawTextHelpFormatter) parser.add_argument("path", nargs='?', default="", help='path to conanfile file, ' 'e.g. /my_project/') self._parse_args(parser) args = parser.parse_args(*args) root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path)) test_folder = os.path.join(root_folder, "test") if not os.path.exists(test_folder): raise ConanException("test folder not available") lib_to_test = self._detect_tested_library_name() # Get False or a list of patterns to check if args.build is None and lib_to_test: # Not specified, force build the tested library args.build = [lib_to_test] else: args.build = self._get_build_sources_parameter(args.build) options = args.options or [] settings = args.settings or [] sha = hashlib.sha1("".join(options + settings)).hexdigest() build_folder = os.path.join(root_folder, "build", sha) rmdir(build_folder) shutil.copytree(test_folder, build_folder) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) self._manager.install(reference=build_folder, current_path=build_folder, remote=args.remote, options=options, settings=settings, build_mode=args.build) self._manager.build(build_folder, build_folder, test=True) def install(self, *args): """ install in the local store the given requirements. Requirements can be defined in the command line or in a conanfile. EX: conans install opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install", formatter_class=RawTextHelpFormatter) parser.add_argument( "reference", nargs='?', default="", help='package recipe reference' 'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/') parser.add_argument( "--package", "-p", nargs=1, action=Extender, help='Force install specified package ID (ignore settings/options)' ) parser.add_argument( "--all", action='store_true', default=False, help='Install all packages from the specified package recipe') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("--update", "-u", action='store_true', default=False, help="update with new upstream packages") self._parse_args(parser) args = parser.parse_args(*args) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath( os.path.join(current_path, args.reference)) if args.all or args.package: # Install packages without settings (fixed ids or all) if args.all: args.package = [] if not args.reference or not isinstance(reference, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., OpenSSL/1.0.2e@lasote/stable") self._manager.download(reference, args.package, remote=args.remote) else: # Classic install, package chosen with settings and options # Get False or a list of patterns to check args.build = self._get_build_sources_parameter(args.build) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, build_mode=args.build, filename=args.file, update=args.update) def info(self, *args): """ Prints information about the requirements. Requirements can be defined in the command line or in a conanfile. EX: conans info opencv/2.4.10@lasote/testing """ parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info", formatter_class=RawTextHelpFormatter) parser.add_argument( "reference", nargs='?', default="", help='reference name or path to conanfile file, ' 'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/') parser.add_argument("--file", "-f", help="specify conanfile filename") parser.add_argument("-r", "--remote", help='look for in the remote storage') parser.add_argument( "--options", "-o", help='load options to build the package, e.g., -o with_qt=true', nargs=1, action=Extender) parser.add_argument( "--settings", "-s", help='load settings to build the package, -s compiler:gcc', nargs=1, action=Extender) args = parser.parse_args(*args) options = self._get_tuples_list_from_extender_arg(args.options) settings = self._get_tuples_list_from_extender_arg(args.settings) current_path = os.getcwd() try: reference = ConanFileReference.loads(args.reference) except: reference = os.path.normpath( os.path.join(current_path, args.reference)) self._manager.install(reference=reference, current_path=current_path, remote=args.remote, options=options, settings=settings, build_mode=False, info=True, filename=args.file) def build(self, *args): """ calls your project conanfile.py "build" method. EX: conans build ./my_project Intended for package creators, requires a conanfile.py. """ parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build") parser.add_argument( "path", nargs="?", help='path to user conanfile.py, e.g., conans build .', default="") parser.add_argument("--file", "-f", help="specify conanfile filename") args = parser.parse_args(*args) current_path = os.getcwd() if args.path: root_path = os.path.abspath(args.path) else: root_path = current_path self._manager.build(root_path, current_path, filename=args.file) def package(self, *args): """ calls your conanfile.py "package" method for a specific package or regenerates the existing package's manifest. Intended for package creators, for regenerating a package without recompiling the source. e.g. conan package OpenSSL/1.0.2e@lasote/stable 9cf83afd07b678da9c1645f605875400847ff3 """ parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package") parser.add_argument( "reference", help= 'package recipe reference name. e.g., openssl/1.0.2@lasote/testing' ) parser.add_argument("package", nargs="?", default="", help='Package ID to regenerate. e.g., ' '9cf83afd07b678d38a9c1645f605875400847ff3') parser.add_argument( "-o", "--only-manifest", default=False, action='store_true', help='Just regenerate manifest for the existing package.' 'If True conan won\'t call your conanfile\'s package method.') parser.add_argument( "--all", action='store_true', default=False, help='Package all packages from specified reference') args = parser.parse_args(*args) try: reference = ConanFileReference.loads(args.reference) except: raise ConanException( "Invalid package recipe reference. e.g., OpenSSL/1.0.2e@lasote/stable" ) if not args.all and not args.package: raise ConanException( "'conan package': Please specify --all or a package ID") self._manager.package(reference, args.package, args.only_manifest, args.all) def export(self, *args): """ copies the package recipe (conanfile.py and associated files) to your local store, where it can be shared and reused in other projects. From that store, it can be uploaded to any remote with "upload" command. """ parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export") parser.add_argument("user", help='user_name[/channel]. By default, channel is ' '"testing", e.g., phil or phil/stable') parser.add_argument( '--path', '-p', default=None, help='Optional. Folder with a %s. Default current directory.' % CONANFILE) parser.add_argument( '--keep-source', '-k', default=False, action='store_true', help='Optional. Do not remove the source folder in local store. ' 'Use for testing purposes only') args = parser.parse_args(*args) current_path = args.path or os.getcwd() keep_source = args.keep_source self._manager.export(args.user, current_path, keep_source) def remove(self, *args): """ Remove any package recipe or package from your local/remote store """ parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove") parser.add_argument('pattern', help='Pattern name, e.g., openssl/*') parser.add_argument( '-p', '--packages', const=[], nargs='?', help='By default, remove all the packages or select one, ' 'specifying the SHA key') parser.add_argument( '-b', '--builds', const=[], nargs='?', help='By default, remove all the build folders or select one, ' 'specifying the SHA key') parser.add_argument('-s', '--src', default=False, action="store_true", help='Remove source folders') parser.add_argument('-f', '--force', default=False, action='store_true', help='Remove without requesting a confirmation') parser.add_argument('-r', '--remote', help='Remote origin') args = parser.parse_args(*args) if args.packages: args.packages = args.packages.split(",") if args.builds: args.builds = args.builds.split(",") self._manager.remove(args.pattern, package_ids_filter=args.packages, build_ids=args.builds, src=args.src, force=args.force, remote=args.remote) def copy(self, *args): """ Copy package recipe and packages to another user/channel """ parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy") parser.add_argument("reference", default="", help='package recipe reference' 'e.g., OpenSSL/1.0.2e@lasote/stable') parser.add_argument("user_channel", default="", help='Destination user/channel' 'e.g., lasote/testing') parser.add_argument("--package", "-p", nargs=1, action=Extender, help='copy specified package ID') parser.add_argument( "--all", action='store_true', default=False, help='Copy all packages from the specified package recipe') parser.add_argument( "--force", action='store_true', default=False, help='Override destination packages and the package recipe') args = parser.parse_args(*args) reference = ConanFileReference.loads(args.reference) new_ref = ConanFileReference.loads( "%s/%s@%s" % (reference.name, reference.version, args.user_channel)) if args.all: args.package = [] self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force) def user(self, *parameters): """ shows or change the current user """ parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user") parser.add_argument( "name", nargs='?', default=None, help='Username you want to use. ' 'If no name is provided it will show the current user.') parser.add_argument( "-p", "--password", help='User password. Use double quotes ' 'if password with spacing, and escape quotes if existing') parser.add_argument("--remote", "-r", help='look for in the remote storage') args = parser.parse_args(*parameters) # To enable -h self._manager.user(args.remote, args.name, args.password) def search(self, *args): """ show local/remote packages """ parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search") parser.add_argument('pattern', nargs='?', help='Pattern name, e.g., openssl/*') parser.add_argument('--case-sensitive', default=False, action='store_true', help='Make a case-sensitive search') parser.add_argument('-r', '--remote', help='Remote origin') parser.add_argument('-v', '--verbose', default=False, action='store_true', help='Show packages options and settings') parser.add_argument('-p', '--package', help='Package ID pattern. EX: 23*', default=None) args = parser.parse_args(*args) self._manager.search(args.pattern, args.remote, ignorecase=not args.case_sensitive, verbose=args.verbose, package_pattern=args.package) def upload(self, *args): """ uploads a conanfile or binary packages from the local store to any remote. To upload something, it should be "exported" first. """ parser = argparse.ArgumentParser(description=self.upload.__doc__, prog="conan upload") parser.add_argument( "reference", help='package recipe reference, e.g., OpenSSL/1.0.2e@lasote/stable' ) # TODO: packageparser.add_argument('package', help='user name') parser.add_argument("--package", "-p", default=None, help='package ID to upload') parser.add_argument("--remote", "-r", help='upload to this specific remote') parser.add_argument("--all", action='store_true', default=False, help='Upload both package recipe and packages') parser.add_argument( "--force", action='store_true', default=False, help='Do not check conans date, override remote with local') args = parser.parse_args(*args) conan_ref = ConanFileReference.loads(args.reference) package_id = args.package if not conan_ref and not package_id: raise ConanException("Enter conans or package id") self._manager.upload(conan_ref, package_id, args.remote, all_packages=args.all, force=args.force) def remote(self, *args): """ manage remotes """ parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote") subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help') # create the parser for the "a" command subparsers.add_parser('list', help='list current remotes') parser_add = subparsers.add_parser('add', help='add a remote') parser_add.add_argument('remote', help='name of the remote') parser_add.add_argument('url', help='url of the remote') parser_rm = subparsers.add_parser('remove', help='remove a remote') parser_rm.add_argument('remote', help='name of the remote') parser_upd = subparsers.add_parser('update', help='update the remote url') parser_upd.add_argument('remote', help='name of the remote') parser_upd.add_argument('url', help='url') subparsers.add_parser( 'list_ref', help='list the package recipes and its associated remotes') parser_padd = subparsers.add_parser( 'add_ref', help="associate a recipe's reference to a remote") parser_padd.add_argument('reference', help='package recipe reference') parser_padd.add_argument('remote', help='name of the remote') parser_prm = subparsers.add_parser( 'remove_ref', help="dissociate a recipe's reference and its remote") parser_prm.add_argument('reference', help='package recipe reference') parser_pupd = subparsers.add_parser( 'update_ref', help="update the remote associated with a package recipe") parser_pupd.add_argument('reference', help='package recipe reference') parser_pupd.add_argument('remote', help='name of the remote') args = parser.parse_args(*args) registry = RemoteRegistry(self._conan_paths.registry, self._user_io.out) if args.subcommand == "list": for r in registry.remotes: self._user_io.out.info("%s: %s" % (r.name, r.url)) elif args.subcommand == "add": registry.add(args.remote, args.url) elif args.subcommand == "remove": registry.remove(args.remote) elif args.subcommand == "update": registry.update(args.remote, args.url) elif args.subcommand == "list_ref": for ref, remote in registry.refs.iteritems(): self._user_io.out.info("%s: %s" % (ref, remote)) elif args.subcommand == "add_ref": registry.add_ref(args.reference, args.remote) elif args.subcommand == "remove_ref": registry.remove_ref(args.reference) elif args.subcommand == "update_ref": registry.update_ref(args.reference, args.remote) def _show_help(self): """ prints a summary of all commands """ self._user_io.out.writeln( 'Conan commands. Type $conan "command" -h for help', Color.BRIGHT_YELLOW) commands = self._commands() for name in sorted(self._commands()): self._user_io.out.write(' %-10s' % name, Color.GREEN) self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0]) def _commands(self): """ returns a list of available commands """ result = {} for m in inspect.getmembers(self, predicate=inspect.ismethod): method_name = m[0] if not method_name.startswith('_'): method = m[1] if method.__doc__ and not method.__doc__.startswith('HIDDEN'): result[method_name] = method return result def run(self, *args): """HIDDEN: entry point for executing commands, dispatcher to class methods """ errors = False try: try: command = args[0][0] commands = self._commands() method = commands[command] except KeyError as exc: if command in ["-v", "--version"]: self._user_io.out.success("Conan version %s" % CLIENT_VERSION) return False self._show_help() if command in ["-h", "--help"]: return False raise ConanException("Unknown command %s" % str(exc)) except IndexError as exc: # No parameters self._show_help() return False method(args[0][1:]) except (KeyboardInterrupt, SystemExit) as exc: logger.error(exc) errors = True except ConanException as exc: logger.error(exc) # logger.debug(traceback.format_exc()) errors = True self._user_io.out.error(str(exc)) return errors
class ConanAPIV1(object): @staticmethod def factory(): """Factory""" def instance_remote_manager(client_cache): requester = get_basic_requester(client_cache) # Verify client version against remotes version_checker_requester = VersionCheckerRequester(requester, Version(CLIENT_VERSION), Version(MIN_SERVER_COMPATIBLE_VERSION), out) # To handle remote connections put_headers = client_cache.read_put_headers() rest_api_client = RestApiClient(out, requester=version_checker_requester, put_headers=put_headers) # To store user and token localdb = LocalDB(client_cache.localdb) # Wraps RestApiClient to add authentication support (same interface) auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb) # Handle remote connections remote_manager = RemoteManager(client_cache, auth_manager, out) return remote_manager use_color = get_env("CONAN_COLOR_DISPLAY", 1) if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty(): import colorama colorama.init() color = True else: color = False out = ConanOutput(sys.stdout, color) user_io = UserIO(out=out) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: client_cache = migrate_and_get_client_cache(user_folder, out) except Exception as e: out.error(str(e)) raise with tools.environment_append(client_cache.conan_config.env_vars): # Adjust CONAN_LOGGING_LEVEL with the env readed conans.util.log.logger = configure_logger() # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager) return conan def __init__(self, client_cache, user_io, runner, remote_manager, search_manager): assert isinstance(user_io, UserIO) assert isinstance(client_cache, ClientCache) self._client_cache = client_cache self._user_io = user_io self._runner = runner self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager) # Patch the tools module with a good requester and user_io tools._global_requester = get_basic_requester(self._client_cache) tools._global_output = self._user_io.out @api_method def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None, visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None, shared=None, upload_url=None, gitignore=None): from conans.client.new import get_files cwd = prepare_cwd(cwd) files = get_files(name, header=header, pure_c=pure_c, test=test, exports_sources=exports_sources, bare=bare, visual_versions=visual_versions, linux_gcc_versions=linux_gcc_versions, linux_clang_versions=linux_clang_versions, osx_clang_versions=osx_clang_versions, shared=shared, upload_url=upload_url, gitignore=gitignore) save_files(cwd, files) for f in sorted(files): self._user_io.out.success("File saved: %s" % f) @api_method def test_package(self, path=None, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build=None, keep_source=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, remote=None, update=False, cwd=None): settings = settings or [] options = options or [] env = env or [] cwd = prepare_cwd(cwd) root_folder = os.path.normpath(os.path.join(cwd, path)) if test_folder: test_folder_name = test_folder test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if not os.path.exists(test_conanfile): raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % test_folder) else: for name in ["test_package", "test"]: test_folder_name = name test_folder = os.path.join(root_folder, test_folder_name) test_conanfile = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile): break else: raise ConanException("test folder 'test_package' not available, " "or it doesn't have a conanfile.py") options = options or [] settings = settings or [] sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) # shutil.copytree(test_folder, build_folder) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) conanfile = load_consumer_conanfile(test_conanfile, "", self._client_cache.settings, self._runner, self._user_io.out) try: # convert to list from ItemViews required for python3 if hasattr(conanfile, "requirements"): conanfile.requirements() reqs = list(conanfile.requires.items()) first_dep = reqs[0][1].conan_reference except Exception: raise ConanException("Unable to retrieve first requirement of test conanfile.py") # Forcing an export! if not not_export: self._user_io.out.info("Exporting package recipe") user_channel = "%s/%s" % (first_dep.user, first_dep.channel) self._manager.export(user_channel, root_folder, keep_source=keep_source) lib_to_test = first_dep.name # Get False or a list of patterns to check if build is None and lib_to_test: # Not specified, force build the tested library build = [lib_to_test] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, root_folder, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests self._manager.install(reference=test_folder, current_path=build_folder, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build, update=update, generators=["txt"] ) test_conanfile = os.path.join(test_folder, CONANFILE) self._manager.build(test_conanfile, test_folder, build_folder, test=True) # Alias to test @api_method def test(self, *args): self.test_package(*args) @api_method def package_files(self, reference, package_folder=None, profile_name=None, force=False, settings=None, options=None, cwd=None): cwd = prepare_cwd(cwd) reference = ConanFileReference.loads(reference) package_folder = package_folder or cwd if not os.path.isabs(package_folder): package_folder = os.path.join(cwd, package_folder) profile = profile_from_args(profile_name, settings, options, env=None, scope=None, cwd=cwd, default_folder=self._client_cache.profiles_path) self._manager.package_files(reference=reference, package_folder=package_folder, profile=profile, force=force) @api_method def install(self, reference="", package=None, settings=None, options=None, env=None, scope=None, all=False, remote=None, werror=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, build=None, profile_name=None, update=False, generator=None, no_imports=False, filename=None, cwd=None): self._user_io.out.werror_active = werror cwd = prepare_cwd(cwd) try: ref = ConanFileReference.loads(reference) except: ref = os.path.normpath(os.path.join(cwd, reference)) if all or package: # Install packages without settings (fixed ids or all) if all: package = [] if not reference or not isinstance(ref, ConanFileReference): raise ConanException("Invalid package recipe reference. " "e.g., MyPackage/1.2@user/channel") self._manager.download(ref, package, remote=remote) else: # Classic install, package chosen with settings and options manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd, self._client_cache.profiles_path) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) self._manager.install(reference=ref, current_path=cwd, remote=remote, profile=profile, build_modes=build, filename=filename, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generator, no_imports=no_imports) @api_method def config_get(self, item): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) self._user_io.out.info(config_parser.get_item(item)) return config_parser.get_item(item) @api_method def config_set(self, item, value): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) config_parser.set_item(item, value) @api_method def config_rm(self, item): config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path) config_parser.rm_item(item) @api_method def info_build_order(self, reference, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, build_order=None, check_updates=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) graph = self._manager.info_build_order(reference, profile, filename, build_order, remote, check_updates, cwd=cwd) return graph @api_method def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, scope=None, profile_name=None, filename=None, remote=None, check_updates=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) ret = self._manager.info_nodes_to_build(reference, profile, filename, build_modes, remote, check_updates, cwd) ref_list, project_reference = ret return ref_list, project_reference @api_method def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, scope=None, profile_name=None, update=False, filename=None, cwd=None): current_path = prepare_cwd(cwd) try: reference = ConanFileReference.loads(reference) except: reference = os.path.normpath(os.path.join(current_path, reference)) profile = profile_from_args(profile_name, settings, options, env, scope, current_path, self._client_cache.profiles_path) ret = self._manager.info_get_graph(reference=reference, current_path=current_path, remote=remote, profile=profile, check_updates=update, filename=filename) deps_graph, graph_updates_info, project_reference = ret return deps_graph, graph_updates_info, project_reference @api_method def build(self, path="", source_folder=None, filename=None, cwd=None): current_path = prepare_cwd(cwd) if path: root_path = os.path.abspath(path) else: root_path = current_path build_folder = current_path source_folder = source_folder or root_path if not os.path.isabs(source_folder): source_folder = os.path.normpath(os.path.join(current_path, source_folder)) if filename and filename.endswith(".txt"): raise ConanException("A conanfile.py is needed to call 'conan build'") conanfile_path = os.path.join(root_path, filename or CONANFILE) self._manager.build(conanfile_path, source_folder, build_folder) @api_method def package(self, reference="", package=None, build_folder=None, source_folder=None, cwd=None): current_path = prepare_cwd(cwd) try: self._manager.package(ConanFileReference.loads(reference), package) except: if "@" in reference: raise recipe_folder = reference if not os.path.isabs(recipe_folder): recipe_folder = os.path.normpath(os.path.join(current_path, recipe_folder)) build_folder = build_folder or current_path if not os.path.isabs(build_folder): build_folder = os.path.normpath(os.path.join(current_path, build_folder)) package_folder = current_path source_folder = source_folder or recipe_folder self._manager.local_package(package_folder, recipe_folder, build_folder, source_folder) @api_method def source(self, reference, force=False, cwd=None): cwd = prepare_cwd(cwd) current_path, reference = _get_reference(reference, cwd) self._manager.source(current_path, reference, force) @api_method def imports(self, reference, undo=False, dest=None, filename=None, cwd=None): cwd = prepare_cwd(cwd) if undo: if not os.path.isabs(reference): current_path = os.path.normpath(os.path.join(cwd, reference)) else: current_path = reference self._manager.imports_undo(current_path) else: cwd = prepare_cwd(cwd) current_path, reference = _get_reference(reference, cwd) self._manager.imports(current_path, reference, filename, dest) @api_method def export(self, user, path=None, keep_source=False, filename=None, cwd=None): cwd = prepare_cwd(cwd) current_path = os.path.abspath(path or cwd) self._manager.export(user, current_path, keep_source, filename=filename) @api_method def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False, remote=None): self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds, src=src, force=force, remote=remote, packages_query=query) @api_method def copy(self, reference="", user_channel="", force=False, all=False, package=None): reference = ConanFileReference.loads(reference) new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name, reference.version, user_channel)) if all: package = [] self._manager.copy(reference, package, new_ref.user, new_ref.channel, force) @api_method def user(self, name=None, clean=False, remote=None, password=None): if clean: localdb = LocalDB(self._client_cache.localdb) localdb.init(clean=True) self._user_io.out.success("Deleted user data") return self._manager.user(remote, name, password) @api_method def search_recipes(self, pattern, remote=None, case_sensitive=False): refs = self._manager.search_recipes(pattern, remote, ignorecase=not case_sensitive) return refs @api_method def search_packages(self, reference, query=None, remote=None): ret = self._manager.search_packages(reference, remote, packages_query=query) return ret @api_method def upload(self, pattern, package=None, remote=None, all=False, force=False, confirm=False, retry=2, retry_wait=5, skip_upload=False): """ Uploads a package recipe and the generated binary packages to a specified remote """ if package and not is_a_reference(pattern): raise ConanException("-p parameter only allowed with a valid recipe reference, " "not with a pattern") self._manager.upload(pattern, package, remote, all_packages=all, force=force, confirm=confirm, retry=retry, retry_wait=retry_wait, skip_upload=skip_upload) @api_method def remote_list(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) for r in registry.remotes: self._user_io.out.info("%s: %s [Verify SSL: %s]" % (r.name, r.url, r.verify_ssl)) @api_method def remote_add(self, remote, url, verify_ssl=True, insert=None): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add(remote, url, verify_ssl, insert) @api_method def remote_remove(self, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove(remote) @api_method def remote_update(self, remote, url, verify_ssl=True): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update(remote, url, verify_ssl) @api_method def remote_list_ref(self): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) for ref, remote in registry.refs.items(): self._user_io.out.info("%s: %s" % (ref, remote)) @api_method def remote_add_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.add_ref(reference, remote) @api_method def remote_remove_ref(self, reference): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.remove_ref(reference) @api_method def remote_update_ref(self, reference, remote): registry = RemoteRegistry(self._client_cache.registry, self._user_io.out) return registry.update_ref(reference, remote) @api_method def profile(self, subcommand, profile=None, cwd=None): cwd = prepare_cwd(cwd) if subcommand == "list": folder = self._client_cache.profiles_path if os.path.exists(folder): profiles = [name for name in os.listdir(folder) if not os.path.isdir(name)] for p in sorted(profiles): self._user_io.out.info(p) else: self._user_io.out.info("No profiles defined") elif subcommand == "show": p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path) Printer(self._user_io.out).print_profile(profile, p)