Mini Shell
#
# DBus interface for the users module.
#
# Copyright (C) 2018 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 pyanaconda.modules.common.constants.services import USERS
from dasbus.server.property import emits_properties_changed
from dasbus.typing import * # pylint: disable=wildcard-import
from pyanaconda.modules.common.base import KickstartModuleInterface
from pyanaconda.modules.common.containers import TaskContainer
from pyanaconda.modules.common.structures.user import UserData
from pyanaconda.modules.common.structures.group import GroupData
from pyanaconda.modules.common.structures.sshkey import SshKeyData
from dasbus.server.interface import dbus_interface
@dbus_interface(USERS.interface_name)
class UsersInterface(KickstartModuleInterface):
"""DBus interface for Users module."""
def connect_signals(self):
super().connect_signals()
self.watch_property("Users", self.implementation.users_changed)
self.watch_property("Groups", self.implementation.groups_changed)
self.watch_property("SshKeys", self.implementation.ssh_keys_changed)
self.watch_property("IsRootPasswordSet",
self.implementation.root_password_is_set_changed)
self.watch_property("IsRootAccountLocked",
self.implementation.root_account_locked_changed)
self.watch_property("RootPasswordSSHLoginAllowed",
self.implementation.root_password_ssh_login_allowed_changed)
self.watch_property("CanChangeRootPassword",
self.implementation.can_change_root_password_changed)
@property
def CanChangeRootPassword(self) -> Bool:
"""Can the root password be changed ?
:return: True, if the root password can the changed, False otherwise
"""
return self.implementation.can_change_root_password
@property
def RootPassword(self) -> Str:
"""Root password.
NOTE: this property should be only temporary and should be
dropped once the users module itself can configure the root password
:return: root password (might be crypted)
"""
return self.implementation.root_password
@property
def IsRootPasswordCrypted(self) -> Bool:
"""Is the root password crypted ?
NOTE: this property should be only temporary and should be
dropped once the users module itself can configure the root password
:return: True, if the root password is crypted, otherwise False
"""
return self.implementation.root_password_is_crypted
@emits_properties_changed
def SetCryptedRootPassword(self, crypted_root_password: Str):
"""Set the root password.
The password is expected to be provided in already crypted.
:param crypted_root_password: already crypted root password
"""
self.implementation.set_root_password(crypted_root_password, crypted=True)
@emits_properties_changed
def ClearRootPassword(self):
"""Clear any set root password."""
self.implementation.clear_root_password()
@property
def IsRootPasswordSet(self) -> Bool:
"""Is the root password set ?
:return: True, if the root password is set, otherwise False
"""
return self.implementation.root_password_is_set
@emits_properties_changed
def SetRootAccountLocked(self, root_account_locked: Bool):
"""Lock or unlock the root account."""
self.implementation.set_root_account_locked(root_account_locked)
@property
def IsRootAccountLocked(self) -> Bool:
"""Is the root account locked ?
:return: True, if the root account is locked, otherwise False
"""
return self.implementation.root_account_locked
@emits_properties_changed
def SetRootPasswordSSHLoginAllowed(self, root_password_ssh_login_allowed: Bool):
"""Allow or disallow the root from logging in via SSH with password authetication."""
self.implementation.set_root_password_ssh_login_allowed(root_password_ssh_login_allowed)
@property
def RootPasswordSSHLoginAllowed(self) -> Bool:
"""Is logging in as root via SSH with password allowed ?
:return: True if root SSH loggin with password is allowed, False otherwise
"""
return self.implementation.root_password_ssh_login_allowed
@property
def Users(self) -> List[Structure]:
"""List of users, each describing a single user.
:return: a list of user describing DBus Structures
"""
# internally we hold the data about users as a list of structures,
# which we need to turn into a list of dicts before returning it
# over DBus
user_dicts = []
for user_data in self.implementation.users:
user_dicts.append(UserData.to_structure(user_data))
return user_dicts
@emits_properties_changed
def SetUsers(self, users: List[Structure]):
"""Set a list of users, each corresponding to a single user.
:param users: a list of user describing DBus structures
"""
self.implementation.set_users(UserData.from_structure_list(users))
@property
def Groups(self) -> List[Structure]:
"""List of groups, each describing a single group.
:return: a list of group describing DBus Structures
"""
# internally we hold the data about groups as a list of structures,
# which we need to turn into a list of dicts before returning it
# over DBus
group_dicts = []
for group_data in self.implementation.groups:
group_dicts.append(GroupData.to_structure(group_data))
return group_dicts
@emits_properties_changed
def SetGroups(self, groups: List[Structure]):
"""Set a list of groups, each corresponding to a single group.
:param groups: a list of group describing DBus structures
"""
self.implementation.set_groups(GroupData.from_structure_list(groups))
@property
def SshKeys(self) -> List[Structure]:
"""List of SSH keys, each describing a single SSH key.
:return: a list of SSH key describing DBus Structures
"""
# internally we hold the data about SSH keys as a list of structures,
# which we need to turn into a list of dicts before returning it
# over DBus
ssh_key_dicts = []
for ssh_key_data in self.implementation.ssh_keys:
ssh_key_dicts.append(SshKeyData.to_structure(ssh_key_data))
return ssh_key_dicts
@emits_properties_changed
def SetSshKeys(self, ssh_keys: List[Structure]):
"""Set a list of DBus structures, each corresponding to a single SSH key.
:param ssh_keys: a list of SSH key describing DBus structures
"""
self.implementation.set_ssh_keys(SshKeyData.from_structure_list(ssh_keys))
def CheckAdminUserExists(self) -> Bool:
"""Reports if at least one admin user exists.
- an unlocked root account is considered to be an admin user
- an unlocked user account that is member of the group "wheel"
is considered to be an admin user
:return: if at least one admin user exists
"""
return self.implementation.check_admin_user_exists
def ConfigureGroupsWithTask(self) -> ObjPath:
"""Configure user groups via a DBus task.
:returns: DBus path of the task
"""
return TaskContainer.to_object_path(
self.implementation.configure_groups_with_task()
)
def ConfigureUsersWithTask(self) -> ObjPath:
"""Configure users via a DBus task.
:returns: DBus path of the task
"""
return TaskContainer.to_object_path(
self.implementation.configure_users_with_task()
)
def SetRootPasswordWithTask(self) -> ObjPath:
"""Set root password via a DBus task.
:returns: DBus path of the task
"""
return TaskContainer.to_object_path(
self.implementation.set_root_password_with_task()
)