def _environment_upgrade(self, env_id):
assert dnf.util.is_string_type(env_id)
comps_env = self.comps._environment_by_id(env_id)
swdb_env = self.history.env.get(comps_env.id)
if not swdb_env:
raise CompsError(_("Environment '%s' is not installed.") % env_id)
if not comps_env:
raise CompsError(_("Environment '%s' is not available.") % env_id)
old_set = set([i.getGroupId() for i in swdb_env.getGroups() if i.getInstalled()])
pkg_types = swdb_env.getPackageTypes()
# create a new record for current transaction
swdb_env = self.history.env.new(comps_env.id, comps_env.name, comps_env.ui_name, pkg_types)
trans = TransactionBunch()
for comps_group in comps_env.mandatory_groups:
if comps_group.id in old_set:
# upgrade existing group
trans += self._group_upgrade(comps_group.id)
else:
# install new group
trans += self._group_install(comps_group.id, pkg_types)
swdb_env.addGroup(comps_group.id, True, MANDATORY)
for comps_group in comps_env.optional_groups:
swdb_env.addGroup(comps_group.id, False, OPTIONAL)
# TODO: if a group is already installed, mark it as installed?
self.history.env.upgrade(swdb_env)
return trans
def _group_upgrade(self, group_id):
assert dnf.util.is_string_type(group_id)
comps_group = self.comps._group_by_id(group_id)
swdb_group = self.history.group.get(group_id)
exclude = []
if not swdb_group:
argument = comps_group.ui_name if comps_group else group_id
raise CompsError(
_("Module or Group '%s' is not installed.") % argument)
if not comps_group:
raise CompsError(
_("Module or Group '%s' is not available.") % group_id)
pkg_types = swdb_group.getPackageTypes()
old_set = set([i.getName() for i in swdb_group.getPackages()])
new_set = self._pkgs_of_type(comps_group, pkg_types, exclude)
# create a new record for current transaction
swdb_group = self.history.group.new(group_id, comps_group.name,
comps_group.ui_name, pkg_types)
for i in comps_group.packages_iter():
swdb_group.addPackage(i.name, False, Package._OPT_MAP[i.type])
self.history.group.upgrade(swdb_group)
trans = TransactionBunch()
trans.install = {pkg for pkg in new_set if pkg.name not in old_set}
trans.remove = {
name
for name in old_set if name not in [pkg.name for pkg in new_set]
}
trans.upgrade = {pkg for pkg in new_set if pkg.name in old_set}
return trans
def _add_from_xml_filename(self, fn):
comps = libcomps.Comps()
ret = comps.fromxml_f(fn)
if ret == -1:
errors = comps.get_last_parse_errors()
raise CompsError(' '.join(errors))
self._i = self._i + comps
def get(self, *patterns):
res = dnf.util.Bunch()
res.environments = []
res.groups = []
for pat in patterns:
envs = grps = []
if self.kinds & self.ENVIRONMENTS:
available = self.comps.environments_by_pattern(pat)
installed = self.history.env.search_by_pattern(pat)
envs = self._get_envs(available, installed)
res.environments.extend(envs)
if self.kinds & self.GROUPS:
available = self.comps.groups_by_pattern(pat)
installed = self.history.group.search_by_pattern(pat)
grps = self._get_groups(available, installed)
res.groups.extend(grps)
if not envs and not grps:
if self.status == self.INSTALLED:
msg = _("Module or Group '%s' is not installed.") % ucd(
pat)
elif self.status == self.AVAILABLE:
msg = _("Module or Group '%s' is not available.") % ucd(
pat)
else:
msg = _("Module or Group '%s' does not exist.") % ucd(pat)
raise CompsError(msg)
return res
def _environment_install(self,
env_id,
pkg_types,
exclude=None,
strict=True,
exclude_groups=None):
assert dnf.util.is_string_type(env_id)
comps_env = self.comps._environment_by_id(env_id)
if not comps_env:
raise CompsError(
_("Environment id '%s' does not exist.") % ucd(env_id))
swdb_env = self.history.env.new(env_id, comps_env.name,
comps_env.ui_name, pkg_types)
self.history.env.install(swdb_env)
trans = TransactionBunch()
for comps_group in comps_env.mandatory_groups:
if exclude_groups and comps_group.id in exclude_groups:
continue
trans += self._group_install(comps_group.id, pkg_types, exclude,
strict)
swdb_env.addGroup(comps_group.id, True, MANDATORY)
for comps_group in comps_env.optional_groups:
if exclude_groups and comps_group.id in exclude_groups:
continue
swdb_env.addGroup(comps_group.id, False, OPTIONAL)
# TODO: if a group is already installed, mark it as installed?
return trans
def _group_install(self,
group_id,
pkg_types,
exclude=None,
strict=True,
exclude_groups=None):
assert dnf.util.is_string_type(group_id)
comps_group = self.comps._group_by_id(group_id)
if not comps_group:
raise CompsError(
_("Group id '%s' does not exist.") % ucd(group_id))
swdb_group = self.history.group.new(group_id, comps_group.name,
comps_group.ui_name, pkg_types)
for i in comps_group.packages_iter():
swdb_group.addPackage(i.name, False, Package._OPT_MAP[i.type])
self.history.group.install(swdb_group)
trans = TransactionBunch()
# TODO: remove exclude
if strict:
trans.install.update(
self._pkgs_of_type(comps_group, pkg_types, exclude=[]))
else:
trans.install_opt.update(
self._pkgs_of_type(comps_group, pkg_types, exclude=[]))
return trans
def _group_install(self, group_id, pkg_types, exclude, strict=True):
group = self.comps._group_by_id(group_id)
if not group:
raise ValueError(_("Group_id '%s' does not exist.") % ucd(group_id))
p_grp = self.persistor.group(group_id)
if p_grp.installed:
raise CompsError(_("Group '%s' is already installed.") %
group.ui_name)
exclude = set() if exclude is None else set(exclude)
p_grp.name = group.name
p_grp.ui_name = group.ui_name
p_grp.pkg_exclude.extend(exclude)
p_grp.pkg_types = pkg_types
p_grp.full_list.extend(self._full_package_set(group))
trans = TransactionBunch()
types = pkg_types & MANDATORY
mandatory = self._pkgs_of_type(group, types, exclude)
types = pkg_types & (DEFAULT | OPTIONAL)
trans.install_opt = self._pkgs_of_type(group, types, exclude)
if strict:
trans.install = mandatory
else:
trans.install_opt.update(mandatory)
return trans
def _environment_upgrade(self, env_id):
if isinstance(env_id, SwdbEnv):
env_id = env_id.name_id
env = self.comps._environment_by_id(env_id)
p_env = self.persistor.environment(env.id)
if not p_env or not p_env.installed:
raise CompsError(
_("Environment '%s' is not installed.") % env.ui_name)
old_set = set(p_env.get_group_list())
pkg_types = p_env.pkg_types
exclude = p_env.get_exclude()
trans = TransactionBunch()
for grp in env.mandatory_groups:
if grp.id in old_set:
# upgrade
try:
trans += self._group_upgrade(grp.id)
except dnf.exceptions.CompsError:
# might no longer be installed
pass
else:
# install
trans += self._group_install(grp.id, pkg_types, exclude)
return trans
def _add_from_xml_filename(self, fn):
comps = libcomps.Comps()
try:
comps.fromxml_f(fn)
except libcomps.ParserError:
errors = comps.get_last_errors()
raise CompsError(' '.join(errors))
self._i += comps
def _group_remove(self, group_id):
assert dnf.util.is_string_type(group_id)
swdb_group = self.history.group.get(group_id)
if not swdb_group:
raise CompsError(_("Module or Group '%s' is not installed.") % group_id)
self.history.group.remove(swdb_group)
trans = TransactionBunch()
trans.remove = {pkg for pkg in swdb_group.getPackages() if self._removable_pkg(pkg.getName())}
return trans
def _group_remove(self, group_id):
p_grp = self.persistor.group(group_id)
if not p_grp.installed:
raise CompsError(_("Group '%s' not installed.") %
p_grp.ui_name)
trans = TransactionBunch()
exclude = p_grp.pkg_exclude
trans.remove = {pkg for pkg in p_grp.full_list
if pkg not in exclude and self._removable_pkg(pkg)}
p_grp.pkg_types = 0
del p_grp.full_list[:]
del p_grp.pkg_exclude[:]
return trans
def _group_remove(self, group_id):
if isinstance(group_id, SwdbGroup):
group_id = group_id.name_id
p_grp = self.persistor.group(group_id)
if not p_grp or not p_grp.installed:
raise CompsError(_("Group '%s' not installed.") %
ucd(p_grp.ui_name))
trans = TransactionBunch()
exclude = p_grp.get_exclude()
trans.remove = {pkg for pkg in p_grp.get_full_list()
if pkg not in exclude and self._removable_pkg(pkg)}
self.persistor.remove_group(p_grp)
return trans
def group_install(self, group, pkg_types, exclude):
p_grp = self.persistor.group(group.id)
if p_grp.installed:
raise CompsError(
_("Group '%s' is already installed.") % group.ui_name)
exclude = set() if exclude is None else set(exclude)
p_grp.pkg_exclude.extend(exclude)
p_grp.pkg_types = pkg_types
p_grp.full_list.extend(self._full_package_set(group))
trans = TransactionBunch()
trans.install = self._pkgs_of_type(group, pkg_types, exclude)
return trans
def _environment_remove(self, env_id):
assert dnf.util.is_string_type(env_id) is True
swdb_env = self.history.env.get(env_id)
if not swdb_env:
raise CompsError(_("Environment '%s' is not installed.") % env_id)
self.history.env.remove(swdb_env)
trans = TransactionBunch()
group_ids = set([i.getGroupId() for i in swdb_env.getGroups()])
for group_id in group_ids:
if not self._removable_grp(group_id):
continue
trans += self._group_remove(group_id)
return trans
def group_upgrade(self, group):
p_grp = self.persistor.group(group.id)
if not p_grp.installed:
raise CompsError(_("Group '%s' not installed.") % group.ui_name)
exclude = set(p_grp.pkg_exclude)
old_set = set(p_grp.full_list)
new_set = self._pkgs_of_type(group, p_grp.pkg_types, exclude)
del p_grp.full_list[:]
p_grp.full_list.extend(self._full_package_set(group))
trans = TransactionBunch()
trans.install = new_set - old_set
trans.remove = old_set - new_set
trans.upgrade = old_set - trans.remove
return trans
def _environment_remove(self, env_id):
if isinstance(env_id, SwdbEnv):
env_id = env_id.name_id
p_env = self.persistor.environment(env_id)
if not p_env or not p_env.installed:
raise CompsError(
_("Environment '%s' is not installed.") % ucd(p_env.ui_name))
trans = TransactionBunch()
group_ids = set(p_env.get_group_list())
for grp in group_ids:
if not self._removable_grp(grp):
continue
trans += self._group_remove(grp)
return trans
def get(self, *patterns):
res = dnf.util.Bunch()
res.environments = []
res.groups = []
for pat in patterns:
envs = grps = None
if self.kinds & self.ENVIRONMENTS:
envs = self._get(self.comps.environments_by_pattern(pat),
self.prst.environment)
res.environments.extend(envs)
if self.kinds & self.GROUPS:
grps = self._get(self.comps.groups_by_pattern(pat),
self.prst.group)
res.groups.extend(grps)
if not envs and not grps:
msg = _("Group '%s' does not exist.") % ucd(pat)
raise CompsError(msg)
return res
def _group_upgrade(self, group_id):
group = self.comps._group_by_id(group_id)
p_grp = self.persistor.group(group.id)
if not p_grp.installed:
raise CompsError(_("Group '%s' not installed.") %
group.ui_name)
exclude = set(p_grp.pkg_exclude)
old_set = set(p_grp.full_list)
new_set = self._pkgs_of_type(group, p_grp.pkg_types, exclude)
del p_grp.full_list[:]
p_grp.full_list.extend(self._full_package_set(group))
trans = TransactionBunch()
trans.install = {pkg for pkg in new_set if pkg.name not in old_set}
trans.remove = {name for name in old_set
if name not in [pkg.name for pkg in new_set]}
trans.upgrade = {pkg for pkg in new_set if pkg.name in old_set}
return trans
def _group_upgrade(self, group_id):
if isinstance(group_id, SwdbGroup):
group_id = group_id.name_id
group = self.comps._group_by_id(group_id)
p_grp = self.persistor.group(group.id)
if not p_grp or not p_grp.installed:
raise CompsError(_("Group '%s' not installed.") %
group.ui_name)
exclude = set(p_grp.get_exclude())
old_set = set(p_grp.get_full_list())
new_set = self._pkgs_of_type(group, p_grp.pkg_types, exclude)
p_grp.update_full_list(list(self._full_package_set(group)))
trans = TransactionBunch()
trans.install = {pkg for pkg in new_set if pkg.name not in old_set}
trans.remove = {name for name in old_set
if name not in [pkg.name for pkg in new_set]}
trans.upgrade = {pkg for pkg in new_set if pkg.name in old_set}
return trans
def _environment_remove(self, env_id):
p_env = self.persistor.environment(env_id)
if not p_env.installed:
raise CompsError(
_("Environment '%s' is not installed.") % p_env.ui_name)
trans = TransactionBunch()
group_ids = set(p_env.full_list)
for grp in group_ids:
if not self._removable_grp(grp):
continue
trans += self._group_remove(grp)
del p_env.full_list[:]
del p_env.pkg_exclude[:]
p_env.grp_types = 0
p_env.pkg_types = 0
return trans
def environment_install(self, env, pkg_types, exclude):
p_env = self.persistor.environment(env.id)
if p_env.installed:
raise CompsError(
_("Environment '%s' is already installed.") % env.ui_name)
p_env.grp_types = CONDITIONAL | DEFAULT | MANDATORY | OPTIONAL
exclude = set() if exclude is None else set(exclude)
p_env.pkg_exclude.extend(exclude)
p_env.pkg_types = pkg_types
p_env.full_list.extend(self._mandatory_group_set(env))
trans = TransactionBunch()
for grp in env.mandatory_groups:
try:
trans += self.group_install(grp, pkg_types, exclude)
except dnf.exceptions.CompsError:
pass
return trans
def _resolved(lib, names):
"""
Resolve group names to IDs.
Args:
lib (LibDnf): An opened lib.
names (collections.Iterable): A list of group names.
Yields:
Group IDs.
Raises:
CompsError: When name cannot be resolved.
"""
for p in names:
group = lib.comps.group_by_pattern(p)
if not group:
raise CompsError(_('Group "{g}" not found.').format(g=p))
else:
yield group.id
def environment_upgrade(self, env):
p_env = self.persistor.environment(env.id)
if not p_env.installed:
raise CompsError(
_("Environment '%s' is not installed.") % env.ui_name)
old_set = set(p_env.full_list)
pkg_types = p_env.pkg_types
exclude = p_env.pkg_exclude
trans = TransactionBunch()
for grp in env.mandatory_groups:
if grp.id in old_set:
# upgrade
try:
trans += self.group_upgrade(grp)
except dnf.exceptions.CompsError:
# might no longer be installed
pass
else:
# install
trans += self.group_install(grp, pkg_types, exclude)
return trans