def _create_property_table(self, element):
labels = []
values = []
# Description
if element.description is not None:
labels.append("Description:")
values.append(element.description)
# Documentation
if element.documentation is not None:
labels.append("Documentation:")
values.append(element.documentation)
# Tags
tag_count = len(element.all_tags)
if tag_count > 0:
labels.append("Tag{s}:".format(s=("s" if tag_count > 1 else "")))
values.append(self._get_tags(element))
# Release date
if element.date is not None:
labels.append("Release date:")
values.append(element.date)
# Count included packages
dependency_count = len(element.depends_packages)
# For Availables Packages
if isinstance(element, AvailablePackage):
# Sources
remote_count = len(element.remotes)
if remote_count > 0:
labels.append(
"Source{s}:".format(s=("s" if remote_count > 1 else "")))
values.append(",".join(remote.alias
for remote in element.remotes))
if dependency_count == 0:
# Size
labels.append("Size:")
values.append(sizeof_fmt(element.size))
# For Installed Packages
elif isinstance(element, InstalledPackage):
# Folder
labels.append("Folder:")
values.append(element.folder)
# Included packages
if dependency_count > 0:
labels.append("Included Package{s}:".format(
s=("s" if dependency_count > 1 else "")))
values.append("\n".join(
self._get_cpis(cpis) for cpis in element.depends_packages))
return map(self.tm.LABEL, labels), values
def __check_cache_folder_size(self):
# Check if it has been checked recently
if self.is_file_outdated(self.download_cache_folder):
# Compute the folder total size
totalsize = fs_compute_total_size(self.download_cache_folder)
if totalsize > LeafConstants.CACHE_SIZE_MAX:
# Display a message
self.logger.print_error(
"You can save {size} by cleaning the leaf cache folder".
format(size=sizeof_fmt(totalsize)))
self.print_hints(
"to clean the cache, you can run: 'rm -r {folder}'".format(
folder=self.download_cache_folder))
# Update the mtime
self.download_cache_folder.touch()
def __check_cache_folder_size(self):
# Check if it has been checked recently
if self.is_file_outdated(self.download_cache_folder):
# Compute the folder total size
totalsize = fs_compute_total_size(self.download_cache_folder)
if totalsize > LeafConstants.CACHE_SIZE_MAX:
# Display a message
self.logger.print_error(
"You can save {size} by cleaning the leaf cache folder".
format(size=sizeof_fmt(totalsize)))
self.print_hints(
"to clean the cache, you can run: 'rm -r {folder}'".format(
folder=self.download_cache_folder))
# Clean the cache
if not LeafSettings.NON_INTERACTIVE.as_boolean(
) and LeafSettings.CACHE_AUTOCLEAN.as_boolean():
if self.print_with_confirm(
question="Do you want to clean the cache?"):
shutil.rmtree(str(self.download_cache_folder))
# Update the mtime
self.download_cache_folder.touch()
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 __init__(self, folder: Path, freespace: int, neededspace: int):
LeafException.__init__(
self, "Not enough space in folder {folder}, missing {size}".format(
folder=folder, size=sizeof_fmt(neededspace - freespace)))
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
def testsizeof_fmt(self):
self.assertEqual(sizeof_fmt(0), "0 bytes")
self.assertEqual(sizeof_fmt(1), "1 byte")
self.assertEqual(sizeof_fmt(123789), "121 kB")
self.assertEqual(sizeof_fmt(456123789), "435.0 MB")