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_resolve_latest(self):
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["testlatest_1.0"]), APMAP, {})
self.assertEqual(["version_2.0", "testlatest_1.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["testlatest_1.0"]), APMAP,
filtermap(IPMAP, "version_1.0"))
self.assertEqual(["version_2.0", "testlatest_1.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["testlatest_1.0"]), APMAP,
filtermap(IPMAP, "version_2.0"))
self.assertEqual(["testlatest_1.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["testlatest_2.0"]), APMAP, {})
self.assertEqual(["version_2.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["testlatest_2.0", "testlatest_2.1"]),
APMAP, {})
self.assertEqual(["version_2.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
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_upgrade(self):
ideps, udeps = DependencyUtils.upgrade(None, APMAP,
filtermap(IPMAP, "upgrade_1.0"))
self.assertEqual([], [str(mf.identifier) for mf in ideps])
self.assertEqual([], [str(mf.identifier) for mf in udeps])
ideps, udeps = DependencyUtils.upgrade(
None, APMAP,
filtermap(IPMAP, "upgrade_1.0", "upgrade_1.1", "upgrade_1.2"))
self.assertEqual(["upgrade_2.0"], [str(mf.identifier) for mf in ideps])
self.assertEqual(["upgrade_1.1", "upgrade_1.2"],
[str(mf.identifier) for mf in udeps])
def test_depends_prereq(self):
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages()
)
self.__assert_deps(deps, ["prereq-A_1.0", "prereq-B_2.0"], AvailablePackage)
self.pm.install_packages(PackageIdentifier.parse_list(["pkg-with-prereq_1.0"]))
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages()
)
self.__assert_deps(deps, ["prereq-A_1.0", "prereq-B_2.0"], None)
self.assertIsInstance(deps[0], InstalledPackage)
self.assertIsInstance(deps[1], AvailablePackage)
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)
def get_profile_dependencies(self, profile, ipmap=None):
"""
Returns all latest packages needed by a profile
"""
return DependencyUtils.installed(
profile.packages,
ipmap or self.list_installed_packages(),
only_keep_latest=True,
env=self.build_pf_environment(profile))
def test_prereq_order(self):
pi = "prereq-D_1.0"
prereqs = APMAP[PackageIdentifier.parse(pi)].requires_packages
self.assertEqual(["prereq-true_1.0", "prereq-false_1.0"], prereqs)
prereqs = DependencyUtils.prereq(PackageIdentifier.parse_list([pi]),
APMAP, {})
self.assertEqual(["prereq-false_1.0", "prereq-true_1.0"],
list(map(str, map(IDENTIFIER_GETTER, prereqs))))
def test_uninstall(self):
ipmap = OrderedDict()
for ap in DependencyUtils.install(
PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]), APMAP, {}):
ipmap[ap.identifier] = IPMAP[ap.identifier]
self.assertEqual([
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0", "container-D_1.0", "container-A_2.0"
], deps2strlist(ipmap.values()))
deps = DependencyUtils.uninstall(
PackageIdentifier.parse_list(["container-A_1.0"]), ipmap)
self.assertEqual(
["container-A_1.0", "container-B_1.0", "container-E_1.0"],
deps2strlist(deps))
def test_latest_strategy(self):
deps = DependencyUtils.installed(
PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]), IPMAP)
self.assertEqual(
[
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0", "container-D_1.0", "container-A_2.0"
],
list(map(str, map(IDENTIFIER_GETTER, deps))),
)
deps = DependencyUtils.installed(PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]),
IPMAP,
only_keep_latest=True)
self.assertEqual(
["container-C_1.0", "container-D_1.0", "container-A_2.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
def test_install(self):
deps = DependencyUtils.install(PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]),
APMAP, {},
env=Environment())
self.assertEqual([
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0", "container-D_1.0", "container-A_2.0"
], deps2strlist(deps))
deps = DependencyUtils.install(PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]),
APMAP,
filtermap(IPMAP, "container-E_1.0"),
env=Environment())
self.assertEqual([
"container-B_1.0", "container-C_1.0", "container-A_1.0",
"container-D_1.0", "container-A_2.0"
], deps2strlist(deps))
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_rdepends(self):
for mfmap in (IPMAP, APMAP):
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-A_1.0"]), mfmap)
self.assertEqual(["condition_1.0"], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(PackageIdentifier.parse_list(
["condition-A_1.0"]),
mfmap,
env=Environment(None, {}))
self.assertEqual([], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-A_1.0"]),
mfmap,
env=Environment(None, {"FOO": "BAR"}))
self.assertEqual(["condition_1.0"], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(PackageIdentifier.parse_list(
["condition-B_1.0"]),
mfmap,
env=Environment(None, {}))
self.assertEqual(["condition_1.0"], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-B_1.0"]),
mfmap,
env=Environment(None, {"FOO": "BAR"}))
self.assertEqual([], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-B_1.0"]), {})
self.assertEqual([], list(map(str, pilist)))
def provision_profile(self, profile):
if not profile.folder.is_dir():
# Create folder if needed
profile.folder.mkdir(parents=True)
else:
# Clean folder content
for item in profile.folder.glob("*"):
if item.is_symlink():
item.unlink()
else:
shutil.rmtree(str(item))
# Check if all needed packages are installed
missing_packages = DependencyUtils.install(
profile.packages,
self.list_available_packages(),
self.list_installed_packages(),
env=self.build_pf_environment(profile))
if len(missing_packages) == 0:
self.logger.print_verbose("All packages are already installed")
else:
self.logger.print_default("Profile is out of sync")
try:
self.install_packages(profile.packages,
env=self.build_pf_environment(profile))
except Exception as e:
raise ProfileProvisioningException(e)
# Do all needed links
errors = 0
for ip in self.get_profile_dependencies(profile):
pi_folder = profile.folder / ip.identifier.name
if pi_folder.exists():
pi_folder = profile.folder / str(ip.identifier)
try:
env = self.build_pf_environment(profile)
self.sync_packages([ip.identifier], env=env)
pi_folder.symlink_to(ip.folder)
except Exception as e:
errors += 1
self.logger.print_error(
"Error while sync operation on {ip.identifier}".format(
ip=ip))
self.logger.print_error(str(e))
print_trace()
# Touch folder when provisionning is done without error
if errors == 0:
profile.folder.touch(exist_ok=True)
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]))
def uninstall_packages(self, pilist: list):
"""
Remove given package
"""
with self.application_lock.acquire():
ipmap = self.list_installed_packages()
iplist_to_remove = DependencyUtils.uninstall(pilist,
ipmap,
logger=self.logger)
if len(iplist_to_remove) == 0:
self.logger.print_default("No package to remove")
else:
# Confirm
text = ", ".join(
[str(ip.identifier) for ip in iplist_to_remove])
self.logger.print_quiet(
"Packages to uninstall: {packages}".format(packages=text))
self.print_with_confirm(raise_on_decline=True)
for ip in iplist_to_remove:
if ip.read_only:
raise LeafException(
"Cannot uninstall system package {ip.identifier}".
format(ip=ip))
self.logger.print_default(
"Removing {ip.identifier}".format(ip=ip))
self.__execute_steps(ip.identifier, ipmap,
StepExecutor.uninstall)
self.logger.print_verbose(
"Remove folder: {ip.folder}".format(ip=ip))
rmtree_force(ip.folder)
del ipmap[ip.identifier]
self.logger.print_default("{count} package(s) removed".format(
count=len(iplist_to_remove)))
def test_prereq(self):
prereqs = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_1.0"]), APMAP, {})
self.assertEqual(list(map(str, prereqs)),
["prereq-A_1.0", "prereq-B_1.0"])
for p in prereqs:
self.assertTrue(isinstance(p, AvailablePackage))
prereqs = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_1.0"]), APMAP,
IPMAP)
self.assertEqual(list(map(str, prereqs)),
["prereq-A_1.0", "prereq-B_1.0"])
for p in prereqs:
self.assertTrue(isinstance(p, InstalledPackage))
prereqs = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]), APMAP, {})
self.assertEqual(list(map(str, prereqs)),
["prereq-A_1.0", "prereq-B_2.0"])
prereqs = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_0.1"]), APMAP, {})
self.assertEqual(list(map(str, prereqs)), ["prereq-A_0.1-fail"])
prereqs = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-deps-with-prereq_1.0"]),
APMAP, {})
self.assertEqual(list(map(str, prereqs)), [])
install = DependencyUtils.install(
PackageIdentifier.parse_list(["pkg-with-deps-with-prereq_1.0"]),
APMAP, {})
prereqs = DependencyUtils.prereq([x.identifier for x in install],
APMAP, {})
self.assertEqual(list(map(str, prereqs)),
["prereq-A_1.0", "prereq-B_1.0"])
def install_packages(self,
pilist: list,
env: Environment = None,
keep_folder_on_error: bool = False):
"""
Compute dependency tree, check compatibility, download from remotes and extract needed packages
@return: InstalledPackage list
"""
with self.application_lock.acquire():
prereq_install_folder = None
ipmap = self.list_installed_packages()
apmap = self.list_available_packages()
out = []
# Build env to resolve dynamic dependencies
if env is None:
env = Environment.build(self.build_builtin_environment(),
self.build_user_environment())
try:
ap_to_install = DependencyUtils.install(pilist,
apmap,
ipmap,
env=env)
# Check leaf min version
min_version = check_leaf_min_version(ap_to_install)
if min_version:
raise LeafOutOfDateException(
"You need to upgrade leaf to v{version} to install {text}"
.format(version=min_version,
text=", ".join([
str(ap.identifier) for ap in ap_to_install
])))
# Check nothing to do
if len(ap_to_install) == 0:
self.logger.print_default("All packages are installed")
else:
# Check available size
download_totalsize = 0
for ap in ap_to_install:
if ap.size is not None:
download_totalsize += ap.size
fs_check_free_space(self.download_cache_folder,
download_totalsize)
# Confirm
text = ", ".join(
[str(ap.identifier) for ap in ap_to_install])
self.logger.print_quiet(
"Packages to install: {packages}".format(
packages=text))
if download_totalsize > 0:
self.logger.print_default(
"Total size:", sizeof_fmt(download_totalsize))
self.print_with_confirm(raise_on_decline=True)
# Install prereq
prereq_to_install = DependencyUtils.prereq(pilist,
apmap,
ipmap,
env=env)
if len(prereq_to_install) > 0:
self.logger.print_default("Check required packages")
prereq_install_folder = mkdir_tmp_leaf_dir()
self.install_prereq(
[p.identifier for p in prereq_to_install],
prereq_install_folder,
apmap=apmap,
env=env)
# Download ap list
self.logger.print_default(
"Downloading {size} package(s)".format(
size=len(ap_to_install)))
la_to_install = []
for ap in ap_to_install:
la_to_install.append(self.__download_ap(ap))
# Check the extracted size
extracted_totalsize = 0
for la in la_to_install:
if la.final_size is not None:
extracted_totalsize += la.final_size
else:
extracted_totalsize += la.get_total_size()
fs_check_free_space(self.install_folder,
extracted_totalsize)
# Extract la list
for la in la_to_install:
self.logger.print_default(
"[{current}/{total}] Installing {la.identifier}".
format(current=(len(out) + 1),
total=len(la_to_install),
la=la))
ip = self.__extract_artifact(
la,
env,
self.install_folder,
ipmap=ipmap,
keep_folder_on_error=keep_folder_on_error)
out.append(ip)
finally:
if not keep_folder_on_error and prereq_install_folder is not None:
self.logger.print_verbose(
"Remove prereq root folder {folder}".format(
folder=prereq_install_folder))
rmtree_force(prereq_install_folder)
return out
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)
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)
def execute(self, args, uargs):
wm = self.get_workspacemanager(check_initialized=False)
ipmap = wm.list_installed_packages()
searching_iplist = None
if args.package is not None:
# User forces the package
searching_iplist = DependencyUtils.installed(
[args.package],
ipmap,
env=Environment.build(wm.build_builtin_environment(),
wm.build_user_environment()))
else:
# Use installed packages
searching_iplist = keep_latest_mf(ipmap.values())
topics = self.get_topics(searching_iplist)
if args.topic is not None:
topic = self.find_topic(topics, args.topic)
fmt = args.format
if fmt is None:
# No format given
if LeafSettings.HELP_DEFAULT_FORMAT.value in topic.resources.keys(
):
# Default format is available
fmt = LeafSettings.HELP_DEFAULT_FORMAT.value
elif len(topic.resources.keys()) == 1:
# Only one format available
fmt = next(iter(topic.resources.keys()))
if fmt is None or fmt not in topic.resources.keys():
# Ensure that this topic is available for needed format
raise LeafException(
"You need to specify a format for topic '{topic}'".format(
topic=args.topic),
hints=[
"For example 'leaf help --format {fmt} {topic}'".
format(fmt=fmt, topic=args.topic)
for fmt in topic.resources.keys()
],
)
# Resolve resource path since it can contain @{} variables
resource = VariableResolver(topic.installed_package,
ipmap.values()).resolve(
topic.resources[fmt])
if fmt == "man":
# If format is 'man', use manpage reader
command = [
"man", "-P", "cat"
] if LeafSettings.NON_INTERACTIVE.as_boolean() else ["man"]
command.append(resource)
subprocess.check_call(command)
else:
# Use default resource handler
subprocess.check_call(
[LeafSettings.HELP_DEFAULT_OPEN.value, resource])
else:
# Print mode
scope = "installed packages"
if args.package is not None:
scope = args.package
rend = HelpTopicListRenderer(scope, filter_format=args.format)
rend.extend(searching_iplist)
wm.print_renderer(rend)
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 execute(self, args, uargs):
wm = self.get_workspacemanager(check_initialized=False)
ipmap = wm.list_installed_packages()
searching_iplist = None
env = None
if args.package is not None:
# User forces the package
env = Environment.build(wm.build_builtin_environment(),
wm.build_user_environment())
searching_iplist = DependencyUtils.installed([args.package],
ipmap,
env=env)
env.append(wm.build_packages_environment(searching_iplist))
elif wm.is_initialized:
# We are in a workspace, use the current profile
pfname = wm.current_profile_name
profile = wm.get_profile(pfname)
wm.is_profile_sync(profile, raise_if_not_sync=True)
searching_iplist = wm.get_profile_dependencies(profile)
env = wm.build_full_environment(profile)
else:
# Use installed packages
searching_iplist = sorted(ipmap.values(), key=IDENTIFIER_GETTER)
# Execute
if args.binary is None:
# Print mode
scope = "installed packages"
if args.package is not None:
scope = args.package
elif wm.is_initialized:
scope = "workspace"
rend = EntrypointListRenderer(scope)
rend.extend(searching_iplist)
wm.print_renderer(rend,
verbosity=Verbosity.QUIET
if args.oneline else Verbosity.DEFAULT)
elif args.oneline:
# User gave BIN and --oneline
raise LeafException(
"You must specify a binary or '--oneline', not both",
hints=[
"Run 'leaf run --oneline' to list all binaries",
"Run 'leaf run {bin} -- --oneline {uargs}' pass --oneline to the binary"
.format(bin=args.binary, uargs=" ".join(uargs)),
],
)
else:
# Search entry point
candidate_ip = None
for ip in searching_iplist:
if args.binary in ip.binaries:
if candidate_ip is None:
candidate_ip = ip
elif candidate_ip.name != ip.name:
raise LeafException(
"Binary {bin} is declared by multiple packages".
format(bin=args.binary))
elif ip.identifier > candidate_ip.identifier:
candidate_ip = ip
if candidate_ip is None:
raise LeafException(
"Cannot find binary {bin}".format(bin=args.binary))
if env is None:
env = Environment.build(wm.build_builtin_environment(),
wm.build_user_environment())
env.append(
wm.build_packages_environment(
DependencyUtils.installed([candidate_ip.identifier],
ipmap=ipmap,
env=env)))
ep = candidate_ip.binaries[args.binary]
vr = VariableResolver(candidate_ip, ipmap.values())
return execute_command(vr.resolve(ep.command),
*uargs,
print_stdout=True,
env=env)
def _getdeps(env, ipmap):
return DependencyUtils.install(PackageIdentifier.parse_list(
["condition_1.0"]),
APMAP,
ipmap,
env=env)
def install_packages(self,
items: list,
env: Environment = None,
keep_folder_on_error: bool = False):
"""
Compute dependency tree, check compatibility, download from remotes and extract needed packages
@return: InstalledPackage list
"""
with self.application_lock.acquire():
ipmap = self.list_installed_packages()
apmap = self.list_available_packages()
pilist = []
for item in items:
if isinstance(item, PackageIdentifier):
# Package identifier is given
pilist.append(item)
elif PackageIdentifier.is_valid_identifier(item):
# Package identifier string given
pilist.append(PackageIdentifier.parse(item))
else:
# If leaf artifacts are given, add/replace identifiers of available packages
la = LeafArtifact(Path(item))
pilist.append(la.identifier)
apmap[la.identifier] = la
out = []
# Build env to resolve dynamic dependencies
if env is None:
env = Environment.build(self.build_builtin_environment(),
self.build_user_environment())
ap_to_install = DependencyUtils.install(pilist,
apmap,
ipmap,
env=env)
# Check leaf min version
min_version = check_leaf_min_version(ap_to_install)
if min_version:
raise LeafOutOfDateException(
"You need to upgrade leaf to v{version} to install {text}".
format(version=min_version,
text=", ".join(
[str(ap.identifier) for ap in ap_to_install])))
# Check nothing to do
if len(ap_to_install) == 0:
self.logger.print_default("All packages are installed")
else:
# Check available size
download_totalsize = 0
download_count = 0
for ap in [
ap for ap in ap_to_install
if isinstance(ap, AvailablePackage)
]:
download_count += 1
if ap.size is not None:
download_totalsize += ap.size
fs_check_free_space(self.download_cache_folder,
download_totalsize)
# Confirm
text = ", ".join([str(ap.identifier) for ap in ap_to_install])
self.logger.print_quiet(
"Packages to install: {packages}".format(packages=text))
if download_totalsize > 0:
self.logger.print_default("Total size:",
sizeof_fmt(download_totalsize))
self.print_with_confirm(raise_on_decline=True)
# Install prereq
prereq_to_install = DependencyUtils.prereq(
[ap.identifier for ap in ap_to_install],
apmap,
ipmap,
env=env)
if len(prereq_to_install) > 0:
try:
self.__install_prereq(
prereq_to_install,
ipmap,
env=env,
keep_folder_on_error=keep_folder_on_error)
except BaseException as e:
raise PrereqException(e)
# Download ap list
self.logger.print_default(
"Downloading {size} package(s)".format(
size=download_count))
la_to_install = []
for mf in ap_to_install:
if isinstance(mf, AvailablePackage):
la_to_install.append(self.__download_ap(mf))
elif isinstance(mf, LeafArtifact):
la_to_install.append(mf)
# Check the extracted size
extracted_totalsize = 0
for la in la_to_install:
if la.final_size is not None:
extracted_totalsize += la.final_size
else:
extracted_totalsize += la.get_total_size()
fs_check_free_space(self.install_folder, extracted_totalsize)
# Extract la list
for la in la_to_install:
self.logger.print_default(
"[{current}/{total}] Installing {la.identifier}".
format(current=(len(out) + 1),
total=len(la_to_install),
la=la))
ip = self.__extract_artifact(
la,
env,
ipmap,
keep_folder_on_error=keep_folder_on_error)
out.append(ip)
return out
