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 bashcomp(self, last_arg):
"""
Overridden from SoloCommand
"""
import sys
descriptors = SoloCommandDescriptor.obtain()
descriptors.sort(key = lambda x: x.get_name())
outcome = []
for descriptor in descriptors:
name = descriptor.get_name()
if name == SoloHelp.NAME:
# do not add self
continue
outcome.append(name)
aliases = descriptor.get_class().ALIASES
outcome.extend(aliases)
def _startswith(string):
if last_arg is not None:
return string.startswith(last_arg)
return True
outcome = sorted(filter(_startswith, outcome))
sys.stdout.write(" ".join(outcome) + "\n")
sys.stdout.flush()
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloCache.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloCache.NAME))
subparsers = parser.add_subparsers(
title="action", description=_("manage cache"),
help=_("available commands"))
clean_parser = subparsers.add_parser(
"clean", help=_("clean Entropy Library Cache"))
clean_parser.add_argument(
"--verbose", "-v", action="store_true", default=False,
help=_("show more details"))
clean_parser.add_argument(
"--quiet", "-q", action="store_true", default=False,
help=_("print results in a scriptable way"))
clean_parser.set_defaults(func=self._clean)
_commands.append("clean")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(self.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], self.NAME))
parser.add_argument("packages",
nargs='+',
metavar="<package>",
help=_("package name"))
group = parser.add_mutually_exclusive_group()
group.add_argument("--ask",
"-a",
action="store_true",
default=self._ask,
help=_('ask before making any changes'))
group.add_argument("--pretend",
"-p",
action="store_true",
default=self._pretend,
help=_('only show what would be done'))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloConf.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloConf.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("manage configuration file updates"),
help=_("available commands"))
update_parser = subparsers.add_parser(
"update", help=_("update configuration files"))
update_parser.set_defaults(func=self._update)
_commands.append("update")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloPreservedLibs.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloPreservedLibs.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("manage preserved libraries"),
help=_("available commands"))
list_parser = subparsers.add_parser(
"list", help=_("list the currently preserved libraries"))
list_parser.set_defaults(func=self._list)
self._setup_verbose_quiet_parser(list_parser)
_commands["list"] = {}
gc_parser = subparsers.add_parser(
"gc", help=_("show libraries that could be garbage collected"))
gc_parser.set_defaults(func=self._gc)
_commands["gc"] = {}
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloUnused.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloUnused.NAME))
parser.add_argument("--quiet", "-q", action="store_true",
default=self._quiet,
help=_("show less details (useful for scripting)"))
_commands.append("--quiet")
_commands.append("-q")
parser.add_argument("--sortbysize", action="store_true",
default=self._sortbysize,
help=_("sort packages by size"))
_commands.append("--sortbysize")
parser.add_argument("--by-user", action="store_true",
default=self._byuser,
help=_("include packages installed by user"))
_commands.append("--by-user")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloPreservedLibs.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloPreservedLibs.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("manage preserved libraries"),
help=_("available commands"))
list_parser = subparsers.add_parser(
"list", help=_("list the currently preserved libraries"))
list_parser.set_defaults(func=self._list)
self._setup_verbose_quiet_parser(list_parser)
_commands["list"] = {}
gc_parser = subparsers.add_parser(
"gc", help=_("show libraries that could be garbage collected"))
gc_parser.set_defaults(func=self._gc)
_commands["gc"] = {}
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloUnused.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloUnused.NAME))
parser.add_argument("--quiet",
"-q",
action="store_true",
default=self._quiet,
help=_("show less details (useful for scripting)"))
_commands.append("--quiet")
_commands.append("-q")
parser.add_argument("--sortbysize",
action="store_true",
default=self._sortbysize,
help=_("sort packages by size"))
_commands.append("--sortbysize")
parser.add_argument("--spm-wanted", action="store_true",
default=self._spm_wanted,
help=_("consider packages installed with" \
" a Source Package Manager to be wanted"))
_commands.append("--spm-wanted")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloSearch.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloSearch.NAME))
parser.add_argument("string", nargs='+',
metavar="<string>", help=_("search keyword"))
parser.add_argument("--quiet", "-q", action="store_true",
default=self._quiet,
help=_('quiet output, for scripting purposes'))
parser.add_argument("--verbose", "-v", action="store_true",
default=self._verbose,
help=_('verbose output'))
group = parser.add_mutually_exclusive_group()
group.add_argument("--installed", action="store_true",
default=self._installed,
help=_('search among installed packages only'))
group.add_argument("--available", action="store_true",
default=self._available,
help=_('search among available packages only'))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloCache.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloCache.NAME))
subparsers = parser.add_subparsers(title="action",
description=_("manage cache"),
help=_("available commands"))
clean_parser = subparsers.add_parser(
"clean", help=_("clean Entropy Library Cache"))
clean_parser.add_argument("--verbose",
"-v",
action="store_true",
default=False,
help=_("show more details"))
clean_parser.add_argument("--quiet",
"-q",
action="store_true",
default=False,
help=_("print results in a scriptable way"))
clean_parser.set_defaults(func=self._clean)
_commands.append("clean")
self._commands = _commands
return parser
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.argentlinux.io",
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 bashcomp(self, last_arg):
"""
Overridden from SoloCommand
"""
import sys
descriptors = SoloCommandDescriptor.obtain()
descriptors.sort(key = lambda x: x.get_name())
outcome = []
for descriptor in descriptors:
name = descriptor.get_name()
if name == SoloHelp.NAME:
# do not add self
continue
outcome.append(name)
aliases = descriptor.get_class().ALIASES
outcome.extend(aliases)
def _startswith(string):
if last_arg is not None:
return string.startswith(last_arg)
return True
outcome = sorted(filter(_startswith, outcome))
sys.stdout.write(" ".join(outcome) + "\n")
sys.stdout.flush()
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloDeptest.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloDeptest.NAME))
parser.add_argument("--ask",
"-a",
action="store_true",
default=self._ask,
help=_("ask before making any changes"))
parser.add_argument("--quiet",
"-q",
action="store_true",
default=self._quiet,
help=_("show less details (useful for scripting)"))
parser.add_argument("--pretend",
"-p",
action="store_true",
default=self._pretend,
help=_("just show what would be done"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloCleanup.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloCleanup.NAME))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloStatus.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloStatus.NAME))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloHop.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloHop.NAME))
parser.add_argument("branch", metavar="<branch>", help=_("branch"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloHop.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloHop.NAME))
parser.add_argument(
"branch", metavar="<branch>", help=_("branch"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloNotice.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloNotice.NAME))
parser.add_argument("repo", nargs='+',
metavar="<repo>", help=_("repository"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloNotice.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloNotice.NAME))
parser.add_argument("repo",
nargs='+',
metavar="<repo>",
help=_("repository"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloUpdate.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloUpdate.NAME))
parser.add_argument("repo", nargs='*', default=None,
metavar="<repo>", help=_("repository"))
parser.add_argument("--force", action="store_true",
default=self._force,
help=_("force update"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloLibtest.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloLibtest.NAME))
_commands = []
parser.add_argument("--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands.append("--ask")
_commands.append("-a")
parser.add_argument("--quiet", "-q", action="store_true",
default=False,
help=_("show less details "
"(useful for scripting)"))
_commands.append("--quiet")
_commands.append("-q")
parser.add_argument("--pretend", "-p", action="store_true",
default=False,
help=_("just show what would be done"))
_commands.append("--pretend")
_commands.append("-p")
parser.add_argument("--listfiles", action="store_true",
default=False,
help=_("print broken files to stdout"))
_commands.append("--listfiles")
parser.add_argument("--dump", action="store_true",
default=False,
help=_("dump results to files"))
_commands.append("--dump")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloLibtest.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloLibtest.NAME))
_commands = []
parser.add_argument("--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands.append("--ask")
_commands.append("-a")
parser.add_argument("--quiet", "-q", action="store_true",
default=False,
help=_("show less details "
"(useful for scripting)"))
_commands.append("--quiet")
_commands.append("-q")
parser.add_argument("--pretend", "-p", action="store_true",
default=False,
help=_("just show what would be done"))
_commands.append("--pretend")
_commands.append("-p")
parser.add_argument("--listfiles", action="store_true",
default=False,
help=_("print broken files to stdout"))
_commands.append("--listfiles")
parser.add_argument("--dump", action="store_true",
default=False,
help=_("dump results to files"))
_commands.append("--dump")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloConfig.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloConfig.NAME))
parser.set_defaults(func=self._config)
parser.add_argument(
"packages", nargs='+',
metavar="<package>", help=_("package name"))
mg_group = parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands["--ask"] = {}
_commands["-a"] = {}
mg_group.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_commands["--pretend"] = {}
_commands["-p"] = {}
parser.add_argument(
"--verbose", "-v", action="store_true",
default=False,
help=_("verbose output"))
_commands["--verbose"] = {}
_commands["-v"] = {}
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloConfig.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloConfig.NAME))
parser.set_defaults(func=self._config)
parser.add_argument(
"packages", nargs='+',
metavar="<package>", help=_("package name"))
mg_group = parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands["--ask"] = {}
_commands["-a"] = {}
mg_group.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_commands["--pretend"] = {}
_commands["-p"] = {}
parser.add_argument(
"--verbose", "-v", action="store_true",
default=False,
help=_("verbose output"))
_commands["--verbose"] = {}
_commands["-v"] = {}
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloUpdate.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloUpdate.NAME))
parser.add_argument("repo",
nargs='*',
default=None,
metavar="<repo>",
help=_("repository"))
parser.add_argument("--force",
action="store_true",
default=self._force,
help=_("force update"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloDeptest.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloDeptest.NAME))
parser.add_argument("--ask", "-a", action="store_true",
default=self._ask,
help=_("ask before making any changes"))
parser.add_argument("--quiet", "-q", action="store_true",
default=self._quiet,
help=_("show less details (useful for scripting)"))
parser.add_argument("--pretend", "-p", action="store_true",
default=self._pretend,
help=_("just show what would be done"))
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloConf.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloConf.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("manage configuration file updates"),
help=_("available commands"))
update_parser = subparsers.add_parser(
"update", help=_("update configuration files"))
update_parser.set_defaults(func=self._update)
_commands.append("update")
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
descriptor = SoloCommandDescriptor.obtain_descriptor(
self.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], self.NAME))
parser.add_argument("packages", nargs='+',
metavar="<package>", help=_("package name"))
group = parser.add_mutually_exclusive_group()
group.add_argument("--ask", "-a", action="store_true",
default=self._ask,
help=_('ask before making any changes'))
group.add_argument("--pretend", "-p", action="store_true",
default=self._pretend,
help=_('only show what would be done'))
return parser
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
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloPkg,
SoloPkg.NAME,
_("execute advanced tasks on packages"))
)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloMark.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloMark.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("specify property to mark on a package"),
help=_("available commands"))
def _add_standard_arguments(p, _cmd_dict):
p.add_argument(
"packages", nargs='+',
metavar="<package>", help=_("package name"))
p.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_cmd_dict["--pretend"] = {}
_cmd_dict["-p"] = {}
p.add_argument(
"--ignore-missing", action="store_true",
default=False,
help=_("ignore packages that are not installed on system"))
_cmd_dict["--ignore-missing"] = {}
# It behaves differently than --multimatch from match.py,
# thus a different name.
p.add_argument(
"--multiple-versions", action="store_true",
default=False,
help=_("allow matching multiple versions of a package"))
_cmd_dict["--multiple-versions"] = {}
auto_parser = subparsers.add_parser(
"auto",
help=_("mark package as installed to satisfy a dependency"))
_cmd_dict = {}
_add_standard_arguments(auto_parser, _cmd_dict)
auto_parser.set_defaults(func=self._auto)
_commands["auto"] = _cmd_dict
manual_parser = subparsers.add_parser(
"manual",
help=_("mark package as installed by user"))
_cmd_dict = {}
_add_standard_arguments(manual_parser, _cmd_dict)
manual_parser.set_defaults(func=self._manual)
_commands["manual"] = _cmd_dict
self._commands = _commands
return parser
elif action == 3:
comeback, _continue = self._edit_file(idx, entropy_client,
root, source, dest,
paths_map, scandata)
if _continue:
continue
break
elif action == 4:
comeback, _continue = self._interactive_merge(
idx, entropy_client, root, source, dest, paths_map,
scandata)
if _continue:
continue
break
elif action == 5:
# show diff again
diff = self._showdiff(entropy_client, dest_path, source_path)
continue
if comeback:
return True
return False
SoloCommandDescriptor.register(
SoloCommandDescriptor(SoloConf, SoloConf.NAME,
_("manage package file updates")))
self._get_dep_ids(inst_repo))
not_needed = all_ids - wanted_ids
def _sort_key(x):
sort_index = 1 if self._sortbysize else 0
return x[sort_index]
not_needed_pkgs_data = sorted(
[(inst_repo.retrieveAtom(x), inst_repo.retrieveOnDiskSize(x))
for x in not_needed],
key=_sort_key)
if self._quiet:
entropy_client.output('\n'.join(
[x[0] for x in not_needed_pkgs_data]),
level="generic")
else:
for atom, disk_size in not_needed_pkgs_data:
disk_size = entropy.tools.bytes_into_human(disk_size)
entropy_client.output("# %s%s%s %s" % (
blue("["),
brown(disk_size),
blue("]"),
darkgreen(atom),
))
SoloCommandDescriptor.register(
SoloCommandDescriptor(SoloUnused, SoloUnused.NAME,
_("show unused packages (pay attention)")))
class SoloUnmask(SoloMaskUnmask):
"""
Main Solo Mask command.
"""
NAME = "unmask"
ALIASES = []
INTRODUCTION = """\
Unmask packages so that installation and update will be allowed.
"""
SEE_ALSO = "equo-mask(1)"
def __init__(self, args):
SoloMaskUnmask.__init__(self, args, SoloUnmask.NAME)
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloMask,
SoloMask.NAME,
_("mask one or more packages"))
)
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloUnmask,
SoloUnmask.NAME,
_("unmask one or more packages"))
)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloSecurity.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloSecurity.NAME))
self._setup_verbose_quiet_parser(parser)
subparsers = parser.add_subparsers(
title="action", description=_("system security tools"),
help=_("available commands"))
oscheck_parser = subparsers.add_parser(
"oscheck",
help=_("verify installed files using stored checksums"))
self._setup_verbose_quiet_parser(oscheck_parser)
oscheck_parser.add_argument(
"--mtime", action="store_true", default=False,
help=_("consider mtime instead of SHA256 "
"(false positives ahead)"))
oscheck_parser.add_argument(
"--assimilate", action="store_true", default=False,
help=_("update hashes and mtime (useful after "
"editing config files)"))
oscheck_parser.add_argument(
"--reinstall", action="store_true", default=False,
help=_("reinstall faulty packages"))
mg_group = oscheck_parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true", default=False,
help=_("ask before making any changes"))
mg_group.add_argument(
"--pretend", "-p", action="store_true", default=False,
help=_("show what would be done"))
oscheck_parser.add_argument(
"--fetch", action="store_true", default=False,
help=_("just download packages"))
oscheck_parser.set_defaults(func=self._oscheck)
_commands["oscheck"] = {
"--mtime": {},
"--assimilate": {},
"--reinstall": {},
"--pretend": {},
"-p": {},
"--ask": {},
"-a": {},
"--fetch": {},
}
update_parser = subparsers.add_parser(
"update",
help=_("download the latest Security Advisories"))
self._setup_verbose_quiet_parser(update_parser)
update_parser.add_argument(
"--force", action="store_true", default=False,
help=_("force download"))
update_parser.set_defaults(func=self._update)
_commands["update"] = {
"--force": {},
}
list_parser = subparsers.add_parser(
"list",
help=_("list all the available Security Advisories"))
self._setup_verbose_quiet_parser(list_parser)
mg_group = list_parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--affected", action="store_true", default=False,
help=_("list only affected"))
mg_group.add_argument(
"--unaffected", action="store_true", default=False,
help=_("list only unaffected"))
list_parser.set_defaults(func=self._list)
_commands["list"] = {
"--affected": {},
"--unaffected": {},
}
info_parser = subparsers.add_parser(
"info",
help=_("show information about provided "
"advisories identifiers"))
self._setup_verbose_quiet_parser(info_parser)
info_parser.add_argument(
"ids", nargs='+',
metavar="<id>", help=_("advisory indentifier"))
info_parser.set_defaults(func=self._info)
_commands["info"] = {}
install_parser = subparsers.add_parser(
"install",
help=_("automatically install all the "
"available security updates"))
self._setup_verbose_quiet_parser(install_parser)
mg_group = install_parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true", default=False,
help=_("ask before making any changes"))
mg_group.add_argument(
"--pretend", "-p", action="store_true", default=False,
help=_("show what would be done"))
install_parser.add_argument(
"--fetch", action="store_true", default=False,
help=_("just download packages"))
install_parser.set_defaults(func=self._install)
_commands["install"] = {
"--ask": {},
"-a": {},
"--fetch": {},
"--pretend": {},
"-p": {},
}
self._commands = _commands
return parser
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloRemove.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloRemove.NAME))
parser.set_defaults(func=self._remove)
parser.add_argument(
"packages", nargs='+',
metavar="<package>", help=_("package name"))
mg_group = parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands["--ask"] = {}
_commands["-a"] = {}
mg_group.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_commands["--pretend"] = {}
_commands["-p"] = {}
parser.add_argument(
"--verbose", "-v", action="store_true",
default=False,
help=_("verbose output"))
_commands["--verbose"] = {}
_commands["-v"] = {}
parser.add_argument(
"--nodeps", action="store_true",
default=False,
help=_("exclude package dependencies"))
_commands["--nodeps"] = {}
parser.add_argument(
"--norecursive", action="store_true",
default=False,
help=_("do not calculate dependencies recursively"))
_commands["--norecursive"] = {}
parser.add_argument(
"--deep", action="store_true",
default=False,
help=_("include dependencies no longer needed"))
_commands["--deep"] = {}
parser.add_argument(
"--empty", action="store_true",
default=False,
help=_("when used with --deep, include virtual packages"))
_commands["--empty"] = {}
parser.add_argument(
"--configfiles", action="store_true",
default=False,
help=_("remove package configuration files no longer needed"))
_commands["--configfiles"] = {}
parser.add_argument(
"--force-system", action="store_true",
default=False,
help=_("force system packages removal (dangerous!)"))
_commands["--force-system"] = {}
self._commands = _commands
return parser
level="error", importance=1
)
return 1
if not voted:
entropy_client.output(
"[%s] %s: %s" % (
darkred(pkgkey),
blue(_("UGC error")),
_("already voted"),
),
level="error", importance=1
)
return 1
else:
entropy_client.output("[%s] %s" % (
purple(pkgkey),
blue(_("vote added, thank you!")),
)
)
self._vote_get(entropy_client)
return 0
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloUgc,
SoloUgc.NAME,
_("manage User Generated Content"))
)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloInstall.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloInstall.NAME))
parser.set_defaults(func=self._install)
parser.add_argument(
"packages", nargs='+',
metavar="<package>", help=_("package name"))
mg_group = parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands["--ask"] = {}
_commands["-a"] = {}
mg_group.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_commands["--pretend"] = {}
_commands["-p"] = {}
parser.add_argument(
"--verbose", "-v", action="store_true",
default=False,
help=_("verbose output"))
_commands["--verbose"] = {}
_commands["-v"] = {}
parser.add_argument(
"--quiet", "-q", action="store_true",
default=False,
help=_("quiet output"))
_commands["--quiet"] = {}
_commands["-q"] = {}
parser.add_argument(
"--fetch", action="store_true",
default=False,
help=_("just download packages"))
_commands["--fetch"] = {}
parser.add_argument(
"--bdeps", action="store_true",
default=False,
help=_("include build-time dependencies"))
_commands["--bdeps"] = {}
parser.add_argument(
"--nodeps", action="store_true",
default=False,
help=_("exclude package dependencies"))
_commands["--nodeps"] = {}
parser.add_argument(
"--onlydeps", "-o", action="store_true",
default=False,
help=_("only include dependencies of selected packages"))
_commands["--onlydeps"] = {}
_commands["-o"] = {}
parser.add_argument(
"--norecursive", action="store_true",
default=False,
help=_("do not calculate dependencies recursively"))
_commands["--norecursive"] = {}
parser.add_argument(
"--deep", action="store_true",
default=False,
help=_("include dependencies no longer needed"))
_commands["--deep"] = {}
parser.add_argument(
"--empty", action="store_true",
default=False,
help=_("when used with --deep, include virtual packages"))
_commands["--empty"] = {}
parser.add_argument(
"--configfiles", action="store_true",
default=False,
help=_("remove package configuration files no longer needed"))
_commands["--configfiles"] = {}
parser.add_argument(
"--relaxed", action="store_true",
default=False,
help=_("relax dependencies constraints during calculation"))
_commands["--relaxed"] = {}
parser.add_argument(
"--multifetch",
type=int, default=1,
choices=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
help=_("download multiple packages in parallel (max 10)"))
_commands["--multifetch"] = {}
self._commands = _commands
return parser
exit_st = pkg.start()
if exit_st != 0:
if ugc_thread is not None:
ugc_thread.join()
return 1, True
finally:
if pkg is not None:
pkg.finalize()
finally:
if notif_acquired:
notification_lock.release()
if ugc_thread is not None:
ugc_thread.join()
entropy_client.output(
"%s." % (
blue(_("Installation complete")),),
header=darkred(" @@ "))
return 0, True
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloInstall,
SoloInstall.NAME,
_("install or update packages or package files"))
)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = []
descriptor = SoloCommandDescriptor.obtain_descriptor(SoloRepo.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloRepo.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("manage repositories"),
help=_("available commands"))
enable_parser = subparsers.add_parser("enable",
help=_("enable repositories"))
enable_parser.add_argument("repo",
nargs='+',
metavar="<repo>",
help=_("repository name"))
enable_parser.set_defaults(func=self._enable)
_commands.append("enable")
disable_parser = subparsers.add_parser("disable",
help=_("disable repositories"))
disable_parser.add_argument("repo",
nargs='+',
metavar="<repo>",
help=_("repository name"))
disable_parser.set_defaults(func=self._disable)
_commands.append("disable")
add_parser = subparsers.add_parser("add", help=_("add a repository"))
add_parser.add_argument("id",
metavar="<repository>",
help=_("repository name"))
add_parser.add_argument("--desc",
metavar="<description>",
required=True,
help=_("repository description"))
add_parser.add_argument("--repo",
nargs='+',
metavar="<repo url>",
required=True,
help=_("repository database URL"))
add_parser.add_argument("--pkg",
nargs='+',
metavar="<pkg url>",
required=True,
help=_("repository packages URL"))
add_parser.add_argument("--cformat",
default=etpConst['etpdatabasefileformat'],
metavar="<compression format>",
help=_("repository compression format"))
add_parser.set_defaults(func=self._add)
_commands.append("add")
remove_parser = subparsers.add_parser("remove",
help=_("remove a repository"))
remove_parser.add_argument("repo",
nargs='+',
metavar="<repo>",
help=_("repository name"))
remove_parser.set_defaults(func=self._remove)
_commands.append("remove")
rename_parser = subparsers.add_parser("rename",
help=_("rename a repository"))
rename_parser.add_argument("from_repo",
metavar="<from>",
help=_("from repository"))
rename_parser.add_argument("to_repo",
metavar="<to>",
help=_("to repository"))
rename_parser.set_defaults(func=self._rename)
_commands.append("rename")
list_parser = subparsers.add_parser("list",
help=_("list active repositories"))
list_parser.set_defaults(func=self._list)
list_parser.add_argument(
"--quiet",
"-q",
action="store_true",
default=False,
help=_('quiet output, for scripting purposes'))
_commands.append("list")
mirrorsort_parser = subparsers.add_parser(
"mirrorsort", help=_("reorder mirrors basing on response time"))
mirrorsort_parser.add_argument("repo",
nargs='+',
metavar="<repo>",
help=_("repository name"))
mirrorsort_parser.add_argument("--simulate",
action="store_true",
default=False,
help=_("simulate execution"))
mirrorsort_parser.set_defaults(func=self._mirrorsort)
_commands.append("mirrorsort")
merge_parser = subparsers.add_parser(
"merge",
help=_("merge content of source repository to destination"))
merge_parser.add_argument("source",
metavar="<source>",
help=_("source repository"))
merge_parser.add_argument("dest",
metavar="<destination>",
help=_("destination repository"))
merge_parser.add_argument(
"--conflicts",
action="store_true",
default=False,
help=_("also remove dependency conflicts during merge"))
merge_parser.set_defaults(func=self._merge)
_commands.append("merge")
self._commands = _commands
return parser
current_source_txt = reverse_install_sources.get(
current_source, other_source)
if current_source == source:
txt = "%s: %s" % (
brown(pkg_atom),
_("no change"))
entropy_client.output(
txt,
header=blue(" @@ "))
else:
txt = "%s: %s => %s" % (
brown(pkg_atom),
current_source_txt,
source_txt)
entropy_client.output(
txt,
header=red(" !! "))
if not pretend:
inst_repo.setInstalledPackageSource(pkg_id, source)
return 0
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloMark,
SoloMark.NAME,
_("set properties on installed packages"))
)
def _show_notice_board_summary(self, entropy_client, repository):
"""
Show NoticeBoard information to user after repository update.
"""
mytxt = "%s %s: %s" % (
darkgreen(" @@ "),
brown(_("Notice board")),
bold(repository),
)
entropy_client.output(mytxt)
mydict = self._check_notice_board_availability(entropy_client,
repository)
if not mydict:
return
for key in sorted(mydict.keys()):
mydata = mydict.get(key)
mytxt = " [%s] [%s] %s: %s" % (
blue(str(key)),
brown(mydata['pubDate']),
_("Title"),
darkred(mydata['title']),
)
entropy_client.output(mytxt)
SoloCommandDescriptor.register(
SoloCommandDescriptor(SoloUpdate, SoloUpdate.NAME,
_("update repositories")))
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloPkg.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloPkg.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("execute advanced tasks on packages"),
help=_("available commands"))
def _argparse_easygoing_valid_entropy_path(string):
if os.path.isfile(string) and os.path.exists(string):
return string
# see bug 3873, requires raw string
msg = "%s: %s" % (
_("not a valid Entropy package file"),
string)
msg = const_convert_to_rawstring(
msg, from_enctype="utf-8")
raise argparse.ArgumentTypeError(msg)
quickpkg_parser = subparsers.add_parser(
"quickpkg", help=_("generate packages from "
"the installed system"))
quickpkg_parser.add_argument(
"packages", nargs='+', metavar="<package>",
help=_("installed package name"))
quickpkg_parser.add_argument(
"--savedir", metavar="<path>",
type=self._argparse_is_valid_directory,
default=self._savedir,
help=_("destination directory "
"where to save generated packages"))
quickpkg_parser.set_defaults(func=self._quickpkg)
_commands["quickpkg"] = {}
inflate_parser = subparsers.add_parser(
"inflate", help=_("transform SPM package files "
"into Entropy ones"))
inflate_parser.add_argument(
"files", nargs='+', metavar="<file>",
type=_argparse_easygoing_valid_entropy_path,
help=_("SPM package file path"))
inflate_parser.add_argument(
"--savedir", metavar="<path>",
type=self._argparse_is_valid_directory,
default=self._savedir,
help=_("destination directory "
"where to save generated packages"))
inflate_parser.set_defaults(func=self._inflate)
_commands["inflate"] = {}
deflate_parser = subparsers.add_parser(
"deflate", help=_("transform Entropy package files "
"into SPM ones"))
deflate_parser.add_argument(
"files", nargs='+', metavar="<file>",
type=self._argparse_is_valid_entropy_package,
help=_("Entropy package file path"))
deflate_parser.add_argument(
"--savedir", metavar="<path>",
type=self._argparse_is_valid_directory,
default=self._savedir,
help=_("destination directory "
"where to save generated packages"))
deflate_parser.set_defaults(func=self._deflate)
_commands["deflate"] = {}
extract_parser = subparsers.add_parser(
"extract", help=_("extract Entropy metadata "
"from Entropy packages"))
extract_parser.add_argument(
"files", nargs='+', metavar="<file>",
type=_argparse_easygoing_valid_entropy_path,
help=_("Entropy package file path"))
extract_parser.add_argument(
"--savedir", metavar="<path>",
type=self._argparse_is_valid_directory,
default=self._savedir,
help=_("destination directory "
"where to save generated packages"))
extract_parser.set_defaults(func=self._extract)
_commands["extract"] = {}
self._commands = _commands
return parser
return 1, False
removal_queue += [x for x in plain_removal_queue if x \
not in removal_queue]
self._show_removal_info(entropy_client, removal_queue)
self._prompt_final_removal(
entropy_client, inst_repo, removal_queue)
if pretend:
return 0, False
if ask:
question = " %s" % (
_("Would you like to proceed ?"),)
rc = entropy_client.ask_question(question)
if rc == _("No"):
return 1, False
exit_st = self._execute_action(
entropy_client, inst_repo, removal_queue,
remove_config_files)
return exit_st, True
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloRemove,
SoloRemove.NAME,
_("remove packages from system"))
)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloUgc.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloUgc.NAME))
subparsers = parser.add_subparsers(
title="action", description=_("manage User Generated Content"),
help=_("available commands"))
login_parser = subparsers.add_parser(
"login", help=_("login against the given repository"))
login_parser.add_argument(
"repo", help=_("repository name"))
login_parser.add_argument(
"--force", action="store_true",
default=False, help=_("force action"))
login_parser.set_defaults(func=self._login)
_commands["login"] = {}
logout_parser = subparsers.add_parser(
"logout", help=_("logout from the given repository"))
logout_parser.add_argument(
"repo", help=_("repository name"))
logout_parser.add_argument(
"--force", action="store_true",
default=False, help=_("force action"))
logout_parser.set_defaults(func=self._logout)
_commands["logout"] = {}
documents_parser = subparsers.add_parser(
"documents",
help=_("manage package documents in "
"the selected repository (comments, files, videos)"))
documents_parser.add_argument(
"repo", help=_("repository name"))
docs_d = {}
_commands["documents"] = docs_d
doc_subparsers = documents_parser.add_subparsers(
title="action", description=_("manage Documents"),
help=_("available commands"))
doc_get_parser = doc_subparsers.add_parser(
"get", help=_("get available documents for the "
"provided package name"))
doc_get_parser.add_argument(
"pkgkey", help=_("package name (example: x11-libs/qt)"))
doc_get_parser.set_defaults(func=self._document_get)
docs_d["get"] = {}
doc_add_parser = doc_subparsers.add_parser(
"add", help=_("add a new document to the "
"provided package name"))
doc_add_parser.add_argument(
"pkgkey", help=_("package name (example: x11-libs/qt)"))
doc_add_parser.set_defaults(func=self._document_add)
docs_d["add"] = {}
doc_rm_parser = doc_subparsers.add_parser(
"remove", help=_("remove documents from database "
"using their identifiers"))
doc_rm_parser.add_argument(
"pkgkey", help=_("package name (example: x11-libs/qt)"))
doc_rm_parser.add_argument(
"ids", nargs='+', metavar="<id>", type=int,
help=_("document identifier"))
doc_rm_parser.set_defaults(func=self._document_rm)
docs_d["remove"] = {}
vote_parser = subparsers.add_parser(
"vote",
help=_("manage package votes in "
"the selected repository"))
vote_parser.add_argument(
"repo", help=_("repository name"))
vote_d = {}
_commands["vote"] = vote_d
vote_subparsers = vote_parser.add_subparsers(
title="action", description=_("manage Votes"),
help=_("available commands"))
vote_get_parser = vote_subparsers.add_parser(
"get", help=_("get vote for the provided package name"))
vote_get_parser.add_argument(
"pkgkey", help=_("package name (example: x11-libs/qt)"))
vote_get_parser.set_defaults(func=self._vote_get)
vote_d["get"] = {}
vote_add_parser = vote_subparsers.add_parser(
"add", help=_("add vote to the provided package name"))
vote_add_parser.add_argument(
"pkgkey", help=_("package name (example: x11-libs/qt)"))
vote_add_parser.set_defaults(func=self._vote_add)
vote_d["add"] = {}
self._commands = _commands
return parser
continue
key_slot = inst_repo.retrieveKeySlotAggregated(
inst_package_id)
package_id, repository_id = entropy_client.atom_match(key_slot)
if package_id != -1:
valid_matches.add((package_id, repository_id))
if not valid_matches:
entropy_client.output(
"%s." % (
blue(_("All the available updates "
"have been already installed")),),
header=darkred(" @@ "))
return 0
exit_st, _show_cfgupd = self._install_action(
entropy_client, True, True,
pretend, ask, False, quiet, False,
False, False, fetch, False, False,
False, 1, [], package_matches=list(valid_matches))
return exit_st
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloSecurity,
SoloSecurity.NAME,
_("system security tools"))
)
pkg = action_factory.get(
action_factory.SOURCE_ACTION,
match, opts=metaopts)
xterm_header = "equo (%s) :: %d of %d ::" % (
_("sources download"), count, total)
pkg.set_xterm_header(xterm_header)
entropy_client.output(
darkgreen(atom),
count=(count, total),
header=darkred(" ::: ") + ">>> ")
exit_st = pkg.start()
if exit_st != 0:
return 1
finally:
if pkg is not None:
pkg.finalize()
return 0
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloSource,
SoloSource.NAME,
_("download packages source code"))
)
def main():
is_color = "--color" in sys.argv
if is_color:
sys.argv.remove("--color")
if not is_color and not is_stdout_a_tty():
nocolor()
warn_version_mismatch()
install_exception_handler()
descriptors = SoloCommandDescriptor.obtain()
args_map = {}
catch_all = None
for descriptor in descriptors:
klass = descriptor.get_class()
if klass.CATCH_ALL:
catch_all = klass
args_map[klass.NAME] = klass
for alias in klass.ALIASES:
args_map[alias] = klass
args = sys.argv[1:]
# convert args to unicode, to avoid passing
# raw string stuff down to entropy layers
def _to_unicode(arg):
try:
return const_convert_to_unicode(
arg, enctype=etpConst['conf_encoding'])
except UnicodeDecodeError:
print_error("invalid argument: %s" % (arg,))
raise SystemExit(1)
args = list(map(_to_unicode, args))
is_bashcomp = False
if "--bashcomp" in args:
is_bashcomp = True
args.remove("--bashcomp")
# the first eit, because bash does:
# argv -> equo --bashcomp equo repo
# and we need to drop --bashcomp and
# argv[2]
if args:
args.pop(0)
cmd = None
last_arg = None
if args:
last_arg = args[-1]
cmd = args[0]
args = args[1:]
cmd_class = args_map.get(cmd)
yell_class = args_map.get("yell")
if cmd_class is None:
cmd_class = catch_all
cmd_obj = cmd_class(args)
if is_bashcomp:
try:
cmd_obj.bashcomp(last_arg)
except NotImplementedError:
pass
raise SystemExit(0)
# non-root users not allowed
allowed = True
if os.getuid() != 0 and \
cmd_class is not catch_all and \
not cmd_class.ALLOW_UNPRIVILEGED and \
"--help" not in args:
cmd_class = catch_all
allowed = False
if allowed:
if not cmd_class.ALLOW_UNPRIVILEGED:
if entropy.tools.islive():
warn_live_system()
func, func_args = cmd_obj.parse()
exit_st = func(*func_args)
if exit_st == -10:
# syntax error, yell at user
func, func_args = yell_class(args).parse()
func(*func_args)
raise SystemExit(10)
else:
yell_class.reset()
raise SystemExit(exit_st)
else:
# execute this anyway so that commands are
# incomplete or invalid, the command error
# message will take precedence.
_func, _func_args = cmd_obj.parse()
print_error(_("superuser access required"))
raise SystemExit(1)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloSource.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloSource.NAME))
parser.set_defaults(func=self._source)
parser.add_argument(
"packages", nargs='+',
metavar="<package>", help=_("package name"))
mg_group = parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands["--ask"] = {}
_commands["-a"] = {}
mg_group.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_commands["--pretend"] = {}
_commands["-p"] = {}
parser.add_argument(
"--verbose", "-v", action="store_true",
default=False,
help=_("verbose output"))
_commands["--verbose"] = {}
_commands["-v"] = {}
parser.add_argument(
"--quiet", "-q", action="store_true",
default=False,
help=_("quiet output"))
_commands["--quiet"] = {}
_commands["-q"] = {}
parser.add_argument(
"--nodeps", action="store_true",
default=False,
help=_("exclude package dependencies"))
_commands["--nodeps"] = {}
parser.add_argument(
"--onlydeps", "-o", action="store_true",
default=False,
help=_("only include dependencies of selected packages"))
_commands["--onlydeps"] = {}
_commands["-o"] = {}
parser.add_argument(
"--norecursive", action="store_true",
default=False,
help=_("do not calculate dependencies recursively"))
_commands["--norecursive"] = {}
parser.add_argument(
"--deep", action="store_true",
default=False,
help=_("include dependencies no longer needed"))
_commands["--deep"] = {}
parser.add_argument(
"--relaxed", action="store_true",
default=False,
help=_("calculate dependencies relaxing constraints"))
_commands["--relaxed"] = {}
parser.add_argument(
"--bdeps", action="store_true",
default=False,
help=_("include build-time dependencies"))
_commands["--bdeps"] = {}
parser.add_argument(
"--savehere", action="store_true",
default=False,
help=_("save files into the current working directory"))
_commands["--savehere"] = {}
self._commands = _commands
return parser
"""
# 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)
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloUpgrade,
SoloUpgrade.NAME,
_("upgrade the system"))
)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloUpgrade.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloUpgrade.NAME))
parser.set_defaults(func=self._upgrade)
mg_group = parser.add_mutually_exclusive_group()
mg_group.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_commands["--ask"] = {}
_commands["-a"] = {}
mg_group.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_commands["--pretend"] = {}
_commands["-p"] = {}
parser.add_argument(
"--verbose", "-v", action="store_true",
default=False,
help=_("verbose output"))
_commands["--verbose"] = {}
_commands["-v"] = {}
parser.add_argument(
"--quiet", "-q", action="store_true",
default=False,
help=_("quiet output"))
_commands["--quiet"] = {}
_commands["-q"] = {}
parser.add_argument(
"--fetch", action="store_true",
default=False,
help=_("just download packages"))
_commands["--fetch"] = {}
parser.add_argument(
"--bdeps", action="store_true",
default=False,
help=_("include build-time dependencies"))
_commands["--bdeps"] = {}
parser.add_argument(
"--nodeps", action="store_true",
default=False,
help=_("exclude package dependencies"))
_commands["--nodeps"] = {}
parser.add_argument(
"--norecursive", action="store_true",
default=False,
help=_("do not calculate dependencies recursively"))
_commands["--norecursive"] = {}
parser.add_argument(
"--deep", action="store_true",
default=False,
help=_("include dependencies no longer needed"))
_commands["--deep"] = {}
parser.add_argument(
"--empty", action="store_true",
default=False,
help=_("when used with --deep, include virtual packages"))
_commands["--empty"] = {}
parser.add_argument(
"--purge", action="store_true",
default=False,
help=_("remove unmaintained packages, if any. This will respect "
"--ask, --pretend and other switches."))
_commands["--purge"] = {}
parser.add_argument(
"--configfiles", action="store_true",
default=False,
help=_("remove package configuration files no longer needed"))
_commands["--configfiles"] = {}
parser.add_argument(
"--relaxed", action="store_true",
default=False,
help=_("relax dependencies constraints during calculation"))
_commands["--relaxed"] = {}
parser.add_argument(
"--multifetch",
type=int, default=1,
choices=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
help=_("download multiple packages in parallel (max 10)"))
_commands["--multifetch"] = {}
self._commands = _commands
return parser
target_pkg_ids = dest_db.getPackagesToRemove(
pkg_meta['name'], pkg_meta['category'], pkg_meta['slot'],
pkg_meta['injected'])
if remove_conflicts:
for conflict in pkg_meta['conflicts']:
if conflict in conflict_cache:
continue
conflict_cache.add(conflict)
matches, rc = dest_db.atomMatch(conflict, multiMatch=True)
target_pkg_ids |= matches
for target_pkg_id in target_pkg_ids:
dest_db.removePackage(target_pkg_id)
dest_pkg_id = dest_db.addPackage(pkg_meta, formatted_content=True)
dest_db.commit()
entropy_client.output("[%s] %s" % (
teal(source),
blue(_("done merging packages")),
))
dest_db.commit()
dest_db.close()
# close all repos again
entropy_client.close_repositories()
return 0
SoloCommandDescriptor.register(
SoloCommandDescriptor(SoloRepo, SoloRepo.NAME, _("manage repositories")))
def main():
is_color = "--color" in sys.argv
if is_color:
sys.argv.remove("--color")
if not is_color and not is_stdout_a_tty():
nocolor()
warn_version_mismatch()
install_exception_handler()
descriptors = SoloCommandDescriptor.obtain()
args_map = {}
catch_all = None
for descriptor in descriptors:
klass = descriptor.get_class()
if klass.CATCH_ALL:
catch_all = klass
args_map[klass.NAME] = klass
for alias in klass.ALIASES:
args_map[alias] = klass
args = sys.argv[1:]
# convert args to unicode, to avoid passing
# raw string stuff down to entropy layers
def _to_unicode(arg):
try:
return const_convert_to_unicode(arg,
enctype=etpConst['conf_encoding'])
except UnicodeDecodeError:
print_error("invalid argument: %s" % (arg, ))
raise SystemExit(1)
args = list(map(_to_unicode, args))
is_bashcomp = False
if "--bashcomp" in args:
is_bashcomp = True
args.remove("--bashcomp")
# the first eit, because bash does:
# argv -> equo --bashcomp equo repo
# and we need to drop --bashcomp and
# argv[2]
if args:
args.pop(0)
cmd = None
last_arg = None
if args:
last_arg = args[-1]
cmd = args[0]
args = args[1:]
cmd_class = args_map.get(cmd)
yell_class = args_map.get("yell")
if cmd_class is None:
cmd_class = catch_all
cmd_obj = cmd_class(args)
if is_bashcomp:
try:
cmd_obj.bashcomp(last_arg)
except NotImplementedError:
pass
raise SystemExit(0)
# non-root users not allowed
allowed = True
if os.getuid() != 0 and \
cmd_class is not catch_all and \
not cmd_class.ALLOW_UNPRIVILEGED and \
"--help" not in args:
cmd_class = catch_all
allowed = False
if allowed:
if not cmd_class.ALLOW_UNPRIVILEGED:
if entropy.tools.islive():
warn_live_system()
func, func_args = cmd_obj.parse()
exit_st = func(*func_args)
if exit_st == -10:
# syntax error, yell at user
func, func_args = yell_class(args).parse()
func(*func_args)
raise SystemExit(10)
else:
yell_class.reset()
raise SystemExit(exit_st)
else:
# execute this anyway so that commands are
# incomplete or invalid, the command error
# message will take precedence.
_func, _func_args = cmd_obj.parse()
print_error(_("superuser access required"))
raise SystemExit(1)
def _get_parser(self):
"""
Overridden from SoloCommand.
"""
_commands = {}
descriptor = SoloCommandDescriptor.obtain_descriptor(
SoloRescue.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], SoloRescue.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("execute advanced tasks on packages"),
help=_("available commands"))
def _add_ask_to_parser(p, _cmd_dict):
p.add_argument(
"--ask", "-a", action="store_true",
default=False,
help=_("ask before making any changes"))
_cmd_dict["--ask"] = {}
_cmd_dict["-a"] = {}
def _add_pretend_to_parser(p, _cmd_dict):
p.add_argument(
"--pretend", "-p", action="store_true",
default=False,
help=_("show what would be done"))
_cmd_dict["--pretend"] = {}
_cmd_dict["-p"] = {}
check_parser = subparsers.add_parser(
"check", help=_("check installed packages "
"repository for errors"))
check_parser.set_defaults(func=self._check)
_commands["check"] = {}
vacuum_parser = subparsers.add_parser(
"vacuum",
help=_("compact the installed packages repository"))
vacuum_parser.set_defaults(func=self._vacuum)
_commands["vacuum"] = {}
generate_parser = subparsers.add_parser(
"generate",
help=_("re-generate the installed packages repository"
" using the Source Package Manager"))
generate_parser.set_defaults(func=self._generate)
_commands["generate"] = {}
spmuids_parser = subparsers.add_parser(
"spmuids",
help=_("re-generate SPM<->Entropy package UIDs mapping"))
spmuids_parser.set_defaults(func=self._spmuids)
_commands["spmuids"] = {}
spmsync_parser = subparsers.add_parser(
"spmsync",
help=_("update Entropy installed packages repository "
"merging Source Package Manager changes"))
_cmd_dict = {}
_commands["spmsync"] = _cmd_dict
mg_group = spmsync_parser.add_mutually_exclusive_group()
_add_ask_to_parser(mg_group, _cmd_dict)
_add_pretend_to_parser(mg_group, _cmd_dict)
spmsync_parser.set_defaults(func=self._spmsync)
backup_parser = subparsers.add_parser(
"backup",
help=_("create a backup of the installed packages repository"))
backup_parser.set_defaults(func=self._backup)
_commands["backup"] = {}
restore_parser = subparsers.add_parser(
"restore",
help=_("restore a backup of the installed "
"packages repository"))
restore_parser.set_defaults(func=self._restore)
_commands["restore"] = {}
self._commands = _commands
return parser
obj = spm_wanted_map.setdefault(stripped, set())
obj.add(pkg)
return spm_wanted_map
def is_user_selected(self, pkg):
"""
Determines whether a package is selected by user in SPM "world" file.
"""
spm_package_key = entropy.dep.dep_getkey(pkg)
spm_wanted_candidates = self._map.get(spm_package_key, set())
# Avoid calling spm.match_installed_package() which can be
# a little slow. Now the list is reduced.
spm_wanted_matches = (self._spm_match_installed(x)
for x in spm_wanted_candidates
if x is not None)
return pkg in spm_wanted_matches
def _spm_match_installed(self, pkg):
try:
return self._spm.match_installed_package(pkg)
except KeyError:
return None
SoloCommandDescriptor.register(
SoloCommandDescriptor(
SoloRescue,
SoloRescue.NAME,
_("tools to rescue the running system"))
)
