def _files(self, entropy_server):
"""
Actual Eit files code.
"""
exit_st = 0
for package in self._packages:
pkg_id, pkg_repo = entropy_server.atom_match(package)
if pkg_id == -1:
exit_st = 1
if not self._quiet:
entropy_server.output(
"%s: %s" % (purple(_("Not matched")), teal(package)),
level="warning",
importance=1)
continue
entropy_repository = entropy_server.open_repository(pkg_repo)
files = entropy_repository.retrieveContent(pkg_id, order_by="file")
atom = entropy_repository.retrieveAtom(pkg_id)
if self._quiet:
for path in files:
entropy_server.output(path, level="generic")
else:
for path in files:
entropy_server.output(path)
entropy_server.output(
"[%s] %s: %s %s" %
(purple(pkg_repo), darkgreen(atom), bold(str(
len(files))), teal(_("files found"))))
return exit_st
def _show_did_you_mean(self, entropy_client, package, from_installed):
"""
Show "Did you mean?" results for the given package name.
"""
items = entropy_client.get_meant_packages(
package, from_installed=from_installed)
if not items:
return
mytxt = "%s %s %s %s %s" % (
bold(const_convert_to_unicode(" ?")),
teal(_("When you wrote")),
bold(const_convert_to_unicode(package)),
darkgreen(_("You Meant(tm)")),
teal(_("one of these below?")),
)
entropy_client.output(mytxt)
_cache = set()
for pkg_id, repo_id in items:
if from_installed:
repo = entropy_client.installed_repository()
else:
repo = entropy_client.open_repository(repo_id)
key_slot = repo.retrieveKeySlotAggregated(pkg_id)
if key_slot not in _cache:
entropy_client.output(
enlightenatom(key_slot),
header=brown(" # "))
_cache.add(key_slot)
def _files(self, entropy_server):
"""
Actual Eit files code.
"""
exit_st = 0
for package in self._packages:
pkg_id, pkg_repo = entropy_server.atom_match(package)
if pkg_id == -1:
exit_st = 1
if not self._quiet:
entropy_server.output(
"%s: %s" % (
purple(_("Not matched")), teal(package)),
level="warning", importance=1)
continue
entropy_repository = entropy_server.open_repository(pkg_repo)
files = entropy_repository.retrieveContent(
pkg_id, order_by="file")
atom = entropy_repository.retrieveAtom(pkg_id)
if self._quiet:
for path in files:
entropy_server.output(path, level="generic")
else:
for path in files:
entropy_server.output(path)
entropy_server.output(
"[%s] %s: %s %s" % (
purple(pkg_repo),
darkgreen(atom),
bold(str(len(files))),
teal(_("files found"))))
return exit_st
def _show_did_you_mean(self, entropy_client, package, from_installed):
"""
Show "Did you mean?" results for the given package name.
"""
items = entropy_client.get_meant_packages(
package, from_installed=from_installed)
if not items:
return
mytxt = "%s %s %s %s %s" % (
bold(const_convert_to_unicode(" ?")),
teal(_("When you wrote")),
bold(const_convert_to_unicode(package)),
darkgreen(_("You Meant(tm)")),
teal(_("one of these below?")),
)
entropy_client.output(mytxt)
_cache = set()
for pkg_id, repo_id in items:
if from_installed:
repo = entropy_client.installed_repository()
else:
repo = entropy_client.open_repository(repo_id)
key_slot = repo.retrieveKeySlotAggregated(pkg_id)
if key_slot not in _cache:
entropy_client.output(enlightenatom(key_slot),
header=brown(" # "))
_cache.add(key_slot)
def _add(self, entropy_server):
"""
Eit Repo Add command.
"""
current_repos = entropy_server.repositories()
repository_id = self._nsargs.id
desc = self._nsargs.desc
repos = self._nsargs.repo
pkg_only = self._nsargs.pkg_only
repo_only = self._nsargs.repo_only
base = self._nsargs.base
if repository_id in current_repos:
entropy_server.output("[%s] %s" % (
purple(repository_id),
blue(_("repository already configured")),
),
level="error",
importance=1)
return 1
toc = []
toc.append((purple(_("Repository id:")), teal(repository_id)))
toc.append((darkgreen(_("Description:")), teal(desc)))
base_str = _("Yes")
if base is None:
base_str = _("Unset")
elif not base:
base_str = _("No")
toc.append((darkgreen(_("Base repository:")), teal(base_str)))
for uri in repos:
toc.append((purple(_("Packages + Database URI:")), uri))
for uri in repo_only:
toc.append((purple(_("Database only URI:")), uri))
for uri in pkg_only:
toc.append((purple(_("Packages only URI:")), uri))
toc.append(" ")
print_table(entropy_server, toc)
parser = RepositoryConfigParser()
added = parser.add(repository_id, desc, repos, repo_only, pkg_only,
base)
if added:
entropy_server.output("[%s] %s" % (
purple(repository_id),
blue(_("repository added succesfully")),
))
else:
entropy_server.output("[%s] %s" % (
purple(repository_id),
blue(_("cannot add repository")),
),
level="warning",
importance=1)
return 0
def _inject(self, entropy_server):
"""
Actual Eit inject code.
"""
extensions = entropy_server.Spm_class().binary_packages_extensions()
etp_pkg_files = []
for pkg_path in self._packages:
pkg_path = os.path.realpath(pkg_path)
if not const_file_readable(pkg_path):
entropy_server.output(
"%s: %s" %
(purple(pkg_path), teal(_("no such file or directory"))),
importance=1,
level="error")
return 1
found = False
for ext in extensions:
if pkg_path.endswith("." + ext):
etp_pkg_files.append(pkg_path)
found = True
break
if not found:
entropy_server.output(
"%s: %s" %
(purple(pkg_path), teal(_("unsupported extension"))),
importance=1,
level="error")
return 1
if not etp_pkg_files:
entropy_server.output(teal(_("no valid package paths")),
importance=1,
level="error")
return 1
# in this case, no split package files are provided
repository_id = entropy_server.repository()
etp_pkg_files = [(
[x],
True,
) for x in etp_pkg_files]
package_ids = entropy_server.add_packages_to_repository(
repository_id,
etp_pkg_files,
ask=self._ask,
reset_revision=self._reset_revision)
if package_ids:
# checking dependencies and print issues
entropy_server.extended_dependencies_test([repository_id])
entropy_server.commit_repositories()
if package_ids:
return 0
return 1
def _add(self, entropy_client):
"""
Solo Repo Add command.
"""
settings = entropy_client.Settings()
current_branch = settings['repositories']['branch']
current_product = settings['repositories']['product']
available_repos = settings['repositories']['available']
repository_id = self._nsargs.id
repos = self._nsargs.repo
pkgs = self._nsargs.pkg
desc = self._nsargs.desc
cformat = self._nsargs.cformat
# show info
toc = []
toc.append((purple(_("Repository id:")), teal(repository_id)))
toc.append((darkgreen(_("Description:")), teal(desc)))
toc.append((purple(_("Repository format:")), darkgreen(cformat)))
for pkg_url in pkgs:
toc.append((purple(_("Packages URL:")), pkg_url))
for repo_url in repos:
toc.append((purple(_("Repository URL:")), repo_url))
toc.append(" ")
print_table(entropy_client, toc)
try:
repodata = settings._generate_repository_metadata(
repository_id, desc, pkgs, repos, current_product,
current_branch)
except AttributeError as err:
entropy_client.output("[%s] %s" % (
purple(repository_id),
err,
),
level="error",
importance=1)
return 1
added = entropy_client.add_repository(repodata)
if added:
entropy_client.output("[%s] %s" % (
purple(repository_id),
blue(_("repository added succesfully")),
))
else:
entropy_client.output("[%s] %s" % (
purple(repository_id),
blue(_("cannot add repository")),
),
level="warning",
importance=1)
return 0
def _move_copy(self, entropy_server):
"""
Execute package move or copy (depending on self._copy) from
source repository and destination repository. If deps is true,
also dependencies are pulled in.
"""
package_ids = []
if self._source == self._dest:
entropy_server.output(
"%s: %s" % (purple(_("source equals destination")),
teal(self._dest)),
importance=1,
level="error")
return 1
if self._dest not in entropy_server.repositories():
# destination repository not available
entropy_server.output(
"%s: %s" % (purple(_("repository not available")),
teal(self._dest)),
importance=1,
level="error")
return 1
# match
for package in self._packages:
p_matches, p_rc = entropy_server.atom_match(package,
match_repo = [self._source], multi_match = True)
if not p_matches:
entropy_server.output(
"%s: %s" % (
purple(_("Not matched")), teal(package)),
level="warning", importance=1)
else:
package_ids += [pkg_id for pkg_id, r_id in p_matches if \
(pkg_id not in package_ids)]
if (not self._packages) and (not package_ids):
entropy_server.output(
purple(_("Considering all the packages")),
importance=1, level="warning")
repo = entropy_server.open_repository(self._source)
package_ids = repo.listAllPackageIds()
if not package_ids:
return 1
rc = False
if self._copy:
rc = entropy_server.copy_packages(package_ids, self._source,
self._dest, pull_dependencies = self._deps)
else:
rc = entropy_server.move_packages(package_ids, self._source,
self._dest, pull_dependencies = self._deps)
if rc:
return 0
return 1
def _quickpkg(self, entropy_client, inst_repo):
"""
Solo Pkg Quickpkg command.
"""
packages = self._nsargs.packages
savedir = self._nsargs.savedir
if not os.path.isdir(savedir) and not os.path.exists(savedir):
# this is validated by the parser
# but not in case of no --savedir provided
const_setup_directory(savedir)
if not os.path.exists(savedir):
entropy_client.output(
"%s: %s" % (
brown(_("broken directory path")),
savedir,), level="error", importance=1)
return 1
package_ids = self._scan_packages(entropy_client, inst_repo, packages)
if not package_ids:
return 1
for package_id in package_ids:
atom = inst_repo.retrieveAtom(package_id)
entropy_client.output(
"%s: %s" % (
teal(_("generating package")),
purple(atom),),
header=brown(" @@ "), back=True)
pkg_data = inst_repo.getPackageData(package_id)
file_path = entropy_client.generate_package(
pkg_data, save_directory=savedir)
if file_path is None:
entropy_client.output(
"%s: %s" % (
darkred(_("package file creation error")),
blue(atom),),
level="error", importance=1)
return 3
entropy_client.output(
"[%s] %s: %s" % (
darkgreen(atom),
teal(_("package generated")),
purple(file_path),),
header=brown(" ## "))
return 0
def _inject(self, entropy_server):
"""
Actual Eit inject code.
"""
extensions = entropy_server.Spm_class(
).binary_packages_extensions()
etp_pkg_files = []
for pkg_path in self._packages:
pkg_path = os.path.realpath(pkg_path)
if not const_file_readable(pkg_path):
entropy_server.output(
"%s: %s" % (purple(pkg_path),
teal(_("no such file or directory"))),
importance=1, level="error")
return 1
found = False
for ext in extensions:
if pkg_path.endswith("."+ext):
etp_pkg_files.append(pkg_path)
found = True
break
if not found:
entropy_server.output(
"%s: %s" % (purple(pkg_path),
teal(_("unsupported extension"))),
importance=1, level="error")
return 1
if not etp_pkg_files:
entropy_server.output(
teal(_("no valid package paths")),
importance=1, level="error")
return 1
# in this case, no split package files are provided
repository_id = entropy_server.repository()
etp_pkg_files = [([x], True,) for x in etp_pkg_files]
package_ids = entropy_server.add_packages_to_repository(
repository_id, etp_pkg_files, ask=self._ask,
reset_revision=self._reset_revision)
if package_ids:
# checking dependencies and print issues
entropy_server.extended_dependencies_test([repository_id])
entropy_server.commit_repositories()
if package_ids:
return 0
return 1
def _quickpkg(self, entropy_client, inst_repo):
"""
Solo Pkg Quickpkg command.
"""
packages = self._nsargs.packages
savedir = self._nsargs.savedir
if not os.path.isdir(savedir) and not os.path.exists(savedir):
# this is validated by the parser
# but not in case of no --savedir provided
const_setup_directory(savedir)
if not os.path.exists(savedir):
entropy_client.output(
"%s: %s" % (
brown(_("broken directory path")),
savedir,), level="error", importance=1)
return 1
package_ids = self._scan_packages(entropy_client, inst_repo, packages)
if not package_ids:
return 1
for package_id in package_ids:
atom = inst_repo.retrieveAtom(package_id)
entropy_client.output(
"%s: %s" % (
teal(_("generating package")),
purple(atom),),
header=brown(" @@ "), back=True)
pkg_data = inst_repo.getPackageData(package_id)
file_path = entropy_client.generate_package(
pkg_data, save_directory=savedir)
if file_path is None:
entropy_client.output(
"%s: %s" % (
darkred(_("package file creation error")),
blue(atom),),
level="error", importance=1)
return 3
entropy_client.output(
"[%s] %s: %s" % (
darkgreen(atom),
teal(_("package generated")),
purple(file_path),),
header=brown(" ## "))
return 0
def enlightenatom(atom):
"""
Colorize package atoms with standard colors.
@param atom: atom string
@type atom: string
@return: colorized string
@rtype: string
"""
entropy_rev = entropy.dep.dep_get_entropy_revision(atom)
if entropy_rev is None:
entropy_rev = ''
else:
entropy_rev = '~%s' % (str(entropy_rev),)
entropy_tag = entropy.dep.dep_gettag(atom)
if entropy_tag is None:
entropy_tag = ''
else:
entropy_tag = '#%s' % (entropy_tag,)
slot = entropy.dep.dep_getslot(atom)
slot_pfx = ""
if slot is None:
slot = ""
else:
slot_pfx = etpConst['entropyslotprefix']
clean_atom = entropy.dep.remove_entropy_revision(atom)
clean_atom = entropy.dep.remove_tag(clean_atom)
clean_atom = entropy.dep.remove_slot(atom)
only_cpv = entropy.dep.dep_getcpv(clean_atom)
cpv_split = entropy.dep.catpkgsplit(only_cpv)
if cpv_split is None:
cat, name = only_cpv.split("/", 1)
pv = ""
rev = "r0"
operator = ""
else:
operator = clean_atom[:len(clean_atom)-len(only_cpv)]
cat, name, pv, rev = cpv_split
pv = "-" + pv
if rev == "r0":
rev = ''
else:
rev = '-%s' % (rev,)
return "%s%s%s%s%s%s%s%s%s" % (
purple(operator), teal(cat + "/"),
darkgreen(name), purple(pv), bold(slot_pfx),
darkred(slot), purple(rev), brown(entropy_tag),
teal(entropy_rev),)
def _discard(self, cmd, entropy_client, root,
paths_map, idx, scandata):
"""
Execute the config file discard action.
"""
try:
source = paths_map[idx]
except KeyError:
# idiot
return
data = scandata.get(source)
if data is None:
return
source_path = root + source
destination_path = root + data['destination']
entropy_client.output(
"%s: %s" % (
darkred(_("Source file")),
teal(source_path),)
)
entropy_client.output(
"%s: %s" % (
darkred(_("Destination file")),
purple(destination_path),)
)
if cmd == -7:
rc = entropy_client.ask_question(
_("Discard ?"))
if rc == _("No"):
return
entropy_client.output(
"%s: %s" % (
darkred(_("Discarding")),
teal(source_path),)
)
removed = scandata.remove(source)
del paths_map[idx]
if not removed:
entropy_client.output(
"%s: %s" % (
darkred(_("Cannot remove")),
brown(source_path),),
level="warning")
entropy_client.output("--")
def _sets(self, entropy_server):
"""
Eit query sets code.
"""
repository_ids = []
if self._repository_id is None:
repository_ids += entropy_server.repositories()
else:
repository_ids.append(self._repository_id)
repository_ids = tuple(repository_ids)
sets = entropy_server.Sets()
match_num = 0
if not self._nsargs.sets:
self._nsargs.sets.append("*")
for item in self._nsargs.sets:
results = sets.search(item, match_repo=repository_ids)
key_sorter = lambda x: x[1]
for repo, set_name, set_data in sorted(results,
key=key_sorter):
match_num += 1
found = True
if not self._quiet:
entropy_server.output(
"%s%s" % (brown(etpConst['packagesetprefix']),
darkgreen(set_name),))
if self._verbose:
elements = sorted(set_data)
for element in elements:
entropy_server.output(
teal(element),
header=" ")
else:
entropy_server.output(
"%s%s" % (etpConst['packagesetprefix'],
set_name,), level="generic")
if self._verbose:
for element in sorted(set_data):
entropy_server.output(
element, level="generic")
if not self._quiet:
entropy_server.output(
"[%s] %s %s" % (
darkgreen(item),
bold(str(match_num)),
teal(_("sets found"))))
return 0
def _mirrorsort(self, entropy_client):
"""
Solo Repo Mirrorsort command.
"""
exit_st = 0
settings = entropy_client.Settings()
excluded_repos = settings['repositories']['excluded']
available_repos = settings['repositories']['available']
simulate = self._nsargs.simulate
for repo in self._nsargs.repo:
try:
repo_data = entropy_client.reorder_mirrors(repo,
dry_run=simulate)
except KeyError:
entropy_client.output("[%s] %s" % (
purple(repo),
blue(_("repository not available")),
),
level="warning",
importance=1)
exit_st = 1
continue
# show new order, this doesn't take into account
# fallback mirrors which are put at the end of
# the list by SystemSettings logic.
mirrors = copy.copy(repo_data['plain_packages'])
if mirrors and not simulate:
mirrors.reverse()
entropy_client.output("[%s] %s" % (
teal(repo),
darkgreen(_("mirror order:")),
))
count = 0
for mirror in mirrors:
count += 1
entropy_client.output(" %d. %s" % (
count,
brown(mirror),
))
entropy_client.output("[%s] %s" % (
teal(repo),
blue(_("mirrors sorted successfully")),
))
return exit_st
def _sets(self, entropy_server):
"""
Eit query sets code.
"""
repository_ids = []
if self._repository_id is None:
repository_ids += entropy_server.repositories()
else:
repository_ids.append(self._repository_id)
repository_ids = tuple(repository_ids)
sets = entropy_server.Sets()
match_num = 0
if not self._nsargs.sets:
self._nsargs.sets.append("*")
for item in self._nsargs.sets:
results = sets.search(item, match_repo=repository_ids)
key_sorter = lambda x: x[1]
for repo, set_name, set_data in sorted(results,
key=key_sorter):
match_num += 1
found = True
if not self._quiet:
entropy_server.output(
"%s%s" % (brown(etpConst['packagesetprefix']),
darkgreen(set_name),))
if self._verbose:
elements = sorted(set_data)
for element in elements:
entropy_server.output(
teal(element),
header=" ")
else:
entropy_server.output(
"%s%s" % (etpConst['packagesetprefix'],
set_name,), level="generic")
if self._verbose:
for element in sorted(set_data):
entropy_server.output(
element, level="generic")
if not self._quiet:
entropy_server.output(
"[%s] %s %s" % (
darkgreen(item),
bold(str(match_num)),
teal(_("sets found"))))
return 0
def _show_dependencies_legend(self, entropy_server, indent = None):
"""
Print dependency types legend.
"""
if indent is None:
indent = ""
dep_types = etpConst['dependency_type_ids']
dep_descs = etpConst['dependency_type_ids_desc']
for dep_id, dep_val in sorted(dep_types.items(),
key = lambda x: x[0], reverse = True):
dep_desc = dep_descs.get(dep_id, _("N/A"))
txt = '%s%s%s%s %s' % (
indent, teal("{"), dep_val+1, teal("}"), dep_desc,)
entropy_server.output(txt)
def _print_graph_item_deps(entropy_client, item, out_data = None,
colorize = None):
if out_data is None:
out_data = {}
if "cache" not in out_data:
out_data['cache'] = set()
if "lvl" not in out_data:
out_data['lvl'] = 0
item_translation_callback = out_data.get('txc_cb')
show_already_pulled_in = out_data.get('show_already_pulled_in')
out_val = repr(item.item())
if item_translation_callback:
out_val = item_translation_callback(item.item())
endpoints = set()
for arch in item.arches():
if item.is_arch_outgoing(arch):
endpoints |= arch.endpoints()
valid_endpoints = [x for x in endpoints if x not in \
out_data['cache']]
cached_endpoints = [x for x in endpoints if x in \
out_data['cache']]
if colorize is None and not valid_endpoints:
colorize = darkgreen
elif colorize is None:
colorize = purple
ind_lvl = out_data['lvl']
indent_txt = '[%s]\t' % (teal(str(ind_lvl)),) + ' ' * ind_lvl
entropy_client.output(indent_txt + colorize(out_val), level="generic")
if cached_endpoints and show_already_pulled_in:
indent_txt = '[%s]\t' % (teal(str(ind_lvl)),) + ' ' * (ind_lvl + 1)
for endpoint in sorted(cached_endpoints, key = lambda x: x.item()):
endpoint_item = item_translation_callback(endpoint.item())
entropy_client.output(indent_txt + brown(endpoint_item),
level="generic")
if valid_endpoints:
out_data['lvl'] += 1
out_data['cache'].update(valid_endpoints)
for endpoint in sorted(valid_endpoints, key = lambda x: x.item()):
_print_graph_item_deps(entropy_client, endpoint, out_data)
out_data['lvl'] -= 1
def _extract(self, entropy_client):
"""
Solo Pkg Extract command.
"""
files = self._nsargs.files
savedir = self._nsargs.savedir
if not os.path.isdir(savedir) and not os.path.exists(savedir):
# this is validated by the parser
# but not in case of no --savedir provided
const_setup_directory(savedir)
if not os.path.exists(savedir):
entropy_client.output(
"%s: %s" % (
brown(_("broken directory path")),
savedir,), level="error", importance=1)
return 1
for _file in files:
entropy_client.output(
"%s: %s" % (
teal(_("working on package file")),
purple(_file)),
header=darkred(" @@ "),
back=True)
file_name = os.path.basename(_file)
package_path = os.path.join(
savedir, file_name + ".db")
ext_rc = entropy.tools.dump_entropy_metadata(
_file, package_path)
if not ext_rc:
entropy_client.output(
"%s: %s" % (
teal(_("error during metadata extraction")),
purple(_file)),
header=darkred(" @@ "),
level="error", importance=1)
return 1
entropy_client.output(
"%s: %s" % (
teal(_("metadata file generated")),
purple(package_path)),
header=darkred(" @@ "))
return 0
def _print_graph_item_deps(entropy_client, item, out_data = None,
colorize = None):
if out_data is None:
out_data = {}
if "cache" not in out_data:
out_data['cache'] = set()
if "lvl" not in out_data:
out_data['lvl'] = 0
item_translation_callback = out_data.get('txc_cb')
show_already_pulled_in = out_data.get('show_already_pulled_in')
out_val = repr(item.item())
if item_translation_callback:
out_val = item_translation_callback(item.item())
endpoints = set()
for arch in item.arches():
if item.is_arch_outgoing(arch):
endpoints |= arch.endpoints()
valid_endpoints = [x for x in endpoints if x not in \
out_data['cache']]
cached_endpoints = [x for x in endpoints if x in \
out_data['cache']]
if colorize is None and not valid_endpoints:
colorize = darkgreen
elif colorize is None:
colorize = purple
ind_lvl = out_data['lvl']
indent_txt = '[%s]\t' % (teal(str(ind_lvl)),) + ' ' * ind_lvl
entropy_client.output(indent_txt + colorize(out_val), level="generic")
if cached_endpoints and show_already_pulled_in:
indent_txt = '[%s]\t' % (teal(str(ind_lvl)),) + ' ' * (ind_lvl + 1)
for endpoint in sorted(cached_endpoints, key = lambda x: x.item()):
endpoint_item = item_translation_callback(endpoint.item())
entropy_client.output(indent_txt + brown(endpoint_item),
level="generic")
if valid_endpoints:
out_data['lvl'] += 1
out_data['cache'].update(valid_endpoints)
for endpoint in sorted(valid_endpoints, key = lambda x: x.item()):
_print_graph_item_deps(entropy_client, endpoint, out_data)
out_data['lvl'] -= 1
def _extract(self, entropy_client):
"""
Solo Pkg Extract command.
"""
files = self._nsargs.files
savedir = self._nsargs.savedir
if not os.path.isdir(savedir) and not os.path.exists(savedir):
# this is validated by the parser
# but not in case of no --savedir provided
const_setup_directory(savedir)
if not os.path.exists(savedir):
entropy_client.output(
"%s: %s" % (
brown(_("broken directory path")),
savedir,), level="error", importance=1)
return 1
for _file in files:
entropy_client.output(
"%s: %s" % (
teal(_("working on package file")),
purple(_file)),
header=darkred(" @@ "),
back=True)
file_name = os.path.basename(_file)
package_path = os.path.join(
savedir, file_name + ".db")
ext_rc = entropy.tools.dump_entropy_metadata(
_file, package_path)
if not ext_rc:
entropy_client.output(
"%s: %s" % (
teal(_("error during metadata extraction")),
purple(_file)),
header=darkred(" @@ "),
level="error", importance=1)
return 1
entropy_client.output(
"%s: %s" % (
teal(_("metadata file generated")),
purple(package_path)),
header=darkred(" @@ "))
return 0
def _show_help(self, *args):
# equo help <foo> <bar>
if len(self._args) > 1:
# syntax error
return -10
parser = argparse.ArgumentParser(
description=_("Entropy Command Line Client, Equo"),
epilog="http://www.sabayon.org",
formatter_class=ColorfulFormatter)
# filtered out in solo.main. Will never get here
parser.add_argument("--color",
action="store_true",
default=None,
help=_("force colored output"))
descriptors = SoloCommandDescriptor.obtain()
descriptors.sort(key=lambda x: x.get_name())
group = parser.add_argument_group("command", "available commands")
for descriptor in descriptors:
if descriptor.get_class().HIDDEN:
continue
aliases = descriptor.get_class().ALIASES
aliases_str = ", ".join([teal(x) for x in aliases])
if aliases_str:
aliases_str = " [%s]" % (aliases_str, )
name = "%s%s" % (purple(descriptor.get_name()), aliases_str)
desc = descriptor.get_description()
group.add_argument(name, help=darkgreen(desc), action="store_true")
parser.print_help()
if not self._args:
return 1
return 0
def _disable_repo(self, entropy_client, repo):
"""
Solo Repo Disable for given repository.
"""
disabled = False
try:
disabled = entropy_client.disable_repository(repo)
except ValueError:
entropy_client.output("[%s] %s" % (
purple(repo),
blue(_("cannot disable repository")),
),
level="warning",
importance=1)
return 1
if disabled:
entropy_client.output("[%s] %s" % (
teal(repo),
blue(_("repository disabled")),
))
return 0
entropy_client.output("[%s] %s" % (
purple(repo),
blue(_("cannot disable repository")),
),
level="warning",
importance=1)
return 1
def _scan_packages(self, entropy_client, packages, installed=False):
"""
Scan the list of package names filtering out unmatched
entries.
"""
found_pkgs = []
for package in packages:
if installed:
repo = entropy_client.installed_repository()
repo_id = repo.repository_id()
package_id, _pkg_rc = repo.atomMatch(package)
else:
package_id, repo_id = entropy_client.atom_match(package)
if package_id == -1:
mytxt = "!!! %s: %s %s." % (
purple(_("Warning")),
teal(const_convert_to_unicode(package)),
purple(_("is not available")),
)
entropy_client.output(
"!!!", level="warning", importance=1)
entropy_client.output(
mytxt, level="warning", importance=1)
entropy_client.output(
"!!!", level="warning", importance=1)
continue
found_pkgs.append((package_id, repo_id))
return found_pkgs
def _desc(self, entropy_server):
"""
Eit query desc code.
"""
repository_ids = []
if self._repository_id is None:
repository_ids += entropy_server.repositories()
else:
repository_ids.append(self._repository_id)
for repository_id in repository_ids:
repo = entropy_server.open_repository(repository_id)
key_sorter = lambda x: repo.retrieveAtom(x)
for desc in self._nsargs.descriptions:
pkg_ids = repo.searchDescription(desc, just_id = True)
for pkg_id in sorted(pkg_ids, key = key_sorter):
if self._quiet:
entropy_server.output(
repo.retrieveAtom(pkg_id), level="generic")
else:
print_package_info(pkg_id, entropy_server, repo,
extended = self._verbose,
strict_output = False,
quiet = False)
if not self._quiet:
entropy_server.output(
"[%s] %s %s" % (
darkgreen(desc),
bold(str(len(pkg_ids))),
teal(_("packages found"))))
return 0
def _desc(self, entropy_server):
"""
Eit query desc code.
"""
repository_ids = []
if self._repository_id is None:
repository_ids += entropy_server.repositories()
else:
repository_ids.append(self._repository_id)
for repository_id in repository_ids:
repo = entropy_server.open_repository(repository_id)
key_sorter = lambda x: repo.retrieveAtom(x)
for desc in self._nsargs.descriptions:
pkg_ids = repo.searchDescription(desc, just_id = True)
for pkg_id in sorted(pkg_ids, key = key_sorter):
if self._quiet:
entropy_server.output(
repo.retrieveAtom(pkg_id), level="generic")
else:
print_package_info(pkg_id, entropy_server, repo,
extended = self._verbose,
strict_output = False,
quiet = False)
if not self._quiet:
entropy_server.output(
"[%s] %s %s" % (
darkgreen(desc),
bold(str(len(pkg_ids))),
teal(_("packages found"))))
return 0
def _updates(self, entropy_client):
"""
Solo Query Updates command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
if not quiet:
entropy_client.output(brown(_("Available Updates")), header=darkred(" @@ "))
outcome = entropy_client.calculate_updates(quiet=True)
update, remove = outcome["update"], outcome["remove"]
fine, critical_f = outcome["fine"], outcome["critical_found"]
if quiet:
entropy_client.output("%d" % (len(update),), level="generic")
return 0
toc = []
toc.append((darkgreen(_("Packages to update:")), bold(const_convert_to_unicode(len(update)))))
toc.append((darkred(_("Packages to remove:")), bold(const_convert_to_unicode(len(remove)))))
if verbose:
toc.append((blue(_("Packages already up-to-date:")), bold(const_convert_to_unicode(len(fine)))))
toc.append((purple(_("Critical updates found:")), teal(const_convert_to_unicode(str(critical_f)))))
print_table(entropy_client, toc)
return 0
def _list_available(self, entropy_client):
"""
Solo Query List Available command.
"""
repositories = self._nsargs.repos
quiet = self._nsargs.quiet
entropy_repositories = entropy_client.repositories()
exit_st = 1
for repository_id in repositories:
if repository_id not in entropy_repositories:
if not quiet:
entropy_client.output(
"%s: %s" % (teal(_("Repository is not available")), repository_id),
header=purple(" !!! "),
level="warning",
importance=1,
)
exit_st = 1
break
repo = entropy_client.open_repository(repository_id)
exit_st = self._list_packages(entropy_client, repo, [])
if exit_st != 0:
break
return exit_st
def _disable_repo(self, entropy_client, repo):
"""
Solo Repo Disable for given repository.
"""
disabled = False
try:
disabled = entropy_client.disable_repository(repo)
except ValueError:
entropy_client.output(
"[%s] %s" % (
purple(repo),
blue(_("cannot disable repository")),),
level="warning", importance=1)
return 1
if disabled:
entropy_client.output(
"[%s] %s" % (
teal(repo),
blue(_("repository disabled")),))
return 0
entropy_client.output(
"[%s] %s" % (
purple(repo),
blue(_("cannot disable repository")),),
level="warning", importance=1)
return 1
def _scan_packages(self, entropy_client, inst_repo, packages):
"""
Scan the list of package names filtering out unmatched
entries.
"""
found_pkgs = []
for package in packages:
package_id, _pkg_rc = inst_repo.atomMatch(package)
if package_id == -1:
mytxt = "!!! %s: %s %s." % (
purple(_("Warning")),
teal(const_convert_to_unicode(package)),
purple(_("is not available")),
)
entropy_client.output(
"!!!", level="warning", importance=1)
entropy_client.output(
mytxt, level="warning", importance=1)
entropy_client.output(
"!!!", level="warning", importance=1)
continue
found_pkgs.append(package_id)
return found_pkgs
def _tags(self, entropy_server):
"""
Eit query tags code.
"""
repository_ids = []
if self._repository_id is None:
repository_ids += entropy_server.repositories()
else:
repository_ids.append(self._repository_id)
exit_st = 0
for repository_id in repository_ids:
repo = entropy_server.open_repository(repository_id)
key_sorter = lambda x: repo.retrieveAtom(x[1])
for tag in self._nsargs.tags:
tagged_pkgs = repo.searchTaggedPackages(tag, atoms=True)
results = sorted(tagged_pkgs, key=key_sorter)
for atom, pkg_id in results:
if self._quiet:
entropy_server.output(atom, level="generic")
else:
print_package_info(pkg_id, entropy_server, repo, quiet=False)
if (not results) and (not self._quiet):
entropy_server.output(
"%s: %s" % (purple(_("Nothing found for")), teal(tag)), importance=1, level="warning"
)
if not results:
exit_st = 1
return exit_st
def notify(self):
"""
Overridden from BaseAntiMatterResult
"""
for package in self._result:
if self._nsargs.extended:
cp = package.key()
slot = package.slot()
from_ver = "x"
inst = package.installed()
if inst is not None:
from_ver = inst.version
to_ver = "x"
avail = package.available()
if avail is not None:
to_ver = avail.version
name = "%s:%s [%s->%s]" % (
darkgreen(cp),
brown(slot),
teal(from_ver),
purple(to_ver))
elif self._nsargs.verbose:
name = package.target()
else:
name = package.keyslot()
if self._nsargs.quiet:
print_generic(name)
else:
print_info(name)
def _edit_file(self, idx, entropy_client, root, source, dest, paths_map,
scandata):
"""
Edit the given source file.
"""
source_path = root + source
dest_path = root + dest
entropy_client.output("%s: %s" % (
darkred(_("Editing file")),
darkgreen(source_path),
))
entropy_client.edit_file(source_path)
entropy_client.output(
"%s: %s, %s" % (darkred(_("Edited file")), darkgreen(source_path),
darkred(_("showing difference"))))
diff = self._showdiff(entropy_client, dest_path, source_path)
if not diff:
entropy_client.output("%s: %s" % (
darkred(_("Automerging")),
teal(source_path),
))
scandata.merge(source)
del paths_map[idx]
return True, False
return False, True
def _scan_installed_packages(self, entropy_client, inst_repo, packages):
"""
Scan the Installed Packages repository for matches and
return a list of matched package identifiers.
"""
package_ids = []
for package in packages:
package_id, _result = inst_repo.atomMatch(package)
if package_id != -1:
package_ids.append(package_id)
continue
# support file paths and convert them to package_ids
file_package_ids = inst_repo.isFileAvailable(package, get_id=True)
if file_package_ids:
package_ids.extend(file_package_ids)
continue
mytxt = "!!! %s: %s %s." % (
purple(_("Warning")),
teal(const_convert_to_unicode(package)),
purple(_("is not installed")),
)
entropy_client.output("!!!", level="warning")
entropy_client.output(mytxt, level="warning")
entropy_client.output("!!!", level="warning")
if len(package) > 3:
self._show_did_you_mean(entropy_client, package, True)
entropy_client.output("!!!", level="warning")
return package_ids
def _upgrade_respawn(self, entropy_client, inst_repo):
"""
Respawn the upgrade activity if required.
"""
# It might be an Entropy bug and Entropy was proritized in the
# install queue, ignoring the rest of available packages.
# So, respawning myself again using execvp() should be a much
# better idea.
with inst_repo.shared():
outcome = entropy_client.calculate_updates()
if outcome['update']:
entropy_client.output("%s." % (purple(
_("There are more updates to install, "
"reloading Entropy")), ),
header=teal(" @@ "))
# then spawn a new process
entropy_client.shutdown()
# hack to tell the resurrected equo to block on
# locking acquisition
os.environ['__EQUO_LOCKS_BLOCKING__'] = "1"
# we will acquire them again in blocking mode, cross
# fingers
lock = EntropyResourcesLock(output=entropy_client)
lock.release()
os.execvp("equo", sys.argv)
def _show_help(self, *args):
# equo help <foo> <bar>
if len(self._args) > 1:
# syntax error
return -10
parser = argparse.ArgumentParser(
description=_("Entropy Command Line Client, Equo"),
epilog="http://www.sabayon.org",
formatter_class=ColorfulFormatter)
# filtered out in solo.main. Will never get here
parser.add_argument(
"--color", action="store_true",
default=None, help=_("force colored output"))
descriptors = SoloCommandDescriptor.obtain()
descriptors.sort(key = lambda x: x.get_name())
group = parser.add_argument_group("command", "available commands")
for descriptor in descriptors:
if descriptor.get_class().HIDDEN:
continue
aliases = descriptor.get_class().ALIASES
aliases_str = ", ".join([teal(x) for x in aliases])
if aliases_str:
aliases_str = " [%s]" % (aliases_str,)
name = "%s%s" % (purple(descriptor.get_name()),
aliases_str)
desc = descriptor.get_description()
group.add_argument(name, help=darkgreen(desc), action="store_true")
parser.print_help()
if not self._args:
return 1
return 0
def warn_live_system():
print_warning("")
print_warning(purple(_("Entropy is running off a Live System")))
print_warning(
teal(_("Performance and stability could get"
" severely compromised")))
print_warning("")
def _show_preserved_libraries(self, entropy_client):
"""
Inform User about preserved libraries living on the filesystem.
This method is process and thread safe.
"""
inst_repo = entropy_client.installed_repository()
with inst_repo.shared():
preserved_mgr = PreservedLibraries(
inst_repo, None, frozenset(), root=etpConst['systemroot'])
preserved = preserved_mgr.list()
if preserved:
mytxt = ngettext(
"There is %s preserved library on the system",
"There are %s preserved libraries on the system",
len(preserved)) % (len(preserved),)
entropy_client.output(
darkgreen(mytxt),
level="warning")
for library, elfclass, path, atom in preserved:
entropy_client.output(
"%s [%s:%s -> %s]" % (
darkred(path),
purple(library),
teal(const_convert_to_unicode(elfclass)),
enlightenatom(atom),
))
def _show_preserved_libraries(self, entropy_client):
"""
Inform User about preserved libraries living on the filesystem.
This method is process and thread safe.
"""
inst_repo = entropy_client.installed_repository()
with inst_repo.shared():
preserved_mgr = PreservedLibraries(inst_repo,
None,
frozenset(),
root=etpConst['systemroot'])
preserved = preserved_mgr.list()
if preserved:
mytxt = ngettext("There is %s preserved library on the system",
"There are %s preserved libraries on the system",
len(preserved)) % (len(preserved), )
entropy_client.output(darkgreen(mytxt), level="warning")
for library, elfclass, path, atom in preserved:
entropy_client.output("%s [%s:%s -> %s]" % (
darkred(path),
purple(library),
teal(const_convert_to_unicode(elfclass)),
enlightenatom(atom),
))
def notify(self):
"""
Overridden from BaseAntiMatterResult
"""
for package in self._result:
if self._nsargs.extended:
cp = package.key()
slot = package.slot()
from_ver = "x"
inst = package.installed()
if inst is not None:
from_ver = inst.version
to_ver = "x"
avail = package.available()
if avail is not None:
to_ver = avail.version
name = "%s:%s [%s->%s]" % (darkgreen(cp), brown(slot),
teal(from_ver), purple(to_ver))
elif self._nsargs.verbose:
name = package.target()
else:
name = package.keyslot()
if self._nsargs.quiet:
print_generic(name)
else:
print_info(name)
def _scan_packages(self, entropy_client, inst_repo, packages):
"""
Scan the list of package names filtering out unmatched
entries.
"""
found_pkgs = []
for package in packages:
package_id, _pkg_rc = inst_repo.atomMatch(package)
if package_id == -1:
mytxt = "!!! %s: %s %s." % (
purple(_("Warning")),
teal(const_convert_to_unicode(package)),
purple(_("is not available")),
)
entropy_client.output(
"!!!", level="warning", importance=1)
entropy_client.output(
mytxt, level="warning", importance=1)
entropy_client.output(
"!!!", level="warning", importance=1)
continue
found_pkgs.append(package_id)
return found_pkgs
def _edit_file(self, idx, entropy_client, root, source, dest,
paths_map, scandata):
"""
Edit the given source file.
"""
source_path = root + source
dest_path = root + dest
entropy_client.output(
"%s: %s" % (
darkred(_("Editing file")),
darkgreen(source_path),))
entropy_client.edit_file(source_path)
entropy_client.output(
"%s: %s, %s" % (
darkred(_("Edited file")),
darkgreen(source_path),
darkred(_("showing difference")))
)
diff = self._showdiff(
entropy_client, dest_path, source_path)
if not diff:
entropy_client.output(
"%s: %s" % (
darkred(_("Automerging")),
teal(source_path),)
)
scandata.merge(source)
del paths_map[idx]
return True, False
return False, True
def _upgrade_respawn(self, entropy_client):
"""
Respawn the upgrade activity if required.
"""
# It might be an Entropy bug and Entropy was proritized in the
# install queue, ignoring the rest of available packages.
# So, respawning myself again using execvp() should be a much
# better idea.
outcome = entropy_client.calculate_updates()
if outcome['update']:
entropy_client.output(
"%s." % (
purple(_("There are more updates to install, "
"reloading Entropy")),),
header=teal(" @@ "))
# then spawn a new process
entropy_client.shutdown()
# hack to tell the resurrected equo to block on
# locking acquisition
os.environ['__EQUO_LOCKS_BLOCKING__'] = "1"
# we will acquire them again in blocking mode, cross
# fingers
entropy.tools.release_entropy_locks(entropy_client)
os.execvp("equo", sys.argv)
def _trigger_infofile_install(self):
info_exec = Trigger.INSTALL_INFO_EXEC
if not os.path.isfile(info_exec):
self._entropy.logger.log(
"[Trigger]",
etpConst['logging']['normal_loglevel_id'],
"[POST] %s is not available" % (info_exec,)
)
return 0
env = os.environ.copy()
for info_file in self._pkgdata['affected_infofiles']:
self._entropy.output(
"%s: %s" % (
teal(_("Installing info")),
info_file,),
importance = 0,
header = purple(" # ")
)
info_root = os.path.dirname(info_file)
args = (
info_exec,
"--dir-file=%s/dir" % (info_root,),
info_file)
proc = subprocess.Popen(
args, stdout = sys.stdout, stderr = sys.stderr,
env = env)
proc.wait() # ignore any error
return 0
def _parse_progress_line(self, line):
line_data = line.strip().split()
if len(line_data) < 5:
const_debug_write(__name__,
"_parse_progress_line: cannot parse: %s" % (line_data,))
# mmh... not possible to properly parse data
self.output(line.strip(), back = True)
return
const_debug_write(__name__,
"_parse_progress_line: parsing: %s" % (line_data,))
file_name = line_data[0]
percent = line_data[1]
tx_speed = line_data[3]
tx_size = line_data[2]
eta = line_data[4]
# create text
mytxt = _("Transfer status")
current_txt = "<-> (%s) %s: " % (teal(file_name), brown(mytxt),) + \
darkgreen(tx_size) + " " + \
brown("[") + str(percent) + brown("]") + \
" " + eta + " " + tx_speed
self.output(current_txt, back = True, header = " ")
def _garbage_collect_preserved_libs(self, preserved_mgr):
"""
Garbage collect (and remove) libraries preserved on the system
no longer available or no longer needed by any installed package.
"""
preserved_libs = preserved_mgr.collect()
inst_repo = preserved_mgr.installed_repository()
for library, elfclass, path in preserved_libs:
self._entropy.output(
"%s: %s [%s, %s]" % (
brown(_("Removing library")),
darkgreen(path),
purple(library),
teal(const_convert_to_unicode("%s" % (elfclass,))),
),
importance = 0,
level = "warning",
header = darkgreen(" :: ")
)
self._entropy.logger.log(
"[Package]",
etpConst['logging']['normal_loglevel_id'],
"%s %s [%s:%s]" % (
const_convert_to_unicode("Removing library"),
path, library, elfclass,)
)
# This will also check if path and it's destinations (in case of
# symlink) is owned by other packages.
# If this is the case, removal will fail for that specific path.
# This may be the case for packages like vmware-workstation,
# containing symlinks pointing to system libraries.
# See Sabayon bug #5182.
remove_failed = preserved_mgr.remove(path)
for failed_path, err in remove_failed:
self._entropy.output(
"%s: %s, %s" % (
purple(_("Failed to remove the library")),
darkred(failed_path),
err,
),
importance = 1,
level = "warning",
header = brown(" ## ")
)
self._entropy.logger.log(
"[Package]",
etpConst['logging']['normal_loglevel_id'],
"Error during %s removal: %s" % (failed_path, err)
)
preserved_mgr.unregister(library, elfclass, path)
# commit changes to repository if collected
if preserved_libs:
inst_repo.commit()
def _execute_package_phase(self, action_metadata, package_metadata,
action_name, phase_name):
"""
Wrapper against Source Package Manager's execute_package_phase.
This method handles both fatal and non-fatal exceptions.
"""
self._entropy.output(
"%s: %s" % (brown(_("Package phase")), teal(phase_name),),
importance = 0,
header = red(" ## "))
spm = self._spm
try:
spm.execute_package_phase(
action_metadata, package_metadata,
action_name, phase_name)
except spm.PhaseFailure as err:
txt = "%s: %s %s, %s. %s." % (
bold(_("QA")),
brown(_("Cannot run phase")),
bold(phase_name),
err.message,
brown(_("Please report it")),
)
self._entropy.output(
txt,
importance = 1,
header = red(" ## "),
level = "warning")
return 0 # non-fatal
except spm.OutdatedPhaseError as err:
err_msg = "%s: %s" % (
brown(_("Source Package Manager is too old, "
"please update it")),
err)
self._entropy.output(
err_msg,
importance = 1,
header = darkred(" ## "),
level = "error"
)
return 1
except spm.PhaseError as err:
err_msg = "%s: %s" % (
brown(_("Source Package Manager phase error")),
err)
self._entropy.output(
err_msg,
importance = 1,
header = darkred(" ## "),
level = "error"
)
return 1
return 0
def _garbage_collect_preserved_libs(self, preserved_mgr):
"""
Garbage collect (and remove) libraries preserved on the system
no longer available or no longer needed by any installed package.
"""
preserved_libs = preserved_mgr.collect()
inst_repo = preserved_mgr.installed_repository()
for library, elfclass, path in preserved_libs:
self._entropy.output(
"%s: %s [%s, %s]" % (
brown(_("Removing library")),
darkgreen(path),
purple(library),
teal(const_convert_to_unicode("%s" % (elfclass,))),
),
importance = 0,
level = "warning",
header = darkgreen(" :: ")
)
self._entropy.logger.log(
"[Package]",
etpConst['logging']['normal_loglevel_id'],
"%s %s [%s:%s]" % (
const_convert_to_unicode("Removing library"),
path, library, elfclass,)
)
# This will also check if path and it's destinations (in case of
# symlink) is owned by other packages.
# If this is the case, removal will fail for that specific path.
# This may be the case for packages like vmware-workstation,
# containing symlinks pointing to system libraries.
# See Sabayon bug #5182.
remove_failed = preserved_mgr.remove(path)
for failed_path, err in remove_failed:
self._entropy.output(
"%s: %s, %s" % (
purple(_("Failed to remove the library")),
darkred(failed_path),
err,
),
importance = 1,
level = "warning",
header = brown(" ## ")
)
self._entropy.logger.log(
"[Package]",
etpConst['logging']['normal_loglevel_id'],
"Error during %s removal: %s" % (failed_path, err)
)
preserved_mgr.unregister(library, elfclass, path)
# commit changes to repository if collected
if preserved_libs:
inst_repo.commit()
def warn_live_system():
print_warning("")
print_warning(
purple(_("Entropy is running off a Live System")))
print_warning(
teal(_("Performance and stability could get"
" severely compromised")))
print_warning("")
def show_dependencies_legend(entropy_client, indent = '',
get_data = False):
data = []
dep_type_ids = etpConst['dependency_type_ids']
for dep_id, dep_val in sorted(dep_type_ids.items(),
key = lambda x: x[0], reverse = True):
dep_desc = etpConst['dependency_type_ids_desc'].get(
dep_id, _("N/A"))
txt = '%s%s%s%s %s' % (
indent, teal("{"), dep_val, teal("}"), dep_desc,)
if get_data:
data.append(txt)
else:
entropy_client.output(txt)
if get_data:
return data
def _mirrorsort(self, entropy_client):
"""
Solo Repo Mirrorsort command.
"""
exit_st = 0
settings = entropy_client.Settings()
excluded_repos = settings['repositories']['excluded']
available_repos = settings['repositories']['available']
simulate = self._nsargs.simulate
for repo in self._nsargs.repo:
try:
repo_data = entropy_client.reorder_mirrors(
repo, dry_run = simulate)
except KeyError:
entropy_client.output(
"[%s] %s" % (
purple(repo),
blue(_("repository not available")),),
level="warning", importance=1)
exit_st = 1
continue
# show new order, this doesn't take into account
# fallback mirrors which are put at the end of
# the list by SystemSettings logic.
mirrors = copy.copy(repo_data['plain_packages'])
if mirrors and not simulate:
mirrors.reverse()
entropy_client.output(
"[%s] %s" % (
teal(repo),
darkgreen(_("mirror order:")),))
count = 0
for mirror in mirrors:
count += 1
entropy_client.output(
" %d. %s" % (count, brown(mirror),))
entropy_client.output(
"[%s] %s" % (
teal(repo),
blue(_("mirrors sorted successfully")),))
return exit_st
def _show_kernel_warnings(kernel_atom):
print_info("%s %s" % (purple(kernel_atom), teal(_("has been installed."))))
print_warning(
"%s: %s" %
(red(_("Attention")),
brown(
_("some external drivers cannot work across multiple kernels."))))
print_warning(darkgreen(_("Please reboot your computer now !")))
def show_dependencies_legend(entropy_client, indent = '',
get_data = False):
data = []
dep_type_ids = etpConst['dependency_type_ids']
for dep_id, dep_val in sorted(dep_type_ids.items(),
key = lambda x: x[0], reverse = True):
dep_desc = etpConst['dependency_type_ids_desc'].get(
dep_id, _("N/A"))
txt = '%s%s%s%s %s' % (
indent, teal("{"), dep_val, teal("}"), dep_desc,)
if get_data:
data.append(txt)
else:
entropy_client.output(txt)
if get_data:
return data
def _discard(self, cmd, entropy_client, root, paths_map, idx, scandata):
"""
Execute the config file discard action.
"""
try:
source = paths_map[idx]
except KeyError:
# idiot
return
data = scandata.get(source)
if data is None:
return
source_path = root + source
destination_path = root + data['destination']
entropy_client.output("%s: %s" % (
darkred(_("Source file")),
teal(source_path),
))
entropy_client.output("%s: %s" % (
darkred(_("Destination file")),
purple(destination_path),
))
if cmd == -7:
rc = entropy_client.ask_question(_("Discard ?"))
if rc == _("No"):
return
entropy_client.output("%s: %s" % (
darkred(_("Discarding")),
teal(source_path),
))
removed = scandata.remove(source)
del paths_map[idx]
if not removed:
entropy_client.output("%s: %s" % (
darkred(_("Cannot remove")),
brown(source_path),
),
level="warning")
entropy_client.output("--")
def _needed(self, entropy_server):
"""
Eit query needed code.
"""
repository_ids = []
if self._repository_id is None:
repository_ids += entropy_server.repositories()
else:
repository_ids.append(self._repository_id)
exit_st = 0
for package in self._nsargs.packages:
pkg_id, repo_id = entropy_server.atom_match(package)
if pkg_id == -1:
if not self._quiet:
entropy_server.output(
"%s: %s" % (
purple(_("Not matched")), teal(package)),
level="warning", importance=1)
exit_st = 1
continue
repo = entropy_server.open_repository(repo_id)
atom = repo.retrieveAtom(pkg_id)
neededs = repo.retrieveNeededLibraries(pkg_id)
for usr_path, usr_soname, soname, elfclass, rpath in neededs:
out_str = "%s:%s:%s:%s:%s" % (
usr_path, usr_soname, soname, elfclass, rpath)
if self._quiet:
entropy_server.output(out_str, level="generic")
else:
entropy_server.output(
darkred(const_convert_to_unicode(out_str)),
header=blue(" # "))
if not self._quiet:
entropy_server.output(
"[%s] %s: %s %s" % (
purple(repo_id),
darkgreen(atom),
bold(str(len(neededs))),
teal(_("libraries found"))))
return exit_st
def _status(self, entropy_server):
"""
Actual Eit key status code.
"""
repo_sec = self._get_gpg(entropy_server)
if repo_sec is None:
return 1
repo = entropy_server.repository()
try:
key_meta = repo_sec.get_key_metadata(repo)
except KeyError:
entropy_server.output("%s: %s" % (
darkgreen(_("Keys metadata not available for")),
bold(repo),
),
level="error")
return 1
entropy_server.output("%s: %s" % (
brown(_("GPG information for repository")),
bold(repo),
),
level="info")
def just_print(mystr):
return purple(mystr)
def print_list(myl):
return purple(' '.join(myl))
def print_date(mydate):
if not mydate:
return _("N/A")
try:
return convert_unix_time_to_human_time(int(mydate))
except (
ValueError,
TypeError,
):
return _("N/A")
out_data = [
('uids', _("Description"), print_list),
('keyid', _("Public key identifier"), just_print),
('fingerprint', _("Public key fingerprint"), just_print),
('length', _("Key size"), just_print),
('date', _("Creation date"), print_date),
('expires', _("Expires on"), print_date),
]
for key_id, key_desc, out_func in out_data:
entropy_server.output("%s: %s" % (
teal(key_desc),
out_func(key_meta[key_id]),
))
return 0
def _transfer_callback(transfered, total, download):
if download:
action = _("Downloading")
else:
action = _("Uploading")
percent = 100
if (total > 0) and (transfered <= total):
percent = int(round((float(transfered) / total) * 100, 1))
msg = "[%s%s] %s ..." % (purple(str(percent)), "%", teal(action))
entropy_client.output(msg, back=True)
def _init(self, entropy_server):
rc = entropy_server.initialize_repository(
entropy_server.repository(), ask=self._ask)
if rc == 0:
entropy_server.output(
teal(_("Entropy repository has been initialized")),
header=darkgreen(" * "),
importance=1)
return 0
return 1
