class Analyse(ModuleBase):
"""Installed db analysis tool to query the installed databse
and produce/output stats for USE flags or keywords/mask.
The 'rebuild' action output is in the form suitable for file type output
to create a new package.use, package.keywords, package.unmask
type files in the event of needing to rebuild the
/etc/portage/* user configs
"""
def __init__(self):
ModuleBase.__init__(self)
self.command_name = "enalyze"
self.module_name = "analyze"
self.options = {
"flags": False,
"keywords": False,
"packages": False,
"unset": False,
"verbose": False,
"quiet": False,
'prefix': False,
'portage': True,
"width": 80,
"prepend": "",
}
self.module_opts = {
"-f": ("flags", "boolean", True),
"--flags": ("flags", "boolean", True),
"-k": ("keywords", "boolean", True),
"--keywords": ("keywords", "boolean", True),
"-u": ("unset", "boolean", True),
"--unset": ("unset", "boolean", True),
"-v": ("verbose", "boolean", True),
"--verbose": ("verbose", "boolean", True),
"-p": ("prefix", "boolean", True),
"--prefix": ("prefix", "boolean", True),
"-P": ("prepend", "char", None),
"--prepend": ("prepend", "char", None),
"-G": ("portage", "boolean", False),
"--portage": ("portage", "boolean", False),
"-W": ("width", "int", 80),
"--width": ("width", "int", 80),
}
self.formatted_options = [
(" -h, --help", "Outputs this useage message"),
(" -u, --unset",
"Additionally include any unset USE flags and the packages"),
("", "that could use them"),
(" -v, --verbose",
"Used in the analyze action to output more detailed information"),
(" -p, --prefix",
"Used for testing purposes only, runs report using " +
"a prefix keyword and 'prefix' USE flag"),
(" -P, --prepend",
"Prepend the string to any list output. " +
"ie: prepend '* ' to the ""front of each package being listed."
"This is useful for generating preformatted wiki text."),
#(" -G, --portage",
#"Use portage directly instead of gentoolkit's Package " +
#"object for some operations. Usually a little faster."),
(" -W, --width",
"Format the output to wrap at 'WIDTH' ie: long line output"),
]
self.formatted_args = [
(" use",
"Causes the action to analyze the installed packages USE flags"),
(" pkguse",
"Causes the action to analyze the installed packages PKGUSE flags"),
(" ",
"These are flags that have been set in /etc/portage/package.use"),
(" keywords",
"Causes the action to analyze the installed packages keywords"),
(" packages",
"Causes the action to analyze the installed packages and the"),
(" ",
"USE flags they were installed with"),
(" unmask",
"Causes the action to analyze the installed packages"),
(" ",
"for those that need to be unmasked")
]
self.short_opts = "huvpGP:W:"
self.long_opts = ("help", "unset", "verbose", "prefix", "prepend=",
"width=") #, "portage")
self.need_queries = True
self.arg_spec = "Target"
self.arg_options = ['use', 'pkguse','keywords', 'packages', 'unmask']
self.arg_option = False
self.warning = (
" CAUTION",
"This is beta software and some features/options are incomplete,",
"some features may change in future releases includig its name.",
"Feedback will be appreciated, http://bugs.gentoo.org")
def run(self, input_args, quiet=False):
"""runs the module
@param input_args: input arguments to be parsed
"""
query = self.main_setup(input_args)
query = self.validate_query(query)
self.set_quiet(quiet)
if query in ["use", "pkguse"]:
self.analyse_flags(query)
elif query in ["keywords"]:
self.analyse_keywords()
elif query in ["packages"]:
self.analyse_packages()
elif query in ["unmask"]:
self.analyse_unmask()
def analyse_flags(self, target):
"""This will scan the installed packages db and analyze the
USE flags used for installation and produce a report on how
they were used.
@type target: string
@param target: the target to be analyzed, one of ["use", "pkguse"]
"""
system_use = portage.settings["USE"].split()
self.printer = AnalysisPrinter(
"use",
self.options["verbose"],
system_use,
width=self.options["width"],
prepend=self.options["prepend"])
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#cpvs = get_installed_cpvs()
#print "Total number of installed ebuilds =", len(cpvs)
flag_users = gather_flags_info(cpvs, system_use,
self.options["unset"], target=target.upper(),
use_portage=self.options['portage'])
else:
cpvs = get_installed_cpvs()
flag_users = gather_flags_info(cpvs, system_flags=system_use,
include_unset=self.options["unset"], target=target.upper(),
use_portage=self.options['portage'])
#print flag_users
flag_keys = sorted(flag_users)
if self.options["verbose"]:
print(" Flag System #pkgs cat/pkg-ver")
#blankline = nl
elif not self.options['quiet']:
print(" Flag System #pkgs")
#blankline = lambda: None
for flag in flag_keys:
flag_pos = flag_users[flag]["+"]
if len(flag_pos):
self.printer(flag, "+", flag_pos)
#blankline()
flag_neg = flag_users[flag]["-"]
if len(flag_neg):
self.printer(flag, "-", flag_neg)
#blankline()
if "unset" in flag_users[flag] and flag_users[flag]["unset"]:
flag_unset = flag_users[flag]["unset"]
self.printer(flag, "unset", flag_unset)
#blankline()
if not self.options['quiet']:
print("===================================================")
print("Total number of flags in report =",
pp.output.red(str(len(flag_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len([x for x in cpvs]))))
print()
def analyse_keywords(self, keywords=None):
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
print()
system_keywords = portage.settings["ACCEPT_KEYWORDS"]
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
system_keywords = system_keywords.split()
self.printer = AnalysisPrinter(
"keywords",
self.options["verbose"],
system_keywords,
width=self.options["width"],
prepend=self.options["prepend"])
self.analyser = KeywordAnalyser( arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
#self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options['prefix'] and 'prefix' not in test_use:
print("ANALYSE_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing")
print()
test_use.append('prefix')
self.analyser.set_order(test_use)
# /end testing
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#print "Total number of installed ebuilds =", len(cpvs)
keyword_users = gather_keywords_info(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options['portage'],
keywords=keywords, analyser = self.analyser
)
blankline = nl
else:
keyword_users = gather_keywords_info(
system_keywords=system_keywords,
use_portage=self.options['portage'],
keywords=keywords,
analyser = self.analyser
)
blankline = lambda: None
#print keyword_users
keyword_keys = sorted(keyword_users)
if self.options["verbose"]:
print(" Keyword System #pkgs cat/pkg-ver")
elif not self.options['quiet']:
print(" Keyword System #pkgs")
for keyword in keyword_keys:
kwd_stable = keyword_users[keyword]["stable"]
if len(kwd_stable):
self.printer(keyword, " ", kwd_stable)
blankline()
kwd_testing = keyword_users[keyword]["testing"]
if len(kwd_testing):
self.printer(keyword, "~", kwd_testing)
blankline()
kwd_missing = keyword_users[keyword]["missing"]
if len(kwd_missing):
self.printer(keyword, "-", kwd_missing)
blankline
if not self.options['quiet']:
if self.analyser.mismatched:
print("_________________________________________________")
print(("The following packages were found to have a \n" +
"different recorded ARCH than the current system ARCH"))
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of keywords in report =",
pp.output.red(str(len(keyword_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len(cpvs))))
print()
def analyse_packages(self):
"""This will scan the installed packages db and analyze the
USE flags used for installation and produce a report.
@type target: string
@param target: the target to be analyzed, one of ["use", "pkguse"]
"""
system_use = portage.settings["USE"].split()
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
key_width = 45
else:
cpvs = get_installed_cpvs()
key_width = 1
self.printer = AnalysisPrinter(
"packages",
self.options["verbose"],
key_width=key_width,
width=self.options["width"],
prepend=self.options["prepend"])
cpvs = sorted(cpvs)
flags = FlagAnalyzer(
system=system_use,
filter_defaults=False,
target="USE"
)
if self.options["verbose"]:
print(" cat/pkg-ver USE Flags")
# "app-emulation/emul-linux-x86-sdl-20100915 ...."
#blankline = nl
elif not self.options['quiet']:
print(" cat/pkg-ver USE Flags")
#blankline = lambda: None
for cpv in cpvs:
(flag_plus, flag_neg, unset) = flags.analyse_cpv(cpv)
if self.options["unset"]:
self.printer(cpv, "", (sorted(flag_plus), sorted(flag_neg),
sorted(unset)))
else:
self.printer(cpv, "", (sorted(flag_plus), sorted(flag_neg), []))
if not self.options['quiet']:
print("===================================================")
print("Total number of installed ebuilds =",
pp.output.red(str(len([x for x in cpvs]))))
print()
def analyse_unmask(self):
"""This will scan the installed packages db and analyze the
unmasking used for installation and produce a report on them.
"""
self.not_implemented("unmask")
class Rebuild(ModuleBase):
"""Installed db analysis tool to query the installed databse
and produce/output stats for USE flags or keywords/mask.
The 'rebuild' action output is in the form suitable for file type output
to create a new package.use, package.keywords, package.unmask
type files in the event of needing to rebuild the
/etc/portage/* user configs
"""
def __init__(self):
ModuleBase.__init__(self)
self.command_name = "enalyze"
self.module_name = "rebuild"
self.options = {
"use": False,
"keywords": False,
"unmask": False,
"verbose": False,
"quiet": False,
"exact": False,
"pretend": False,
"prefix": False,
"portage": True,
"slot": False
#"unset": False
}
self.module_opts = {
"-p": ("pretend", "boolean", True),
"--pretend": ("pretend", "boolean", True),
"-e": ("exact", "boolean", True),
"--exact": ("exact", "boolean", True),
"-s": ("slot", "boolean", True),
"--slot": ("slot", "boolean", True),
"-v": ("verbose", "boolean", True),
"--verbose": ("verbose", "boolean", True),
}
self.formatted_options = [
(" -h, --help", "Outputs this useage message"),
(" -p, --pretend", "Does not actually create the files."),
(" ", "It directs the outputs to the screen"),
(" -e, --exact", "will atomize the package with a"),
(" ", "leading '=' and include the version"),
(" -s, --slot", "will atomize the package with a"),
(" ", "leading '=' and include the slot")
]
self.formatted_args = [
(" use",
"causes the action to analyze the installed packages USE flags"),
(" keywords",
"causes the action to analyze the installed packages keywords"),
(" unmask",
"causes the action to analyze the installed packages " + \
"current mask status")
]
self.short_opts = "hepsv"
self.long_opts = ("help", "exact", "pretend", "slot", "verbose")
self.need_queries = True
self.arg_spec = "TargetSpec"
self.arg_options = ['use', 'keywords', 'unmask']
self.arg_option = False
self.warning = (
" CAUTION",
"This is beta software and some features/options are incomplete,",
"some features may change in future releases includig its name.",
"The file generated is saved in your home directory",
"Feedback will be appreciated, http://bugs.gentoo.org")
def run(self, input_args, quiet=False):
"""runs the module
@param input_args: input arguments to be parsed
"""
self.options['quiet'] = quiet
query = self.main_setup(input_args)
query = self.validate_query(query)
if query in ["use"]:
self.rebuild_use()
elif query in ["keywords"]:
self.rebuild_keywords()
elif query in ["unmask"]:
self.rebuild_unmask()
def rebuild_use(self):
if not self.options["quiet"]:
print()
print(" -- Scanning installed packages for USE flag settings that")
print(" do not match the default settings")
system_use = portage.settings["USE"].split()
output = RebuildPrinter(
"use", self.options["pretend"], self.options["exact"],
self.options['slot'])
pkgs, cp_counts = cpv_all_diff_use(system_flags=system_use)
pkg_count = len(pkgs)
if self.options["verbose"]:
print()
print((pp.emph(" -- Found ") + pp.number(str(pkg_count)) +
pp.emph(" packages that need entries")))
#print pp.emph(" package.use to maintain their current setting")
pkg_keys = []
if pkgs:
pkg_keys = sorted(pkgs)
#print len(pkgs)
if self.options["pretend"] and not self.options["quiet"]:
print()
print(pp.globaloption(
" -- These are the installed packages & use flags " +
"that were detected"))
print(pp.globaloption(" to need use flag settings other " +
"than the defaults."))
print()
elif not self.options["quiet"]:
print(" -- preparing pkgs for file entries")
for pkg in pkg_keys:
output(pkg, pkgs[pkg], cp_counts[pkg])
if self.options['verbose']:
message = (pp.emph(" ") +
pp.number(str(pkg_count)) +
pp.emph(" different packages"))
print()
print(pp.globaloption(" -- Totals"))
print(message)
#print
#unique = list(unique_flags)
#unique.sort()
#print unique
if not self.options["pretend"]:
filepath = os.path.expanduser('~/package.use.test')
self.save_file(filepath, output.lines)
def rebuild_keywords(self):
#print("Module action not yet available")
#print()
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
system_keywords = portage.settings["ACCEPT_KEYWORDS"].split()
output = RebuildPrinter(
"keywords", self.options["pretend"], self.options["exact"],
self.options['slot'])
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
self.analyser = KeywordAnalyser( arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
#self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options['prefix'] and 'prefix' not in test_use:
print("REBUILD_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing")
print()
test_use.append('prefix')
self.analyser.set_order(test_use)
# /end testing
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#print "Total number of installed ebuilds =", len(cpvs)
pkgs, cp_counts = cpv_all_diff_keywords(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options['portage'],
analyser = self.analyser
)
#print([pkgs[p][0].cpv for p in pkgs])
pkg_keys = []
if pkgs:
pkg_keys = sorted(pkgs)
#print(len(pkgs))
if self.options["pretend"] and not self.options["quiet"]:
print()
print(pp.globaloption(
" -- These are the installed packages & keywords " +
"that were detected"))
print(pp.globaloption(" to need keyword settings other " +
"than the defaults."))
print()
elif not self.options["quiet"]:
print(" -- preparing pkgs for file entries")
for pkg in pkg_keys:
output(pkg, pkgs[pkg], cp_counts[pkg])
if not self.options['quiet']:
if self.analyser.mismatched:
print("_________________________________________________")
print(("The following packages were found to have a \n" +
"different recorded ARCH than the current system ARCH"))
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of entries in report =",
pp.output.red(str(len(pkg_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len(cpvs))))
print()
if not self.options["pretend"]:
filepath = os.path.expanduser('~/package.keywords.test')
self.save_file(filepath, output.lines)
def rebuild_unmask(self):
self.not_implemented("unmask")
def save_file(self, filepath, data):
"""Writes the data to the file determined by filepath
@param filepath: string. eg. '/path/to/filename'
@param data: list of lines to write to filepath
"""
if not self.options["quiet"]:
print(' - Saving file: %s' %filepath)
with open(_unicode_encode(filepath, encoding=_encodings['fs']), mode="w",
encoding=_encodings['content']) as output:
output.write('\n'.join(data))
print(" - Done")
class Rebuild(ModuleBase):
"""Installed db analysis tool to query the installed databse
and produce/output stats for USE flags or keywords/mask.
The 'rebuild' action output is in the form suitable for file type output
to create a new package.use, package.keywords, package.unmask
type files in the event of needing to rebuild the
/etc/portage/* user configs
"""
def __init__(self):
ModuleBase.__init__(self)
self.command_name = "enalyze"
self.module_name = "rebuild"
self.options = {
"use": False,
"keywords": False,
"unmask": False,
"verbose": False,
"quiet": False,
"exact": False,
"pretend": False,
"prefix": False,
"portage": True,
"slot": False
# "unset": False
}
self.module_opts = {
"-p": ("pretend", "boolean", True),
"--pretend": ("pretend", "boolean", True),
"-e": ("exact", "boolean", True),
"--exact": ("exact", "boolean", True),
"-s": ("slot", "boolean", True),
"--slot": ("slot", "boolean", True),
"-v": ("verbose", "boolean", True),
"--verbose": ("verbose", "boolean", True),
}
self.formatted_options = [
(" -h, --help", "Outputs this useage message"),
(" -p, --pretend", "Does not actually create the files."),
(" ", "It directs the outputs to the screen"),
(" -e, --exact", "will atomize the package with a"),
(" ", "leading '=' and include the version"),
(" -s, --slot", "will atomize the package with a"),
(" ", "leading '=' and include the slot"),
]
self.formatted_args = [
(
" use",
"causes the action to analyze the installed packages USE flags",
),
(
" keywords",
"causes the action to analyze the installed packages keywords",
),
(
" unmask",
"causes the action to analyze the installed packages "
+ "current mask status",
),
]
self.short_opts = "hepsv"
self.long_opts = ("help", "exact", "pretend", "slot", "verbose")
self.need_queries = True
self.arg_spec = "TargetSpec"
self.arg_options = ["use", "keywords", "unmask"]
self.arg_option = False
self.warning = (
" CAUTION",
"This is beta software and some features/options are incomplete,",
"some features may change in future releases includig its name.",
"The file generated is saved in your home directory",
"Feedback will be appreciated, http://bugs.gentoo.org",
)
def run(self, input_args, quiet=False):
"""runs the module
@param input_args: input arguments to be parsed
"""
self.options["quiet"] = quiet
query = self.main_setup(input_args)
query = self.validate_query(query)
if query in ["use"]:
self.rebuild_use()
elif query in ["keywords"]:
self.rebuild_keywords()
elif query in ["unmask"]:
self.rebuild_unmask()
def rebuild_use(self):
if not self.options["quiet"]:
print()
print(" -- Scanning installed packages for USE flag settings that")
print(" do not match the default settings")
system_use = portage.settings["USE"].split()
output = RebuildPrinter(
"use", self.options["pretend"], self.options["exact"], self.options["slot"]
)
pkgs, cp_counts = cpv_all_diff_use(system_flags=system_use)
pkg_count = len(pkgs)
if self.options["verbose"]:
print()
print(
(
pp.emph(" -- Found ")
+ pp.number(str(pkg_count))
+ pp.emph(" packages that need entries")
)
)
# print pp.emph(" package.use to maintain their current setting")
pkg_keys = []
if pkgs:
pkg_keys = sorted(pkgs)
# print len(pkgs)
if self.options["pretend"] and not self.options["quiet"]:
print()
print(
pp.globaloption(
" -- These are the installed packages & use flags "
+ "that were detected"
)
)
print(
pp.globaloption(
" to need use flag settings other " + "than the defaults."
)
)
print()
elif not self.options["quiet"]:
print(" -- preparing pkgs for file entries")
for pkg in pkg_keys:
output(pkg, pkgs[pkg], cp_counts[pkg])
if self.options["verbose"]:
message = (
pp.emph(" ")
+ pp.number(str(pkg_count))
+ pp.emph(" different packages")
)
print()
print(pp.globaloption(" -- Totals"))
print(message)
# print
# unique = list(unique_flags)
# unique.sort()
# print unique
if not self.options["pretend"]:
filepath = os.path.expanduser("~/package.use.test")
self.save_file(filepath, output.lines)
def rebuild_keywords(self):
# print("Module action not yet available")
# print()
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
system_keywords = portage.settings["ACCEPT_KEYWORDS"].split()
output = RebuildPrinter(
"keywords",
self.options["pretend"],
self.options["exact"],
self.options["slot"],
)
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
self.analyser = KeywordAnalyser(
arch, system_keywords, portage.db[portage.root]["vartree"].dbapi
)
# self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options["prefix"] and "prefix" not in test_use:
print(
"REBUILD_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing",
)
print()
test_use.append("prefix")
self.analyser.set_order(test_use)
# /end testing
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
# print "Total number of installed ebuilds =", len(cpvs)
pkgs, cp_counts = cpv_all_diff_keywords(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options["portage"],
analyser=self.analyser,
)
# print([pkgs[p][0].cpv for p in pkgs])
pkg_keys = []
if pkgs:
pkg_keys = sorted(pkgs)
# print(len(pkgs))
if self.options["pretend"] and not self.options["quiet"]:
print()
print(
pp.globaloption(
" -- These are the installed packages & keywords "
+ "that were detected"
)
)
print(
pp.globaloption(
" to need keyword settings other " + "than the defaults."
)
)
print()
elif not self.options["quiet"]:
print(" -- preparing pkgs for file entries")
for pkg in pkg_keys:
output(pkg, pkgs[pkg], cp_counts[pkg])
if not self.options["quiet"]:
if self.analyser.mismatched:
print("_________________________________________________")
print(
(
"The following packages were found to have a \n"
+ "different recorded ARCH than the current system ARCH"
)
)
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print(
"Total number of entries in report =", pp.output.red(str(len(pkg_keys)))
)
if self.options["verbose"]:
print(
"Total number of installed ebuilds =", pp.output.red(str(len(cpvs)))
)
print()
if not self.options["pretend"]:
filepath = os.path.expanduser("~/package.keywords.test")
self.save_file(filepath, output.lines)
def rebuild_unmask(self):
self.not_implemented("unmask")
def save_file(self, filepath, data):
"""Writes the data to the file determined by filepath
@param filepath: string. eg. '/path/to/filename'
@param data: list of lines to write to filepath
"""
if not self.options["quiet"]:
print(" - Saving file: %s" % filepath)
with open(
_unicode_encode(filepath, encoding=_encodings["fs"]),
mode="w",
encoding=_encodings["content"],
) as output:
output.write("\n".join(data))
print(" - Done")
class Analyse(ModuleBase):
"""Installed db analysis tool to query the installed databse
and produce/output stats for USE flags or keywords/mask.
The 'rebuild' action output is in the form suitable for file type output
to create a new package.use, package.keywords, package.unmask
type files in the event of needing to rebuild the
/etc/portage/* user configs
"""
def __init__(self):
ModuleBase.__init__(self)
self.command_name = "enalyze"
self.module_name = "analyze"
self.options = {
"flags": False,
"keywords": False,
"packages": False,
"unset": False,
"verbose": False,
"quiet": False,
"prefix": False,
"portage": True,
}
self.module_opts = {
"-f": ("flags", "boolean", True),
"--flags": ("flags", "boolean", True),
"-k": ("keywords", "boolean", True),
"--keywords": ("keywords", "boolean", True),
"-u": ("unset", "boolean", True),
"--unset": ("unset", "boolean", True),
"-v": ("verbose", "boolean", True),
"--verbose": ("verbose", "boolean", True),
"-p": ("prefix", "boolean", True),
"--prefix": ("prefix", "boolean", True),
"-G": ("portage", "boolean", False),
"--portage": ("portage", "boolean", False),
}
self.formatted_options = [
(" -h, --help", "Outputs this useage message"),
(" -a, --analyze", "Action, sets the module to gather data and output the"),
("", "formatted stats/information to the screen"),
(" -u, --unset", "Additionally include any unset USE flags and the packages"),
("", "that could use them"),
(" -v, --verbose", "Used in the analyze action to output more detailed information"),
(
" -p, --prefix",
"Used for testing purposes only, runs report using " + "a prefix keyword and 'prefix' USE flag",
),
# (" -G, --portage",
# "Use portage directly instead of gentoolkit's Package " +
# "object for some operations. Usually a little faster."),
]
self.formatted_args = [
(" use", "Causes the action to analyze the installed packages USE flags"),
(" pkguse", "Causes the action to analyze the installed packages PKGUSE flags"),
(" ", "These are flags that have been set in /etc/portage/package.use"),
(" keywords", "Causes the action to analyze the installed packages keywords"),
(" packages", "Causes the action to analyze the installed packages and the"),
(" ", "USE flags they were installed with"),
(" unmask", "Causes the action to analyze the installed packages"),
(" ", "for those that need to be unmasked"),
]
self.short_opts = "huvpG"
self.long_opts = ("help", "unset", "verbose", "prefix") # , "portage")
self.need_queries = True
self.arg_spec = "Target"
self.arg_options = ["use", "pkguse", "keywords", "packages", "unmask"]
self.arg_option = False
self.warning = (
" CAUTION",
"This is beta software and some features/options are incomplete,",
"some features may change in future releases includig its name.",
"Feedback will be appreciated, http://bugs.gentoo.org",
)
def run(self, input_args, quiet=False):
"""runs the module
@param input_args: input arguments to be parsed
"""
query = self.main_setup(input_args)
query = self.validate_query(query)
self.set_quiet(quiet)
if query in ["use", "pkguse"]:
self.analyse_flags(query)
elif query in ["keywords"]:
self.analyse_keywords()
elif query in ["packages"]:
self.analyse_packages()
elif query in ["unmask"]:
self.analyse_unmask()
def analyse_flags(self, target):
"""This will scan the installed packages db and analyze the
USE flags used for installation and produce a report on how
they were used.
@type target: string
@param target: the target to be analyzed, one of ["use", "pkguse"]
"""
system_use = portage.settings["USE"].split()
self.printer = AnalysisPrinter("use", self.options["verbose"], system_use)
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
# cpvs = get_installed_cpvs()
# print "Total number of installed ebuilds =", len(cpvs)
flag_users = gather_flags_info(
cpvs, system_use, self.options["unset"], target=target.upper(), use_portage=self.options["portage"]
)
else:
cpvs = get_installed_cpvs()
flag_users = gather_flags_info(
cpvs,
system_flags=system_use,
include_unset=self.options["unset"],
target=target.upper(),
use_portage=self.options["portage"],
)
# print flag_users
flag_keys = sorted(flag_users)
if self.options["verbose"]:
print(" Flag System #pkgs cat/pkg-ver")
blankline = nl
elif not self.options["quiet"]:
print(" Flag System #pkgs")
blankline = lambda: None
for flag in flag_keys:
flag_pos = flag_users[flag]["+"]
if len(flag_pos):
self.printer(flag, "+", flag_pos)
# blankline()
flag_neg = flag_users[flag]["-"]
if len(flag_neg):
self.printer(flag, "-", flag_neg)
# blankline()
if "unset" in flag_users[flag] and flag_users[flag]["unset"]:
flag_unset = flag_users[flag]["unset"]
self.printer(flag, "unset", flag_unset)
# blankline()
if not self.options["quiet"]:
print("===================================================")
print("Total number of flags in report =", pp.output.red(str(len(flag_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =", pp.output.red(str(len([x for x in cpvs]))))
print()
def analyse_keywords(self, keywords=None):
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
print()
system_keywords = portage.settings["ACCEPT_KEYWORDS"]
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
system_keywords = system_keywords.split()
self.printer = AnalysisPrinter("keywords", self.options["verbose"], system_keywords)
self.analyser = KeywordAnalyser(arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
# self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options["prefix"] and "prefix" not in test_use:
print("ANALYSE_KEYWORDS() 'prefix' flag not found in system", "USE flags!!! appending for testing")
print()
test_use.append("prefix")
self.analyser.set_order(test_use)
# /end testing
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
# print "Total number of installed ebuilds =", len(cpvs)
keyword_users = gather_keywords_info(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options["portage"],
keywords=keywords,
analyser=self.analyser,
)
blankline = nl
else:
keyword_users = gather_keywords_info(
system_keywords=system_keywords,
use_portage=self.options["portage"],
keywords=keywords,
analyser=self.analyser,
)
blankline = lambda: None
# print keyword_users
keyword_keys = sorted(keyword_users)
if self.options["verbose"]:
print(" Keyword System #pkgs cat/pkg-ver")
elif not self.options["quiet"]:
print(" Keyword System #pkgs")
for keyword in keyword_keys:
kwd_stable = keyword_users[keyword]["stable"]
if len(kwd_stable):
self.printer(keyword, " ", kwd_stable)
blankline()
kwd_testing = keyword_users[keyword]["testing"]
if len(kwd_testing):
self.printer(keyword, "~", kwd_testing)
blankline()
kwd_missing = keyword_users[keyword]["missing"]
if len(kwd_missing):
self.printer(keyword, "-", kwd_missing)
blankline
if not self.options["quiet"]:
if self.analyser.mismatched:
print("_________________________________________________")
print(
(
"The following packages were found to have a \n"
+ "different recorded ARCH than the current system ARCH"
)
)
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of keywords in report =", pp.output.red(str(len(keyword_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =", pp.output.red(str(len(cpvs))))
print()
def analyse_packages(self):
"""This will scan the installed packages db and analyze the
USE flags used for installation and produce a report.
@type target: string
@param target: the target to be analyzed, one of ["use", "pkguse"]
"""
system_use = portage.settings["USE"].split()
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
key_width = 45
else:
cpvs = get_installed_cpvs()
key_width = 1
self.printer = AnalysisPrinter("packages", self.options["verbose"], key_width=key_width)
cpvs = sorted(cpvs)
flags = FlagAnalyzer(system=system_use, filter_defaults=False, target="USE")
if self.options["verbose"]:
print(" cat/pkg-ver USE Flags")
# "app-emulation/emul-linux-x86-sdl-20100915 ...."
blankline = nl
elif not self.options["quiet"]:
print(" cat/pkg-ver USE Flags")
blankline = lambda: None
for cpv in cpvs:
(flag_plus, flag_neg, unset) = flags.analyse_cpv(cpv)
if self.options["unset"]:
self.printer(cpv, "", (flag_plus, flag_neg, unset))
else:
self.printer(cpv, "", (flag_plus, flag_neg, []))
if not self.options["quiet"]:
print("===================================================")
print("Total number of installed ebuilds =", pp.output.red(str(len([x for x in cpvs]))))
print()
def analyse_unmask(self):
"""This will scan the installed packages db and analyze the
unmasking used for installation and produce a report on them.
"""
self.not_implemented("unmask")