def _search_descriptions(self, descriptions, entropy_client, entropy_repository, quiet, verbose):
key_sorter = lambda x: entropy_repository.retrieveAtom(x)
found = 0
for desc in descriptions:
pkg_ids = entropy_repository.searchDescription(desc, just_id=True)
if not pkg_ids:
continue
found += len(pkg_ids)
for pkg_id in sorted(pkg_ids, key=key_sorter):
if quiet:
entropy_client.output(entropy_repository.retrieveAtom(pkg_id))
else:
print_package_info(
pkg_id, entropy_client, entropy_repository, extended=verbose, strict_output=False, quiet=False
)
if not quiet:
toc = []
toc.append(("%s:" % (blue(_("Keyword")),), purple(desc)))
toc.append(
(
"%s:" % (blue(_("Found")),),
"%s %s" % (len(pkg_ids), brown(ngettext("entry", "entries", len(pkg_ids)))),
)
)
print_table(entropy_client, toc)
return found
def match(self, entropy_client, inst_repo):
"""
Solo Match command.
"""
if not self._quiet:
entropy_client.output(
"%s..." % (darkgreen(_("Matching")),),
header=darkred(" @@ "))
matches_found = 0
for string in self._packages:
results = self._match(
entropy_client, inst_repo, string)
matches_found += len(results)
if not self._quiet:
toc = []
toc.append(("%s:" % (blue(_("Keywords")),),
purple(', '.join(self._packages))))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (
matches_found,
brown(ngettext("entry", "entries", matches_found)),)))
print_table(entropy_client, toc)
if not matches_found:
return 1
return 0
def match(self, entropy_client):
"""
Solo Match command.
"""
if not self._quiet:
entropy_client.output(
"%s..." % (darkgreen(_("Matching")),),
header=darkred(" @@ "))
matches_found = 0
for string in self._packages:
results = self._match(
entropy_client, string)
matches_found += len(results)
if not self._quiet:
toc = []
toc.append(("%s:" % (blue(_("Keywords")),),
purple(', '.join(self._packages))))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (
matches_found,
brown(ngettext("entry", "entries", matches_found)),)))
print_table(entropy_client, toc)
if not matches_found:
return 1
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 _needed(self, entropy_client, inst_repo):
"""
Solo Query Needed command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
packages = self._nsargs.packages
if not quiet:
entropy_client.output(darkgreen(_("Needed Libraries Search")), header=darkred(" @@ "))
for package in packages:
pkg_id, pkg_rc = inst_repo.atomMatch(package)
if pkg_id == -1:
continue
atom = inst_repo.retrieveAtom(pkg_id)
neededs = inst_repo.retrieveNeededLibraries(pkg_id)
for usr_path, usr_soname, soname, elfclass, rpath in neededs:
out_str = "%s:%s" % (soname, elfclass)
if verbose:
out_str = "%s:%s:%s:%s:%s" % (usr_path, usr_soname, soname, elfclass, rpath)
if quiet:
entropy_client.output(out_str, level="generic")
else:
entropy_client.output(darkred(const_convert_to_unicode(out_str)), header=blue(" # "))
if not quiet:
toc = []
toc.append(("%s:" % (blue(_("Package")),), purple(atom)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(neededs), brown(_("libraries")))))
print_table(entropy_client, toc)
return 0
def _required(self, entropy_client, inst_repo):
"""
Solo Query Required command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
libraries = self._nsargs.libraries
if not quiet:
entropy_client.output(darkgreen(_("Required Packages Search")), header=darkred(" @@ "))
key_sorter = lambda x: inst_repo.retrieveAtom(x)
for library in libraries:
results = inst_repo.searchNeeded(library, like=True)
for pkg_id in sorted(results, key=key_sorter):
print_package_info(
pkg_id,
entropy_client,
inst_repo,
installed_search=True,
strict_output=True,
extended=verbose,
quiet=quiet,
)
if not quiet:
toc = []
entity_str = ngettext("package", "packages", len(results))
toc.append(("%s:" % (blue(_("Library")),), purple(library)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(results), brown(entity_str))))
print_table(entropy_client, toc)
return 0
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 _search_mimetype(self, entropy_client, inst_repo, associate=False):
"""
Solo Query Mimetype command.
"""
installed = self._nsargs.installed
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
settings = entropy_client.Settings()
inst_repo_id = inst_repo.repository_id()
if associate:
mimetypes = self._nsargs.files
else:
mimetypes = self._nsargs.mimes
if not quiet:
entropy_client.output(darkgreen(_("Searching Mimetype")), header=darkred(" @@ "))
found = False
for mimetype in mimetypes:
if associate:
# consider mimetype a file path
mimetype = get_file_mime(mimetype)
if mimetype is None:
continue
if not quiet:
entropy_client.output(bold(mimetype), header=blue(" # "))
if installed:
matches = [(x, inst_repo_id) for x in entropy_client.search_installed_mimetype(mimetype)]
else:
matches = entropy_client.search_available_mimetype(mimetype)
if matches:
found = True
key_sorter = lambda x: entropy_client.open_repository(x[1]).retrieveAtom(x[0])
for pkg_id, pkg_repo in sorted(matches, key=key_sorter):
repo = entropy_client.open_repository(pkg_repo)
print_package_info(pkg_id, entropy_client, repo, extended=verbose, quiet=quiet)
if not quiet:
entry_str = ngettext("entry", "entries", len(matches))
toc = []
toc.append(("%s:" % (blue(_("Keyword")),), purple(mimetype)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(matches), brown(entry_str))))
print_table(entropy_client, toc)
if not quiet and not found:
entropy_client.output(darkgreen("%s." % (_("No matches"),)), header=darkred(" @@ "))
return 0
def _license(self, entropy_client):
"""
Solo Query License command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
licenses = self._nsargs.licenses
settings = entropy_client.Settings()
if not quiet:
entropy_client.output(darkgreen(_("License Search")), header=darkred(" @@ "))
found = False
repo_number = 0
for repo_id in entropy_client.repositories():
repo_number += 1
repo_data = settings["repositories"]["available"][repo_id]
if not quiet:
header = (
const_convert_to_unicode(" #")
+ const_convert_to_unicode(repo_number)
+ const_convert_to_unicode(" ")
)
entropy_client.output("%s" % (bold(repo_data["description"]),), header=blue(header))
repo = entropy_client.open_repository(repo_id)
key_sorter = lambda x: repo.retrieveAtom(x)
for mylicense in licenses:
results = repo.searchLicense(mylicense, just_id=True)
if not results:
continue
found = True
for pkg_id in sorted(results, key=key_sorter):
print_package_info(pkg_id, entropy_client, repo, extended=verbose, strict_output=quiet, quiet=quiet)
if not quiet:
res_txt = ngettext("entry", "entries", len(results))
toc = []
toc.append(("%s:" % (blue(_("Keyword")),), purple(mylicense)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(results), brown(res_txt))))
print_table(entropy_client, toc)
if not quiet and not found:
entropy_client.output(darkgreen("%s." % (_("No matches"),)), header=darkred(" @@ "))
return 0
def _tags(self, entropy_client):
"""
Solo Query Tags command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
tags = self._nsargs.tags
settings = entropy_client.Settings()
if not quiet:
entropy_client.output(darkgreen(_("Tag Search")), header=darkred(" @@ "))
found = False
# search inside each available database
repo_number = 0
for repo_id in entropy_client.repositories():
repo_number += 1
repo_data = settings["repositories"]["available"][repo_id]
if not quiet:
header = (
const_convert_to_unicode(" #")
+ const_convert_to_unicode(repo_number)
+ const_convert_to_unicode(" ")
)
entropy_client.output("%s" % (bold(repo_data["description"]),), header=blue(header))
repo = entropy_client.open_repository(repo_id)
for tag in tags:
results = repo.searchTaggedPackages(tag)
key_sorter = lambda x: repo.retrieveAtom(x)
for pkg_id in sorted(results, key=key_sorter):
found = True
print_package_info(pkg_id, entropy_client, repo, extended=verbose, strict_output=quiet, quiet=quiet)
if not quiet:
toc = []
entity_str = ngettext("entry", "entries", len(results))
toc.append(("%s:" % (blue(_("Keyword")),), purple(tag)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(results), brown(entity_str))))
print_table(entropy_client, toc)
if not quiet and not found:
entropy_client.output(darkgreen("%s." % (_("No matches"),)), header=darkred(" @@ "))
return 0
def _sets(self, entropy_client):
"""
Solo Query Sets command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
items = self._nsargs.sets
if not items:
items.append("*")
if not quiet:
entropy_client.output(darkgreen(_("Package Set Search")), header=darkred(" @@ "))
sets = entropy_client.Sets()
count = 0
found = False
for item in items:
results = sets.search(item)
key_sorter = lambda x: x[1]
for repo, set_name, set_data in sorted(results, key=key_sorter):
count += 1
found = True
if not quiet:
entropy_client.output(bold(set_name), header=blue(" #%d " % (count,)))
elements = sorted(set_data)
for element in elements:
entropy_client.output(brown(element), header=" ")
else:
for element in sorted(set_data):
entropy_client.output(element, level="generic")
if not quiet:
toc = []
entity_str = ngettext("entry", "entries", count)
toc.append(("%s:" % (blue(_("Keyword")),), purple(item)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (count, brown(entity_str))))
print_table(entropy_client, toc)
if not quiet and not found:
entropy_client.output(darkgreen("%s." % (_("No matches"),)), header=darkred(" @@ "))
return 0
def _revisions(self, entropy_client, inst_repo):
"""
Solo Query Revisions command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
revisions = self._nsargs.revisions
settings = entropy_client.Settings()
if not quiet:
entropy_client.output(darkgreen(_("Revision Search")), header=darkred(" @@ "))
found = False
key_sorter = lambda x: inst_repo.retrieveAtom(x)
for revision in revisions:
results = inst_repo.searchRevisionedPackages(revision)
found = True
for pkg_id in sorted(results, key=key_sorter):
print_package_info(
pkg_id,
entropy_client,
inst_repo,
extended=verbose,
strict_output=quiet,
installed_search=True,
quiet=quiet,
)
if not quiet:
toc = []
entity_str = ngettext("entry", "entries", len(results))
toc.append(("%s:" % (blue(_("Keyword")),), purple(revision)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(results), brown(entity_str))))
print_table(entropy_client, toc)
if not quiet and not found:
entropy_client.output(darkgreen("%s." % (_("No matches"),)), header=darkred(" @@ "))
return 0
def _files(self, entropy_client, inst_repo):
"""
Solo Query Files command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
packages = self._nsargs.packages
if not quiet:
entropy_client.output(darkgreen(_("Files Search")), header=darkred(" @@ "))
for package in packages:
pkg_id, pkg_rc = inst_repo.atomMatch(package)
if pkg_id == -1:
continue
atom = inst_repo.retrieveAtom(pkg_id)
files = inst_repo.retrieveContentIter(pkg_id, order_by="file")
files_len = 0
if quiet:
for xfile, ftype in files:
files_len += 1
entropy_client.output(xfile, level="generic")
else:
for xfile, ftype in files:
files_len += 1
entropy_client.output(brown(xfile), header=blue(" ### "))
if not quiet:
toc = []
toc.append(("%s:" % (blue(_("Package")),), purple(atom)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (files_len, brown(_("files")))))
print_table(entropy_client, toc)
return 0
def _print_advisory_information(self, entropy_client,
advisory_data, key):
"""
Print Security Advisory.
"""
toc = []
# print advisory code
toc.append(
blue(" @@ ") + \
red("%s " % (_("Advisory Identifier"),)) + bold(key) + \
red(" | ")+blue(advisory_data['url']))
# title
toc.append((darkgreen(" %s:" % (_("Title"),)),
darkred(advisory_data['title'])))
# description
description = advisory_data['description'].split("\n")
desc_text = darkgreen(" %s:" % (_("Description"),) )
for x in description:
toc.append((desc_text, x.strip()))
desc_text = " "
for item in advisory_data['description_items']:
desc_text = " %s " % (darkred("(*)"),)
count = 8
mystr = []
for word in item.split():
count -= 1
mystr.append(word)
if count < 1:
toc.append((" ", desc_text+' '.join(mystr)))
desc_text = " "
mystr = []
count = 8
if count < 8:
toc.append((" ", desc_text+' '.join(mystr)))
# background
if advisory_data['background']:
background = advisory_data['background'].split("\n")
bg_text = darkgreen(" %s:" % (_("Background"),))
for x in background:
toc.append((bg_text, purple(x.strip())))
bg_text = " "
# access
if advisory_data['access']:
toc.append((darkgreen(" %s:" % (_("Exploitable"),)),
bold(advisory_data['access'])))
# impact
if advisory_data['impact']:
impact = advisory_data['impact'].split("\n")
imp_text = darkgreen(" %s:" % (_("Impact"),))
for x in impact:
toc.append((imp_text, brown(x.strip())))
imp_text = " "
# impact type
if advisory_data['impacttype']:
toc.append((darkgreen(" %s:" % (_("Impact type"),)),
bold(advisory_data['impacttype'])))
# revised
if advisory_data['revised']:
toc.append((darkgreen(" %s:" % (_("Revised"),)),
brown(advisory_data['revised'])))
# announced
if advisory_data['announced']:
toc.append((darkgreen(" %s:" % (_("Announced"),)),
brown(advisory_data['announced'])))
# synopsis
synopsis = advisory_data['synopsis'].split("\n")
syn_text = darkgreen(" %s:" % (_("Synopsis"),))
for x in synopsis:
toc.append((syn_text, x.strip()))
syn_text = " "
# references
if advisory_data['references']:
toc.append(darkgreen(" %s:" % (_("References"),)))
for reference in advisory_data['references']:
toc.append((" ", darkblue(reference)))
# gentoo bugs
if advisory_data['bugs']:
toc.append(darkgreen(" %s:" % (_("Upstream bugs"),)))
for bug in advisory_data['bugs']:
toc.append((" ", darkblue(bug)))
# affected
if advisory_data['affected']:
toc.append(darkgreen(" %s:" % (_("Affected"),)))
for key in advisory_data['affected']:
toc.append((" ", darkred(key)))
affected_data = advisory_data['affected'][key][0]
vul_vers = affected_data['vul_vers']
unaff_vers = affected_data['unaff_vers']
if vul_vers:
toc.append((" ", brown("%s: " % (
_("vulnerable versions"),))+", ".join(vul_vers)))
if unaff_vers:
toc.append((" ", brown("%s: " % (
_("unaffected versions"),))+", ".join(unaff_vers)))
# workaround
workaround = advisory_data['workaround'].split("\n")
if advisory_data['workaround']:
work_text = darkgreen(" %s:" % (_("Workaround"),))
for x in workaround:
toc.append((work_text, darkred(x.strip())))
work_text = " "
# resolution
if advisory_data['resolution']:
res_text = darkgreen(" %s:" % (_("Resolution"),))
resolutions = advisory_data['resolution']
for resolution in resolutions:
for x in resolution.split("\n"):
toc.append((res_text, x.strip()))
res_text = " "
print_table(entropy_client, toc, cell_spacing=3)
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 _revdeps(self, entropy_client, inst_repo):
"""
Solo Query Revdeps command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
packages = self._nsargs.packages
settings = entropy_client.Settings()
if not quiet:
entropy_client.output(darkgreen(_("Reverse Dependencies Search")), header=darkred(" @@ "))
include_build_deps = False
excluded_dep_types = None
if include_build_deps:
excluded_dep_types.append(etpConst["dependency_type_ids"]["bdepend_id"])
for package in packages:
repository_id = inst_repo.repository_id()
package_id, _inst_rc = inst_repo.atomMatch(package)
match_in_repo = False
repo_masked = False
if package_id == -1:
match_in_repo = True
package_id, repository_id = entropy_client.atom_match(package)
if package_id == -1:
package_id, repository_id = entropy_client.atom_match(package, mask_filter=False)
if package_id != -1:
repo_masked = True
if package_id == -1:
continue
repo = inst_repo
if match_in_repo:
repo = entropy_client.open_repository(repository_id)
found_atom = repo.retrieveAtom(package_id)
if repo_masked:
package_id_masked, idmasking_reason = repo.maskFilter(package_id)
search_results = repo.retrieveReverseDependencies(package_id, exclude_deptypes=excluded_dep_types)
key_sorter = lambda x: repo.retrieveAtom(x)
for pkg_id in sorted(search_results, key=key_sorter):
print_package_info(
pkg_id,
entropy_client,
repo,
installed_search=True,
strict_output=quiet,
extended=verbose,
quiet=quiet,
)
if quiet:
continue
masking_reason = ""
if repo_masked:
masking_reason = ", %s" % (settings["pkg_masking_reasons"].get(idmasking_reason),)
repo_masked_str = const_convert_to_unicode(repo_masked)
mask_str = bold(repo_masked_str) + masking_reason
toc = []
toc.append(("%s:" % (blue(_("Keyword")),), purple(package)))
toc.append(("%s:" % (blue(_("Matched")),), teal(found_atom)))
toc.append(("%s:" % (blue(_("Masked")),), mask_str))
if match_in_repo:
where = "%s %s" % (_("from repository"), repository_id)
else:
where = _("from the installed packages repository")
entry_str = ngettext("entry", "entries", len(search_results))
toc.append(("%s:" % (blue(_("Found")),), "%s %s %s" % (len(search_results), brown(entry_str), where)))
print_table(entropy_client, toc)
return 0
def _belongs(self, entropy_client, inst_repo):
"""
Solo Query Belongs command.
"""
quiet = self._nsargs.quiet
verbose = self._nsargs.verbose
files = self._nsargs.files
if not quiet:
entropy_client.output(darkgreen(_("Belong Search")), header=darkred(" @@ "))
results = {}
reverse_symlink_map = entropy_client.Settings()["system_rev_symlinks"]
for xfile in files:
outcome = results.setdefault(xfile, set())
pkg_ids = inst_repo.searchBelongs(xfile)
if not pkg_ids:
# try real path if possible
pkg_ids = inst_repo.searchBelongs(os.path.realpath(xfile))
if not pkg_ids:
# try using reverse symlink mapping
for sym_dir in reverse_symlink_map:
if not xfile.startswith(sym_dir):
continue
for sym_child in reverse_symlink_map[sym_dir]:
my_file = sym_child + xfile[len(sym_dir) :]
pkg_ids = inst_repo.searchBelongs(my_file)
if pkg_ids:
break
outcome.update(pkg_ids)
key_sorter = lambda x: inst_repo.retrieveAtom(x)
matches_found = 0
for xfile, pkg_ids in results.items():
matches_found += len(pkg_ids) # can be incorrect
for pkg_id in sorted(pkg_ids, key=key_sorter):
if quiet:
atom = inst_repo.retrieveAtom(pkg_id)
if atom is not None:
entropy_client.output(atom, level="generic")
else:
print_package_info(
pkg_id, entropy_client, inst_repo, installed_search=True, extended=verbose, quiet=quiet
)
if not quiet:
entries_txt = ngettext("entry", "entries", len(pkg_ids))
toc = []
toc.append(("%s:" % (blue(_("Keyword")),), purple(xfile)))
toc.append(("%s:" % (blue(_("Found")),), "%s %s" % (len(pkg_ids), brown(entries_txt))))
print_table(entropy_client, toc)
return 0
