Пример #1
0
 def __execute_steps(self,
                     pi: PackageIdentifier,
                     ipmap: dict,
                     se_func: callable,
                     env: Environment = None):
     # Find the package
     ip = find_manifest(pi, ipmap)
     # The environment
     if env is None:
         env = Environment.build(self.build_builtin_environment(),
                                 self.build_user_environment())
     # build the dependencies
     deps = DependencyUtils.installed([pi],
                                      ipmap,
                                      env=env,
                                      ignore_unknown=True)
     # Update env
     env.append(self.build_packages_environment(deps))
     # Fix PREREQ_ROOT
     env.set_variable("LEAF_PREREQ_ROOT", self.install_folder)
     # The Variable resolver
     vr = VariableResolver(ip, ipmap.values())
     # Execute steps
     se = StepExecutor(self.logger, ip, vr, env=env)
     se_func(se)
Пример #2
0
    def test_multiple(self):
        env = Environment("my env 1",
                          content=[("A1", "a1"), ("B1", "b1")],
                          in_files=["/tmp/a1.in", "/tmp/b1.in"],
                          out_files=["/tmp/a1.out", "/tmp/b1.out"])
        env.append(
            Environment("my env 2",
                        content=[("A2", "a2"), ("B2", "b2")],
                        in_files=["/tmp/a2.in", "/tmp/b2.in"],
                        out_files=["/tmp/a2.out", "/tmp/b2.out"]))
        env.append(
            Environment("my env 3",
                        in_files=["/tmp/a3.in", "/tmp/b3.in"],
                        out_files=["/tmp/a3.out", "/tmp/b3.out"]))
        env.append(
            Environment("my env 4",
                        content=[("A4", "a4"), ("B4", "b4")],
                        in_files=["/tmp/a4.in", "/tmp/b4.in"]))
        env.append(
            Environment("my env 5",
                        content=[("A5", "a5"), ("B5", "b5")],
                        out_files=["/tmp/a5.out", "/tmp/b5.out"]))
        env.append(Environment("my env 6"))

        with self.assertStdout(template_out="activate.out"):
            env.activate(
                comment_consumer=lambda l: print(
                    Environment.tostring_comment(l)),
                kv_consumer=lambda k, v: print(
                    Environment.tostring_export(k, v)),
                file_consumer=lambda f: print(Environment.tostring_file(f)),
            )
        with self.assertStdout(template_out="deactivate.out"):
            env.deactivate(
                comment_consumer=lambda l: print(
                    Environment.tostring_comment(l)),
                kv_consumer=lambda k, v: print(
                    Environment.tostring_export(k, v)),
                file_consumer=lambda f: print(Environment.tostring_file(f)),
            )

        env.generate_scripts(
            activate_file=self.volatile_folder / "activate.sh",
            deactivate_file=self.volatile_folder / "deactivate.sh")
        self.assertFileContentEquals(self.volatile_folder / "activate.sh",
                                     "activate.out")
        self.assertFileContentEquals(self.volatile_folder / "deactivate.sh",
                                     "deactivate.out")
Пример #3
0
    def install_prereq(self,
                       pilist: list,
                       tmp_install_folder: Path,
                       apmap: dict = None,
                       env: Environment = None,
                       raise_on_error: bool = True):
        """
        Install given prereg available package in alternative root folder
        @return: error count
        """
        if apmap is None:
            apmap = self.list_available_packages()

        # Get packages to install
        aplist = [find_manifest(pi, apmap) for pi in pilist]

        errors = 0
        if len(aplist) > 0:
            self.logger.print_verbose(
                "Installing {count} pre-required package(s) in {folder}".
                format(count=len(aplist), folder=tmp_install_folder))
            if env is None:
                env = Environment.build(self.build_builtin_environment(),
                                        self.build_user_environment())
            env.append(
                Environment("Prereq",
                            {"LEAF_PREREQ_ROOT": tmp_install_folder}))
            for prereqap in aplist:
                try:
                    prereqla = self.__download_ap(prereqap)
                    prereqip = self.__extract_artifact(
                        prereqla,
                        env,
                        tmp_install_folder,
                        keep_folder_on_error=True)
                    self.logger.print_verbose(
                        "Prereq package {ip.identifier} is OK".format(
                            ip=prereqip))
                except Exception as e:
                    if raise_on_error:
                        raise e
                    self.logger.print_verbose(
                        "Prereq package {ap.identifier} has error: {error}".
                        format(ap=prereqap, error=e))
                    errors += 1
        return errors
Пример #4
0
    def __execute(self, step, label):
        command = step[JsonConstants.STEP_EXEC_COMMAND]
        command = list(map(self.__vr.resolve, command))
        command_text = " ".join(command)
        self.__logger.print_verbose("Execute: {command}".format(command=command_text))

        env = Environment()
        env.append(self.__env)
        env.append(Environment(content=step.get(JsonConstants.STEP_EXEC_ENV)))

        verbose = step.get(JsonConstants.STEP_EXEC_VERBOSE, False)

        rc = execute_command(*command, cwd=self.__target_folder, env=env, print_stdout=verbose or self.__logger.isverbose())
        if rc != 0:
            self.__logger.print_verbose("Command '{command}' exited with {rc}".format(command=command_text, rc=rc))
            if step.get(JsonConstants.STEP_IGNORE_FAIL, False):
                self.__logger.print_verbose("Step ignores failure")
            else:
                raise LeafException("Error during {label} step for {ip.identifier} (command returned {rc})".format(label=label, ip=self.__package, rc=rc))
Пример #5
0
    def test_envprovider(self):
        class MyEnvProvider(IEnvProvider):
            def _getenvmap(self):
                return {"AaaA": "a b c"}

            def _getenvinfiles(self):
                return ["/tmp/a.in", "/tmp/b.in"]

            def _getenvoutfiles(self):
                return ["/tmp/a.out", "/tmp/b.out"]

        env = Environment("my env 1",
                          content=[("A1", "a1"), ("B1", "b1")],
                          in_files=["/tmp/a1.in", "/tmp/b1.in"],
                          out_files=["/tmp/a1.out", "/tmp/b1.out"])
        env.append(
            MyEnvProvider("My custom env").build_environment(
                vr=lambda x: x.upper()))

        with self.assertStdout(template_out="activate.out"):
            env.activate(
                comment_consumer=lambda l: print(
                    Environment.tostring_comment(l)),
                kv_consumer=lambda k, v: print(
                    Environment.tostring_export(k, v)),
                file_consumer=lambda f: print(Environment.tostring_file(f)),
            )
        with self.assertStdout(template_out="deactivate.out"):
            env.deactivate(
                comment_consumer=lambda l: print(
                    Environment.tostring_comment(l)),
                kv_consumer=lambda k, v: print(
                    Environment.tostring_export(k, v)),
                file_consumer=lambda f: print(Environment.tostring_file(f)),
            )

        env.generate_scripts(
            activate_file=self.volatile_folder / "activate.sh",
            deactivate_file=self.volatile_folder / "deactivate.sh")
        self.assertFileContentEquals(self.volatile_folder / "activate.sh",
                                     "activate.out")
        self.assertFileContentEquals(self.volatile_folder / "deactivate.sh",
                                     "deactivate.out")
Пример #6
0
 def build_packages_environment(self, items: list, ipmap=None):
     """
     Get the env vars declared by given packages
     @param items: a list of InstalledPackage or PackageIdentifier
     """
     ipmap = ipmap or self.list_installed_packages()
     out = Environment()
     for item in items:
         ip = None
         if isinstance(item, InstalledPackage):
             ip = item
         elif isinstance(item, PackageIdentifier):
             ip = None
             if is_latest_package(item):
                 ip = find_manifest(item, ipmap)
             else:
                 ip = ipmap.get(item)
             if ip is None:
                 raise InvalidPackageNameException(item)
         else:
             raise InvalidPackageNameException(item)
         vr = VariableResolver(ip, ipmap.values())
         out.append(ip.build_environment(vr=vr.resolve))
     return out
Пример #7
0
    def get_setting_value(self,
                          setting_id: str,
                          user_env=None,
                          ws_env=None,
                          pf_env=None) -> str:
        setting = self.get_setting(setting_id)

        # build env
        env = Environment()
        if Scope.USER in setting.scopes:
            env.append(user_env or self.build_user_environment())
        if self.is_initialized:
            if Scope.WORKSPACE in setting.scopes:
                env.append(ws_env or self.build_ws_environment())
            if Scope.PROFILE in setting.scopes:
                try:
                    env.append(pf_env or self.get_profile(
                        self.current_profile_name).build_environment())
                except NoProfileSelected:
                    pass
        # Search the setting value
        return env.find_setting(setting)