def install_reference(self, reference, settings=None, options=None, env=None, remote_name=None, verify=None, manifests=None, manifests_interactive=None, build=None, profile_name=None, update=False, generators=None, install_folder=None, cwd=None): try: recorder = ActionRecorder() 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) manager = self._init_manager(recorder) manager.install(reference=reference, install_folder=install_folder, remote_name=remote_name, profile=profile, build_modes=build, update=update, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, generators=generators) return recorder.get_info() except ConanException as exc: recorder.error = True exc.info = recorder.get_info() raise
def test_returns_on_failures(self): test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")]) servers = {"default": test_server} class Response(object): ok = None status_code = None charset = None text = "" headers = {} def __init__(self, ok, status_code): self.ok = ok self.status_code = status_code class BuggyRequester(object): def __init__(self, *args, **kwargs): pass def get(self, *args, **kwargs): return Response(False, 404) client2 = TestClient(servers=servers, requester_class=BuggyRequester) conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable") registry = RemoteRegistry(client2.client_cache.registry, client2.out) installer = ConanProxy(client2.paths, client2.user_io.out, client2.remote_manager, registry=registry) with self.assertRaises(NotFoundException): installer.get_recipe(conan_ref, False, False, None, ActionRecorder()) class BuggyRequester2(BuggyRequester): def get(self, *args, **kwargs): return Response(False, 500) client2 = TestClient(servers=servers, requester_class=BuggyRequester2) registry = RemoteRegistry(client2.client_cache.registry, client2.out) installer = ConanProxy(client2.paths, client2.user_io.out, client2.remote_manager, registry=registry) try: installer.get_recipe(conan_ref, False, False, None, ActionRecorder()) except NotFoundException: self.assertFalse(True) # Shouldn't capture here except ConanException: pass
def install(self, path="", settings=None, options=None, env=None, remote_name=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): try: recorder = ActionRecorder() cwd = cwd or os.getcwd() 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) wspath = _make_abs_path(path, cwd) if install_folder: if os.path.isabs(install_folder): wsinstall_folder = install_folder else: wsinstall_folder = os.path.join(cwd, install_folder) else: wsinstall_folder = None workspace = Workspace.get_workspace(wspath, wsinstall_folder) if workspace: self._user_io.out.success("Using conanws.yml file from %s" % workspace._base_folder) manager = self._init_manager(recorder) manager.install_workspace(profile, workspace, remote_name, build, update) return install_folder = _make_abs_path(install_folder, cwd) conanfile_path = _get_conanfile_path(path, cwd, py=None) manager = self._init_manager(recorder) manager.install(reference=conanfile_path, install_folder=install_folder, remote_name=remote_name, 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) return recorder.get_info() except ConanException as exc: recorder.error = True exc.info = recorder.get_info() raise
def inspect(self, path, attributes, remote_name=None): try: reference = ConanFileReference.loads(path) except ConanException: reference = None cwd = get_cwd() conanfile_path = _get_conanfile_path(path, cwd, py=True) else: update = True if remote_name else False result = self._proxy.get_recipe(reference, update, update, remote_name, ActionRecorder()) conanfile_path, _, _, reference = result conanfile = self._loader.load_basic(conanfile_path, self._user_io.out) result = OrderedDict() if not attributes: attributes = ['name', 'version', 'url', 'license', 'author', 'description', 'generators', 'exports', 'exports_sources', 'short_paths', 'apply_env', 'build_policy'] for attribute in attributes: try: attr = getattr(conanfile, attribute) result[attribute] = attr except AttributeError as e: raise ConanException(str(e)) return result
def build_graph(self, content, profile_build_requires=None, ref=None, create_ref=None, install=True): path = temp_folder() path = os.path.join(path, "conanfile.py") save(path, str(content)) self.loader.cached_conanfiles = {} profile = Profile() if profile_build_requires: profile.build_requires = profile_build_requires profile.process_settings(self.cache) update = check_updates = False recorder = ActionRecorder() remotes = Remotes() build_mode = [] # Means build all ref = ref or ConanFileReference(None, None, None, None, validate=False) options = OptionsValues() graph_info = GraphInfo(profile, options, root_ref=ref) deps_graph, _ = self.manager.load_graph(path, create_ref, graph_info, build_mode, check_updates, update, remotes, recorder) if install: self.binary_installer.install(deps_graph, None, False, graph_info) return deps_graph
def __call__(self, require): try: m, reference = self._modules[require] self._references.append(reference) return m except KeyError: r = ConanFileReference.loads(require) requirement = Requirement(r) self._range_resolver.resolve(requirement, "python_require", update=False, remote_name=None) r = requirement.conan_reference result = self._proxy.get_recipe(r, False, False, remote_name=None, recorder=ActionRecorder()) path, _, _, reference = result self._references.append(reference) try: sys.path.append(os.path.dirname(path)) module = imp.load_source("python_require", path) finally: sys.path.pop() self._modules[require] = module, reference return module
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 get_cwd() profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) reference = ConanFileReference.loads(reference) recorder = ActionRecorder() manager = self._init_manager(recorder) pt = PackageTester(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)
def _build_graph(self, profile_host, profile_build, install=False): path = temp_folder() path = os.path.join(path, "conanfile.txt") save(path, textwrap.dedent(""" [requires] app/testing@user/channel """)) ref = ConanFileReference(None, None, None, None, validate=False) options = OptionsValues() graph_info = GraphInfo(profile_host=profile_host, profile_build=profile_build, options=options, root_ref=ref) recorder = ActionRecorder() app = self._get_app() deps_graph = app.graph_manager.load_graph(path, create_reference=None, graph_info=graph_info, build_mode=[], check_updates=False, update=False, remotes=Remotes(), recorder=recorder) if install: build_mode = [] # Means build all binary_installer = BinaryInstaller(app, recorder) build_mode = BuildMode(build_mode, app.out) binary_installer.install(deps_graph, None, build_mode, update=False, profile_host=profile_host, profile_build=profile_build, graph_lock=None, keep_build=False) return deps_graph
def _look_for_require(self, require): try: python_require = self._cached_requires[require] except KeyError: ref = ConanFileReference.loads(require) requirement = Requirement(ref) self._range_resolver.resolve(requirement, "python_require", update=False, remote_name=None) ref = requirement.ref result = self._proxy.get_recipe(ref, self._check_updates, self._update, remote_name=self._remote_name, recorder=ActionRecorder()) path, _, _, new_ref = result module, conanfile = parse_conanfile(conanfile_path=path, python_requires=self) # Check for alias if getattr(conanfile, "alias", None): # Will register also the aliased python_require = self._look_for_require(conanfile.alias) else: python_require = PythonRequire(new_ref, module, conanfile) self._cached_requires[require] = python_require return python_require
def package(self, path, build_folder, package_folder, source_folder=None, install_folder=None, cwd=None): cwd = cwd or get_cwd() 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) recorder = ActionRecorder() manager = self._init_manager(recorder) manager.local_package(package_folder, conanfile_path, build_folder, source_folder, install_folder)
def _look_for_require(self, reference): ref = ConanFileReference.loads(reference) ref = self.locked_versions[ref.name] if self.locked_versions is not None else ref try: python_require = self._cached_requires[ref] except KeyError: requirement = Requirement(ref) self._range_resolver.resolve(requirement, "python_require", update=self._update, remotes=self._remotes) ref = requirement.ref result = self._proxy.get_recipe(ref, self._check_updates, self._update, remotes=self._remotes, recorder=ActionRecorder()) path, _, _, new_ref = result module, conanfile = parse_conanfile(conanfile_path=path, python_requires=self) # Check for alias if getattr(conanfile, "alias", None): # Will register also the aliased python_require = self._look_for_require(conanfile.alias) else: package_layout = self._proxy._cache.package_layout(new_ref, conanfile.short_paths) exports_sources_folder = package_layout.export_sources() exports_folder = package_layout.export() python_require = PythonRequire(new_ref, module, conanfile, exports_folder, exports_sources_folder) self._cached_requires[ref] = python_require return python_require
def build_consumer(self, path, profile_build_requires=None, ref=None, create_ref=None, install=True): profile = Profile() if profile_build_requires: profile.build_requires = profile_build_requires profile.process_settings(self.cache) update = check_updates = False recorder = ActionRecorder() remotes = Remotes() build_mode = [] # Means build all ref = ref or ConanFileReference(None, None, None, None, validate=False) options = OptionsValues() graph_info = GraphInfo(profile, options, root_ref=ref) app = self._get_app() deps_graph = app.graph_manager.load_graph(path, create_ref, graph_info, build_mode, check_updates, update, remotes, recorder) if install: binary_installer = BinaryInstaller(app, recorder) build_mode = BuildMode(build_mode, app.out) binary_installer.install(deps_graph, None, build_mode, update, False, graph_info) return deps_graph
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 get_cwd() 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) recorder = ActionRecorder() manager = self._init_manager(recorder) manager.build(conanfile_path, source_folder, build_folder, package_folder, install_folder, should_configure=should_configure, should_build=should_build, should_install=should_install)
def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False, remote=None, outdated=False): recorder = ActionRecorder() manager = self._init_manager(recorder) manager.remove(pattern, package_ids_filter=packages, build_ids=builds, src=src, force=force, remote_name=remote, packages_query=query, outdated=outdated)
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) recorder = ActionRecorder() manager = self._init_manager(recorder) manager.download(conan_ref, package, remote_name=remote, recipe=recipe)
def download(self, reference, remote_name=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) recorder = ActionRecorder() download(conan_ref, package, remote_name, recipe, self._registry, self._remote_manager, self._client_cache, self._user_io.out, recorder, self._loader)
def info(self, reference, remote_name=None, settings=None, options=None, env=None, profile_name=None, update=False, install_folder=None, build=None): reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings, options, env) recorder = ActionRecorder() deps_graph, conanfile, _ = self._graph_manager.load_graph(reference, None, profile, build, update, False, remote_name, recorder, workspace=None) return deps_graph, conanfile
def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, profile_name=None, remote_name=None, check_updates=None, install_folder=None): reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings, options, env) recorder = ActionRecorder() deps_graph, conanfile, _ = self._graph_manager.load_graph(reference, None, profile, build_modes, check_updates, False, remote_name, recorder, workspace=None) nodes_to_build = deps_graph.nodes_to_build() return nodes_to_build, conanfile
def info_build_order(self, reference, settings=None, options=None, env=None, profile_name=None, remote_name=None, build_order=None, check_updates=None, install_folder=None): reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings, options, env) recorder = ActionRecorder() deps_graph, _, _ = self._graph_manager.load_graph(reference, None, profile, ["missing"], check_updates, False, remote_name, recorder, workspace=None) return deps_graph.build_order(build_order)
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 get_cwd() # 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") cmd_export(conanfile_path, name, version, user, channel, False, self._user_io.out, self._client_cache) if not (name and version): name = conanfile.name version = conanfile.version reference = ConanFileReference(name, version, user, channel) recorder = ActionRecorder() manager = self._init_manager(recorder) manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder, package_folder=package_folder, install_folder=install_folder, profile=profile, force=force)
def test_returns_on_failures(self): test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")]) servers = {"default": test_server} class Response(object): ok = None status_code = None charset = None text = "" headers = {} def __init__(self, ok, status_code): self.ok = ok self.status_code = status_code class BuggyRequester(object): def __init__(self, *args, **kwargs): pass def get(self, *args, **kwargs): return Response(False, 404) client2 = TestClient(servers=servers, requester_class=BuggyRequester) ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable") proxy = client2.proxy remotes = Remotes() remotes.add("remotename", "url") with self.assertRaises(NotFoundException): proxy.get_recipe(ref, False, False, remotes, ActionRecorder()) class BuggyRequester2(BuggyRequester): def get(self, *args, **kwargs): return Response(False, 500) client2 = TestClient(servers=servers, requester_class=BuggyRequester2) proxy = client2.proxy try: proxy.get_recipe(ref, False, False, remotes, ActionRecorder()) except NotFoundException: self.assertFalse(True) # Shouldn't capture here except ConanException: pass
def workspace_install(self, path, settings=None, options=None, env=None, remote_name=None, build=None, profile_name=None, update=False, cwd=None, install_folder=None): cwd = cwd or get_cwd() abs_path = os.path.normpath(os.path.join(cwd, path)) remotes = self.app.load_remotes(remote_name=remote_name, update=update) # remotes = self.app.cache.registry.load_remotes() # remotes.select(remote_name) # self.app.python_requires.enable_remotes(update=update, remotes=remotes) workspace = Workspace(abs_path, self.app.cache) graph_info = get_graph_info(profile_name, settings, options, env, cwd, None, self.app.cache, self.app.out) self.app.out.info("Configuration:") self.app.out.writeln(graph_info.profile_host.dumps()) self.app.cache.editable_packages.override(workspace.get_editable_dict()) recorder = ActionRecorder() deps_graph = self.app.graph_manager.load_graph(workspace.root, None, graph_info, build, False, update, remotes, recorder) print_graph(deps_graph, self.app.out) # Inject the generators before installing for node in deps_graph.nodes: if node.recipe == RECIPE_EDITABLE: generators = workspace[node.ref].generators if generators is not None: tmp = list(node.conanfile.generators) tmp.extend([g for g in generators if g not in tmp]) node.conanfile.generators = tmp installer = BinaryInstaller(self.app, recorder) installer.install(deps_graph, remotes, build, update, keep_build=False, graph_info=graph_info) install_folder = install_folder or cwd workspace.generate(install_folder, deps_graph, self.app.out) workspace.build(install_folder, deps_graph, self.app.out, self.app)
def incomplete_process_test(self): tracer = ActionRecorder() tracer.recipe_install_error(self.ref1, INSTALL_ERROR_NETWORK, "SSL wtf", "http://drl.com") tracer.add_recipe_being_developed(self.ref1) install_info = tracer.get_info() self.assertTrue(install_info["error"]) self.assertEquals(install_info["installed"][0]["packages"], []) self.assertEquals(install_info["installed"][0]["recipe"]["dependency"], False)
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) recorder = ActionRecorder() manager = self._init_manager(recorder) graph = manager.info_build_order(reference, profile, build_order, remote, check_updates) return graph
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) recorder = ActionRecorder() manager = self._init_manager(recorder) ret = manager.info_nodes_to_build(reference, profile, build_modes, remote, check_updates) ref_list, project_reference = ret return ref_list, project_reference
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) recorder = ActionRecorder() manager = self._init_manager(recorder) ret = manager.info_get_graph(reference, remote_name=remote, profile=profile, check_updates=update) deps_graph, graph_updates_info, project_reference = ret return deps_graph, graph_updates_info, project_reference
def double_actions_test(self): tracer = ActionRecorder() tracer.recipe_downloaded(self.ref1, "http://drl.com") tracer.recipe_fetched_from_cache(self.ref1) tracer.package_downloaded(self.ref_p1, "http://drl.com") tracer.package_fetched_from_cache(self.ref_p1) install_info = tracer.get_info() self.assertFalse(install_info["error"]) first_installed = install_info["installed"][0] self.assertFalse(first_installed["recipe"]["cache"]) self.assertTrue(first_installed["recipe"]["downloaded"]) self.assertIsNone(first_installed["recipe"]["error"]) self.assertEquals(str(first_installed["recipe"]["id"]), "lib1/1.0@conan/stable") self.assertFalse(first_installed["packages"][0]["cache"]) self.assertTrue(first_installed["packages"][0]["downloaded"]) self.assertIsNone(first_installed["packages"][0]["error"]) self.assertEquals(first_installed["packages"][0]["remote"], 'http://drl.com') self.assertEquals(str(first_installed["packages"][0]["id"]), "1")
def source(self, path, source_folder=None, info_folder=None, cwd=None): cwd = cwd or get_cwd() 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") recorder = ActionRecorder() manager = self._init_manager(recorder) manager.source(conanfile_path, source_folder, info_folder)
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_name=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 [] try: cwd = cwd or os.getcwd() recorder = ActionRecorder() conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) reference, conanfile = self._loader.load_export(conanfile_path, name, version, user, channel) # Make sure keep_source is set for keep_build keep_source = keep_source or keep_build # Forcing an export! if not not_export: cmd_export(conanfile_path, conanfile, reference, keep_source, self._user_io.out, self._client_cache, self._plugin_manager) if build_modes is None: # Not specified, force build the tested library build_modes = [conanfile.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) manager = self._init_manager(recorder) recorder.add_recipe_being_developed(reference) create(reference, manager, self._user_io, profile, remote_name, update, build_modes, manifest_folder, manifest_verify, manifest_interactive, keep_build, test_build_folder, test_folder, conanfile_path) return recorder.get_info() except ConanException as exc: recorder.error = True exc.info = recorder.get_info() raise
def incomplete_process_test(self): tracer = ActionRecorder() tracer.recipe_install_error(self.ref1, INSTALL_ERROR_NETWORK, "SSL wtf", "http://drl.com") tracer.add_recipe_being_developed(self.ref1) install_info = tracer.get_info() self.assertTrue(install_info["error"]) self.assertEquals(install_info["installed"][0]["packages"], []) self.assertEquals(install_info["installed"][0]["recipe"]["dependency"], False)
def _load_pyreq_conanfile(self, loader, lock_python_requires, ref): recipe = self._proxy.get_recipe(ref, self._check_updates, self._update, remotes=self._remotes, recorder=ActionRecorder()) path, _, _, new_ref = recipe conanfile, module = loader.load_basic_module(path, lock_python_requires, user=new_ref.user, channel=new_ref.channel) conanfile.name = new_ref.name conanfile.version = str(new_ref.version) \ if os.environ.get(CONAN_V2_MODE_ENVVAR, False) else new_ref.version if getattr(conanfile, "alias", None): ref = ConanFileReference.loads(conanfile.alias) conanfile, module, new_ref, path = self._load_pyreq_conanfile(loader, lock_python_requires, ref) return conanfile, module, new_ref, os.path.dirname(path)
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 get_cwd() 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) recorder = ActionRecorder() manager = self._init_manager(recorder) manager.imports(conanfile_abs_path, dest, info_folder)
def test_install(self): tracer = ActionRecorder() tracer.recipe_fetched_from_cache(self.ref1) tracer.package_downloaded(self.ref_p1, "http://drl.com") tracer.recipe_downloaded(self.ref2, "http://drl.com") tracer.package_install_error(self.ref_p2, INSTALL_ERROR_MISSING, "no package found", remote="https://drl.com") tracer.recipe_fetched_from_cache(self.ref3) tracer.package_built(self.ref_p3) tracer.add_recipe_being_developed(self.ref1) install_info = tracer.get_info() self.assertTrue(install_info["error"]) first_installed = install_info["installed"][0] self.assertTrue(first_installed["recipe"]["cache"]) self.assertFalse(first_installed["recipe"]["dependency"]) self.assertFalse(first_installed["recipe"]["downloaded"]) self.assertIsNone(first_installed["recipe"]["error"]) self.assertEquals(str(first_installed["recipe"]["id"]), "lib1/1.0@conan/stable") self.assertFalse(first_installed["packages"][0]["cache"]) self.assertTrue(first_installed["packages"][0]["downloaded"]) self.assertIsNone(first_installed["packages"][0]["error"]) self.assertEquals(first_installed["packages"][0]["remote"], 'http://drl.com') self.assertEquals(str(first_installed["packages"][0]["id"]), "1") second_installed = install_info["installed"][1] self.assertFalse(second_installed["recipe"]["cache"]) self.assertTrue(second_installed["recipe"]["dependency"]) self.assertTrue(second_installed["recipe"]["downloaded"]) self.assertIsNone(second_installed["recipe"]["error"]) self.assertEquals(str(second_installed["recipe"]["id"]), "lib2/1.0@conan/stable") self.assertFalse(second_installed["packages"][0]["cache"]) self.assertEquals(second_installed["packages"][0]["error"], {'type': 'missing', 'description': 'no package found', 'remote': 'https://drl.com'}) self.assertEquals(second_installed["packages"][0]["remote"], 'https://drl.com') self.assertEquals(str(second_installed["packages"][0]["id"]), "2") third_installed = install_info["installed"][2] self.assertTrue(third_installed["recipe"]["dependency"]) self.assertFalse(third_installed["packages"][0]["cache"]) self.assertFalse(third_installed["packages"][0]["error"]) self.assertTrue(third_installed["packages"][0]["built"]) self.assertIsNone(third_installed["packages"][0]["remote"]) self.assertEquals(str(third_installed["packages"][0]["id"]), "3")