# groups_manager.py
# DNF plugin for managing comps groups metadata files
#
# Copyright (C) 2020 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details. You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
from __future__ import absolute_import
from __future__ import unicode_literals
import argparse
import gzip
import libcomps
import os
import re
import shutil
import tempfile
from dnfpluginscore import _, logger
import dnf
import dnf.cli
RE_GROUP_ID_VALID = '-a-z0-9_.:'
RE_GROUP_ID = re.compile(r'^[{}]+$'.format(RE_GROUP_ID_VALID))
RE_LANG = re.compile(r'^[-a-zA-Z0-9_.@]+$')
COMPS_XML_OPTIONS = {
'default_explicit': True,
'uservisible_explicit': True,
'empty_groups': True}
def group_id_type(value):
'''group id validator'''
if not RE_GROUP_ID.match(value):
raise argparse.ArgumentTypeError(_('Invalid group id'))
return value
def translation_type(value):
'''translated texts validator'''
data = value.split(':', 2)
if len(data) != 2:
raise argparse.ArgumentTypeError(
_("Invalid translated data, should be in form 'lang:text'"))
lang, text = data
if not RE_LANG.match(lang):
raise argparse.ArgumentTypeError(_('Invalid/empty language for translated data'))
return lang, text
def text_to_id(text):
'''generate group id based on its name'''
group_id = text.lower()
group_id = re.sub('[^{}]'.format(RE_GROUP_ID_VALID), '', group_id)
if not group_id:
raise dnf.cli.CliError(
_("Can't generate group id from '{}'. Please specify group id using --id.").format(
text))
return group_id
@dnf.plugin.register_command
class GroupsManagerCommand(dnf.cli.Command):
aliases = ('groups-manager',)
summary = _('create and edit groups metadata file')
def __init__(self, cli):
super(GroupsManagerCommand, self).__init__(cli)
self.comps = libcomps.Comps()
@staticmethod
def set_argparser(parser):
# input / output options
parser.add_argument('--load', action='append', default=[],
metavar='COMPS.XML',
help=_('load groups metadata from file'))
parser.add_argument('--save', action='append', default=[],
metavar='COMPS.XML',
help=_('save groups metadata to file'))
parser.add_argument('--merge', metavar='COMPS.XML',
help=_('load and save groups metadata to file'))
parser.add_argument('--print', action='store_true', default=False,
help=_('print the result metadata to stdout'))
# group options
parser.add_argument('--id', type=group_id_type,
help=_('group id'))
parser.add_argument('-n', '--name', help=_('group name'))
parser.add_argument('--description',
help=_('group description'))
parser.add_argument('--display-order', type=int,
help=_('group display order'))
parser.add_argument('--translated-name', action='append', default=[],
metavar='LANG:TEXT', type=translation_type,
help=_('translated name for the group'))
parser.add_argument('--translated-description', action='append', default=[],
metavar='LANG:TEXT', type=translation_type,
help=_('translated description for the group'))
visible = parser.add_mutually_exclusive_group()
visible.add_argument('--user-visible', dest='user_visible', action='store_true',
default=None,
help=_('make the group user visible (default)'))
visible.add_argument('--not-user-visible', dest='user_visible', action='store_false',
default=None,
help=_('make the group user invisible'))
# package list options
section = parser.add_mutually_exclusive_group()
section.add_argument('--mandatory', action='store_true',
help=_('add packages to the mandatory section'))
section.add_argument('--optional', action='store_true',
help=_('add packages to the optional section'))
section.add_argument('--remove', action='store_true', default=False,
help=_('remove packages from the group instead of adding them'))
parser.add_argument('--dependencies', action='store_true',
help=_('include also direct dependencies for packages'))
parser.add_argument("packages", nargs='*', metavar='PACKAGE',
help=_('package specification'))
def configure(self):
demands = self.cli.demands
if self.opts.packages:
demands.sack_activation = True
demands.available_repos = True
demands.load_system_repo = False
# handle --merge option (shortcut to --load and --save the same file)
if self.opts.merge:
self.opts.load.insert(0, self.opts.merge)
self.opts.save.append(self.opts.merge)
# check that group is specified when editing is attempted
if (self.opts.description
or self.opts.display_order
or self.opts.translated_name
or self.opts.translated_description
or self.opts.user_visible is not None
or self.opts.packages):
if not self.opts.id and not self.opts.name:
raise dnf.cli.CliError(
_("Can't edit group without specifying it (use --id or --name)"))
def load_input_files(self):
"""
Loads all input xml files.
Returns True if at least one file was successfuly loaded
"""
for file_name in self.opts.load:
file_comps = libcomps.Comps()
try:
if file_name.endswith('.gz'):
# libcomps does not support gzipped files - decompress to temporary
# location
with gzip.open(file_name) as gz_file:
temp_file = tempfile.NamedTemporaryFile(delete=False)
try:
shutil.copyfileobj(gz_file, temp_file)
# close temp_file to ensure the content is flushed to disk
temp_file.close()
file_comps.fromxml_f(temp_file.name)
finally:
os.unlink(temp_file.name)
else:
file_comps.fromxml_f(file_name)
except (IOError, OSError, libcomps.ParserError) as err:
# gzip module raises OSError on reading from malformed gz file
# get_last_errors() output often contains duplicit lines, remove them
seen = set()
for error in file_comps.get_last_errors():
if error in seen:
continue
logger.error(error.strip())
seen.add(error)
raise dnf.exceptions.Error(
_("Can't load file \"{}\": {}").format(file_name, err))
else:
self.comps += file_comps
def save_output_files(self):
for file_name in self.opts.save:
try:
# xml_f returns a list of errors / log entries
errors = self.comps.xml_f(file_name, xml_options=COMPS_XML_OPTIONS)
except libcomps.XMLGenError as err:
errors = [err]
if errors:
# xml_f() method could return more than one error. In this case
# raise the latest of them and log the others.
for err in errors[:-1]:
logger.error(err.strip())
raise dnf.exceptions.Error(_("Can't save file \"{}\": {}").format(
file_name, errors[-1].strip()))
def find_group(self, group_id, name):
'''
Try to find group according to command line parameters - first by id
then by name.
'''
group = None
if group_id:
for grp in self.comps.groups:
if grp.id == group_id:
group = grp
break
if group is None and name:
for grp in self.comps.groups:
if grp.name == name:
group = grp
break
return group
def edit_group(self, group):
'''
Set attributes and package lists for selected group
'''
def langlist_to_strdict(lst):
str_dict = libcomps.StrDict()
for lang, text in lst:
str_dict[lang] = text
return str_dict
# set group attributes
if self.opts.name:
group.name = self.opts.name
if self.opts.description:
group.desc = self.opts.description
if self.opts.display_order:
group.display_order = self.opts.display_order
if self.opts.user_visible is not None:
group.uservisible = self.opts.user_visible
if self.opts.translated_name:
group.name_by_lang = langlist_to_strdict(self.opts.translated_name)
if self.opts.translated_description:
group.desc_by_lang = langlist_to_strdict(self.opts.translated_description)
# edit packages list
if self.opts.packages:
# find packages according to specifications from command line
packages = set()
for pkg_spec in self.opts.packages:
q = self.base.sack.query().filterm(name__glob=pkg_spec).latest()
if not q:
logger.warning(_("No match for argument: {}").format(pkg_spec))
continue
packages.update(q)
if self.opts.dependencies:
# add packages that provide requirements
requirements = set()
for pkg in packages:
requirements.update(pkg.requires)
packages.update(self.base.sack.query().filterm(provides=requirements))
pkg_names = {pkg.name for pkg in packages}
if self.opts.remove:
for pkg_name in pkg_names:
for pkg in group.packages_match(name=pkg_name,
type=libcomps.PACKAGE_TYPE_UNKNOWN):
group.packages.remove(pkg)
else:
if self.opts.mandatory:
pkg_type = libcomps.PACKAGE_TYPE_MANDATORY
elif self.opts.optional:
pkg_type = libcomps.PACKAGE_TYPE_OPTIONAL
else:
pkg_type = libcomps.PACKAGE_TYPE_DEFAULT
for pkg_name in sorted(pkg_names):
if not group.packages_match(name=pkg_name, type=pkg_type):
group.packages.append(libcomps.Package(name=pkg_name, type=pkg_type))
def run(self):
self.load_input_files()
if self.opts.id or self.opts.name:
# we are adding / editing a group
group = self.find_group(group_id=self.opts.id, name=self.opts.name)
if group is None:
# create a new group
if self.opts.remove:
raise dnf.exceptions.Error(_("Can't remove packages from non-existent group"))
group = libcomps.Group()
if self.opts.id:
group.id = self.opts.id
group.name = self.opts.id
elif self.opts.name:
group_id = text_to_id(self.opts.name)
if self.find_group(group_id=group_id, name=None):
raise dnf.cli.CliError(
_("Group id '{}' generated from '{}' is duplicit. "
"Please specify group id using --id.").format(
group_id, self.opts.name))
group.id = group_id
self.comps.groups.append(group)
self.edit_group(group)
self.save_output_files()
if self.opts.print or (not self.opts.save):
print(self.comps.xml_str(xml_options=COMPS_XML_OPTIONS))