示例#1
0
    def install_workspace(self, profile, workspace, remote_name, build_modes,
                          update):
        loader = self.get_loader(profile)
        references = [
            ConanFileReference(v, "root", "project", "develop")
            for v in workspace.root
        ]
        conanfile = loader.load_virtual(references)
        remote_proxy = self.get_proxy(remote_name=remote_name)
        graph_builder = self._get_graph_builder(loader, remote_proxy)
        graph_builder._workspace = workspace
        deps_graph = graph_builder.load_graph(conanfile, False, update)

        output = ScopedOutput(str("Workspace"), self._user_io.out)
        output.highlight("Installing...")
        print_graph(deps_graph, self._user_io.out)

        build_mode = BuildMode(build_modes, self._user_io.out)
        build_requires = BuildRequires(loader, graph_builder, self._registry)
        installer = ConanInstaller(self._client_cache,
                                   output,
                                   remote_proxy,
                                   build_mode,
                                   build_requires,
                                   recorder=self._recorder)
        installer._workspace = workspace

        installer.install(deps_graph,
                          profile.build_requires,
                          keep_build=False,
                          update=update)
        build_mode.report_matches()
        workspace.generate()
示例#2
0
    def _install(self, conanfile, reference, build_requires, installer, profile_build_requires, output,
                 update, discard=False):
        if isinstance(reference, ConanFileReference):
            build_requires.pop(reference.name, None)
        if not build_requires:
            return
        if discard:
            profile_build_requires = copy.copy(profile_build_requires)
            profile_build_requires.pop("*", None)
            profile_build_requires.pop("&!", None)

        reference = str(reference)
        output.info("Installing build requirements of: %s" % (reference or "PROJECT"))
        output.info("Build requires: [%s]" % ", ".join(str(r) for r in build_requires.values()))
        # clear root package options, they won't match the build-require
        conanfile.build_requires_options.clear_unscoped_options()
        virtual = self._loader.load_virtual(build_requires.values(), scope_options=False,
                                            build_requires_options=conanfile.build_requires_options)

        # compute and print the graph of transitive build-requires
        deps_graph = self._graph_builder.load_graph(virtual, check_updates=False, update=update)
        print_graph(deps_graph, output)
        # install them, recursively
        installer.install(deps_graph, profile_build_requires, update=update)
        _apply_build_requires(deps_graph, conanfile, build_requires)
        output.info("Installed build requirements of: %s" % (reference or "PROJECT"))
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)
示例#4
0
    def install_workspace(self, profile, workspace, remote_name, build_modes, update):
        references = [ConanFileReference(v, "root", "project", "develop") for v in workspace.root]
        deps_graph, _, _ = self._graph_manager.load_graph(references, None, profile, build_modes,
                                                          False, update, remote_name, self._recorder,
                                                          workspace)

        output = ScopedOutput(str("Workspace"), self._user_io.out)
        output.highlight("Installing...")
        print_graph(deps_graph, self._user_io.out)

        installer = ConanInstaller(self._client_cache, output, self._remote_manager,
                                   self._registry, recorder=self._recorder, workspace=workspace,
                                   hook_manager=self._hook_manager)
        installer.install(deps_graph, keep_build=False)
        workspace.generate()
示例#5
0
def deps_install(app,
                 ref_or_path,
                 install_folder,
                 base_folder,
                 graph_info,
                 remotes=None,
                 build_modes=None,
                 update=False,
                 manifest_folder=None,
                 manifest_verify=False,
                 manifest_interactive=False,
                 generators=None,
                 no_imports=False,
                 create_reference=None,
                 keep_build=False,
                 recorder=None,
                 lockfile_node_id=None,
                 is_build_require=False,
                 add_txt_generator=True,
                 require_overrides=None,
                 conanfile_path=None,
                 test=None,
                 source_folder=None,
                 output_folder=None):
    """ Fetch and build all dependencies for the given reference
    @param app: The ConanApp instance with all collaborators
    @param ref_or_path: ConanFileReference or path to user space conanfile
    @param install_folder: where the output files will be saved
    @param build_modes: List of build_modes specified
    @param update: Check for updated in the upstream remotes (and update)
    @param manifest_folder: Folder to install the manifests
    @param manifest_verify: Verify dependencies manifests against stored ones
    @param manifest_interactive: Install deps manifests in folder for later verify, asking user
    for confirmation
    @param generators: List of generators from command line.
    @param no_imports: Install specified packages but avoid running imports
    @param add_txt_generator: Add the txt to the list of generators

    """

    out, user_io, graph_manager, cache = app.out, app.user_io, app.graph_manager, app.cache
    remote_manager, hook_manager = app.remote_manager, app.hook_manager

    profile_host, profile_build = graph_info.profile_host, graph_info.profile_build

    if profile_build:
        out.info("Configuration (profile_host):")
        out.writeln(profile_host.dumps())
        out.info("Configuration (profile_build):")
        out.writeln(profile_build.dumps())
    else:
        out.info("Configuration:")
        out.writeln(profile_host.dumps())

    deps_graph = graph_manager.load_graph(ref_or_path,
                                          create_reference,
                                          graph_info,
                                          build_modes,
                                          False,
                                          update,
                                          remotes,
                                          recorder,
                                          lockfile_node_id=lockfile_node_id,
                                          is_build_require=is_build_require,
                                          require_overrides=require_overrides)
    graph_lock = graph_info.graph_lock  # After the graph is loaded it is defined
    root_node = deps_graph.root
    conanfile = root_node.conanfile
    if root_node.recipe == RECIPE_VIRTUAL:
        out.highlight("Installing package: %s" % str(ref_or_path))
    else:
        conanfile.output.highlight("Installing package")
    print_graph(deps_graph, out)

    try:
        if cross_building(conanfile):
            settings = get_cross_building_settings(conanfile)
            message = "Cross-build from '%s:%s' to '%s:%s'" % settings
            out.writeln(message, Color.BRIGHT_MAGENTA)
    except ConanException:  # Setting os doesn't exist
        pass

    installer = BinaryInstaller(app, recorder=recorder)
    # TODO: Extract this from the GraphManager, reuse same object, check args earlier
    build_modes = BuildMode(build_modes, out)
    installer.install(deps_graph,
                      remotes,
                      build_modes,
                      update,
                      profile_host,
                      profile_build,
                      graph_lock,
                      keep_build=keep_build)

    graph_lock.complete_matching_prevs()

    if manifest_folder:
        manifest_manager = ManifestManager(manifest_folder,
                                           user_io=user_io,
                                           cache=cache)
        for node in deps_graph.nodes:
            if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL):
                continue
            retrieve_exports_sources(remote_manager, cache, node.conanfile,
                                     node.ref, remotes)
        manifest_manager.check_graph(deps_graph,
                                     verify=manifest_verify,
                                     interactive=manifest_interactive)
        manifest_manager.print_log()

    if hasattr(conanfile, "layout") and not test:
        conanfile.folders.set_base_source(source_folder or conanfile_path)
        conanfile.folders.set_base_install(output_folder or conanfile_path)
        conanfile.folders.set_base_imports(output_folder or conanfile_path)
        conanfile.folders.set_base_generators(output_folder or conanfile_path)
    else:
        conanfile.folders.set_base_install(install_folder)
        conanfile.folders.set_base_imports(install_folder)
        conanfile.folders.set_base_generators(base_folder)

    output = conanfile.output if root_node.recipe != RECIPE_VIRTUAL else out

    if install_folder:
        # Write generators
        tmp = list(
            conanfile.generators)  # Add the command line specified generators
        generators = set(generators) if generators else set()
        tmp.extend([g for g in generators if g not in tmp])
        if add_txt_generator:
            tmp.append("txt")
        conanfile.generators = tmp
        app.generator_manager.write_generators(conanfile, install_folder,
                                               conanfile.generators_folder,
                                               output)
        write_toolchain(conanfile, conanfile.generators_folder, output)

        if not isinstance(ref_or_path, ConanFileReference):
            # Write conaninfo
            content = normalize(conanfile.info.dumps())
            save(os.path.join(install_folder, CONANINFO), content)
            output.info("Generated %s" % CONANINFO)
            graph_info.save(install_folder)
            output.info("Generated graphinfo")
            graph_lock_file = GraphLockFile(profile_host, profile_build,
                                            graph_lock)
            graph_lock_file.save(os.path.join(install_folder, "conan.lock"))
        if not no_imports:
            run_imports(conanfile)
        if type(conanfile
                ).system_requirements != ConanFile.system_requirements:
            call_system_requirements(conanfile, conanfile.output)

        if not create_reference and isinstance(ref_or_path,
                                               ConanFileReference):
            # The conanfile loaded is a virtual one. The one w deploy is the first level one
            neighbours = deps_graph.root.neighbors()
            deploy_conanfile = neighbours[0].conanfile
            if hasattr(deploy_conanfile, "deploy") and callable(
                    deploy_conanfile.deploy):
                run_deploy(deploy_conanfile, install_folder)
示例#6
0
文件: manager.py 项目: zhuhaow/conan
    def install(self,
                reference,
                install_folder,
                profile,
                remote_name=None,
                build_modes=None,
                update=False,
                manifest_folder=None,
                manifest_verify=False,
                manifest_interactive=False,
                generators=None,
                no_imports=False,
                create_reference=None,
                keep_build=False):
        """ Fetch and build all dependencies for the given reference
        @param reference: ConanFileReference or path to user space conanfile
        @param install_folder: where the output files will be saved
        @param remote: install only from that remote
        @param profile: Profile object with both the -s introduced options and profile read values
        @param build_modes: List of build_modes specified
        @param update: Check for updated in the upstream remotes (and update)
        @param manifest_folder: Folder to install the manifests
        @param manifest_verify: Verify dependencies manifests against stored ones
        @param manifest_interactive: Install deps manifests in folder for later verify, asking user
        for confirmation
        @param generators: List of generators from command line. If False, no generator will be
        written
        @param no_imports: Install specified packages but avoid running imports
        @param inject_require: Reference to add as a requirement to the conanfile
        """

        if generators is not False:
            generators = set(generators) if generators else set()
            generators.add("txt")  # Add txt generator by default

        result = self._graph_manager.load_graph(reference, create_reference,
                                                profile, build_modes, False,
                                                update, remote_name,
                                                self._recorder, None)
        deps_graph, conanfile, cache_settings = result

        if not isinstance(reference, ConanFileReference):
            output = ScopedOutput(
                ("%s (test package)" %
                 str(create_reference)) if create_reference else "PROJECT",
                self._user_io.out)
            output.highlight("Installing %s" % reference)
        else:
            output = ScopedOutput(str(reference), self._user_io.out)
            output.highlight("Installing package")
        print_graph(deps_graph, self._user_io.out)

        try:
            if cross_building(cache_settings):
                b_os, b_arch, h_os, h_arch = get_cross_building_settings(
                    cache_settings)
                message = "Cross-build from '%s:%s' to '%s:%s'" % (
                    b_os, b_arch, h_os, h_arch)
                self._user_io.out.writeln(message, Color.BRIGHT_MAGENTA)
        except ConanException:  # Setting os doesn't exist
            pass

        installer = ConanInstaller(self._client_cache,
                                   output,
                                   self._remote_manager,
                                   self._registry,
                                   recorder=self._recorder,
                                   workspace=None)
        installer.install(deps_graph, keep_build)

        if manifest_folder:
            manifest_manager = ManifestManager(manifest_folder,
                                               user_io=self._user_io,
                                               client_cache=self._client_cache)
            for node in deps_graph.nodes:
                if not node.conan_ref:
                    continue
                complete_recipe_sources(self._remote_manager,
                                        self._client_cache, self._registry,
                                        node.conanfile, node.conan_ref)
            manifest_manager.check_graph(deps_graph,
                                         verify=manifest_verify,
                                         interactive=manifest_interactive)
            manifest_manager.print_log()

        if install_folder:
            # Write generators
            if generators is not False:
                tmp = list(conanfile.generators
                           )  # Add the command line specified generators
                tmp.extend([g for g in generators if g not in tmp])
                conanfile.generators = tmp
                write_generators(conanfile, install_folder, output)
            if not isinstance(reference, ConanFileReference):
                # Write conaninfo
                content = normalize(conanfile.info.dumps())
                save(os.path.join(install_folder, CONANINFO), content)
                output.info("Generated %s" % CONANINFO)
            if not no_imports:
                run_imports(conanfile, install_folder, output)
            call_system_requirements(conanfile, output)

            if not create_reference and isinstance(reference,
                                                   ConanFileReference):
                # The conanfile loaded is really a virtual one. The one with the deploy is the first level one
                neighbours = deps_graph.root.neighbors()
                deploy_conanfile = neighbours[0].conanfile
                if hasattr(deploy_conanfile, "deploy") and callable(
                        deploy_conanfile.deploy):
                    run_deploy(deploy_conanfile, install_folder, output)
示例#7
0
    def install(self, ref_or_path, install_folder, graph_info, remotes=None, build_modes=None,
                update=False, manifest_folder=None, manifest_verify=False,
                manifest_interactive=False, generators=None, no_imports=False, create_reference=None,
                keep_build=False):
        """ Fetch and build all dependencies for the given reference
        @param ref_or_path: ConanFileReference or path to user space conanfile
        @param install_folder: where the output files will be saved
        @param remote_name: install only from that remote
        @param profile: Profile object with both the -s introduced options and profile read values
        @param build_modes: List of build_modes specified
        @param update: Check for updated in the upstream remotes (and update)
        @param manifest_folder: Folder to install the manifests
        @param manifest_verify: Verify dependencies manifests against stored ones
        @param manifest_interactive: Install deps manifests in folder for later verify, asking user
        for confirmation
        @param generators: List of generators from command line. If False, no generator will be
        written
        @param no_imports: Install specified packages but avoid running imports
        """

        if generators is not False:
            generators = set(generators) if generators else set()
            generators.add("txt")  # Add txt generator by default

        self._user_io.out.info("Configuration:")
        self._user_io.out.writeln(graph_info.profile.dumps())
        result = self._graph_manager.load_graph(ref_or_path, create_reference, graph_info,
                                                build_modes, False, update, remotes,
                                                self._recorder)
        deps_graph, conanfile = result

        if conanfile.display_name == "virtual":
            self._user_io.out.highlight("Installing package: %s" % str(ref_or_path))
        else:
            conanfile.output.highlight("Installing package")
        print_graph(deps_graph, self._user_io.out)

        try:
            if cross_building(graph_info.profile.processed_settings):
                settings = get_cross_building_settings(graph_info.profile.processed_settings)
                message = "Cross-build from '%s:%s' to '%s:%s'" % settings
                self._user_io.out.writeln(message, Color.BRIGHT_MAGENTA)
        except ConanException:  # Setting os doesn't exist
            pass

        installer = BinaryInstaller(self._cache, self._user_io.out, self._remote_manager,
                                    recorder=self._recorder,
                                    hook_manager=self._hook_manager)
        installer.install(deps_graph, remotes, keep_build=keep_build, graph_info=graph_info)

        if manifest_folder:
            manifest_manager = ManifestManager(manifest_folder, user_io=self._user_io,
                                               cache=self._cache)
            for node in deps_graph.nodes:
                if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL):
                    continue
                complete_recipe_sources(self._remote_manager, self._cache, node.conanfile, node.ref,
                                        remotes)
            manifest_manager.check_graph(deps_graph,
                                         verify=manifest_verify,
                                         interactive=manifest_interactive)
            manifest_manager.print_log()

        if install_folder:
            # Write generators
            output = conanfile.output if conanfile.display_name != "virtual" else self._user_io.out
            if generators is not False:
                tmp = list(conanfile.generators)  # Add the command line specified generators
                tmp.extend([g for g in generators if g not in tmp])
                conanfile.generators = tmp
                write_generators(conanfile, install_folder, output)
            if not isinstance(ref_or_path, ConanFileReference):
                # Write conaninfo
                content = normalize(conanfile.info.dumps())
                save(os.path.join(install_folder, CONANINFO), content)
                output.info("Generated %s" % CONANINFO)
                graph_info.save(install_folder)
                output.info("Generated graphinfo")
            if not no_imports:
                run_imports(conanfile, install_folder)
            call_system_requirements(conanfile, conanfile.output)

            if not create_reference and isinstance(ref_or_path, ConanFileReference):
                # The conanfile loaded is a virtual one. The one w deploy is the first level one
                neighbours = deps_graph.root.neighbors()
                deploy_conanfile = neighbours[0].conanfile
                if hasattr(deploy_conanfile, "deploy") and callable(deploy_conanfile.deploy):
                    run_deploy(deploy_conanfile, install_folder)
示例#8
0
文件: manager.py 项目: zhongpan/conan
def deps_install(app, ref_or_path, install_folder, graph_info, remotes=None, build_modes=None,
                 update=False, manifest_folder=None, manifest_verify=False,
                 manifest_interactive=False, generators=None, no_imports=False,
                 create_reference=None, keep_build=False, use_lock=False, recorder=None):
    """ Fetch and build all dependencies for the given reference
    :param app: The ConanApp instance with all collaborators
    @param ref_or_path: ConanFileReference or path to user space conanfile
    @param install_folder: where the output files will be saved
    @param build_modes: List of build_modes specified
    @param update: Check for updated in the upstream remotes (and update)
    @param manifest_folder: Folder to install the manifests
    @param manifest_verify: Verify dependencies manifests against stored ones
    @param manifest_interactive: Install deps manifests in folder for later verify, asking user
    for confirmation
    @param generators: List of generators from command line. If False, no generator will be
    written
    @param no_imports: Install specified packages but avoid running imports

    """
    out, user_io, graph_manager, cache = app.out, app.user_io, app.graph_manager, app.cache
    remote_manager, hook_manager = app.remote_manager, app.hook_manager
    if generators is not False:
        generators = set(generators) if generators else set()
        generators.add("txt")  # Add txt generator by default

    out.info("Configuration:")
    out.writeln(graph_info.profile_host.dumps())
    deps_graph = graph_manager.load_graph(ref_or_path, create_reference, graph_info, build_modes,
                                          False, update, remotes, recorder)
    root_node = deps_graph.root
    conanfile = root_node.conanfile
    if root_node.recipe == RECIPE_VIRTUAL:
        out.highlight("Installing package: %s" % str(ref_or_path))
    else:
        conanfile.output.highlight("Installing package")
    print_graph(deps_graph, out)

    try:
        if cross_building(graph_info.profile_host.processed_settings):
            settings = get_cross_building_settings(graph_info.profile_host.processed_settings)
            message = "Cross-build from '%s:%s' to '%s:%s'" % settings
            out.writeln(message, Color.BRIGHT_MAGENTA)
    except ConanException:  # Setting os doesn't exist
        pass

    installer = BinaryInstaller(app, recorder=recorder)
    # TODO: Extract this from the GraphManager, reuse same object, check args earlier
    build_modes = BuildMode(build_modes, out)
    installer.install(deps_graph, remotes, build_modes, update, keep_build=keep_build,
                      graph_info=graph_info)
    # GraphLock always != None here (because of graph_manager.load_graph)
    graph_info.graph_lock.update_check_graph(deps_graph, out)

    if manifest_folder:
        manifest_manager = ManifestManager(manifest_folder, user_io=user_io, cache=cache)
        for node in deps_graph.nodes:
            if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL):
                continue
            complete_recipe_sources(remote_manager, cache, node.conanfile, node.ref,
                                    remotes)
        manifest_manager.check_graph(deps_graph, verify=manifest_verify,
                                     interactive=manifest_interactive)
        manifest_manager.print_log()

    if install_folder:
        conanfile.install_folder = install_folder
        # Write generators
        output = conanfile.output if root_node.recipe != RECIPE_VIRTUAL else out
        if generators is not False:
            tmp = list(conanfile.generators)  # Add the command line specified generators
            tmp.extend([g for g in generators if g not in tmp])
            conanfile.generators = tmp
            write_generators(conanfile, install_folder, output)
        if not isinstance(ref_or_path, ConanFileReference) or use_lock:
            # Write conaninfo
            content = normalize(conanfile.info.dumps())
            save(os.path.join(install_folder, CONANINFO), content)
            output.info("Generated %s" % CONANINFO)
            graph_info.save(install_folder)
            output.info("Generated graphinfo")
        if not no_imports:
            run_imports(conanfile, install_folder)
        call_system_requirements(conanfile, conanfile.output)

        if not create_reference and isinstance(ref_or_path, ConanFileReference):
            # The conanfile loaded is a virtual one. The one w deploy is the first level one
            neighbours = deps_graph.root.neighbors()
            deploy_conanfile = neighbours[0].conanfile
            if hasattr(deploy_conanfile, "deploy") and callable(deploy_conanfile.deploy):
                run_deploy(deploy_conanfile, install_folder)