def bashcomp(self, last_arg):
"""
Overridden from EitCommand
"""
import sys
descriptors = EitCommandDescriptor.obtain()
descriptors.sort(key = lambda x: x.get_name())
outcome = []
for descriptor in descriptors:
name = descriptor.get_name()
if name == EitHelp.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 EitCommit """
descriptor = EitCommandDescriptor.obtain_descriptor(EitAdd.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitAdd.NAME))
parser.add_argument("packages",
nargs='+',
metavar="<package>",
help=_("package names"))
parser.add_argument("--conservative",
action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--to",
metavar="<repository>",
help=_("add to given repository"),
default=None)
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitCommit.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitCommit.NAME))
parser.add_argument("repo",
nargs='?',
default=None,
metavar="<repo>",
help=_("repository"))
parser.add_argument("--conservative",
action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--interactive",
action="store_true",
default=False,
help=_("selectively pick changes"))
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
""" Overridden from EitCp """
descriptor = EitCommandDescriptor.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("source",
metavar="<source>",
help=_("source repository"))
parser.add_argument("dest",
metavar="<dest>",
help=_("destination repository"))
parser.add_argument("--conservative",
action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--deps",
action="store_true",
default=False,
help=_("include dependencies"))
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
parser.add_argument("packages",
nargs='*',
metavar="<package>",
help=_("package dependency"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitGraph.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitGraph.NAME))
parser.add_argument("packages",
nargs='+',
metavar="<package>",
help=_("package name"))
parser.add_argument("--in",
metavar="<repository>",
help=_("search packages in given repository"),
dest="inrepo",
default=None)
parser.add_argument(
"--complete",
action="store_true",
default=self._complete,
help=_('show system packages, build deps, circular deps'))
parser.add_argument("--quiet",
"-q",
action="store_true",
default=self._quiet,
help=_('quiet output, for scripting purposes'))
return parser
def _get_parser(self):
self._real_command = sys.argv[0]
descriptor = EitCommandDescriptor.obtain_descriptor(EitPull.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitPull.NAME))
parser.add_argument("repo",
nargs='?',
default=None,
metavar="<repo>",
help=_("repository"))
parser.add_argument("--conservative",
action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--quick",
action="store_true",
default=False,
help=_("no stupid questions"))
parser.add_argument("--pretend",
action="store_true",
default=False,
help=_("show what would be done"))
group = parser.add_mutually_exclusive_group()
group.add_argument("--all",
action="store_true",
default=False,
help=_("pull all the repositories"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(EitRemote.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRemote.NAME))
subparsers = parser.add_subparsers(title="action",
description=_("execute action"),
help=_("available actions"))
list_parser = subparsers.add_parser("list",
help=_("list repositories"))
list_parser.set_defaults(func=self._list)
add_parser = subparsers.add_parser("add", help=_("add repository"))
add_parser.add_argument("repository",
metavar="<repository>",
help=_("repository id"))
add_parser.add_argument("--desc",
metavar="<description>",
default=None,
help=_("repository description"))
add_parser.add_argument("uri",
metavar="<uri>",
nargs="+",
help=_("repository uri"))
add_parser.set_defaults(func=self._add)
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(EitCleanup.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitCleanup.NAME))
parser.add_argument("repo",
nargs='?',
default=None,
metavar="<repo>",
help=_("repository"))
parser.add_argument("--quick",
action="store_true",
default=False,
help=_("no stupid questions"))
parser.add_argument("--pretend",
action="store_true",
default=False,
help=_("show what would be done"))
parser.add_argument('--days',
type=int,
default=self._days,
help=_("expired since how many days"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitRemote.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRemote.NAME))
subparsers = parser.add_subparsers(
title="action", description=_("execute action"),
help=_("available actions"))
list_parser = subparsers.add_parser("list",
help=_("list repositories"))
list_parser.set_defaults(func=self._list)
add_parser = subparsers.add_parser("add",
help=_("add repository"))
add_parser.add_argument("repository", metavar="<repository>",
help=_("repository id"))
add_parser.add_argument("--desc", metavar="<description>",
default=None,
help=_("repository description"))
add_parser.add_argument("uri", metavar="<uri>", nargs="+",
help=_("repository uri"))
add_parser.set_defaults(func=self._add)
return parser
def bashcomp(self, last_arg):
"""
Overridden from EitCommand
"""
import sys
descriptors = EitCommandDescriptor.obtain()
descriptors.sort(key=lambda x: x.get_name())
outcome = []
for descriptor in descriptors:
name = descriptor.get_name()
if name == EitHelp.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 EitCp """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitCp.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitCp.NAME))
parser.add_argument("source", nargs=1,
metavar="<source>",
help=_("source repository"))
parser.add_argument("dest", nargs=1,
metavar="<dest>",
help=_("destination repository"))
parser.add_argument("--conservative", action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--deps", action="store_true",
default=False,
help=_("include dependencies"))
parser.add_argument("package", nargs='+', metavar="<package>",
help=_("package dependency"))
return parser
def _get_parser(self):
self._real_command = sys.argv[0]
descriptor = EitCommandDescriptor.obtain_descriptor(
EitPush.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitPush.NAME))
parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
parser.add_argument("--conservative", action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--quick", action="store_true",
default=False,
help=_("no stupid questions"))
parser.add_argument("--force", action="store_true",
default=False,
help=_("force push in case of QA errors"))
group = parser.add_mutually_exclusive_group()
group.add_argument("--all", action="store_true",
default=False,
help=_("push all the repositories"))
group.add_argument("--as", metavar="<repo>", default=None,
help=_("push as fake repository"),
dest="asrepo")
parser.add_argument("--pretend", action="store_true",
default=False,
help=_("show what would be done"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitOwn.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitOwn.NAME))
parser.add_argument("paths",
nargs='+',
metavar="<path>",
help=_("path"))
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=_('output more package info'))
parser.add_argument("--in",
metavar="<repository>",
help=_("search packages in given repository"),
dest="inrepo",
default=None)
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitList.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitList.NAME))
parser.add_argument("repo",
nargs='+',
default=None,
metavar="<repo>",
help=_("repository"))
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=_('output more package info'))
parser.add_argument("--injected",
action="store_true",
default=self._injected,
help=_('only list injected packages'))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitNotice.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitNotice.NAME))
subparsers = parser.add_subparsers(
title="action", description=_("execute given action"),
help=_("available actions"))
add_parser = subparsers.add_parser("add",
help=_("add notice-board entry"))
add_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
add_parser.set_defaults(func=self._add)
remove_parser = subparsers.add_parser("remove",
help=_("remove notice-board entry"))
remove_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
remove_parser.set_defaults(func=self._remove)
show_parser = subparsers.add_parser("show",
help=_("show notice-board"))
show_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
show_parser.set_defaults(func=self._show)
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitLock.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], self._name))
parser.add_argument("repo",
nargs=1,
metavar="<repo>",
help=_("repository"))
group = parser.add_mutually_exclusive_group()
group.add_argument("--client",
action="store_true",
default=False,
help=_('affect entropy clients only'))
group.add_argument("--status",
action="store_true",
default=False,
help=_('show current status'))
parser.add_argument("--quiet",
"-q",
action="store_true",
default=self._quiet,
help=_('quiet output, for scripting purposes'))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(EitBranch.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitBranch.NAME))
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
parser.add_argument("branch",
nargs='?',
metavar="<branch>",
help=_("switch to given branch"))
parser.add_argument("repo",
nargs='?',
metavar="<repo>",
help=_("repository"))
parser.add_argument("--from",
metavar="<branch>",
help=_("from branch"),
dest="frombranch",
default=None)
parser.add_argument("--no-copy",
action="store_true",
default=not self._copy,
dest="nocopy",
help=_("don't copy packages from branch"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitBranch.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitBranch.NAME))
parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
parser.add_argument("branch", nargs='?',
metavar="<branch>",
help=_("switch to given branch"))
parser.add_argument("repo", nargs='?',
metavar="<repo>",
help=_("repository"))
parser.add_argument("--from", metavar="<branch>",
help=_("from branch"),
dest="frombranch", default=None)
parser.add_argument("--no-copy", action="store_true",
default=not self._copy, dest="nocopy",
help=_("don't copy packages from branch"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitTest.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitTest.NAME))
subparsers = parser.add_subparsers(
title="test", description=_("run given test"),
help=_("available tests"))
deps_parser = subparsers.add_parser("deps",
help=_("dependencies test"))
deps_parser.set_defaults(func=self._deptest)
libs_parser = subparsers.add_parser("libs",
help=_("libraries test"))
libs_parser.add_argument("--dump", action="store_true",
default=False, help=_("dump results to file"))
libs_parser.set_defaults(func=self._libtest)
links_parser = subparsers.add_parser("links",
help=_("library linking test (using repository metadata)"))
links_parser.add_argument("excllibs", nargs='*', default=None,
metavar="<excluded lib>",
help=_("excluded soname"))
links_parser.set_defaults(func=self._linktest)
pkglibs_parser = subparsers.add_parser("pkglibs",
help=_("library linking test (using live system)"))
pkglibs_parser.add_argument("packages", nargs='+', default=None,
metavar="<package>",
help=_("package names"))
pkglibs_parser.set_defaults(func=self._pkglibs)
pkgs_parser = subparsers.add_parser("local",
help=_("verify local packages integrity"))
pkgs_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
pkgs_parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
pkgs_parser.set_defaults(func=self._pkgtest)
rempkgs_parser = subparsers.add_parser("remote",
help=_("verify remote packages integrity"))
rempkgs_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
rempkgs_parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
rempkgs_parser.set_defaults(func=self._rem_pkgtest)
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitTest.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitTest.NAME))
subparsers = parser.add_subparsers(
title="test", description=_("run given test"),
help=_("available tests"))
deps_parser = subparsers.add_parser("deps",
help=_("dependencies test"))
deps_parser.set_defaults(func=self._deptest)
libs_parser = subparsers.add_parser("libs",
help=_("libraries test"))
libs_parser.add_argument("--dump", action="store_true",
default=False, help=_("dump results to file"))
libs_parser.set_defaults(func=self._libtest)
links_parser = subparsers.add_parser("links",
help=_("library linking test (using repository metadata)"))
links_parser.add_argument("excllibs", nargs='*', default=None,
metavar="<excluded lib>",
help=_("excluded soname"))
links_parser.set_defaults(func=self._linktest)
pkglibs_parser = subparsers.add_parser("pkglibs",
help=_("library linking test (using live system)"))
pkglibs_parser.add_argument("packages", nargs='+', default=None,
metavar="<package>",
help=_("package names"))
pkglibs_parser.set_defaults(func=self._pkglibs)
pkgs_parser = subparsers.add_parser("local",
help=_("verify local packages integrity"))
pkgs_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
pkgs_parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
pkgs_parser.set_defaults(func=self._pkgtest)
rempkgs_parser = subparsers.add_parser("remote",
help=_("verify remote packages integrity"))
rempkgs_parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
rempkgs_parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
rempkgs_parser.set_defaults(func=self._rem_pkgtest)
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitLog.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitLog.NAME))
parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitCheckout.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitCheckout.NAME))
parser.add_argument("repo", metavar="<repo>",
help=_("repository"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitRepo.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRepo.NAME))
subparsers = parser.add_subparsers(
title="action", description=_("manage repositories"),
help=_("available commands"))
show_parser = subparsers.add_parser(
"show", help=_("show repositories and mirrors status"))
show_parser.set_defaults(func=self._show)
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 uri>", required=True,
help=_("synchronization URI for both packages and database"))
add_parser.add_argument(
"--repo-only", nargs='*', default=[],
metavar="<database only uri>",
help=_("synchronization URI for database only"))
add_parser.add_argument(
"--pkg-only", nargs='*', default=[],
metavar="<packages only uri>",
help=_("synchronization URI for packages only"))
add_parser.add_argument(
"--base", action="store_true", default=None,
help=_("set this to make this repository the "
"'base' for all the others"))
add_parser.set_defaults(func=self._add)
remove_parser = subparsers.add_parser("remove",
help=_("remove a repository"))
remove_parser.add_argument(
"id", nargs='+',
metavar="<repository>",
help=_("repository name"))
remove_parser.set_defaults(func=self._remove)
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitRepo.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRepo.NAME))
subparsers = parser.add_subparsers(
title="action", description=_("manage repositories"),
help=_("available commands"))
show_parser = subparsers.add_parser(
"show", help=_("show repositories and mirrors status"))
show_parser.set_defaults(func=self._show)
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 uri>", required=True,
help=_("synchronization URI for both packages and database"))
add_parser.add_argument(
"--repo-only", nargs='*', default=[],
metavar="<database only uri>",
help=_("synchronization URI for database only"))
add_parser.add_argument(
"--pkg-only", nargs='*', default=[],
metavar="<packages only uri>",
help=_("synchronization URI for packages only"))
add_parser.add_argument(
"--base", action="store_true", default=None,
help=_("set this to make this repository the "
"'base' for all the others"))
add_parser.set_defaults(func=self._add)
remove_parser = subparsers.add_parser("remove",
help=_("remove a repository"))
remove_parser.add_argument(
"id", nargs='+',
metavar="<repository>",
help=_("repository name"))
remove_parser.set_defaults(func=self._remove)
return parser
def _get_parser(self):
""" Overridden from EitInit """
descriptor = EitCommandDescriptor.obtain_descriptor(EitInit.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitInit.NAME),
)
parser.add_argument("repo", nargs=1, default=None, metavar="<repo>", help=_("repository"))
parser.add_argument("--quick", action="store_true", default=not self._ask, help=_("no stupid questions"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitStatus.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitStatus.NAME))
parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitFiles.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitFiles.NAME),
)
parser.add_argument("packages", nargs="+", metavar="<package>", help=_("package names"))
parser.add_argument(
"--quiet", "-q", action="store_true", default=self._quiet, help=_("quiet output, for scripting purposes")
)
return parser
def _get_parser(self):
""" Overridden from EitCommit """
descriptor = EitCommandDescriptor.obtain_descriptor(EitRepack.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRepack.NAME),
)
parser.add_argument("packages", nargs="+", metavar="<package>", help=_("package names"))
parser.add_argument(
"--in", metavar="<repository>", help=_("repack to given repository"), default=None, dest="into"
)
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitDeps.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitDeps.NAME))
parser.add_argument("packages", nargs='+', metavar="<package>",
help=_("package name"))
parser.add_argument("--in", metavar="<repository>",
help=_("inject into given repository"),
dest="inrepo", default=None)
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitBump.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitBump.NAME))
parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
parser.add_argument("--sync", action="store_true",
default=self._sync,
help=_("sync with remote repository"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitInject.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitInject.NAME))
parser.add_argument("packages",
nargs='+',
metavar="<path>",
help=_("package paths"))
parser.add_argument("--to",
metavar="<repository>",
help=_("inject into given repository"),
default=None)
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitInject.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitInject.NAME))
parser.add_argument("packages", nargs='+', metavar="<path>",
help=_("package paths"))
parser.add_argument("--to", metavar="<repository>",
help=_("inject into given repository"),
default=None)
parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(EitFiles.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitFiles.NAME))
parser.add_argument("packages",
nargs='+',
metavar="<package>",
help=_("package names"))
parser.add_argument("--quiet",
"-q",
action="store_true",
default=self._quiet,
help=_('quiet output, for scripting purposes'))
return parser
def _get_parser(self):
""" Overridden from EitCommit """
descriptor = EitCommandDescriptor.obtain_descriptor(EitRepack.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRepack.NAME))
parser.add_argument("packages",
nargs='+',
metavar="<package>",
help=_("package names"))
parser.add_argument("--in",
metavar="<repository>",
help=_("repack to given repository"),
default=None,
dest="into")
return parser
def _get_parser(self):
""" Overridden from EitCommit """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitMerge.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitMerge.NAME))
parser.add_argument("branch", metavar="<branch>",
help=_("repository branch"))
parser.add_argument("--in", metavar="<repository>",
help=_("work inside given repository"),
default=None, dest="into")
parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
""" Overridden from EitInit """
descriptor = EitCommandDescriptor.obtain_descriptor(EitInit.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitInit.NAME))
parser.add_argument("repo",
nargs=1,
default=None,
metavar="<repo>",
help=_("repository"))
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitSearch.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitSearch.NAME))
parser.add_argument("packages", nargs='+', metavar="<package>",
help=_("package name"))
parser.add_argument("--in", metavar="<repository>",
help=_("search packages in given repository"),
dest="inrepo", default=None)
parser.add_argument("--quiet", "-q", action="store_true",
default=self._quiet,
help=_('quiet output, for scripting purposes'))
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(EitNotice.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitNotice.NAME))
subparsers = parser.add_subparsers(
title="action",
description=_("execute given action"),
help=_("available actions"))
add_parser = subparsers.add_parser("add",
help=_("add notice-board entry"))
add_parser.add_argument("repo",
nargs='?',
default=None,
metavar="<repo>",
help=_("repository"))
add_parser.set_defaults(func=self._add)
remove_parser = subparsers.add_parser(
"remove", help=_("remove notice-board entry"))
remove_parser.add_argument("repo",
nargs='?',
default=None,
metavar="<repo>",
help=_("repository"))
remove_parser.set_defaults(func=self._remove)
show_parser = subparsers.add_parser("show",
help=_("show notice-board"))
show_parser.add_argument("repo",
nargs='?',
default=None,
metavar="<repo>",
help=_("repository"))
show_parser.set_defaults(func=self._show)
return parser
def _get_parser(self):
""" Overridden from EitCommand """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitCleanup.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitCleanup.NAME))
parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
parser.add_argument("--quick", action="store_true",
default=False,
help=_("no stupid questions"))
parser.add_argument("--pretend", action="store_true",
default=False,
help=_("show what would be done"))
parser.add_argument('--days', type=int, default=self._days,
help=_("expired since how many days"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitList.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitList.NAME))
parser.add_argument("repo", nargs='+', default=None,
metavar="<repo>", help=_("repository"))
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=_('output more package info'))
parser.add_argument("--injected", action="store_true",
default=self._injected,
help=_('only list injected packages'))
return parser
def _show_help(self, *args):
parser = argparse.ArgumentParser(
description=_("Entropy Infrastructure Toolkit"),
epilog="http://www.sabayon.org",
formatter_class=ColorfulFormatter)
descriptors = EitCommandDescriptor.obtain()
descriptors.sort(key=lambda x: x.get_name())
group = parser.add_argument_group("command", "available commands")
for descriptor in descriptors:
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 _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitRemove.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitRemove.NAME))
parser.add_argument("packages", nargs='+', metavar="<package>",
help=_("package name"))
parser.add_argument("--from", metavar="<repository>",
help=_("remove from given repository"),
dest="fromrepo", default=None)
parser.add_argument("--nodeps", action="store_true",
help=_("do not include reverse dependencies"),
dest="nodeps", default=self._nodeps)
parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitCommit.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitCommit.NAME))
parser.add_argument("repo", nargs='?', default=None,
metavar="<repo>", help=_("repository"))
parser.add_argument("--conservative", action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--interactive", action="store_true",
default=False,
help=_("selectively pick changes"))
parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
""" Overridden from EitCommit """
descriptor = EitCommandDescriptor.obtain_descriptor(
EitAdd.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitAdd.NAME))
parser.add_argument("packages", nargs='+', metavar="<package>",
help=_("package names"))
parser.add_argument("--conservative", action="store_true",
help=_("do not execute implicit package name "
"and slot updates"),
default=self._conservative)
parser.add_argument("--to", metavar="<repository>",
help=_("add to given repository"),
default=None)
parser.add_argument("--quick", action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _get_parser(self):
""" Overridden from EitCommit """
descriptor = EitCommandDescriptor.obtain_descriptor(EitMerge.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], EitMerge.NAME))
parser.add_argument("branch",
metavar="<branch>",
help=_("repository branch"))
parser.add_argument("--in",
metavar="<repository>",
help=_("work inside given repository"),
default=None,
dest="into")
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def _show_help(self, *args):
parser = argparse.ArgumentParser(
description=_("Entropy Infrastructure Toolkit"),
epilog="http://www.sabayon.org",
formatter_class=ColorfulFormatter)
descriptors = EitCommandDescriptor.obtain()
descriptors.sort(key = lambda x: x.get_name())
group = parser.add_argument_group("command", "available commands")
for descriptor in descriptors:
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 _get_parser(self):
descriptor = EitCommandDescriptor.obtain_descriptor(
EitLock.NAME)
parser = argparse.ArgumentParser(
description=descriptor.get_description(),
formatter_class=argparse.RawDescriptionHelpFormatter,
prog="%s %s" % (sys.argv[0], self._name))
parser.add_argument("repo", nargs=1, metavar="<repo>",
help=_("repository"))
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--client", action="store_true", default=False,
help=_('affect entropy clients only'))
group.add_argument(
"--status", action="store_true", default=False,
help=_('show current status'))
parser.add_argument("--quiet", "-q", action="store_true",
default=self._quiet,
help=_('quiet output, for scripting purposes'))
return parser
(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
EitCommandDescriptor.register(
EitCommandDescriptor(
EitCp,
EitCp.NAME,
_('copy packages from a repository to another'))
)
except (OSError) as err:
if err.errno != errno.ENOENT:
raise
# write new actions
actions_meta = []
# time is completely fake, no particular precision required
for unix_time, action in new_actions:
# make sure unix_time has final .XX
if "." not in unix_time:
unix_time += ".00"
elif unix_time.index(".") == (len(unix_time) - 2):
# only .X and not .XX
unix_time += "0"
actions_meta.append((action, branch, unix_time))
repo.removeTreeUpdatesActions(self._repository_id)
try:
repo.insertTreeUpdatesActions(actions_meta, self._repository_id)
except Exception as err:
repo.rollback()
raise
repo.commit()
return 0
EitCommandDescriptor.register(
EitCommandDescriptor(EitPkgmove, EitPkgmove.NAME,
_('edit automatic package moves for repository')))
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)
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
EitCommandDescriptor.register(
EitCommandDescriptor(EitInject, EitInject.NAME,
_('inject package files into repository')))
nsargs = parser.parse_args(self._args)
except IOError:
return parser.print_help, []
self._quiet = nsargs.quiet
self._packages += nsargs.packages
self._complete = nsargs.complete
self._repository_id = nsargs.inrepo
return self._call_shared, [self._revgraph, self._repository_id]
def _revgraph(self, entropy_server):
"""
Actual Eit revgraph code.
"""
if self._repository_id is None:
repository_ids = entropy_server.repositories()
else:
repository_ids = [self._repository_id]
return revgraph_packages(
self._packages, entropy_server,
complete = self._complete,
repository_ids = repository_ids, quiet = self._quiet)
EitCommandDescriptor.register(
EitCommandDescriptor(
EitRevgraph,
EitRevgraph.NAME,
_('show reverse dependency graph for packages'))
)
"""
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
EitCommandDescriptor.register(EitCommandDescriptor(EitFiles, EitFiles.NAME, _("show files owned by packages")))
to_be_added = set(map(pkg_filter, self._packages))
to_be_added.discard(None)
if not (to_be_removed or to_be_added or to_be_injected):
entropy_server.output(red(_("Zarro thinggz to do")),
header=brown(" * "),
importance=1)
return 0
exit_st = 0
if to_be_injected:
injected_s = sorted(to_be_injected, key=key_sorter)
self._inject_packages(entropy_server, injected_s)
if to_be_removed:
removed_s = sorted(to_be_removed, key=key_sorter)
self._remove_packages(entropy_server, removed_s)
if to_be_added:
# drop spm_uid, no longer needed
added_s = sorted(to_be_added)
exit_st = self._add_packages(entropy_server, repository_id,
added_s)
return exit_st
EitCommandDescriptor.register(
EitCommandDescriptor(EitCommit, EitCommit.NAME,
_("commit changes to repository")))
"and slot updates"),
default=self._conservative)
parser.add_argument("--to",
metavar="<repository>",
help=_("add to given repository"),
default=None)
parser.add_argument("--quick",
action="store_true",
default=not self._ask,
help=_("no stupid questions"))
return parser
def parse(self):
""" Overridden from EitCommit """
parser = self._get_parser()
try:
nsargs = parser.parse_args(self._args)
except IOError as err:
return parser.print_help, []
# setup atoms variable before spawning commit
self._ask = not nsargs.quick
self._entropy_class()._inhibit_treeupdates = nsargs.conservative
self._packages = nsargs.packages[:]
return self._call_exclusive, [self._commit, nsargs.to]
EitCommandDescriptor.register(
EitCommandDescriptor(EitAdd, EitAdd.NAME,
_('commit to repository the provided packages')))
level="warning")
entropy_server.output(
purple(_("Users with older repositories will have to update")),
importance=1,
level="warning")
entropy_server.output("", level="warning")
repository_id = entropy_server.repository()
entropy_server.Mirrors.tidy_mirrors(
repository_id, ask = self._ask,
pretend = self._pretend, expiration_days = self._days)
return 0
EitCommandDescriptor.register(
EitCommandDescriptor(
EitCleanup,
EitCleanup.NAME,
_('clean expired packages from a repository'))
)
class EitVacuum(EitCleanup):
"""
Main Eit vacuum command (kept for backward compat).
"""
NAME = "vacuum"
ALIASES = []
def __init__(self, args):
EitCleanup.__init__(self, args)
# default is 0 here
self._days = 0
repository_id = entropy_server.repository()
if repository_id not in entropy_server.repositories():
entropy_server.output(
"%s: %s" % (
purple(_("Invalid repository")),
teal(repository_id)),
importance=1, level="error")
return 1
fine, failed, dl_fine, dl_err = \
entropy_server._verify_local_packages(
repository_id, [], ask = not self._nsargs.quick)
if failed:
return 1
return 0
def _rem_pkgtest(self, entropy_server):
repository_id = self._nsargs.repo
if repository_id is None:
repository_id = entropy_server.repository()
entropy_server._verify_remote_packages(repository_id, [],
ask = self._ask)
return 0
EitCommandDescriptor.register(
EitCommandDescriptor(
EitTest,
EitTest.NAME,
_('run QA tests'))
)
"""
count = 0
for package in self._packages:
pkg_id, pkg_repo = entropy_server.atom_match(package)
if pkg_id == -1:
continue
count += 1
print_package_info(
pkg_id,
entropy_server,
entropy_server.open_repository(pkg_repo),
installed_search = True,
extended = True,
quiet = self._quiet
)
if not count and not self._quiet:
entropy_server.output(
purple(_("Nothing found")),
importance=1, level="warning")
return 0
EitCommandDescriptor.register(
EitCommandDescriptor(
EitMatch,
EitMatch.NAME,
_('match packages in repositories'))
)
switched, already_switched, ignored, \
not_found, no_checksum = status
if not_found or no_checksum:
return 1
return 0
def _status(self, entropy_server):
"""
Show branch information (list of branches, current branch)
"""
repository_id = entropy_server.repository()
branch_dir = entropy_server._get_local_repository_dir(repository_id,
branch="")
branches = []
if os.path.isdir(branch_dir):
branches += [x for x in os.listdir(branch_dir) if \
os.path.isdir(os.path.join(branch_dir, x))]
current_branch = self._settings()['repositories']['branch']
branches.sort()
for branch in branches:
cur_txt = ""
if branch == current_branch:
cur_txt = purple("*") + " "
entropy_server.output("%s%s" % (cur_txt, branch))
return 0
EitCommandDescriptor.register(
EitCommandDescriptor(EitBranch, EitBranch.NAME,
_('manage repository branches')))
