Beispiel #1
0
 def test_environment(self):
     pm = PackageManager()
     env = Environment.build(pm.build_builtin_environment(),
                             pm.build_user_environment(),
                             Environment("test", {"FOO": "BAR"}))
     rend = EnvironmentRenderer(env)
     with self.assertStdout(template_out="env.out"):
         self.loggerManager.print_renderer(rend)
Beispiel #2
0
    def execute(self, args, uargs):
        pm = PackageManager()

        env = Environment.build(pm.build_builtin_environment(),
                                pm.build_user_environment())

        install_list, uninstall_list = DependencyUtils.upgrade(
            None if len(args.packages) == 0 else args.packages,
            pm.list_available_packages(),
            pm.list_installed_packages(),
            env=env)

        pm.logger.print_verbose(
            "{count} package(s) to be upgraded: {text}".format(
                count=len(install_list),
                text=" ".join([str(ap.identifier) for ap in install_list])))
        if args.clean:
            pm.logger.print_verbose(
                "{count} package(s) to be removed: {text}".format(
                    count=len(uninstall_list),
                    text=" ".join(
                        [str(ip.identifier) for ip in uninstall_list])))

        if len(install_list) == 0:
            pm.logger.print_default("No package to upgrade")
        else:
            pm.install_packages(map(IDENTIFIER_GETTER, install_list), env=env)
            if len(uninstall_list) > 0:
                if args.clean:
                    pm.uninstall_packages(
                        map(IDENTIFIER_GETTER, uninstall_list))
                else:
                    pm.logger.print_default(
                        "These packages can be removed:",
                        " ".join([str(ip.identifier)
                                  for ip in uninstall_list]))
class TestApiPackageManager(LeafTestCaseWithRepo):
    def setUp(self):
        super().setUp()

        self.pm = PackageManager()

        with self.assertRaises(NoRemoteException):
            self.pm.list_available_packages()
        self.assertEqual(0, len(self.pm.list_installed_packages()))
        with self.assertRaises(NoRemoteException):
            self.pm.list_remotes()
        self.assertEqual(0, len(self.pm.read_user_configuration().remotes))

        self.pm.create_remote("default", self.remote_url1, insecure=True)
        self.pm.create_remote("other", self.remote_url2, insecure=True)
        self.assertEqual(2, len(self.pm.read_user_configuration().remotes))
        self.pm.fetch_remotes(True)
        self.assertEqual(2, len(self.pm.list_remotes()))
        self.assertTrue(self.pm.list_remotes()["default"].is_fetched)
        self.assertTrue(self.pm.list_remotes()["other"].is_fetched)
        self.assertNotEqual(0, len(self.pm.list_available_packages()))

    def test_compression(self):
        pislist = ["compress-bz2_1.0", "compress-gz_1.0", "compress-tar_1.0", "compress-xz_1.0"]
        self.pm.install_packages(PackageIdentifier.parse_list(pislist))
        self.check_content(self.pm.list_installed_packages(), pislist)

    def test_enable_disable_remote(self):
        self.assertEqual(2, len(self.pm.list_remotes(True)))
        self.assertTrue(len(self.pm.list_available_packages()) > 0)

        remote = self.pm.list_remotes()["default"]
        remote.enabled = False
        self.pm.update_remote(remote)
        self.assertEqual(2, len(self.pm.list_remotes(False)))
        self.assertEqual(1, len(self.pm.list_remotes(True)))
        self.assertEqual(len(ALT_INDEX_CONTENT), len(self.pm.list_available_packages()))

        remote = self.pm.list_remotes()["other"]
        remote.enabled = False
        self.pm.update_remote(remote)
        self.assertEqual(2, len(self.pm.list_remotes(False)))
        with self.assertRaises(NoEnabledRemoteException):
            self.pm.list_remotes(True)
        with self.assertRaises(NoEnabledRemoteException):
            self.pm.list_available_packages()

        remote = self.pm.list_remotes()["default"]
        remote.enabled = True
        self.pm.update_remote(remote)
        remote = self.pm.list_remotes()["other"]
        remote.enabled = True
        self.pm.update_remote(remote)
        self.assertEqual(2, len(self.pm.list_remotes(False)))
        self.assertEqual(2, len(self.pm.list_remotes(True)))
        self.assertTrue(len(self.pm.list_available_packages()) > 0)

    def test_container(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["container-A_1.0", "container-B_1.0", "container-C_1.0", "container-E_1.0"])

        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_2.0"]))
        self.check_content(
            self.pm.list_installed_packages(),
            ["container-A_1.0", "container-B_1.0", "container-C_1.0", "container-E_1.0", "container-A_2.0", "container-D_1.0"],
        )

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["container-A_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["container-A_2.0", "container-C_1.0", "container-D_1.0"])

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["container-A_2.0"]))
        self.check_content(self.pm.list_installed_packages(), [])

    def test_install_unknown_package(self):
        with self.assertRaises(InvalidPackageNameException):
            self.pm.install_packages(PackageIdentifier.parse_list(["unknwonPackage"]))
        with self.assertRaises(InvalidPackageNameException):
            self.pm.install_packages(PackageIdentifier.parse_list(["container-A"]))
        with self.assertRaises(InvalidPackageNameException):
            self.pm.install_packages(PackageIdentifier.parse_list(["unknwonPackage_1.0"]))

    def test_bad_container(self):
        with self.assertRaises(Exception):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-depends-leaf_1.0"]))
        self.check_content(self.pm.list_installed_packages(), [])

    def test_container_not_master(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_1.1"]))
        self.check_content(self.pm.list_installed_packages(), ["container-A_1.1", "container-B_1.0", "container-C_1.0", "container-E_1.0"])

        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_2.1"]))
        self.check_content(
            self.pm.list_installed_packages(),
            ["container-A_1.1", "container-B_1.0", "container-C_1.0", "container-E_1.0", "container-A_2.1", "container-D_1.0"],
        )

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["container-A_1.1"]))
        self.check_content(self.pm.list_installed_packages(), ["container-A_2.1", "container-C_1.0", "container-D_1.0"])

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["container-A_2.1"]))
        self.check_content(self.pm.list_installed_packages(), [])

    def test_steps(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["install_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["install_1.0"])

        folder = self.install_folder / "install_1.0"

        self.assertTrue(folder.is_dir())
        self.assertTrue((folder / "data1").is_file())
        self.assertTrue((folder / "folder").is_dir())
        self.assertTrue((folder / "folder" / "data2").is_file())
        self.assertTrue((folder / "folder" / "data1-symlink").is_symlink())

        self.assertFalse((self.install_folder / "uninstall.log").is_file())
        self.assertTrue((folder / "postinstall.log").is_file())
        self.assertTrue((folder / "targetFileFromEnv").is_file())
        self.assertTrue((folder / "dump.env").is_file())
        self.assertTrue((folder / "folder2").is_dir())
        with (folder / "targetFileFromEnv").open() as fp:
            content = fp.read().splitlines()
            self.assertEqual(1, len(content))
            self.assertEqual(str(folder), content[0])

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["install_1.0"]))
        self.check_content(self.pm.list_installed_packages(), [])
        self.assertTrue((self.install_folder / "uninstall.log").is_file())

    def test_postinstall_error(self):
        with self.assertRaises(Exception):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-postinstall-exec_1.0"]), keep_folder_on_error=True)
        found = False
        for folder in self.install_folder.iterdir():
            if folder.name.startswith("failure-postinstall-exec_1.0"):
                self.assertTrue(is_folder_ignored(folder))
                found = True
                break
        self.assertTrue(found)

    def test_cannot_uninstall_to_keep_dependencies(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_2.0"]))
        self.check_content(self.pm.list_installed_packages(), ["container-A_2.0", "container-C_1.0", "container-D_1.0"])

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["container-C_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["container-A_2.0", "container-C_1.0", "container-D_1.0"])

    def test_env(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["env-A_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["env-A_1.0", "env-B_1.0"])

        env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["env-A_1.0"]))
        self.assertEqual(3, len(env_tolist(env)))
        self.assertEqual(
            [
                ("LEAF_ENV_A", "FOO"),
                ("LEAF_ENV_A2", "Hello"),
                ("LEAF_PATH_A", "$PATH:{folder}/env-A_1.0:{folder}/env-B_1.0".format(folder=self.install_folder)),
            ],
            env_tolist(env),
        )

        env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["env-B_1.0", "env-A_1.0"]))
        self.assertEqual(5, len(env_tolist(env)))
        self.assertEqual(
            [
                ("LEAF_ENV_B", "BAR"),
                ("LEAF_PATH_B", "$PATH:{folder}/env-B_1.0".format(folder=self.install_folder)),
                ("LEAF_ENV_A", "FOO"),
                ("LEAF_ENV_A2", "Hello"),
                ("LEAF_PATH_A", "$PATH:{folder}/env-A_1.0:{folder}/env-B_1.0".format(folder=self.install_folder)),
            ],
            env_tolist(env),
        )
        self.assertFileContentEquals(self.install_folder / "env-A_1.0" / "dump.out", "dump.out")

    def test_silent_fail(self):
        with self.assertRaises(Exception):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-postinstall-exec_1.0"]))
        self.check_content(self.pm.list_installed_packages(), [])

        self.pm.install_packages(PackageIdentifier.parse_list(["failure-postinstall-exec-silent_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["failure-postinstall-exec-silent_1.0"])

    def test_cannot_install_badhash(self):
        with self.assertRaises(InvalidHashException):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-badhash_1.0"]))

    def test_outdated_leaf_version(self):
        with self.assertRaises(LeafOutOfDateException):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-minver_1.0"]))

    def test_outdated_cache_file(self):
        remote_cache_file = self.pm.cache_folder / "remotes" / "default.json"

        def get_mtime():
            return remote_cache_file.stat().st_mtime

        # Initial refresh
        self.pm.fetch_remotes(force_refresh=False)
        previous_mtime = get_mtime()

        # Second refresh, same day, file should not be updated
        time.sleep(1)
        self.pm.fetch_remotes(force_refresh=False)
        self.assertEqual(previous_mtime, get_mtime())
        os.remove(str(remote_cache_file))
        self.assertFalse(remote_cache_file.exists())

        # File has been deleted
        time.sleep(1)
        self.pm.fetch_remotes(force_refresh=False)
        self.assertNotEqual(previous_mtime, get_mtime())
        previous_mtime = get_mtime()

        # Initial refresh
        time.sleep(1)
        self.pm.fetch_remotes(force_refresh=False)
        self.assertEqual(previous_mtime, get_mtime())

        # New refresh, 23h ago, file should not be updated
        time.sleep(1)
        today = datetime.now()
        almostyesterday = today - timedelta(hours=23)
        os.utime(str(remote_cache_file), (int(almostyesterday.timestamp()), int(almostyesterday.timestamp())))
        self.assertNotEqual(previous_mtime, get_mtime())
        previous_mtime = get_mtime()
        self.pm.fetch_remotes(force_refresh=False)
        self.assertEqual(previous_mtime, get_mtime())

        # New refresh, 24h ago, file should be updated
        time.sleep(1)
        yesterday = today - timedelta(hours=24)
        os.utime(str(remote_cache_file), (int(yesterday.timestamp()), int(yesterday.timestamp())))
        self.assertNotEqual(previous_mtime, get_mtime())
        previous_mtime = get_mtime()
        self.pm.fetch_remotes(force_refresh=False)
        self.assertNotEqual(previous_mtime, get_mtime())

    def test_conditional_install(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["condition_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["condition_1.0", "condition-B_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0"])

        self.pm.install_packages(PackageIdentifier.parse_list(["condition_1.0"]), env=Environment("test", {"FOO": "BAR"}))
        self.check_content(
            self.pm.list_installed_packages(),
            ["condition_1.0", "condition-A_1.0", "condition-B_1.0", "condition-C_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0"],
        )

        self.pm.update_user_environment(set_map={"FOO2": "BAR2", "HELLO": "WoRld"})

        env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("test", {"FOO": "BAR"}))
        self.pm.install_packages(PackageIdentifier.parse_list(["condition_1.0"]), env=env)
        self.check_content(
            self.pm.list_installed_packages(),
            [
                "condition_1.0",
                "condition-A_1.0",
                "condition-B_1.0",
                "condition-C_1.0",
                "condition-D_1.0",
                "condition-E_1.0",
                "condition-F_1.0",
                "condition-G_1.0",
                "condition-H_1.0",
            ],
        )

        self.pm.uninstall_packages(PackageIdentifier.parse_list(["condition_1.0"]))
        self.check_content(self.pm.list_installed_packages(), [])

    def test_prereq_root(self):
        motifs = ["prereq-A_1.0", "prereq-B_1.0", "prereq-C_1.0", "prereq-D_1.0", "prereq-true_1.0", "prereq-env_1.0", "prereq-false_1.0"]
        errors = self.pm.install_prereq(PackageIdentifier.parse_list(motifs), self.alt_workspace_folder, raise_on_error=False)
        self.assertEqual(1, errors)
        for m in motifs:
            self.assertEqual("false" not in m, (self.alt_workspace_folder / m).is_dir())

    def test_prereq_a(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["prereq-A_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["prereq-A_1.0"])

    def test_prereq_b(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["prereq-B_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["prereq-A_1.0", "prereq-B_1.0"])

    def test_prereq_c(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["prereq-C_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["prereq-C_1.0", "prereq-true_1.0"])

    def test_prereq_d(self):
        with self.assertRaises(LeafException):
            self.pm.install_packages(PackageIdentifier.parse_list(["prereq-D_1.0"]))

    def test_prereq_env(self):
        motifs = ["prereq-env_1.0"]
        errors = self.pm.install_prereq(PackageIdentifier.parse_list(motifs), self.alt_workspace_folder, raise_on_error=False)
        self.assertEqual(0, errors)
        dump = self.alt_workspace_folder / "prereq-env_1.0" / "dump.env"
        self.assertTrue(dump.exists())
        env = env_file_to_map(dump)
        self.assertEqual(env["LEAF_PREREQ_ROOT"], str(self.alt_workspace_folder))

    def test_depends_available(self):
        deps = DependencyUtils.install(PackageIdentifier.parse_list([]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, [], AvailablePackage)

        deps = DependencyUtils.install(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, ["container-E_1.0", "container-B_1.0", "container-C_1.0", "container-A_1.0"], AvailablePackage)

    def test_depends_with_custom_env(self):
        env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("Custom env", {}))
        deps = DependencyUtils.install(
            PackageIdentifier.parse_list(["condition_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages(), env=env
        )
        self.__assert_deps(deps, ["condition-B_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0", "condition_1.0"], AvailablePackage)

        self.pm.update_user_environment(set_map={"FOO": "HELLO"})
        env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("Custom env", {}))
        deps = DependencyUtils.install(
            PackageIdentifier.parse_list(["condition_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages(), env=env
        )
        self.__assert_deps(deps, ["condition-A_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0", "condition_1.0"], AvailablePackage)

        self.pm.update_user_environment(set_map={"FOO": "HELLO"})
        env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("Custom env", {"FOO": "BAR"}))
        deps = DependencyUtils.install(
            PackageIdentifier.parse_list(["condition_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages(), env=env
        )
        self.__assert_deps(deps, ["condition-A_1.0", "condition-C_1.0", "condition-F_1.0", "condition_1.0"], AvailablePackage)

    def test_depends_install(self):
        deps = DependencyUtils.install(PackageIdentifier.parse_list([]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, [], AvailablePackage)

        deps = DependencyUtils.install(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, ["container-E_1.0", "container-B_1.0", "container-C_1.0", "container-A_1.0"], AvailablePackage)

        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_1.0"]))

        deps = DependencyUtils.install(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, [], AvailablePackage)

        deps = DependencyUtils.install(PackageIdentifier.parse_list(["container-A_2.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, ["container-D_1.0", "container-A_2.0"], AvailablePackage)

    def test_depends_installed(self):
        deps = DependencyUtils.installed(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_installed_packages(), ignore_unknown=True)
        self.__assert_deps(deps, [], InstalledPackage)

        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_1.0"]))

        deps = DependencyUtils.installed(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_installed_packages())
        self.__assert_deps(deps, ["container-E_1.0", "container-B_1.0", "container-C_1.0", "container-A_1.0"], InstalledPackage)

    def test_depends_uninstall(self):
        deps = DependencyUtils.uninstall(PackageIdentifier.parse_list([]), self.pm.list_installed_packages())
        self.__assert_deps(deps, [], InstalledPackage)

        self.pm.install_packages(PackageIdentifier.parse_list(["container-A_1.0"]))

        deps = DependencyUtils.uninstall(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_installed_packages())
        self.__assert_deps(deps, ["container-A_1.0", "container-C_1.0", "container-B_1.0", "container-E_1.0"], InstalledPackage)

    def test_depends_prereq(self):
        deps = DependencyUtils.prereq(PackageIdentifier.parse_list(["prereq-D_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages())
        self.__assert_deps(deps, ["prereq-false_1.0", "prereq-true_1.0"], AvailablePackage)

    def __assert_deps(self, result, expected, itemtype):
        for item in result:
            self.assertEqual(itemtype, type(item))
            self.assertTrue(isinstance(item, itemtype))
        deps = [str(mf.identifier) for mf in result]
        self.assertEqual(expected, deps)

    def test_sync(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["sync_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["sync_1.0"])
        self.check_installed_packages(["sync_1.0"])
        sync_file = self.install_folder / "sync_1.0" / "sync.log"

        self.assertFalse(sync_file.exists())

        self.pm.sync_packages(PackageIdentifier.parse_list(["sync_1.0"]))
        self.assertTrue(sync_file.exists())
        self.assertEqual(["MYVALUE"], get_lines(sync_file))

        self.pm.sync_packages(PackageIdentifier.parse_list(["sync_1.0"]))
        self.assertTrue(sync_file.exists())
        self.assertEqual(["MYVALUE", "MYVALUE"], get_lines(sync_file))

        self.pm.update_user_environment({"MYVAR2": "MYOTHERVALUE"})
        self.pm.sync_packages(PackageIdentifier.parse_list(["sync_1.0"]))
        self.assertTrue(sync_file.exists())
        self.assertEqual(["MYVALUE", "MYVALUE", "MYVALUE MYOTHERVALUE"], get_lines(sync_file))

    def test_resolve_latest(self):
        self.pm.install_packages(PackageIdentifier.parse_list(["version_1.0"]))
        self.check_content(self.pm.list_installed_packages(), ["version_1.0"])
        self.check_installed_packages(["version_1.0"])

        self.pm.install_packages(PackageIdentifier.parse_list(["version_1.1"]))
        self.check_content(self.pm.list_installed_packages(), ["version_1.0", "version_1.1"])
        self.check_installed_packages(["version_1.0", "version_1.1"])

        env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["version_latest"]))
        self.assertEqual("1.1", env.find_value("TEST_VERSION"))

        self.pm.install_packages(PackageIdentifier.parse_list(["version_latest"]))
        self.check_content(self.pm.list_installed_packages(), ["version_1.0", "version_1.1", "version_2.0"])
        self.check_installed_packages(["version_1.0", "version_1.1", "version_2.0"])

        env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["version_latest"]))
        self.assertEqual("2.0", env.find_value("TEST_VERSION"))

    def test_multiple_volatile_tags(self):
        def toggle_remote(name, enabled):
            remote = self.pm.list_remotes()[name]
            remote.enabled = enabled
            self.pm.update_remote(remote)

        pi = PackageIdentifier.parse("multitags_1.0")

        toggle_remote("other", False)
        self.assertEqual(["staticTag1", "staticTag2", "volatileTag1", "volatileTag2"], self.pm.list_available_packages()[pi].tags)

        toggle_remote("other", True)
        toggle_remote("default", False)
        self.assertEqual(["staticTag1", "staticTag2", "volatileTag3", "volatileTag4"], self.pm.list_available_packages()[pi].tags)

        toggle_remote("default", True)
        self.assertEqual(
            ["staticTag1", "staticTag2", "volatileTag1", "volatileTag2", "volatileTag3", "volatileTag4"], self.pm.list_available_packages()[pi].tags
        )

    def test_free_space_issue(self):
        with self.assertRaises(NotEnoughSpaceException):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-large-ap_1.0"]))
        with self.assertRaises(NotEnoughSpaceException):
            self.pm.install_packages(PackageIdentifier.parse_list(["failure-large-extracted_1.0"]))

    def test_tar_size(self):
        for filename, testfunc in (("compress-tar_1.0.leaf", self.assertGreater), ("compress-xz_1.0.leaf", self.assertLess)):
            file = self.repository_folder / filename
            self.assertTrue(file.exists())
            la = LeafArtifact(file)
            testfunc(file.stat().st_size, la.get_total_size())
Beispiel #4
0
    def execute(self, args, uargs):
        pm = PackageManager()
        env = None
        # If the user specified env values, build a complete env
        if args.custom_envlist is not None:
            env = Environment.build(
                pm.build_builtin_environment(), pm.build_user_environment(),
                Environment("Custom env",
                            env_list_to_map(args.custom_envlist)))

        items = None
        if args.dependency_type == "available":
            items = DependencyUtils.install(PackageIdentifier.parse_list(
                args.packages),
                                            pm.list_available_packages(), {},
                                            env=env)
        elif args.dependency_type == "install":
            items = DependencyUtils.install(PackageIdentifier.parse_list(
                args.packages),
                                            pm.list_available_packages(),
                                            pm.list_installed_packages(),
                                            env=env)
        elif args.dependency_type == "installed":
            items = DependencyUtils.installed(PackageIdentifier.parse_list(
                args.packages),
                                              pm.list_installed_packages(),
                                              env=env,
                                              ignore_unknown=True)
        elif args.dependency_type == "uninstall":
            items = DependencyUtils.uninstall(PackageIdentifier.parse_list(
                args.packages),
                                              pm.list_installed_packages(),
                                              env=env)
        elif args.dependency_type == "prereq":
            items = DependencyUtils.prereq(PackageIdentifier.parse_list(
                args.packages),
                                           pm.list_available_packages(),
                                           pm.list_installed_packages(),
                                           env=env)
        elif args.dependency_type == "upgrade":
            items, _ = DependencyUtils.upgrade(
                None if len(args.packages) == 0 else args.packages,
                pm.list_available_packages(),
                pm.list_installed_packages(),
                env=env)
        elif args.dependency_type == "rdepends":
            mfmap = OrderedDict()
            mfmap.update(
                DependencyUtils.rdepends(PackageIdentifier.parse_list(
                    args.packages),
                                         pm.list_available_packages(),
                                         env=env))
            mfmap.update(
                DependencyUtils.rdepends(PackageIdentifier.parse_list(
                    args.packages),
                                         pm.list_installed_packages(),
                                         env=env))
            items = mfmap.values()
        else:
            raise ValueError()

        rend = ManifestListRenderer()
        rend.extend(items)
        pm.print_renderer(rend)
Beispiel #5
0
    def execute(self, args, uargs):
        pm = PackageManager()
        wm = self.get_workspacemanager()
        profilename = wm.current_profile_name
        profile = wm.get_profile(profilename)

        env = Environment.build(pm.build_builtin_environment(),
                                pm.build_user_environment())

        install_list, upgraded_list = DependencyUtils.upgrade(
            None if len(args.packages) == 0 else args.packages,
            pm.list_available_packages(),
            pm.list_installed_packages(),
            env=env)

        pm.logger.print_verbose(
            "{count} package(s) to be upgraded: {text}".format(
                count=len(install_list),
                text=" ".join([str(ap.identifier) for ap in install_list])))
        if args.clean:
            pm.logger.print_verbose(
                "{count} package(s) to be removed: {text}".format(
                    count=len(upgraded_list),
                    text=" ".join([str(ip.identifier)
                                   for ip in upgraded_list])))

        if len(install_list) == 0:
            pm.logger.print_default("No package to upgrade")
        else:
            pm.install_packages(map(IDENTIFIER_GETTER, install_list), env=env)
            if len(upgraded_list) > 0:
                if args.clean:
                    pm.uninstall_packages(map(IDENTIFIER_GETTER,
                                              upgraded_list))
                else:
                    pm.logger.print_default(
                        "Packages upgraded:",
                        " ".join([str(ip.identifier) for ip in upgraded_list]))
                    pm.logger.print_default(
                        'Hint: Use "leaf profile config -p {PACKAGENAME}" to add these packages to your workspace profile'
                    )

        update_pilist = install_list
        profile_pkg_map = profile.pkg_map

        installed_packages = group_package_identifiers_by_name(
            wm.list_installed_packages())
        pkg_list = args.packages if args.packages else profile_pkg_map.keys()

        for pkg in pkg_list:
            pi = None
            if pkg in installed_packages.keys():
                # Get latest version
                pi = installed_packages[pkg][-1]

            if pi is not None and pi not in update_pilist:
                # Get PI in profile
                previous_pi = PackageIdentifier(pi.name, profile_pkg_map[
                    pi.name]) if pi.name in profile_pkg_map else None
                if previous_pi is None:
                    # Package is not in profile yet, add it
                    update_pilist.append(pi)
                elif previous_pi != pi:
                    # Package is already in profile with a different version, update it
                    update_pilist.append(pi)
                else:
                    # Package is already in profile with same version, do nothing
                    pass

        if len(update_pilist) == 0:
            pm.logger.print_default(
                "Packages are already in profile with same version")
        else:
            pm.logger.print_default(
                "Packages to be updated in profile:",
                " ".join([str(pi) for pi in update_pilist]))
            profile.add_packages(update_pilist)
            wm.update_profile(profile)