|
|
#-*- coding: utf-8 -*-
|
|
|
|
|
|
# Copyright 2008-2010 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
|
|
|
import sys
|
|
|
import types
|
|
|
import time
|
|
|
from cl_print import color_print
|
|
|
from cl_template import template
|
|
|
from server.utils import execProg
|
|
|
# Перевод модуля
|
|
|
import cl_lang
|
|
|
tr = cl_lang.lang()
|
|
|
tr.setLocalDomain('cl_lib')
|
|
|
tr.setLanguage(sys.modules[__name__])
|
|
|
|
|
|
class services(color_print):
|
|
|
"""Общие методы для серверных программ,
|
|
|
|
|
|
Методы для работы с сервисами"""
|
|
|
|
|
|
# Переменная объект Vars
|
|
|
clVars = False
|
|
|
# Сервисы и демоны
|
|
|
servicesDaemons = {"ldap":["slapd"],
|
|
|
"unix":["slapd"],
|
|
|
"samba":["samba"],
|
|
|
"mail":["postfix","dovecot"],
|
|
|
"mail_relay":["postfix"],
|
|
|
"jabber":["ejabberd"],
|
|
|
"ftp":["proftpd"],
|
|
|
"proxy":["squid"],
|
|
|
"dns":["named"],
|
|
|
"dhcp":["dhcpd"]}
|
|
|
|
|
|
def getServiceSetup(self):
|
|
|
"""находит установленные сервисы
|
|
|
|
|
|
Выдаем список [установленные сервисы]
|
|
|
"""
|
|
|
# инсталированнные сервисы
|
|
|
servInstalled = []
|
|
|
# доступные сервисы
|
|
|
services = ('ldap', 'unix', 'samba', 'mail',
|
|
|
'jabber', 'ftp', 'proxy', 'dns', 'dhcp')
|
|
|
for serv in services:
|
|
|
if self.clVars.Get("sr_%s_set"%serv) == "on":
|
|
|
servInstalled.append(serv)
|
|
|
return servInstalled
|
|
|
|
|
|
def _getDefaultRunlevelDaemons(self):
|
|
|
"""Получаем всех демонов в default уровне"""
|
|
|
execStr = "rc-update show"
|
|
|
textLine = execProg(execStr, None, False)
|
|
|
if textLine == False:
|
|
|
self.printERROR(_("ERROR") + ": " + execStr)
|
|
|
return False
|
|
|
else:
|
|
|
splLines = filter(lambda x: len(x)==2 and "default" in x[1],\
|
|
|
map(lambda x: x.split("|"),textLine))
|
|
|
splLines = map(lambda x: x[0].strip(), splLines)
|
|
|
return splLines
|
|
|
|
|
|
|
|
|
def setDaemonAutostart(self, daemon):
|
|
|
"""Прописывает демона в автозагрузку"""
|
|
|
if daemon in self._getDefaultRunlevelDaemons():
|
|
|
return True
|
|
|
execStr = "rc-update add %s default" %daemon
|
|
|
textLine = execProg(execStr)
|
|
|
if textLine == False:
|
|
|
self.printERROR(_("ERROR") + ": " + execStr)
|
|
|
self.printERROR(_("Can not add '%s' at default runlevel")%daemon)
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def delDaemonAutostart(self, daemon):
|
|
|
"""Удаляет демона из автозагрузки"""
|
|
|
if not (daemon in self._getDefaultRunlevelDaemons()):
|
|
|
return True
|
|
|
self._getDefaultRunlevelDaemons()
|
|
|
execStr = "rc-update del %s default" %daemon
|
|
|
textLine = execProg(execStr)
|
|
|
if textLine == False:
|
|
|
self.printERROR(_("ERROR") + ": " + execStr)
|
|
|
self.printERROR(_("Can not deleted '%s' from default runlevel")\
|
|
|
%daemon)
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def runLdapServer(self):
|
|
|
"""Запускает LDAP сервер"""
|
|
|
textLines = execProg("/etc/init.d/slapd start")
|
|
|
if textLines == False:
|
|
|
self.printNotOK(_("Starting LDAP")+ " ...")
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def restartLdapServer(self):
|
|
|
"""Запускает LDAP сервер"""
|
|
|
textLines = execProg("/etc/init.d/slapd restart")
|
|
|
if textLines == False:
|
|
|
self.printNotOK(_("Restarting LDAP")+ " ...")
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def stopLdapServer(self):
|
|
|
"""Останавливает LDAP сервер"""
|
|
|
textLines = execProg("/etc/init.d/slapd stop")
|
|
|
if textLines == False:
|
|
|
self.printNotOK(_("Stopping LDAP")+ " ...")
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def getALLServices(self):
|
|
|
"""Получаем все сервисы которые описаны в шаблонах"""
|
|
|
# путь к директории шаблонов
|
|
|
templatePath = self.clVars.Get("cl_template_path")[0]
|
|
|
data = os.listdir(templatePath)
|
|
|
service = []
|
|
|
for fileData in data:
|
|
|
if os.path.isdir(os.path.join(templatePath, fileData)):
|
|
|
service.append(fileData)
|
|
|
if service:
|
|
|
# После добавления сервисов в класс необходимо удалить
|
|
|
# apache и backup
|
|
|
if 'backup' in service:
|
|
|
service.remove('backup')
|
|
|
if 'apache' in service:
|
|
|
service.remove('apache')
|
|
|
return service
|
|
|
|
|
|
def getTemplatePath(self, nameService):
|
|
|
"""список накладываемых профилей в зависимости от сервиса"""
|
|
|
profpath = []
|
|
|
profPaths = ['/usr/lib/calculate/calculate-server/profile/%s'\
|
|
|
%nameService,
|
|
|
'/var/calculate/remote/server-profile/%s'%nameService,
|
|
|
'/var/calculate/server-profile/%s'%nameService]
|
|
|
for profPath in profPaths:
|
|
|
if os.path.exists(profPath):
|
|
|
profpath.append(profPath)
|
|
|
return profpath
|
|
|
|
|
|
def applyTemplatesFromService(self, service, verbose=False):
|
|
|
"""Применяем шаблоны для данного сервиса"""
|
|
|
# Пути к шаблонам для сервиса
|
|
|
profPaths = self.getTemplatePath(service)
|
|
|
# Устанавливаем пути к шаблонам для сервиса
|
|
|
self.clVars.Set("cl_template_path", profPaths, True)
|
|
|
clTempl = template(self.clVars)
|
|
|
# Объединяем шаблоны
|
|
|
data = clTempl.applyTemplates()
|
|
|
if clTempl.getError():
|
|
|
self.printERROR(clTempl.getError())
|
|
|
return False
|
|
|
else:
|
|
|
if verbose and type(data) == types.TupleType:
|
|
|
dirs, files = data
|
|
|
return files
|
|
|
return True
|
|
|
|
|
|
def delServicesAutostart(self, servInstalled):
|
|
|
"""Удаляет из автозагрузки сервисы
|
|
|
|
|
|
Входные данные - список названий сервисов
|
|
|
"""
|
|
|
flagError = False
|
|
|
delDaemons = []
|
|
|
for service in servInstalled:
|
|
|
if not service in self.servicesDaemons.keys():
|
|
|
self.printERROR(_("Not supported service '%s'")%service)
|
|
|
self.printERROR(\
|
|
|
_("Can not deleted service from default runlevel"))
|
|
|
flagError = True
|
|
|
break
|
|
|
for daemon in self.servicesDaemons[service]:
|
|
|
if not daemon in delDaemons:
|
|
|
delDaemons.append(daemon)
|
|
|
if not self.delDaemonAutostart(daemon):
|
|
|
flagError = True
|
|
|
break
|
|
|
if flagError:
|
|
|
break
|
|
|
if flagError:
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def startDaemons(self, service, daemons, printSuccess=True):
|
|
|
"""Стартует демонов"""
|
|
|
flagError = False
|
|
|
for daemon in daemons:
|
|
|
if not self.getRunDaemons([daemon]):
|
|
|
textLines = execProg("/etc/init.d/%s start" %(daemon))
|
|
|
if textLines == False:
|
|
|
self.printERROR( _("Daemon %s was not started") %daemon)
|
|
|
flagError = True
|
|
|
break
|
|
|
prnService = self.printNameService(service)
|
|
|
if flagError:
|
|
|
self.printNotOK(_("Starting") + " " + prnService + " " +\
|
|
|
_("service") + " ...")
|
|
|
return False
|
|
|
else:
|
|
|
if printSuccess:
|
|
|
self.printOK(_("Starting") + " " + prnService + " "+\
|
|
|
_("service") + " ...")
|
|
|
return True
|
|
|
|
|
|
def startServices(self, servInstalled, printSuccess=True):
|
|
|
"""Запускает все сервисы поданные на вход этому методу
|
|
|
|
|
|
Также прописывает в автозагрузку
|
|
|
Входные даннные - список названий сервисов
|
|
|
"""
|
|
|
addDaemons = []
|
|
|
if 'ldap' in servInstalled or 'unix' in servInstalled:
|
|
|
if not self.startDaemons('ldap',['slapd'], printSuccess):
|
|
|
return False
|
|
|
# Устанавливаем автозапуск демона
|
|
|
if not self.setDaemonAutostart("slapd"):
|
|
|
return False
|
|
|
addDaemons.append("slapd")
|
|
|
flagError = False
|
|
|
for service in servInstalled:
|
|
|
if not service in self.servicesDaemons.keys():
|
|
|
self.printERROR(_("Can not supported service '%s'")%service)
|
|
|
self.printERROR(_("Can not add service at default runlevel"))
|
|
|
flagError = True
|
|
|
break
|
|
|
for daemon in self.servicesDaemons[service]:
|
|
|
if not daemon in addDaemons:
|
|
|
addDaemons.append(daemon)
|
|
|
if not self.startDaemons(service, [daemon], printSuccess):
|
|
|
flagError = True
|
|
|
break
|
|
|
if not self.setDaemonAutostart(daemon):
|
|
|
flagError = True
|
|
|
break
|
|
|
if flagError:
|
|
|
break
|
|
|
if flagError:
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def stopServices(self, servInstalled):
|
|
|
"""Останавливает все сервисы поданные на вход этому методу
|
|
|
|
|
|
Входные даннные - список названий сервисов
|
|
|
"""
|
|
|
addDaemons = []
|
|
|
if 'ldap' in servInstalled or 'unix' in servInstalled:
|
|
|
addDaemons.append("slapd")
|
|
|
flagError = False
|
|
|
for service in servInstalled:
|
|
|
if not service in self.servicesDaemons.keys():
|
|
|
self.printERROR(_("Can not supported service '%s'")%service)
|
|
|
self.printERROR(_("Can not stop service"))
|
|
|
flagError = True
|
|
|
break
|
|
|
# Название сервиса для вывода на экран
|
|
|
servicePrn = self.printNameService(service)
|
|
|
for daemon in self.servicesDaemons[service]:
|
|
|
if not daemon in addDaemons:
|
|
|
addDaemons.append(daemon)
|
|
|
# Если демон запущен и не squid то останавливаем его
|
|
|
if not daemon in ["squid"] and self.getRunDaemons([daemon]):
|
|
|
ret = execProg("/etc/init.d/%s stop"%daemon)
|
|
|
if ret == False:
|
|
|
self.printERROR(servicePrn + " " +\
|
|
|
_("service is not stopped"))
|
|
|
flagError = True
|
|
|
break
|
|
|
# Удаляем процессы ejabberd
|
|
|
if daemon == "ejabberd":
|
|
|
strCmd = "ps ax"
|
|
|
listProcess = execProg(strCmd,False,False)
|
|
|
if listProcess == False:
|
|
|
self.printERROR(_('Can not execute "%s"')%strCmd)
|
|
|
return False
|
|
|
killPid = []
|
|
|
for process in listProcess:
|
|
|
if "erlang" in process:
|
|
|
killPid.append(process.split(" ")[0])
|
|
|
if killPid and " ".join(killPid).strip():
|
|
|
textLine=execProg("kill %s" %" ".join(killPid))
|
|
|
if textLine == False:
|
|
|
self.printERROR(_("Can not 'kill %s'")\
|
|
|
%" ".join(killPid))
|
|
|
flagError = True
|
|
|
break
|
|
|
elif daemon == "squid" and self.getRunDaemons(["squid"]):
|
|
|
errStopProxy = False
|
|
|
# Создаем 2 процесса
|
|
|
pid = os.fork()
|
|
|
tic = 0
|
|
|
if pid:
|
|
|
message = _("Waiting for squid to shutdown") + " "
|
|
|
self.printSUCCESS(message, 0, False)
|
|
|
perm = [0]
|
|
|
offset = 0
|
|
|
while not perm[0]:
|
|
|
perm = os.waitpid(pid, os.WNOHANG)
|
|
|
if perm[1]:
|
|
|
errStopProxy = True
|
|
|
break
|
|
|
time.sleep(0.1)
|
|
|
tic += 1
|
|
|
if tic>=15:
|
|
|
sys.stdout.flush()
|
|
|
sys.stdout.write(".")
|
|
|
offset += 1
|
|
|
tic = 0
|
|
|
if errStopProxy:
|
|
|
self.printOnlyNotOK(" ",\
|
|
|
self.lenString(message)+\
|
|
|
offset+3)
|
|
|
else:
|
|
|
self.printOnlyOK(" ",self.lenString(message)+\
|
|
|
offset+3)
|
|
|
else:
|
|
|
sys.stdout.flush()
|
|
|
if os.system("/etc/init.d/squid stop &>/dev/null"):
|
|
|
sys.exit(1)
|
|
|
else:
|
|
|
sys.exit(0)
|
|
|
# Если ошибка при остановке proxy сервера
|
|
|
if errStopProxy:
|
|
|
self.printERROR(servicePrn + " " +\
|
|
|
_("service is not stopped"))
|
|
|
flagError = True
|
|
|
break
|
|
|
if flagError:
|
|
|
break
|
|
|
if not flagError and "slapd" in addDaemons:
|
|
|
if self.getRunService('ldap'):
|
|
|
textLines = execProg("/etc/init.d/slapd stop")
|
|
|
if textLines == False:
|
|
|
self.printERROR("LDAP" + " " +\
|
|
|
_("service is not stopped"))
|
|
|
flagError = True
|
|
|
if flagError:
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def getRunDaemons(self, daemons, printError=False):
|
|
|
"""Проверка, запущены ли демоны"""
|
|
|
baseDir = "/var/run"
|
|
|
runDaemons = {}
|
|
|
flagBaselayoutDir = False
|
|
|
for daemon in daemons:
|
|
|
# Проверка на запуск демона postfix
|
|
|
if daemon == 'postfix':
|
|
|
flagRun = False
|
|
|
strCmd = "ps ax"
|
|
|
listProcess = execProg(strCmd, False, False)
|
|
|
if not listProcess:
|
|
|
self.printERROR(_('Can not execute "%s"')%strCmd)
|
|
|
return False
|
|
|
for process in listProcess:
|
|
|
if "postfix/master" in process:
|
|
|
flagRun = True
|
|
|
break
|
|
|
if flagRun:
|
|
|
runDaemons['postfix'] = True
|
|
|
else:
|
|
|
runDaemons['postfix'] = False
|
|
|
continue
|
|
|
addDirDict = {"slapd":("openldap","slapd.pid"),
|
|
|
"dovecot":("dovecot","master.pid"),
|
|
|
"proftpd":("","proftpd.pid"),
|
|
|
"squid":("","squid.pid")}
|
|
|
baselayoutDir = "/var/lib/init.d/daemons"
|
|
|
if not flagBaselayoutDir:
|
|
|
if os.path.exists(baselayoutDir):
|
|
|
flagBaselayoutDir = True
|
|
|
if flagBaselayoutDir:
|
|
|
addDirDict["ejabberd"] = (baselayoutDir,"ejabberd")
|
|
|
addDirDict["samba"] = (baselayoutDir,"samba")
|
|
|
addDirDict["named"] = (baselayoutDir,"named")
|
|
|
addDirDict["dhcpd"] = (baselayoutDir,"dhcpd")
|
|
|
elif daemon in ["ejabberd", "samba", "named", "dhcpd"]:
|
|
|
if not os.system("/lib/rc/bin/service_started %s" %daemon):
|
|
|
runDaemons[daemon] = True
|
|
|
else:
|
|
|
runDaemons[daemon] = False
|
|
|
continue
|
|
|
if addDirDict[daemon][0][:1] == "/":
|
|
|
pidDir = addDirDict[daemon][0]
|
|
|
else:
|
|
|
pidDir = os.path.join(baseDir,addDirDict[daemon][0])
|
|
|
if os.access(pidDir, os.F_OK) and os.listdir(pidDir) and\
|
|
|
os.path.exists(os.path.join(pidDir,addDirDict[daemon][1])):
|
|
|
runDaemons[daemon] = True
|
|
|
else:
|
|
|
runDaemons[daemon] = False
|
|
|
if printError:
|
|
|
for daemon in daemons:
|
|
|
if not runDaemons[daemon]:
|
|
|
self.printERROR(_("Daemon %s is not started") %daemon)
|
|
|
if False in runDaemons.values():
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
|
|
|
def getRunService(self, nameService, printError=False):
|
|
|
"""Проверка, запущен ли сервис с данным именем"""
|
|
|
flagError = False
|
|
|
if not nameService in self.servicesDaemons.keys():
|
|
|
self.printERROR(_("Can not supported service '%s'")%nameService)
|
|
|
self.printERROR(_("Can not check run service"))
|
|
|
return False
|
|
|
# Названия демонов для сервиса
|
|
|
daemons = self.servicesDaemons[nameService]
|
|
|
if not self.getRunDaemons(daemons, printError):
|
|
|
flagError = True
|
|
|
if flagError:
|
|
|
if printError:
|
|
|
self.printERROR(self.printNameService(nameService) + " " +\
|
|
|
_("service is not started"))
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def isServiceSetup(self, service, printError=True):
|
|
|
"""Проверяет установлен ли сервис"""
|
|
|
if not self.clVars:
|
|
|
# Cоздаем объект переменные
|
|
|
self.createClVars()
|
|
|
if self.clVars.Get("sr_%s_set"%service) == "on":
|
|
|
return True
|
|
|
if printError:
|
|
|
self.printERROR(_("Service %s is not installed")%service)
|
|
|
return False
|
|
|
|
|
|
def initialChecks(self, service, printError=True):
|
|
|
"""Начальная проверка перед запуском методов сервиса"""
|
|
|
# Создаем объект переменных
|
|
|
self.createClVars()
|
|
|
if self.clVars.Get("sr_mail_relay_set") == "on":
|
|
|
if printError:
|
|
|
self.printERROR(_("This server is a mail relay. \
|
|
|
This command is not allowed."))
|
|
|
return False
|
|
|
if not self.isServiceSetup(service, printError):
|
|
|
return False
|
|
|
return True
|
|
|
|
|
|
def initialChecksSetup(self):
|
|
|
# Создаем объект переменных
|
|
|
self.createClVars()
|
|
|
"""Начальная проверка перед запуском метода setup"""
|
|
|
if self.clVars.Get("sr_mail_relay_set") == "on":
|
|
|
self.printERROR(_("This server is a mail relay. \
|
|
|
This command is not allowed."))
|
|
|
return False
|
|
|
return True
|
