|
|
#-*- coding: utf-8 -*-
|
|
|
|
|
|
# Copyright 2008-2010 Mir Calculate Ltd. 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 os, sys, re
|
|
|
#from cl_print import color_print
|
|
|
from cl_datavars import DataVars
|
|
|
from server.utils import execProg
|
|
|
from cl_template import template
|
|
|
from cl_api import packagesAPI, APIError
|
|
|
from server.ldap import iniLdapParser, ldapFunction, shareldap
|
|
|
from server.utils import genSleep
|
|
|
from cl_utils import removeDir, _error
|
|
|
from cl_lang import lang
|
|
|
tr = lang()
|
|
|
tr.setLocalDomain('cl_ldap')
|
|
|
tr.setLanguage(sys.modules[__name__])
|
|
|
|
|
|
__version__ = "2.2.0.0"
|
|
|
__app__ = "calculate-ldap"
|
|
|
|
|
|
from cl_abstract import abs_api_service
|
|
|
|
|
|
class DataVarsLdap(DataVars):
|
|
|
"""Хранение переменных"""
|
|
|
# Имя секции в calculate2.env
|
|
|
envSection = "ldap"
|
|
|
def importLdap(self, **args):
|
|
|
'''Импорт переменных для calculate-ldap'''
|
|
|
# Импорт переменных
|
|
|
self.importData(self.envSection, ('cl_vars_ldap','cl_fill_ldap'))
|
|
|
|
|
|
class Template:
|
|
|
"""Templates methods"""
|
|
|
|
|
|
def applyTemplates(self):
|
|
|
"""Apply templates"""
|
|
|
clTempl = template(self.clVars)
|
|
|
dirsFiles = clTempl.applyTemplates()
|
|
|
if clTempl.getError():
|
|
|
self.printERROR(clTempl.getError().strip())
|
|
|
return False
|
|
|
else:
|
|
|
return dirsFiles
|
|
|
|
|
|
class shareVars:
|
|
|
"""share methods template vars"""
|
|
|
# template variables
|
|
|
clVars = False
|
|
|
|
|
|
def createClVars(self, clVars=False):
|
|
|
"""Создает объект Vars"""
|
|
|
if not clVars:
|
|
|
clVars = DataVarsLdap()
|
|
|
# Импортируем переменные
|
|
|
clVars.importLdap()
|
|
|
# Заменяем значения переменных переменными из env файлов
|
|
|
clVars.flIniFile()
|
|
|
# Устанавливаем у объекта атрибут объект переменных
|
|
|
self.clVars = clVars
|
|
|
return self.clVars
|
|
|
|
|
|
class internalMethods(abs_api_service, shareVars, Template):
|
|
|
'''Methods ldap service'''
|
|
|
prioritet = 25
|
|
|
nameService = "ldap"
|
|
|
nameDaemon = 'slapd'
|
|
|
_templDict = {'name':nameDaemon}
|
|
|
# files
|
|
|
pidFile = '/var/run/openldap/%(name)s.pid' %_templDict
|
|
|
# command
|
|
|
cmdPath = '/etc/init.d/%(name)s' %_templDict
|
|
|
_templDict.update({'cmd':cmdPath})
|
|
|
cmdStart = '%(cmd)s start' %_templDict
|
|
|
cmdReStart = '%(cmd)s restart' %_templDict
|
|
|
cmdStop = '%(cmd)s stop' %_templDict
|
|
|
cmdShowDaemons = 'rc-update show default'
|
|
|
reShowDaemons = re.compile("(.+)\s+\|\s+.+")
|
|
|
cmdAddRunlevel = 'rc-update add %(name)s default' %_templDict
|
|
|
cmdDelRunlevel = 'rc-update del %(name)s default' %_templDict
|
|
|
|
|
|
def get_service_name(self):
|
|
|
'''Get name service'''
|
|
|
return self.nameService
|
|
|
|
|
|
def get_pkg_name(self):
|
|
|
'''Get name service'''
|
|
|
return __app__
|
|
|
|
|
|
def get_vars(self):
|
|
|
'''Get Service vars'''
|
|
|
return self.createClVars(self.clVars)
|
|
|
|
|
|
def is_setup(self):
|
|
|
'''Is setup service (True/False)'''
|
|
|
self.createClVars(self.clVars)
|
|
|
return self.clVars.Get('sr_ldap_set') == "on"
|
|
|
|
|
|
def _getRunlevelDaemons(self):
|
|
|
"""Получаем всех демонов в default уровне"""
|
|
|
textLines = execProg(self.cmdShowDaemons)
|
|
|
if textLines is False:
|
|
|
self.printERROR(_("ERROR") + ": " + self.cmdShowDaemons)
|
|
|
return False
|
|
|
else:
|
|
|
daemons = []
|
|
|
for line in textLines:
|
|
|
res = self.reShowDaemons.search(line)
|
|
|
if res:
|
|
|
daemon = res.groups(0)[0]
|
|
|
daemons.append(daemon)
|
|
|
return daemons
|
|
|
|
|
|
def is_start(self):
|
|
|
'''Run ldap server (True/False)'''
|
|
|
if os.access(self.pidFile, os.R_OK):
|
|
|
pid = open(self.pidFile).read().strip()
|
|
|
if pid:
|
|
|
procDir = "/proc"+"/"+pid
|
|
|
if os.access(procDir, os.F_OK):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
def start(self):
|
|
|
'''Start LDAP server'''
|
|
|
if not self.is_start():
|
|
|
if execProg(self.cmdStart) is False:
|
|
|
self.printERROR(_("Can't execute '%s'") %self.cmdStart)
|
|
|
self.printNotOK(_("Starting LDAP") + " ...")
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def restart(self):
|
|
|
'''Restart LDAP server'''
|
|
|
if self.is_start():
|
|
|
if execProg(self.cmdReStart) is False:
|
|
|
self.printERROR(_("Can't execute '%s'") %self.cmdReStart)
|
|
|
self.printNotOK(_("Restarting LDAP")+ " ...")
|
|
|
return False
|
|
|
else:
|
|
|
return self.start()
|
|
|
return True
|
|
|
|
|
|
def stop(self):
|
|
|
'''Stop LDAP server'''
|
|
|
if self.is_start():
|
|
|
if execProg(self.cmdStop) is False:
|
|
|
self.printERROR(_("Can't execute '%s'") %self.cmdStop)
|
|
|
self.printNotOK(_("Stopping LDAP")+ " ...")
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def is_runlevel(self):
|
|
|
'''Находится ли LDAP в автозагрузке'''
|
|
|
daemons = self._getRunlevelDaemons()
|
|
|
if daemons is False:
|
|
|
return False
|
|
|
if self.nameDaemon in daemons:
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
def add_runlevel(self):
|
|
|
'''Add daemon to runlevel'''
|
|
|
if not self.is_runlevel():
|
|
|
if execProg(self.cmdAddRunlevel) is False:
|
|
|
self.printERROR(_("Can't execute '%s'") %self.cmdAddRunlevel)
|
|
|
self.printNotOK(_("service %(name)s added to runlevel")\
|
|
|
%self._templDict + " ...")
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def del_runlevel(self):
|
|
|
'''Delete daemon from runlevel'''
|
|
|
if self.is_runlevel():
|
|
|
if execProg(self.cmdDelRunlevel) is False:
|
|
|
self.printERROR(_("Can't execute '%s'") %self.cmdDelRunlevel)
|
|
|
self.printNotOK(_("service %(name)s removed from runlevel")\
|
|
|
%self._templDict + " ...")
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def get_prioritet(self):
|
|
|
'''Get run daemon prioritet'''
|
|
|
return self.prioritet
|
|
|
|
|
|
def del_vars_from_env(self):
|
|
|
'''Delete template vars in env files'''
|
|
|
self.createClVars(self.clVars)
|
|
|
deleteVariables = ("sr_ldap_set",)
|
|
|
locations = map(lambda x: x[0], self.clVars.Get("cl_env_data"))
|
|
|
for varName in deleteVariables:
|
|
|
for locate in locations:
|
|
|
if not self.clVars.Delete(varName, location=locate,
|
|
|
header=self.clVars.envSection):
|
|
|
fileName = filter(lambda x: x[0] == locate,
|
|
|
self.clVars.Get("cl_env_data"))[0][1]
|
|
|
self.printERROR(_("Can't delete variable '%(name)s' "
|
|
|
"in file %(file)s") %{'name':varName,
|
|
|
'file':fileName})
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def updateVars(self):
|
|
|
self.createClVars()
|
|
|
return True
|
|
|
|
|
|
def get_service_info(self, request):
|
|
|
'''Get service information'''
|
|
|
res = ""
|
|
|
if request == "scheme":
|
|
|
self.createClVars(self.clVars)
|
|
|
res = self.clVars.Get('ld_ldap_scheme_conf')
|
|
|
elif request == "access_pw":
|
|
|
self.createClVars(self.clVars)
|
|
|
res = self.clVars.Get('ld_ldap_access_pw_conf')
|
|
|
elif request == "access_dn":
|
|
|
self.createClVars(self.clVars)
|
|
|
res = self.clVars.Get('ld_ldap_access_dn_conf')
|
|
|
return res
|
|
|
|
|
|
def scheme(self):
|
|
|
'''include lines in slapd.conf'''
|
|
|
return self.get_service_info('scheme')
|
|
|
|
|
|
def access_pw(self):
|
|
|
'''Access userPasswod lines in slapd.conf'''
|
|
|
return self.get_service_info('access_pw')
|
|
|
|
|
|
def access_dn(self):
|
|
|
'''Access DN lines in slapd.conf'''
|
|
|
return self.get_service_info('access_dn')
|
|
|
|
|
|
def apply_templates(self):
|
|
|
'''Apply package templates'''
|
|
|
if self.is_setup():
|
|
|
self.clVars.Set("ac_ldap_update","up", force=True)
|
|
|
return Template.applyTemplates(self)
|
|
|
return True
|
|
|
|
|
|
class Singleton(object):
|
|
|
_instance = None
|
|
|
def __new__(cls, *args, **kwargs):
|
|
|
if not cls._instance:
|
|
|
cls._instance = super(Singleton, cls).__new__(
|
|
|
cls, *args, **kwargs)
|
|
|
return cls._instance
|
|
|
|
|
|
class allMethods(Singleton, internalMethods, shareldap):
|
|
|
"""Методы севисa Ldap"""
|
|
|
# Базовый ldif файл
|
|
|
ldifFileBase = '/usr/lib/calculate-2.2/calculate-ldap/ldif/base.ldif'
|
|
|
apiFile = '/usr/lib/calculate-2.2/calculate-ldap/pym/cl_ldap_api.py'
|
|
|
libAPIObj = packagesAPI()
|
|
|
|
|
|
def removeLdapDatabase(self):
|
|
|
"""Удаляем предыдущую базу данных"""
|
|
|
pathDatabase = "/var/lib/openldap-data"
|
|
|
#if os.path.exists(pathDatabase) and os.listdir(pathDatabase):
|
|
|
#if os.system("rm /var/lib/openldap-data/* &>/dev/null") !=0:
|
|
|
#self.printERROR("Can't remove /var/lib/openldap-data/*")
|
|
|
#return False
|
|
|
#return True
|
|
|
if os.path.exists(pathDatabase):
|
|
|
fileOrDirNames = os.listdir(pathDatabase)
|
|
|
if fileOrDirNames:
|
|
|
for fileOrDirName in fileOrDirNames:
|
|
|
fullFileOrDirName = os.path.join(pathDatabase,
|
|
|
fileOrDirName)
|
|
|
if os.path.isdir(fullFileOrDirName):
|
|
|
try:
|
|
|
removeDir(pathDatabase)
|
|
|
except:
|
|
|
self.printERROR(_("Can't remove directory %s")\
|
|
|
%fullFileOrDirName)
|
|
|
return False
|
|
|
else:
|
|
|
try:
|
|
|
os.remove(fullFileOrDirName)
|
|
|
except:
|
|
|
self.printERROR(_("Can't remove file %s")\
|
|
|
%fullFileOrDirName)
|
|
|
return False
|
|
|
self.printOK(_("Erased LDAP Database") + " ...")
|
|
|
return True
|
|
|
|
|
|
def connectLdapServer(self):
|
|
|
"""Соединяемся с LDAP сервером
|
|
|
|
|
|
используем DN и пароль временного админстратора
|
|
|
"""
|
|
|
# Если раннее была ошибка то выходим
|
|
|
if self.getError():
|
|
|
self.printERROR (_("ERROR") + ": " +\
|
|
|
self.getError().strip())
|
|
|
return False
|
|
|
tmpDn = self.clVars.Get("ld_temp_dn")
|
|
|
tmpPw = self.clVars.Get("ld_temp_pw")
|
|
|
ldapObj = ldapFunction(tmpDn, tmpPw)
|
|
|
# Генератор задержек
|
|
|
wait = genSleep()
|
|
|
while ldapObj.getError():
|
|
|
try:
|
|
|
# Задержка
|
|
|
wait.next()
|
|
|
except StopIteration:
|
|
|
break
|
|
|
# Очистка ошибки
|
|
|
_error.error = []
|
|
|
ldapObj = ldapFunction(tmpDn, tmpPw)
|
|
|
self.ldapObj = ldapObj
|
|
|
self.conLdap = ldapObj.conLdap
|
|
|
if ldapObj.getError():
|
|
|
# Удаляем одинаковые ошибки
|
|
|
listError = []
|
|
|
for e in ldapObj.error:
|
|
|
if not e in listError:
|
|
|
listError.append(e)
|
|
|
_error.error = listError
|
|
|
self.printERROR(_("Can not connected to LDAP server"))
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def setup(self, force=False):
|
|
|
"""Настройка LDAP сервиса (создание дерева)"""
|
|
|
# Принудительная установка
|
|
|
if self.clVars.Get("sr_ldap_set") == "on" and not force:
|
|
|
self.printWARNING (_("WARNING") + ": " +\
|
|
|
_("LDAP server is configured")+ ".")
|
|
|
return True
|
|
|
if not force:
|
|
|
# предупреждение при выполнении этой программы будут изменены
|
|
|
# конфигурационные файлы и база данных сервиса LDAP а также
|
|
|
# конфигурационные файлы установленных сервисов
|
|
|
self.printWARNING (_("WARNING") + ": " +\
|
|
|
_("Executing of the program will change") + " " +\
|
|
|
_("the configuration files and database of LDAP service")+\
|
|
|
".")
|
|
|
# если вы готовы продолжить работу программы нажмите Y если нет n
|
|
|
messDialog = \
|
|
|
_("If you are ready to continue executing the program")+", "+\
|
|
|
_("input 'yes'") +", "+ _("if not 'no'")
|
|
|
if not dialogYesNo(messDialog):
|
|
|
return True
|
|
|
else:
|
|
|
# делаем backup
|
|
|
# Проверим запущен ли ldap
|
|
|
if not self.is_start():
|
|
|
# Запускаем LDAP сервер
|
|
|
if not self.start():
|
|
|
return False
|
|
|
#if not self.backupServer():
|
|
|
#return False
|
|
|
if self.is_runlevel():
|
|
|
# Удаляем из автозапуска демона
|
|
|
if not self.del_runlevel():
|
|
|
return False
|
|
|
listAPIObj = self.libAPIObj.all.APIList()
|
|
|
listAPIObjReverse = self.libAPIObj.all.APIListReverse()
|
|
|
if filter(lambda x:\
|
|
|
x.api.get_pkg_name()=="calculate_ldap",listAPIObj):
|
|
|
self.printERROR(_("Can not found API module in package "
|
|
|
"calculate-ldap"))
|
|
|
self.printWARNING(_("Run: cl-ldap-setup --install"))
|
|
|
return False
|
|
|
# Останавливаем все установленные сервисы
|
|
|
for obj in listAPIObjReverse:
|
|
|
apiObj = obj.api
|
|
|
if hasattr(apiObj, 'stop') and not apiObj.stop():
|
|
|
return False
|
|
|
# Удаляем из автозагрузки все установленные сервисы
|
|
|
for obj in listAPIObjReverse:
|
|
|
apiObj = obj.api
|
|
|
if hasattr(apiObj, 'del_runlevel') and not apiObj.del_runlevel():
|
|
|
return False
|
|
|
# Удаляем из крона скрипт для чистки удаленых пользователей
|
|
|
# создаем объект репликации
|
|
|
#objRepl = servRepl()
|
|
|
#if not objRepl.cronReplicationOFF():
|
|
|
#return False
|
|
|
# Удаляем из share файл .replrun
|
|
|
#if not self.servSambaObj.delReplFile(self.clVars):
|
|
|
#return False
|
|
|
# Удаляем переменные
|
|
|
for obj in listAPIObjReverse:
|
|
|
apiObj = obj.api
|
|
|
if hasattr(apiObj,'del_vars_from_env') and \
|
|
|
not apiObj.del_vars_from_env():
|
|
|
return False
|
|
|
# Получим путь к ldap файлу
|
|
|
ldapParser = iniLdapParser()
|
|
|
ldapFile = ldapParser.nameIniFile
|
|
|
# Удаляем ldap файл
|
|
|
if os.path.exists(ldapFile):
|
|
|
os.remove(ldapFile)
|
|
|
self.clVars.Write("sr_ldap_set", "off",force=True)
|
|
|
self.clVars.Set("sr_ldap_set", "on", force=True)
|
|
|
self.clVars.Set("ac_ldap_setup","up", force=True)
|
|
|
# Первый проход
|
|
|
self.clVars.Set("cl_pass_step", "1", True)
|
|
|
if self.applyTemplates() is False:
|
|
|
self.printERROR(_("Can not apply templates") + ":" + " " +\
|
|
|
_("first pass"))
|
|
|
return False
|
|
|
# Удаляем старую базу данных
|
|
|
if not self.removeLdapDatabase():
|
|
|
return False
|
|
|
# Запускаем LDAP сервер
|
|
|
if not self.start():
|
|
|
return False
|
|
|
# Соединяемся с LDAP временным пользователем
|
|
|
if not self.connectLdapServer():
|
|
|
return False
|
|
|
# Получаем текст нужного ldif-a
|
|
|
baseLdif = self.createLdif(self.ldifFileBase)
|
|
|
# Если нет ошибок при соединении применяем ldif
|
|
|
if not self.ldapObj.getError():
|
|
|
self.ldapObj.ldapAdd(baseLdif)
|
|
|
if self.ldapObj.getError():
|
|
|
print _("LDAP Error") + ": " + self.ldapObj.getError().strip()
|
|
|
return False
|
|
|
self.printOK(_("Added ldif file") + " ...")
|
|
|
# Второй проход,
|
|
|
# удаляем временного пользователя root из конфигурационного файла
|
|
|
self.clVars.Set("cl_pass_step","2",True)
|
|
|
if self.applyTemplates() is False:
|
|
|
self.printERROR(_("Can not apply profiles") +":"+ _("second pass"))
|
|
|
return False
|
|
|
# Перезапускаем LDAP сервер
|
|
|
if not self.restart():
|
|
|
return False
|
|
|
# Записываем данные администратора сервера
|
|
|
ldapParser.setVar("admin",
|
|
|
{"DN":self.clVars.Get("ld_admin_dn"),
|
|
|
"PASS":self.clVars.Get("ld_admin_pw")})
|
|
|
# Устанавливаем автозапуск демона
|
|
|
if not self.add_runlevel():
|
|
|
return False
|
|
|
# Записываем переменные для пользователя
|
|
|
#clientVars = ["ur_organization", "ur_signature"]
|
|
|
#if not self.saveVarsClient(clientVars):
|
|
|
#return False
|
|
|
#self.apply_templates()
|
|
|
self.clVars.Write("sr_ldap_set","on",force=True)
|
|
|
self.printOK(_("LDAP service configured") + " ...")
|
|
|
return True
|
|
|
|
|
|
REGISTERED_METHODS = ['access_pw', 'access_pw', 'add_runlevel',
|
|
|
'apply_templates', 'get_pkg_name', 'get_prioritet', 'get_service_info',
|
|
|
'get_service_name', 'get_vars', 'is_runlevel', 'is_setup', 'is_start',
|
|
|
'restart', 'scheme', 'setup', 'start', 'stop']
|
|
|
|
|
|
class serviceAPI(object):
|
|
|
"""Proxy object"""
|
|
|
def __init__(self):
|
|
|
self.__subject = allMethods()
|
|
|
for attr in dir(self.__subject):
|
|
|
if attr in REGISTERED_METHODS:
|
|
|
object.__setattr__(self, attr, getattr(self.__subject, attr))
|
|
|
|
|
|
|
|
|
|
