5
0
Derivar 0
Não pode escolher mais do que 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
calculate-utils-3-unix/pym/unix/variables/users.py

722 linhas
21 KiB

Este ficheiro contém caracteres Unicode ambíguos!

Este ficheiro contém caracteres Unicode ambíguos que podem ser confundidos com outros da sua configuração regional vigente. Se o uso é intencional e legítimo, pode ignorar este aviso com segurança. Use o botão Revelar para realçar esses caracteres.

# -*- coding: utf-8 -*-
# Copyright 2016 Mir Calculate. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
from os import path
from calculate.lib.cl_ldap import LDAPConnectError
from calculate.lib.datavars import (ReadonlyVariable, Variable,
VariableError, PasswordError)
from calculate.ldap.variables.helpers import (HashHelper,
LdapMaxHelper)
from calculate.unix.variables.helpers import (UnixUserHelper, UnixGroupHelper,
ExistsUserHelper,
ShowFieldsHelper,
FieldsHelper, UnixActionHelper)
from .action import Actions
import re
_ = lambda x: x
from calculate.lib.cl_lang import (setLocalTranslate, getLazyLocalTranslate)
setLocalTranslate('cl_unix3', sys.modules[__name__])
__ = getLazyLocalTranslate(_)
class VariableUrUnixLogin(UnixUserHelper, UnixActionHelper, Variable):
"""
Логин настраиваемого пользователя
"""
untrusted = True
opt = ("ur_unix_login",)
metavalue = "USER"
def init(self):
self.label = _("Login")
self.help = _("set user login")
def get_new(self):
return ""
def get_exists(self):
return self.Get('ur_unix_login_exists')
def check_new(self, value):
if not value:
raise VariableError(_("You should specify login"))
if not re.match("^[a-zA-Z_]([a-zA-Z0-9_ -]*[a-zA-Z0-9_-])?$", value):
raise VariableError(_("Wrong user login"))
if self.search_ldap_user_name(value):
raise VariableError(_("User %s already exists" % value))
if self.search_system_user_name(value):
raise VariableError(
_("User %s already exists in /etc/passwd") % value)
class VariableUrUnixLoginExists(UnixUserHelper, UnixActionHelper, Variable):
"""
Логин настраиваемого пользователя
"""
type = "choice"
opt = ("ur_unix_login_exists",)
metavalue = "USER"
untrusted = True
guitype = "readonly"
def init(self):
self.label = _("Login")
self.help = _("set user login")
def get_new(self):
return ""
def get_exists(self):
return ""
def choice_exists(self):
return ((user.username,
"%s (%s)" % (user.username, user.comment))
for user in self.iterate_ldap_user("uid=*"))
def raiseWrongChoice(self, name, choiceVal, value, error):
if not value:
raise VariableError(_("Please specify user login"))
else:
raise VariableError(_("%s user not found") % value)
class VariableUrUnixBaseDir(Variable):
"""
Базовая директория для нового пользователя
"""
value = "/home"
opt = ('-b', '--base-dir')
metavalue = "BASE_DIR"
def init(self):
self.label = _("Base directory")
self.help = _("base directory for the home directory of new account")
class VariableUrUnixComment(ExistsUserHelper, UnixActionHelper, Variable):
"""
Описание учётной записи
"""
attribute = "comment"
value_format = "{ldap.ld_base_root.capitalize()} user"
opt = ('-c', '--comment')
metavalue = "COMMENT"
def init(self):
self.label = _("Full name")
self.help = _("set fullname of the account")
def get_new(self):
return ""
# self._value_formatter.format(self.value_format, self.Get)
class VariableUrUnixHomePath(ExistsUserHelper, UnixActionHelper, Variable):
"""
Путь до домашней директории
"""
value_format = "{unix.ur_unix_base_dir}/{unix.ur_unix_login}"
opt = ('-d', '--home-dir')
metavalue = "HOME_DIR"
check_after = ["ur_unix_login"]
def init(self):
self.label = _("Home directory")
self.help = _("set home directory of the account")
def get_exists(self):
return self.Get('ur_unix_home_path_exists')
def get_new(self):
return self._value_formatter.format(self.value_format, self.Get)
def check_exists(self, value):
if "," in value:
raise VariableError(_("Wrong home directory"))
if not value.startswith('/'):
raise VariableError(_("Home directory path must be absolutly"))
class VariableUrUnixHomePathExists(ExistsUserHelper, UnixActionHelper,
ReadonlyVariable):
"""
Путь до домашней директории
"""
attribute = "homedir"
class VariableUrUnixHomePathMove(Variable):
"""
Перемещать домашнуюю пользовательскую директорию
"""
type = "bool"
opt = ('-m', '--move-home')
value = "off"
check_after = ["ur_unix_home_path", "ur_unix_home_path_exists"]
def init(self):
self.label = _("Move home directory")
self.help = _("move contents of the home directory to the new location")
def check_on(self):
new_path = self.Get('ur_unix_home_path')
old_path = self.Get('ur_unix_home_path_exists')
if new_path == old_path:
raise VariableError(_("You should change home directory"))
if path.exists(new_path):
raise VariableError(
_("New home directory %s exists") % new_path)
if not path.exists(old_path):
raise VariableError(
_("Previous home directory %s not found") % old_path)
class VariableClUnixGroupDefault(Variable):
"""
Основная группа пользователя по умолчанию
"""
value = "domain"
class VariableUrUnixPrimaryGroup(ExistsUserHelper, UnixGroupHelper,
UnixActionHelper, Variable):
"""
ID основной группы
"""
attribute = "gid"
type = "choiceedit"
opt = ('-g', '--gid')
metavalue = "GROUP"
@property
def domain_group(self):
return self.Get('cl_unix_group_default')
def init(self):
self.label = _("Primary group")
self.help = _("set name or ID of primary group of the account "
"('default' value for create default group)")
def get_new(self):
return self.domain_group
def get_exists(self):
value = str(ExistsUserHelper.get_exists(self))
if value:
return str(self.gid_to_name(value))
def set(self, value):
return str(self.gid_to_name(value))
def choice_new(self):
return ([(self.domain_group, self.domain_group)]
+ self.ldap_group_list())
def choice_exists(self):
return self.ldap_group_list()
def check_new(self, value):
if not value:
raise VariableError(_("You should specify primary group ID"))
def check_exists(self, value):
if not value:
raise VariableError(_("You should specify primary group ID"))
if value:
self.check_group(value)
def raiseWrongChoice(self, name, choiceVal, value, error):
raise VariableError(_("Group %s not found") % value)
class VariableUrUnixGid(UnixGroupHelper, ReadonlyVariable):
"""
ID основной группы пользователя
"""
type = "int"
def get(self):
group_name = self.Get('ur_unix_primary_group')
group = self.search_ldap_group_name(group_name)
if group:
return str(group.gid)
else:
return self.Get('ur_unix_next_gid')
class VariableUrUnixUid(UnixUserHelper, UnixActionHelper, Variable):
"""
UID пользователя
"""
type = "int"
opt = ('-u', '--uid')
metavalue = "UID"
value = ""
def init(self):
self.label = _("User ID")
self.help = _("set user ID of the account")
def get_new(self):
return self.Get('ur_unix_next_uid')
def get_exists(self):
login = self.Get('ur_unix_login')
if login:
return str(self.search_ldap_user_name(login).uid)
def check_new(self, value):
user = self.search_ldap_user_id(value)
if user:
raise VariableError(_("Uid %s is used by user %s")
% (user.uid, user.username))
user = self.search_system_user_id(value)
if user:
raise VariableError(_("Uid %s is used by system user %s")
% (user.uid, user.username))
class VariableUrUnixGroups(UnixGroupHelper, UnixActionHelper, Variable):
"""
Список груп
"""
type = "choiceedit-list"
opt = ("-G", "--groups")
metavalue = "GROUPS"
value = []
def init(self):
self.label = _("Supplimentary groups")
self.help = _("set list of supplementary groups of the account")
def set(self, value):
return map(self.gid_to_name, value)
def get_exists(self):
return self.Get('ur_unix_groups_exists')
def choice(self):
return self.ldap_group_list()
def check(self, value):
for group in value:
self.check_group(group)
class VariableUrUnixGroupsExists(UnixGroupHelper, UnixActionHelper, Variable):
"""
Список груп
"""
type = "list"
value = []
# def get_bylogin(self, login, obj):
# return [x.group_name for x in
# self.iterate_ldap_group("memberUid=%s" % login)]
def get_exists(self):
login = self.Get('ur_unix_login')
if login:
return [x.group_name for x in
self.iterate_ldap_group("memberUid=%s" % login)]
return []
class VariableUrUnixGroupsAdd(UnixGroupHelper, UnixActionHelper, Variable):
"""
Список групп в которые необходимо добавить пользователя
"""
type = "choiceedit-list"
guitype = "hidden"
opt = ("-a", "--append")
metavalue = "GROUPS"
value = []
def init(self):
self.label = _("Include to groups")
self.help = _("include user into groups")
def set(self, value):
return map(self.gid_to_name, value)
def get_exists(self):
exists_groups = set(self.Get('ur_unix_groups_exists'))
replace_group = set(self.Get('ur_unix_groups'))
return sorted(list(replace_group - exists_groups))
def choice_exists(self):
login = self.Get('ur_unix_login')
if login:
exists_groups = self.Get('ur_unix_groups_exists')
return (x for x in self.ldap_group_list()
if x[0] not in exists_groups)
return []
def check_exists(self, value):
exists_groups = self.Get('ur_unix_groups_exists')
replace_groups = self.Get('ur_unix_groups')
if set(exists_groups) != set(replace_groups):
raise VariableError(_(
"Appending user to groups unavailable "
"with the replace groups using"))
login = self.Get('ur_unix_login')
groups = self.ldap_group_names()
failed = [x for x in value if x not in groups]
if failed:
raise VariableError(
_("Wrong groups {groups}").format(
groups=", ".join(failed)))
self.check_special(value, exists_groups, login)
def check_special(self, value, exists_groups, login):
already_exists = [x for x in value if x in exists_groups]
if already_exists:
raise VariableError(
_("User {user} already exist in groups {groups}").format(
groups=", ".join(already_exists), user=login))
def humanReadable(self):
if not self.Get():
return _("Not change")
class VariableUrUnixGroupsDel(VariableUrUnixGroupsAdd):
"""
Список групп из которых необходимо исключить пользователя
"""
type = "choiceedit-list"
opt = ("-r", "--remove")
guitype = "hidden"
metavalue = "GROUPS"
value = []
def init(self):
self.label = _("Exclude from groups")
self.help = _("exclude user from groups")
def get_exists(self):
exists_groups = set(self.Get('ur_unix_groups_exists'))
replace_groups = set(self.Get('ur_unix_groups'))
return sorted(list(exists_groups - replace_groups))
def choice_exists(self):
login = self.Get('ur_unix_login')
if login:
exists_groups = self.Get('ur_unix_groups_exists')
return (x for x in self.ldap_group_list()
if x[0] in exists_groups)
return []
def check_special(self, value, exists_groups, login):
not_exists = [x for x in value if x not in exists_groups]
if not_exists:
raise VariableError(
_("User {user} is not exist in groups {groups}").format(
groups=", ".join(not_exists), user=login))
class VariableUrUnixSkel(Variable):
"""
Skel директория
"""
opt = ("-k", "--skel")
metavalue = "SKEL_DIR"
value = "/etc/skel"
def init(self):
self.label = _("Skeleton directory")
self.help = _("set skeletion directory for new account")
class VariableUrUnixCreateHomeSet(Variable):
"""
Создавать домашнюю директорию пользователю
"""
type = "bool"
opt = ("-m", "--create-home")
value = "off"
check_after = ["ur_unix_home_path"]
def init(self):
self.label = _("Create home directory")
self.help = _("create the user's home directory")
def check_on(self):
home_path = self.Get('ur_unix_home_path')
if path.exists(home_path):
raise VariableError(
_("Home directory %s already exists") % home_path)
class VariableUrUnixPw(Variable):
"""
Пароль пользователя
"""
type = "password"
opt = ("-p", "--password")
value = ""
untrusted = True
metavalue = "PASSWORD"
check_after = ["ur_unix_pw_delete_set", 'ur_unix_lock_set']
def init(self):
self.label = _("Password")
self.help = _("set user password")
def check(self, value):
delete_pw = self.GetBool('ur_unix_pw_delete_set')
change_lock = self.GetBool('ur_unix_lock_set')
if (self.Get('cl_unix_action') == Actions.Passwd and
not delete_pw and change_lock is None and not value):
raise PasswordError(_("Specify user password"))
if self.Get('cl_unix_action') in (Actions.Passwd, Actions.UserMod):
if self.Get('ur_unix_pw_delete_set') == 'on' and value:
raise VariableError(_("Can not use remove and "
"set the password options together"))
class VariableUrUnixPwSet(UnixActionHelper, UnixUserHelper, ReadonlyVariable):
"""
Указан ли пароль у пользователя
"""
type = "bool"
def init(self):
self.label = _("Password")
def get_exists(self):
username = self.Get('ur_unix_login')
pw = self.get_password_hash(username)
if pw and pw != self.DeletedPassword:
return "on"
else:
return "off"
class VariableUrUnixPwDeleteSet(Variable):
"""
Удалить пароль пользователя
"""
type = "bool"
value = "off"
opt = ("--delete-password",)
def init(self):
self.label = _("Remove user password")
self.help = _("delete the password for the named account")
class VariableUrUnixHash(HashHelper, ReadonlyVariable):
"""
Хэш пароля
"""
source = "unix.ur_unix_pw"
class VariableUrUnixUserObject(UnixUserHelper, UnixActionHelper,
ReadonlyVariable):
"""
Объект данных пользователя
"""
def get_exists(self):
login = self.Get('ur_unix_login')
if login:
return self.search_ldap_user_name(login) or ""
return ""
class VariableUrUnixShell(ExistsUserHelper, UnixActionHelper, Variable):
"""
Командная оболочка по умолчанию для пользователя
"""
attribute = "shell"
opt = ("-s", "--shell")
metavalue = "SHELL"
def init(self):
self.label = _("Shell")
self.help = _("login shell of the account")
def get_new(self):
return "/bin/bash"
class VariableUrUnixVisibleSet(ExistsUserHelper, UnixActionHelper, Variable):
"""
Виден ли пользователь
"""
attribute = "visible"
type = "boolauto"
opt = ("-v", "--visible")
def init(self):
self.label = _("Visible")
self.help = _("set visible of the account")
def get_new(self):
return "on"
def get_exists(self):
return "auto"
class VariableUrUnixLockSet(ExistsUserHelper, UnixActionHelper, Variable):
"""
Виден ли пользователь
"""
attribute = "lock"
type = "boolauto"
opt = ("-l", "--lock")
def init(self):
self.label = _("Locked")
self.help = _("lock the account")
def get(self):
return "auto"
class VariableUrUnixVisibleFlag(UnixUserHelper, ReadonlyVariable):
"""
Значение используемое для шаблона
"""
def get(self):
return self.visible_to_flag(self.GetBool('ur_unix_visible_set'))
class VariableUrUnixLockFlag(UnixUserHelper, ReadonlyVariable):
"""
Значение используемое для шаблона
"""
def get(self):
return self.lock_to_flag(self.GetBool('ur_unix_lock_set'))
class VariableUrUnixNextUid(LdapMaxHelper, ReadonlyVariable):
"""
Следующий свободный Uid
"""
base_dn = "{ld_unix_users_dn}"
search_filter = "uid=*"
attr = "uidNumber"
def get(self):
value = self.get_max()
if value is None:
return self.Get('ur_unix_min_uid')
else:
return str(value + 1)
class VariableUrUnixMinUid(Variable):
"""
Минимальный uid
"""
type = "int"
value = "10000"
class VariableUrUnixUserCount(UnixUserHelper, UnixActionHelper,
ReadonlyVariable):
"""
Количество пользователей
"""
type = "int"
def get_exists(self):
return len(self.ldap_user_list())
class VariableClUnixUserAliases(ReadonlyVariable):
"""
Алиасы для переменных
"""
type = "table"
value = [
# ('login', 'ur_unix_login'),
('uid', 'ur_unix_uid'),
('gid', 'ur_unix_primary_group'),
('comment', 'ur_unix_comment'),
('lock', 'ur_unix_lock_set'),
('visible', 'ur_unix_visible_set'),
('groups', 'ur_unix_groups'),
('home', 'ur_unix_home_path'),
('shell', 'ur_unix_shell'),
('password', 'ur_unix_pw_set'),
]
class VariableClUnixUserFields(FieldsHelper, Variable):
"""
Список полей для вывода данных группы
"""
alias_variable = "cl_unix_user_aliases"
class VariableClUnixUserShowFields(ShowFieldsHelper, ReadonlyVariable):
"""
Список переменных полей при отображении списка групп
"""
alias_variable = "cl_unix_user_aliases"
source_variable = "cl_unix_user_fields"
class VariableClUnixCreateGroupSet(UnixGroupHelper, ReadonlyVariable):
"""
Нужно ли создавать primary группу или она уже существует
"""
def get(self):
group_name = self.Get('ur_unix_primary_group')
if self.search_ldap_group("cn={0}".format(group_name)):
return "off"
return "on"
class VariableUrUnixUserShow(UnixUserHelper, UnixActionHelper, Variable):
"""
Фильтр на login
"""
type = "choiceedit"
opt = ["ur_unix_user_show"]
metavalue = "USER"
def init(self):
self.label = _("Login")
self.help = _("show user")
def get(self):
return ""
def choice_exists(self):
try:
return [("", "")] + self.ldap_user_list()
except LDAPConnectError as s:
raise VariableError(str(s))
def check_exists(self, value):
if value:
if not self.search_ldap_user_name(value):
raise VariableError(_("%s user not found") % value)