anaconda/anaconda-40.22.3.13/pyanaconda/modules/payloads/payload/dnf/dnf_interface.py

237 lines
8.6 KiB
Python
Raw Normal View History

2024-11-14 21:39:56 -08:00
#
# DBus interface for DNF payload.
#
# Copyright (C) 2019 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 dasbus.server.interface import dbus_interface
from dasbus.server.property import emits_properties_changed
from dasbus.typing import * # pylint: disable=wildcard-import
from pyanaconda.modules.common.containers import TaskContainer
from pyanaconda.modules.common.constants.interfaces import PAYLOAD_DNF
from pyanaconda.modules.common.structures.comps import CompsEnvironmentData, CompsGroupData
from pyanaconda.modules.common.structures.payload import RepoConfigurationData
from pyanaconda.modules.common.structures.packages import PackagesConfigurationData, \
PackagesSelectionData
from pyanaconda.modules.payloads.payload.payload_base_interface import PayloadBaseInterface
__all__ = ["DNFInterface"]
@dbus_interface(PAYLOAD_DNF.interface_name)
class DNFInterface(PayloadBaseInterface):
"""DBus interface for DNF payload module."""
def connect_signals(self):
"""Connect the signals."""
super().connect_signals()
self.watch_property(
"Repositories",
self.implementation.repositories_changed
)
self.watch_property(
"PackagesConfiguration",
self.implementation.packages_configuration_changed
)
self.watch_property(
"PackagesSelection",
self.implementation.packages_selection_changed
)
@property
def Repositories(self) -> List[Structure]:
"""The configuration of repositories.
:return: a list of structures of the type RepoConfigurationData
"""
return RepoConfigurationData.to_structure_list(
self.implementation.repositories
)
@Repositories.setter
@emits_properties_changed
def Repositories(self, data: List[Structure]):
"""Set the configuration of repositories.
:param data: a list of structures of the type RepoConfigurationData
"""
self.implementation.set_repositories(
RepoConfigurationData.from_structure_list(data)
)
@property
def PackagesConfiguration(self) -> Structure:
"""The packages configuration.
:return: a structure of the type PackagesConfigurationData
"""
return PackagesConfigurationData.to_structure(
self.implementation.packages_configuration
)
@PackagesConfiguration.setter
@emits_properties_changed
def PackagesConfiguration(self, data: Structure):
"""Set the packages configuration.
:param data: a structure of the type PackagesConfigurationData
"""
self.implementation.set_packages_configuration(
PackagesConfigurationData.from_structure(data)
)
@property
def PackagesSelection(self) -> Structure:
"""The packages selection.
:return: a structure of the type PackagesSelectionData
"""
return PackagesSelectionData.to_structure(
self.implementation.packages_selection
)
@PackagesSelection.setter
@emits_properties_changed
def PackagesSelection(self, data: Structure):
"""Set the packages selection.
:param: a structure of the type PackagesSelectionData
"""
self.implementation.set_packages_selection(
PackagesSelectionData.from_structure(data)
)
@property
def PackagesKickstarted(self) -> Bool:
"""Are the packages set from a kickstart?
FIXME: This is a temporary property.
:return: True or False
"""
return self.implementation.packages_kickstarted
def GetAvailableRepositories(self) -> List[Str]:
"""Get a list of available repositories.
:return: a list with names of available repositories
"""
return self.implementation.get_available_repositories()
def GetEnabledRepositories(self) -> List[Str]:
"""Get a list of enabled repositories.
:return: a list with names of enabled repositories
"""
return self.implementation.get_enabled_repositories()
def GetDefaultEnvironment(self) -> Str:
"""Get a default environment.
:return: an identifier of an environment or an empty string
"""
return self.implementation.get_default_environment()
def GetEnvironments(self) -> List[Str]:
"""Get a list of environments defined in comps.xml files.
:return: a list with identifiers of environments
"""
return self.implementation.get_environments()
def ResolveEnvironment(self, environment_spec: Str) -> Str:
"""Translate the given specification to an environment identifier.
:param environment_spec: an environment specification
:return: an identifier of an environment or an empty string
"""
return self.implementation.resolve_environment(environment_spec) or ""
def GetEnvironmentData(self, environment_spec: Str) -> Structure:
"""Get data about the specified environment.
:param environment_spec: an environment specification
:return: a data structure defined by CompsEnvironmentData
:raise UnknownCompsEnvironmentError: if the environment is unknown
"""
return CompsEnvironmentData.to_structure(
self.implementation.get_environment_data(environment_spec)
)
def ResolveGroup(self, group_spec: Str) -> Str:
"""Translate the given specification into a group identifier.
:param group_spec: a group specification
:return: an identifier of a group or an empty string
"""
return self.implementation.resolve_group(group_spec) or ""
def GetGroupData(self, group_spec: Str) -> Structure:
"""Get data about the specified group.
:param group_spec: a group specification
:return: a data structure defined by CompsGroupData
:raise UnknownCompsGroupError: if the group is unknown
"""
return CompsGroupData.to_structure(
self.implementation.get_group_data(group_spec)
)
def VerifyRepomdHashesWithTask(self) -> ObjPath:
"""Verify a hash of the repomd.xml file for each enabled repository with a task.
This task tests if URL links from active repositories can be reached.
It is useful when network settings are changed so that we can verify if
repositories are still reachable. The task returns a validation report.
:return: a DBus path of the task
"""
return TaskContainer.to_object_path(
self.implementation.verify_repomd_hashes_with_task()
)
def ValidatePackagesSelectionWithTask(self, data: Structure) -> ObjPath:
"""Validate the specified packages selection.
Return a task for validation of the software selection.
The result of the task is a validation report.
:param data: a structure of the type PackagesSelectionData
:return: a DBus path of a task
"""
return TaskContainer.to_object_path(
self.implementation.validate_packages_selection_with_task(
PackagesSelectionData.from_structure(data))
)
def GetRepoConfigurations(self) -> List[Structure]:
"""Get RepoConfigurationData structures for all attached sources.
FIXME: This is a temporary solution. Will be removed after DNF payload logic is moved.
"""
return RepoConfigurationData.to_structure_list(
self.implementation.get_repo_configurations()
)
def MatchAvailablePackages(self, pattern: Str) -> List[Str]:
"""Find available packages that match the specified pattern.
:param pattern: a pattern for package names
:return: a list of matched package names
"""
return self.implementation.match_available_packages(pattern)