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 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 _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 _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 _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 _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 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 _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