Merge branch 'py3_forced'

master
commit 9ede582b1e

@ -11,6 +11,14 @@ account required pam_unix.so
account sufficient pam_ldap.so account sufficient pam_ldap.so
#?pkg(cracklib)!=# #?pkg(cracklib)!=#
<<<<<<< HEAD
=======
password required pam_cracklib.so difok=2 minlen=8 dcredit=2 ocredit=2 try_first_pass retry=3
#pkg#
#?pkg(passwdqc)!=#
password required pam_passwdqc.so min=8,8,8,8,8 retry=3
#pkg#
>>>>>>> py3_forced
password required pam_cracklib.so difok=2 minlen=8 dcredit=2 ocredit=2 try_first_pass retry=3 password required pam_cracklib.so difok=2 minlen=8 dcredit=2 ocredit=2 try_first_pass retry=3
#pkg# #pkg#
#?pkg(passwdqc)!=# #?pkg(passwdqc)!=#

File diff suppressed because it is too large Load Diff

@ -0,0 +1,304 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 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.
_ = lambda x : x
import re
import os
import types
import cl_utils
import cl_base
class fillVars(cl_base.glob_attr):
def get_os_net_domain(self):
''' Определим домен'''
domain=self._runos("hostname -d 2>&1")
if not domain:
print(_("Error:") + " " +_("Not found domain name"))
print(_("Command 'hostname -d' returns an empty value"))
cl_base.exit(1)
elif re.search("^hostname: ",domain):
return "local"
else:
return domain
def get_os_linux_shortname(self):
'''Получить переменную короткого названия системы'''
path = '/etc/calculate/calculate.ini'
if os.path.exists(path):
FD = open(path)
data = FD.readlines()
FD.close()
shortNameList = [x for x in (len(y.split("=")) == 2 and\
y.split("=")[0]=="calculate" and\
y.split("=")[1].strip() for y in data) if x]
if shortNameList:
return shortNameList[0]
gentooFile = "/etc/gentoo-release"
shortName = "Linux"
if os.path.exists(gentooFile):
shortName = "Gentoo"
return shortName
def get_os_linux_name(self):
"""полное название системы"""
linuxShortName = self.Get("os_linux_shortname")
if linuxShortName:
dictLinuxName = {"CLD":"Calculate Linux Desktop",
"CLDX":"Calculate Linux Desktop",
"CLDG":"Calculate Linux Desktop",
"CDS":"Calculate Directory Server",
"Gentoo":"Gentoo"}
if linuxShortName in dictLinuxName.keys():
return dictLinuxName[linuxShortName]
else:
return "Linux"
else:
return "Linux"
def get_os_linux_subname(self):
"""постфикс к названию системы"""
linuxShortName = self.Get("os_linux_shortname")
if linuxShortName:
dictLinuxSubName = {"CLD":"KDE", "CLDX":"XFCE", "CLDG":"GNOME"}
if linuxShortName in dictLinuxSubName.keys():
return dictLinuxSubName[linuxShortName]
else:
return ""
else:
return ""
def get_os_linux_ver(self):
'''Получить версию системы'''
path = '/etc/calculate/calculate.ini'
if os.path.exists(path):
FD = open(path)
data = FD.readlines()
FD.close()
shortNameList = [x for x in ( len(y.split("="))==2 and\
y.split("=")[0]=="linuxver" and\
y.split("=")[1].strip() for y in data) if x]
if shortNameList:
return shortNameList[0]
gentooFile = "/etc/gentoo-release"
systemVersion = ""
flagGentoo = False
if os.path.exists(gentooFile):
gentooLink = "/etc/make.profile"
if os.path.islink(gentooLink):
systemVersion = os.readlink(gentooLink).rpartition("/")[2]
flagGentoo = True
if not flagGentoo:
kernelVersion=self._runos("uname -r")
if kernelVersion:
systemVersion = kernelVersion.partition("-")[0]
return systemVersion
def get_os_net_hostname(self):
'''Считать имя компьютера net_host'''
hostname=self._runos("hostname -s 2>&1")
if not hostname:
return ""
if re.search("^hostname: ",hostname):
hostname=self._runos("hostname 2>&1")
if not hostname:
return ""
if re.search("^hostname: ",hostname):
return self.Get('os_linux_shortname')
else:
if hostname=='livecd':
return self.Get('os_linux_shortname')
return hostname
# все ip
def get_os_net_ip(self):
"""все ip компьютера, разделитель запятая"""
return ",".join(cl_utils.getIp(x) for x in cl_utils.getInterfaces())
# Разрешенные сети (в данном случае все сети)
def get_os_net_allow(self):
"""Разрешенные сети разделитель запятая"""
networks=[]
netInterfaces=cl_utils.getInterfaces()
for i in netInterfaces:
ipaddr, mask = cl_utils.getIp(i), \
cl_utils.cidrToMask(cl_utils.getMask(i))
if ipaddr and mask:
networks.append(cl_utils.getIpNet(ipaddr, mask))
else:
networks.append("")
return ",".join(x for x in networks if x)
def get_os_locale_locale(self):
"""локаль (прим: ru_RU.UTF-8)"""
if "LANG" in os.environ:
return os.environ["LANG"]
else:
return "en_US.UTF-8"
def get_os_locale_lang(self):
"""язык (прим: ru_RU)"""
locale = self.Get("os_locale_locale")
if locale:
return locale.split(".")[0]
return ""
def get_os_locale_language(self):
"""язык (прим: ru)"""
lang = self.Get("os_locale_lang")
if lang:
return lang.split("_")[0]
return ""
def get_os_locale_xkb(self):
"""раскладка клавиатуры для X"""
path = '/etc/conf.d/keymaps'
mapDict={"by":"us,by",
"be-latin1":"be,us",
"br-abnt2":"br,us",
"cf":"ca,us",
"dk-latin1":"dk,us",
"fr-latin9":"fr,us",
"de-latin1":"de,us",
"is-latin1":"is,us",
"it":"it,us",
"no-latin1":"no,us",
"pl":"pl,us",
"-u ru4":"us,ru(winkeys)",
"es euro2":"es,us",
"sv-latin1":"se,us",
"ua-utf":"us,ua(winkeys)",
"uk":"gb,us",
"us":"us"}
if os.path.exists(path):
FD = open(path)
data = FD.readlines()
FD.close()
shortNameList = [x for x in (len(y.split("="))==2 and\
y.split("=")[0]=="KEYMAP" and\
y.split("=")[1].replace('"',"").strip()
for y in data) if x]
if shortNameList:
if shortNameList[0] in mapDict.keys():
return mapDict[shortNameList[0]]
lang = self.Get("os_locale_lang")
# Языки:
# Португальский - pt_BR
# Французский - fr_FR
# Немецкий - de_DE
# Итальянский - it_IT
# Польский - pl_PL
# Русский - ru_RU
# Испанский - es_ES
# Украинский - uk_UA
# Английский - en_US
xkbDict = {'pt_BR':'br,us',
'fr_FR':'fr,us',
'de_DE':'de,us',
'it_IT':'it,us',
'pl_PL':'pl,us',
'ru_RU':'us,ru(winkeys)',
'es_ES':'es,us',
'uk_UA':'us,ua(winkeys)',
'en_US':'us'}
if lang:
if lang in xkbDict:
return xkbDict[lang]
return ""
def get_os_locale_xkbname(self):
"""названия используемых раскладок клавиатуры для X"""
localeXkb = self.Get("os_locale_xkb")
if localeXkb:
return localeXkb.split("(")[0]
return ""
def get_os_arch_machine(self):
"""архитектура процессора"""
march = self._runos("uname -m")
if not march:
return ""
return march
def get_os_root_dev(self):
"""корневой раздел файловой системы"""
for record in open('/proc/cmdline','rb').readlines():
re_res=re.search('^root=(\/dev\/[a-z]+[0-9]).*',record.strip())
if re_res:
return re_res.group(1)
else:
mountLunes = self._runos("mount")
if not mountLunes:
return ""
if type(mountLunes) == list:
root_dev = mountLunes[0].split("on / type")[0].strip()
if root_dev:
return root_dev
return ""
def get_os_root_type(self):
"""тип носителя (ram, hdd, livecd)"""
mountLunes = self._runos("mount")
if not mountLunes:
return ""
rootType = "hdd"
if type(mountLunes) == list:
flagCD = False
for line in mountLunes:
if "/dev/loop0 on / type" in line:
rootType = "ram"
break
elif "/dev/loop0 on /newroot/mnt/livecd type" in line:
rootType = "ram"
flagCD = True
break
if rootType == "ram":
if os.path.exists("/mnt/livecd") or flagCD:
rootType = "livecd"
return rootType
rootDev = self.Get("os_root_dev")
if rootType != "ram" and rootDev:
slpRootDev = rootDev.split("/dev/")
if len(slpRootDev) == 2:
rDev = slpRootDev[1]
devLines = self._runos("ls -la /dev/disk/by-id/", None,
{"LANG":"C"})
if not devLines:
return ""
if type(devLines) == list:
for line in devLines:
if rDev in line and "usb-" in line:
rootType = "usb-hdd"
break
if rootType == "ram":
rootType = "hdd"
return rootType
else:
return ""
def get_hr_virtual(self):
"""Название виртуальной машины (virtualbox, vmware, qemu)"""
pciLines = self._runos("/usr/sbin/lspci")
if not pciLines:
return False
virtSysDict = {'VirtualBox':'virtualbox',
'VMware':'vmware',
'Qumranet':'qemu'}
virtName = ''
for vName in virtSysDict.keys():
if [x for x in pciLines if vName in x]:
virtName = virtSysDict[vName]
break
return virtName

@ -13,12 +13,17 @@
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import os import os
import cl_base import cl_base
import cl_utils import cl_utils
import hashlib import hashlib
import re
import types
# _ = lambda x: x
class fillVars(object, cl_base.glob_attr): class fillVars(cl_base.glob_attr):
def getHash(self, password, encrypt): def getHash(self, password, encrypt):
"""Получить хеш пароля """Получить хеш пароля
@ -30,7 +35,7 @@ class fillVars(object, cl_base.glob_attr):
res = self._runos(runStr) res = self._runos(runStr)
if res: if res:
return res.strip() return res.strip()
print "Error generate hash (slappasswd)" print("Error generate hash (slappasswd)")
exit(1) exit(1)
def get_cl_profile_path(self): def get_cl_profile_path(self):
@ -230,7 +235,7 @@ class fillVars(object, cl_base.glob_attr):
for replServer in replServers: for replServer in replServers:
if replServer: if replServer:
md5hex = hashlib.md5(replServer).hexdigest() md5hex = hashlib.md5(replServer).hexdigest()
data8bit = "".join(map(lambda x: str(int(x,16)/2),list(md5hex))) data8bit = "".join((str(int(x,16)/2) for x in list(md5hex)))
dStart = 0 dStart = 0
dEnd = 3 dEnd = 3
dMax = 32 dMax = 32
@ -470,13 +475,13 @@ class fillVars(object, cl_base.glob_attr):
netAllow = self.Get("sr_proxy_net_allow") netAllow = self.Get("sr_proxy_net_allow")
if netAllow: if netAllow:
netAllow = netAllow.split(",") netAllow = netAllow.split(",")
netAllow = map(lambda x: "acl localnet src %s"%x,netAllow) netAllow = ["acl localnet src %s" % x for x in netAllow]
netAllow = "\n".join(netAllow) netAllow = "\n".join(netAllow)
return netAllow return netAllow
netAllow = self.Get("os_net_allow") netAllow = self.Get("os_net_allow")
if netAllow: if netAllow:
netAllow = netAllow.split(",") netAllow = netAllow.split(",")
netAllow = map(lambda x: "acl localnet src %s"%x,netAllow) netAllow = ["acl localnet src %s" % x for x in netAllow]
netAllow = "\n".join(netAllow) netAllow = "\n".join(netAllow)
return netAllow return netAllow
return "acl localnet src 127.0.0.1/32" return "acl localnet src 127.0.0.1/32"
@ -543,14 +548,14 @@ class fillVars(object, cl_base.glob_attr):
"""Текст в ejabberd.cfg - имена хостов с которыми работает сервис""" """Текст в ejabberd.cfg - имена хостов с которыми работает сервис"""
jabberHosts = self.Get("sr_jabber_hosts") jabberHosts = self.Get("sr_jabber_hosts")
if jabberHosts: if jabberHosts:
return ", ".join(map(lambda x: '"'+x+'"', jabberHosts.split(","))) return ", ".join(('"'+x+'"' for x in jabberHosts.split(",")))
return "" return ""
def get_sr_jabber_hosts_yml(self): def get_sr_jabber_hosts_yml(self):
"""Текст в ejabberd.cfg - имена хостов с которыми работает сервис""" """Текст в ejabberd.cfg - имена хостов с которыми работает сервис"""
jabberHosts = self.Get("sr_jabber_hosts") jabberHosts = self.Get("sr_jabber_hosts")
if jabberHosts: if jabberHosts:
return "\n".join(map(lambda x: ' - "%s"' % x, jabberHosts.split(","))) return "\n".join((' - "%s"' % x for x in jabberHosts.split(",")))
return "" return ""
def get_sr_jabber_user_name(self): def get_sr_jabber_user_name(self):
@ -591,7 +596,7 @@ class fillVars(object, cl_base.glob_attr):
break break
if not foundLoc: if not foundLoc:
netAllow.append("127.0.0.1") netAllow.append("127.0.0.1")
netAllow = map(lambda x: "%s;"%x,netAllow) netAllow = ["%s;" % x for x in netAllow]
netAllow = " ".join(netAllow) netAllow = " ".join(netAllow)
return "listen-on { %s };"%netAllow return "listen-on { %s };"%netAllow
netAllow = self.Get("sr_dns_net_allow") netAllow = self.Get("sr_dns_net_allow")
@ -601,3 +606,5 @@ class fillVars(object, cl_base.glob_attr):
if netAllow: if netAllow:
return getNetAllow(netAllow) return getNetAllow(netAllow)
return "listen-on { 127.0.0.1; };" return "listen-on { 127.0.0.1; };"

File diff suppressed because it is too large Load Diff

@ -0,0 +1,59 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 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 os
import time
class log():
"""Класс для записи в лог"""
# Директория хранения логов
logDir = "/var/log/calculate"
def __init__(self,fileName, addDataTime=True):
self.logFile = os.path.join(self.logDir,fileName)
if not os.path.exists(self.logDir):
os.makedirs(self.logDir)
self.addDataTime = addDataTime
def addLog(self, textLog):
"""Добавляет текст в лог файл"""
if not os.path.exists(self.logFile):
try:
fd = os.open(self.logFile, os.O_CREAT,0o600)
os.close(fd)
except:
print("Error creating file %s" % self.logFile)
return False
textWrite = textLog
if not textLog[-1:] == "\n" :
textWrite = "%s\n" % textLog
if self.addDataTime:
textWrite = "%s %s" % (time.strftime("%d/%m/%Y %H:%M:%S",\
time.localtime()), textWrite)
try:
FD = open (self.logFile, "a")
FD.write(textWrite)
FD.close()
except:
print("Error writing to file %s" % self.logFile)
return False
return True
def writeError(self, textLog):
"""Добавляет сообщение об ошибке в log"""
return self.addLog("ERROR: %s" % textLog)
def writeSuccess(self, textLog):
"""Добавляет сообщение об успехе в log"""
return self.addLog("SUCCESS: %s" % textLog)

File diff suppressed because it is too large Load Diff

@ -0,0 +1,609 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 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 filecmp
import string
from random import choice
from re import search, compile, S
import os
import types
import subprocess
import socket
import struct
import fcntl
import math
import ctypes
from functools import reduce
def getdirlist(s_path):
#Получить список директорий по указаному пути
fdir=filecmp.dircmp(s_path, s_path)
dir_list=fdir.common_dirs
return dir_list
def prettyColumnStr(*cols):
'''Функция преобразования строк в текстовые колонки. Если указанный текст
не помещается в колонку, то строка переносится на следующую этой же колонки
перенос текста идет по словам, и текст выравнивается по ширине колонки за
счет дополнительных пробелов между словами. Если в строке используется
перенос строки, то текст переносится не просто на следующую строку, а также
на следующую строку колонки, причем если используется \r текст выравнива-
ется по ширине, а если \n, то просто перевод строки.
Параметры:
cols множестово пар: текст, ширина колонки, причем, если у последней
колонки не указывать ширину, то она будет выведена вся.
Возвращаемые параметры:
строка, которую можно использовать для вывода на экран
Пример: columnWrite( "Some text", 10, "Next column", 20 )
'''
# шаблон поиска переводов строк
wherenr = compile( '[\n\r]', S )
retstr = ""
# перевести кортеж в список, т.к. изменяется
cols = list(cols)
# перевести текст в юникод, заодно перевести числа в строку
noconvert = False
space = u' '
nospace = u''
for i in range(0,len(cols),2):
cols[i] = _toUNICODE(cols[i])
# флаг "есть еще текст для вывода"
repeat = True
while repeat:
# сбросить итератор на первый элемент
q = 0
repeat = False
# пока не закончили перебирать параметры (перебираем по парам)
while q < len(cols):
# если это последний параметр, и для него не указана ширина
if q == len(cols)-1:
# выводим его полностью не смотря на ширину окна
retstr += cols[q] + " "
cols[q] = ''
else:
# вывести часть строки не больше указанной ширины колонки
partstr = cols[q][:cols[q+1]]
# искать перевод строки с полученной части
brfind = wherenr.search(partstr)
# если это не последняя колонка
if q + 2 < len(cols):
# добавить разделитель между колонками
cellspacing = space
else:
# разделитель не нужен
cellspacing = nospace
# если перевод строки найден, то
if brfind != None:
# для текущего вывода в колонку
# берем часть строки до перевода
partstr = partstr[:brfind.start()]
# остальная часть идет в остаток (без перевода)
cols[q] = cols[q][brfind.start()+1:]
# # если используется перевод каретки
# if brfind.group() == '\r':
# # то выравниваем по ширине колонки
# partstr = partstr.ljust(cols[q+1], ' ')
# else:
# # добавить отступы чтобы закончить колонку
partstr = partstr.ljust(cols[q+1], ' ')
# если взята часть строки
elif len(partstr) == cols[q+1] and partstr != cols[q]:
# если взята часть строки (разрыв в слове)
if cols[q][cols[q+1]] != ' ':
# ищем ближайший пробел справа
spacepos = partstr.rfind(' ')
# если пробел найти не удалось
if spacepos == -1:
# то на вывод идет часть строки равной ширине
cols[q] = cols[q][cols[q+1]:]
# если пробел найден
else:
# обрезаем строку до найденного пробела
partstr = partstr[:spacepos]
cols[q] = cols[q][spacepos+1:]
# если взята часть строки (разрыв на пробеле)
else:
# ислючить переносной пробел
cols[q] = cols[q][cols[q+1]+1:]
# выровнить текст по ширине колонки
partstr = partstr.ljust(cols[q+1], ' ')
#partstr = justify(partstr, cols[q+1])
# остатки строки
else:
# добавить отступы чтобы закончить колонку
partstr = partstr.ljust(cols[q+1], ' ')
cols[q] = ''
retstr+= partstr + cellspacing
# остальную часть строки оставить на следующую итерацию
# если от строки что то осаталось
if len(cols[q]) > 0:
# отметить запуск еще одной итерации по параметрам
repeat = True
# следующая пара
q += 2
# колонки отображены
retstr += "\n"
return retstr
def columnStr(*cols):
'''Вывод данных по колонкам, причем, если данные не вмещаются в указнаную
колонку, то они переносятся на следующую строку в нужную колонку. В строку.
Параметры:
cols множестово пар: текст, ширина колонки, причем, если у последней
колонки не указывать ширину, то она будет выведена вся.
Возвращаемые параметры:
строка, которую можно использовать для вывода на экран
Пример: columnWrite( "Some text", 10, "Next column", 20 )
'''
retstr = ""
# перевести кортеж в список, т.к. изменяется
cols = list(cols)
# перевести текст в юникод, заодно перевести числа в строку
for i in range(0,len(cols),2):
cols[i] = (str(cols[i]))
# флаг "есть еще текст для вывода"
repeat = True
while repeat:
# сбросить итератор на первый элемент
q = 0
repeat = False
# пока не закончили перебирать параметры (перебираем по парам)
while q < len(cols):
# если это последний параметр, и для него не указана ширина
if q == len(cols)-1:
# выводим его полностью не смотря на ширину окна
retstr += cols[q] + " "
cols[q] = ''
else:
# вывести часть строки не больше указанной ширины колонки
retstr+=(cols[q][:cols[q+1]].ljust(cols[q+1])) \
+ " "
# остальную часть строки оставить на следующую итерацию
cols[q] = cols[q][cols[q+1]:]
# если от строки что то осаталось
if len(cols[q]) > 0:
# отметить запуск еще одной итерации по параметрам
repeat = True
# следующая пара
q += 2
# колонки отображены
retstr += "\n"
return retstr
def columnWrite(*cols):
'''Вывод данных по колонкам, причем, если данные не вмещаются в указнаную
колонку, то они переносятся на следующую строку в нужную колонку.
Параметры:
cols множестово пар: текст, ширина колонки, причем, если у последней
колонки не указывать ширину, то она будет выведена вся.
Пример: columnWrite( "Some text", 10, "Next column", 20 )
'''
# перевести кортеж в список, т.к. изменяется
cols = list(cols)
# перевести текст в юникод, заодно перевести числа в строку
for i in range(0,len(cols),2):
cols[i] = (str(cols[i]))
# флаг "есть еще текст для вывода"
repeat = True
while repeat:
# сбросить итератор на первый элемент
q = 0
repeat = False
# пока не закончили перебирать параметры (перебираем по парам)
while q < len(cols):
# если это последний параметр, и для него не указана ширина
if q == len(cols)-1:
# выводим его полностью не смотря на ширину окна
print(cols[q], end=' ')
cols[q] = ''
else:
# вывести часть строки не больше указанной ширины колонки
print((cols[q][:cols[q+1]].ljust(cols[q+1])), end=' ')
# остальную часть строки оставить на следующую итерацию
cols[q] = cols[q][cols[q+1]:]
# если от строки что то осаталось
if len(cols[q]) > 0:
# отметить запуск еще одной итерации по параметрам
repeat = True
# следующая пара
q += 2
# колонки отображены
print()
def justify(s, width):
'''Выровнить текст по ширине
Параметры:
s выводимая строка
width ширина на которую надо выровнить строку
Возвращаямые параметры:
Выровненная строка
'''
# если подана строка без пробелов - прекратить обработку
if s.find(' ') == -1:
return s
pos = 0
# переводим в юникод для правильного вычисления длины
try:
s = s
# пропуск если это не utf-8
except UnicodeEncodeError:
pass
# пока длина строки меньше указанной
while len(s) < width:
# находим очередной пробел
pos = s.find( ' ', pos )
# если не найден искать сначала
if pos == -1:
pos = s.find(' ')
# вставить в позицию еще один пробел
s = s[:pos] +' ' +s[pos:]
# оставить удвоенный пробел
pos += 3
# вернуть строку в utf8 если она пришла в utf8
return s
def runOsCommand(cmd, inStr=None, ret_first=None, env_dict=None):
"""Выполняет внешнюю программу
Параметры:
cmd внешняя программа
inStr данные передаваемые программе на страндартный вход.
ret_first вернуть только первую строку
env_dict словарь переменных окружения
Возвращаемые параметры:
строка/строки которую выведет внешняя программа
Возвращает код возврата, stdout+stderr
"""
pipe = subprocess.Popen(cmd, stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env_dict,
close_fds=True,
shell=True)
fout, fin, ferr = (pipe.stdout, pipe.stdin, pipe.stderr)
# если есть данные на вход, передать их
if inStr:
inStr = inStr.encode("UTF-8") if isinstance(inStr, str) else inStr
fin.write(inStr)
fin.close()
# Код возврата
retcode = pipe.wait()
res = fout.readlines()
fout.close()
if not ("dovecot start" in cmd or "dovecot restart" in cmd):
res += ferr.readlines()
ferr.close()
if res:
if len(res) == 1 or ret_first:
return retcode, res[0].decode("UTF-8").strip()
else:
return retcode, [x.decode("UTF-8") for x in res]
return retcode, None
def genpassword(passlen=9):
'''Вернуть случайный пассворд указанной длины
Параметры:
passlen длина пароля который нужно сгенерировать
Возвращаемые параметры:
Сгенерированный пароль указанной длины
'''
res=''.join([choice(string.ascii_letters+string.digits)\
for i in range(passlen)])
return res
def fillstr(char, width):
'''Заполнить строку указанным числом символов. Псеводоним символ*кол-во'''
return str(char) * width
#вернуть пути для запуска утилит
def getpathenv():
bindir=['/sbin','/bin','/usr/sbin','/usr/bin']
env=os.environ
if env and 'PATH' in env:
lpath=env['PATH'].split(":")
npath = []
for dirname in bindir:
if os.path.exists(dirname) and dirname not in lpath:
npath.append(dirname)
lpath=npath+lpath
return ":".join(lpath)
#класс для работы с установленными пакетами
class pakages:
#путь к директории установленнх пакетов
pkgdir="/var/db/pkg/"
#список установленных пакетов
pkglist = {}
#Объект содержащий параметры пакета
class pakage():
#имя пакета с версией
fullname=""
#имя пакета
name=""
#версия
ver=""
#тип пакета в портежах
portdir=""
def __init__(self, **args):
for atname, atvalue in args.items():
setattr(self,atname, atvalue)
def __init__(self):
self.pkglist=self.__getpkglist()
#разбить имя пакета на тип и имя
def __getpkgver(self, fname):
res=search('^(.+)\-([0-9]+.*)$',fname)
if res:
return res.groups()
else:
return (None,None)
#собрать установленные в системе пакеты
def __getpkglist(self):
portageDirs = []
instaledPkg = {}
#проверим на существование директории с установленными пакетами
if os.path.exists(self.pkgdir):
#получим список типов пакетов
portageDirs=getdirlist(self.pkgdir)
if len(portageDirs)>0:
#обрабатываем содержимое каждого из типов
for portageDir in portageDirs:
pkgList=getdirlist(self.pkgdir+portageDir)
for pkg in pkgList:
fullname=pkg
pkgName,pkgVer= self.__getpkgver(pkg)
pobj=self.pakage(fullname=fullname,
name=pkgName, \
ver=pkgVer,\
portdir=portageDir)
fpkg=portageDir+"/"+pkgName
if fpkg in instaledPkg:
instaledPkg[fpkg].append(pobj)
else:
instaledPkg[fpkg]=[pobj]
return instaledPkg
#разбить pkgname на составляющие имени пакета
def __partname(self, pkgname):
if not pkgname.strip():
return False
res=search('^(.+\/)?(.+)',pkgname)
tname=None
if res.group(1):
tname=res.group(1)
if res.group(2):
res2=search('^(.+)(\-[0-9]+.+$)',res.group(2))
if res2:
name=res2.group(1)
ver=res2.group(2)
else:
name=res.group(2)
ver=None
if res:
if name and name[-1:]=='-':
name=name[:-1]
if tname and tname[-1:]=='/':
tname=tname[:-1]
if ver and ver[0]=='-':
ver=ver[1:]
return [tname, name, ver]
#проверить установленн ли пакет
#isinstalled('dev-db/postgresql')
def isinstalled(self, pkgname):
res=self.getinstpkg(pkgname)
if len(res)>0:
return True
else:
return False
#вернуть список объектов pakage() соответствующих pkgname
#getinstpkg('dev-db/postgresql')
#в случае отсутствия пакетов возвращает пустой список
def getinstpkg(self, pkgname):
pinfo=self.__partname(pkgname)
if pinfo:
ret = []
if pinfo[0] and pinfo[1] and pinfo[2]:
if pinfo[0]+'/'+pinfo[1] not in self.pkglist:
return []
fpkg=self.pkglist[pinfo[0]+'/'+pinfo[1]]
ret = []
for i in fpkg:
if i.ver==pinfo[2]:
ret.append(i)
return ret
elif pinfo[0] and pinfo[1]:
if pinfo[0]+'/'+pinfo[1] not in self.pkglist:
return []
return self.pkglist[pinfo[0]+'/'+pinfo[1]]
elif pinfo[1] and pinfo[2]:
for i in self.pkglist.keys():
if search('^.+\/%s$'%(pinfo[1]),i):
for el in self.pkglist[i]:
if el.ver==pinfo[2]:
ret.append(el)
return ret
elif pinfo[1]:
for i in self.pkglist.keys():
if search('^.+\/%s$'%(pinfo[1]),i):
ret+=self.pkglist[i]
return ret
return []
def getListPkg(self):
return self.pkglist
def list2str(list):
'''Функция переводит список в строку'''
return '['+','.join(list)+']'
def str2list(s):
'''Функция переводит строку в список'''
return s[1:-1].split(',')
def dict2str(dict):
'''Функция перводит словарь в строку'''
return '{'+','.join(["%s:%s" % (str(k),str(v)) \
for (k,v) in dict.items()])+'}' #:
def str2dict(s):
'''Функция переводит строку в словарь'''
dict = {}
for i in s[1:-1].split(','):
k,v = i.split(':')
dict[k] = v
return dict
def convertStrListDict(val):
'''Функция определеяется что на входе (строка, список, словарь)
и переводит их в строку и обратно'''
# если подан список
if type(val) == list:
return list2str(val)
# если подан словарь
elif type(val) == dict:
return dict2str(val)
# если подана строка
else:
# если поданная строка содержит словарь
if ':' in val and '{' in val:
return str2dict(val)
# если поданная строка содержит список
elif ',' in val and '[' in val:
return str2list(val)
# если это просто строка
else:
return val
def _toUNICODE(val):
"""перевод текста в юникод"""
if type(val) == str:
return val
else:
return str(val)
SYSFS_NET_PATH = "/sys/class/net"
# From linux/sockios.h
SIOCGIFADDR = 0x8915
SIOCGIFNETMASK = 0x891B
SIOCGIFHWADDR = 0x8927
def getInterfaces():
"""
Get available interfaces (discard which hasn't device)
"""
try:
return [x for x in os.listdir(SYSFS_NET_PATH) if x!= "lo"]
except:
return []
def getIp(iface):
sockfd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
ifreq = struct.pack('16sH14s', iface.encode("UTF-8"), socket.AF_INET, b'\x00'*14)
try:
res = fcntl.ioctl(sockfd, SIOCGIFADDR, ifreq)
except IOError:
return ""
finally:
sockfd.close()
ip = struct.unpack('16sH2x4s8x', res)[2]
return socket.inet_ntoa(ip)
def getMask(iface):
"""
Get mask for interface
"""
sockfd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
ifreq = struct.pack('16sH14s', iface.encode("UTF-8"), socket.AF_INET, b'\x00'*14)
try:
res = fcntl.ioctl(sockfd, SIOCGIFNETMASK, ifreq)
except IOError:
return 0
finally:
sockfd.close()
netmask = socket.ntohl(struct.unpack('16sH2xI8x', res)[2])
return 32 - int(math.log(ctypes.c_uint32(~netmask).value + 1, 2))
def getMac(iface):
"""
Get mac for interface
"""
sockfd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
ifreq = struct.pack('16sH14s', iface.encode("UTF-8"), socket.AF_UNIX, b'\x00'*14)
res = fcntl.ioctl(sockfd, SIOCGIFHWADDR, ifreq)
address = struct.unpack('16sH14s', res)[2]
mac = struct.unpack('6B8x', address)
sockfd.close()
return ":".join(['%02X' % i for i in mac])
def intIpToStrIp(addr):
"""Convert ip specified by integer to string"""
return "{0}.{1}.{2}.{3}".format(
addr>>24,(addr>>16)&0xff,(addr>>8)&0xff,addr&0xff)
def maskToCidr(mask):
"""Convert mask specified by str to net"""
mask = strIpToIntIp(mask)
return 32-int(math.log(((~mask) & 0xffffffff)+1,2))
def cidrToMask(cidr):
"""Convert net to mask specified by str"""
return intIpToStrIp((2**cidr-1)<<(32-cidr))
def strIpToIntIp(addr):
"""Convert ip specified by string to integer"""
addr = addr.split('.')
return ((int(addr[0])<<24)|
(int(addr[1])<<16)|
(int(addr[2])<<8)|
(int(addr[3])))
return reduce(lambda x,y:x+(int(y[1])<<(y[0]*8)),
enumerate(reversed(addr.split("."))),0)
def getIpNet(ip,mask=None,cidr=None):
"""Get net (xx.xx.xx.xx/xx) by ip address and mask"""
ip = strIpToIntIp(ip)
if mask is not None:
net = maskToCidr(mask)
else:
net = int(cidr)
mask = cidrToMask(net)
mask = strIpToIntIp(mask)
return "{ip}/{net}".format(ip=intIpToStrIp(ip&mask),
net=net)

@ -0,0 +1,564 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 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
import struct
import termios
import fcntl
# from . import cl_utils
# from . import cl_profile
import cl_utils
import cl_profile
import ldap
class ldapFun(cl_profile._error):
'''Объект для работы с LDAP сервером
подключение к серверу и поиск данных
'''
def __init__(self, dnUser, password, host="localhost"):
self.conLdap = False
# Получаем соединение с LDAP
try:
self.conLdap = self.__ldapConnect(dnUser, password, host)
except ldap.LDAPError as e:
self.setError(str(e))
def __ldapConnect(self, dnUser, password, host):
"""Соединение с LDAP сервером"""
conLdap = ldap.initialize('ldap://%s'%host, bytes_mode=False)
conLdap.simple_bind_s(dnUser, password)
return conLdap
def ldapSearch(self,baseDN, searchScope, searchFilter, retrieveAttributes):
try:
ldap_result_id = self.conLdap.search(baseDN, searchScope,
searchFilter,
retrieveAttributes)
result_set = []
while 1:
result_type, result_data = self.conLdap.result(ldap_result_id,
0)
if (result_data == []):
break
else:
if result_type == ldap.RES_SEARCH_ENTRY:
result_set.append(result_data)
except ldap.NO_SUCH_OBJECT:
return []
except:
return False
return result_set
pcs = cl_utils.prettyColumnStr
class cl_help:
"""Объект для работы со справкой, и обработкой параметров.
Конструктор __init__ должен определить следующие переменные:
self.chapter список разделов справки, каждый элементы состоит из
имени раздела, флаг видимый/скрытый, кол-во переводов строк
после названия раздела, количество строк после раздела,
тип раздела
Пример: [("Copyright",False,0,2),"options"]
self.relService словарь связей сервисов и действующих опций
ключ - название сервиса, значение - список отображаемых
разделов отмеченных как "options"
Пример: {"samba":[_("Common options"),
_("Service Samba options")]}
self.relOptions словарь связей длинных опций помощи и выводимых разделов
помощи с опциями
ключ - параметр справки, значение список отображаемых
разделов справки
Пример: {"help-ldap":[_("Common options"),
_("Service LDAP options)]}
self.progName словарь имена используемых программ и их номера для
доступа к переменным
Пример: {'cl-groupadd':0, 'cl-groupdel':1}
self.data список данных для справки, каждый элемент словарь:
progAccess: список номеров программ отображающих
Пример: {'progAccess':(0,),
'shortOption':"g",
'longOption':"gid",
'optVal':"GID",
'helpChapter':_("Options"),
'help':_("use GID for the new group")
},
после заполнения параметров необходимо выполнить
self._cl_help__setParamHelp() для заполнения справки
"""
def __init__(self, cmdName):
# ширина консоли взята за 80
# -1 чтобы компенсировать расстрояние между колонками
self.consolewidth = 79
self.column_width = 32
self.cmdName = cmdName
#короткие опции командной строки
self.shortOpt = []
#длинные опции командной строки
self.longOpt = []
# массив разделов (заполняется в __setParamHelp)
self.chapterBloc = []
#optEnd = ""
#if "user" in self.cmdName and not "mod" in self.cmdName:
#optEnd = _("user")
#elif "group" in self.cmdName and not "mod" in self.cmdName:
#optEnd = _("group")
#self.__setParamHelp()
def getChapterNumber(self,NameChapter):
"""Получить номер раздела по имени"""
num = 0
for i in self.chapter:
if i[0] == NameChapter:
return num
num += 1
return False
def __setParamHelp(self):
"""Внутренняя функция формирования справки по данным
Перебирает все элементы списка data, проверяет их на доступность
данной программы, разбирает опции на среди data и формирует
для по ним справку.
"""
# сформировать нужное количество блоков раздела
self.chapterBloc = [""] * len(self.chapter)
#
sp = {}
i = 0
# перебираем все элементы справки собираем элементы опции
# так же формируем разделы не опции
for par in self.data:
# перебираем только те опции, которые принадлежат команде
if self.access(par):
# есть короткая (возможно есть и длинная)
if "shortOption" in par:
sp[par["shortOption"]+":"+par["helpChapter"]] = i
# есть только длинная опция
elif "longOption" in par:
sp[par["longOption"]+":"+par["helpChapter"]] = i
# формирование разделов не опций
else:
helpTxt = par['help']
numChapter = self.getChapterNumber(par['helpChapter'])
self.addChapterHelp(numChapter,helpTxt)
i += 1
# перебираем все "собранные" опции
# опции перебираются по порядку в списке date
# для сортировки по ключам следует применить код:
# for index in sorted(sp.keys()):
# par = self.data[sp[index]]
for index in sorted(sp.values()):
par = self.data[index]
numChapter = self.getChapterNumber(par['helpChapter'])
# если есть и короткая и длинная
if "shortOption" in par and "longOption" in par:
paraminfo = "-%s, --%s "%(par["shortOption"],par["longOption"])
# если есть только короткая
elif "shortOption" in par:
paraminfo = "-%s "%par["shortOption"]
# если только длинная
else:
paraminfo = "--%s "%par["longOption"]
# если указан параметр для опции
if "optVal" in par:
optVal = par["optVal"]
else:
optVal = ""
# вывод вида: " [-o, ][--option] [PARAM]" "helpstring"
helpTxt = pcs(" "+paraminfo+optVal, self.column_width, \
par['help'], self.consolewidth-self.column_width)
# добавить строку в нужный раздел
self.addChapterHelp(numChapter,helpTxt)
def getHelp(self, optionsChapters=False):
"""Выдать справку.
Выдает справку в случае если указан optionsChapters, то фильтрует по
типу разделов.
Параметры:
optionsChapters Flase или список опциональных разделов для
отображения
Возвращаемые параметры:
Строка со справкой.
"""
# Выдать справку
help = ""
# перебираем все элементы справочных блоков
iterChapterBloc = iter(self.chapterBloc)
# перебираем все разделы по параметрам
for (nameChapter, visibleChapter, beforeStrChapter, \
afterStrChapter, typeChapter) in self.chapter:
# получаем следующий блок (т.о. textChapterBloc соответ, chapter)
textChapterBloc = next(iterChapterBloc)
# если тип раздела опциональный
if optionsChapters and typeChapter=="options":
# проверяем нужно ли его отображать
if not (nameChapter in optionsChapters):
continue
bef = "\n" * beforeStrChapter
aft = "\n" * afterStrChapter
# если блок не пустой и раздел отображаемый
if len(textChapterBloc) > 0:
if visibleChapter:
help += nameChapter + ": " + bef
help += textChapterBloc + aft
help = help.rstrip() + "\n"
return help
def addChapterHelp(self, numChapter, helpTxt):
"""Добавить в раздел помощи numChapteк тектстовую строку helpTxt
Параметры:
numChapter номер раздела в который нужно добавить данные справки
helpTxt строка, содержащая данные
"""
self.chapterBloc[numChapter] += helpTxt
return True
def addData(self,dataHash):
# На будущее (добавляет опции)
self.data.append(dataHash)
return True
def handleCheckAccess(self,dataHash):
"""Замещаемый дополнительный обработчик проверки
доступности опции.
Входные параметры:
dataHash элементы списка данных справки (self.data)
"""
return True
def access(self,dataHash):
"""Доступна ли опция вызывающей программе
Параметры:
dataHash словарь элемент типа self.data
Возвращаемые параметры:
True/False доступна/недоступна
"""
# доступна ли опция вызывающей программе
# опция без progAccess доступна
numProg = self.progName[self.cmdName]
if 'progAccess' in dataHash:
if numProg in dataHash['progAccess']:
# вызов дополнительной проверки доступа к опции
return self.handleCheckAccess(dataHash)
else:
return False
else:
# вызов дополнительной проверки доступа к опции
return self.handleCheckAccess(dataHash)
def getTypeChapter(self, nameChapter):
"""Получить тип раздела по его имени
Параметры:
nameChapter название раздела
Возвращаемые параметры:
строка тип раздела
Flase(Boolean) такой раздел отсутствует
"""
# фильтруем список по имени раздела, помещаем в список тип раздела
filtered = [typeChapter for name, na, na, na, typeChapter \
in self.chapter if name == nameChapter]
# если среди фильтрованных есть хоть один элемент
if len(filtered) > 0:
# возвращаем - он запрашиваемый
return filtered[0]
else:
# такой раздел отсутствует
return False
def clearAllOpt(self):
"""Очистить все опции, полученные посредством getAllOpt"""
if len(self.shortOpt) > 0:
self.shortOpt = []
if len(self.longOpt) > 0:
self.longOpt = []
return True
def getAllOpt(self,typeOpt="all", optionsChapters=False):
"""Получить все доступные опции
Параметры:
typeOpt 'short'/'long'/'all', вернуть короткие или длинные
опции или все (возвращаются кортежем)
optionsChapters фильтр для опций по типам разделов (список,кортеж)
Возвращаемые параметры:
строка коротки или список строк длинных опций ('hb:c:wg:G:k:ms:u:')
"""
# Выдать все действующие опции
if typeOpt=="short" or typeOpt=="all":
if len(self.shortOpt) == 0:
for par in self.data:
if optionsChapters and\
self.getTypeChapter(par['helpChapter'])=="options":
if not (par['helpChapter'] in optionsChapters):
continue
if "shortOption" in par and self.access(par):
if "optVal" in par:
self.shortOpt.append(par["shortOption"]+':')
else:
self.shortOpt.append(par["shortOption"])
if typeOpt=="long" or typeOpt=="all":
if len(self.longOpt) == 0:
for par in self.data:
if optionsChapters and\
self.getTypeChapter(par['helpChapter'])=="options":
#print par["longOption"]
if not (par['helpChapter'] in optionsChapters):
continue
if "longOption" in par and self.access(par):
if "optVal" in par:
self.longOpt.append(par["longOption"]+'=')
else:
self.longOpt.append(par["longOption"])
if typeOpt=="short":
return "".join(self.shortOpt)
elif typeOpt=="long":
return self.longOpt
elif typeOpt=="all":
return ("".join(self.shortOpt),self.longOpt)
def getShortOpt(self,option):
"""Из любой опции получить короткую опцию.
Фильтрация также происходит и по названию команды.
Параметры:
option запрашиваемая опция
Возвращаемые параметры:
короткая опция, если же для длинной опции нет короткой, возвращается
пустая строка.
"""
# Из любой опции получаем короткую опцию
for par in self.data:
if "shortOption" in par and self.access(par):
if ("longOption" in par and\
par["longOption"] == option) or \
par["shortOption"] == option:
return par["shortOption"]
break
return ""
class cl_smartcon():
def getconsolewidth(self):
"""Получить ширину текущей консоли"""
s = struct.pack("HHHH", 0, 0, 0, 0)
fd_stdout = sys.stdout.fileno()
try:
x = fcntl.ioctl(fd_stdout, termios.TIOCGWINSZ, s)
except IOError:
# если ошибка то ширина 80 символов
return 80
#(rows, cols, x pixels, y pixels)
return struct.unpack("HHHH", x)[1]
def printRight(self, offsetLeft, offsetRight):
"""Добавляет необходимое количество пробелов:
количество пробелов = (ширина консоли - offsetLeft - offsetRight)
"""
cols = self.getconsolewidth()
for i in range(cols - offsetLeft - offsetRight):
sys.stdout.write(" ")
def colorPrint(self,attr,fg,bg,string):
"""Раскрашивает выводимое сообщение
Параметры:
attr - это атрибут
fg - цвет символа
bg - цвет фона
в случае если параметр равен "" то он не изменяется
attr может принимать следующие значения:
0 сбросить все атрибуты (вернуться в нормальный режим)
1 яркий (обычно включает толстый шрифт)
2 тусклый
3 подчёркнутый
5 мигающий
7 реверсный
8 невидимый
fg может принимать следующие значения:
30 чёрный
31 красный
32 зелёный
33 жёлтый
34 синий
35 фиолетовый
36 голубой
37 белый
bg может принимать следующие значения:
40 чёрный
41 красный
42 зелёный
43 жёлтый
44 синий
45 фиолетовый
46 голубой
47 белый
"""
lst = []
if attr:
lst.append(attr)
if fg:
lst.append(fg)
if bg:
lst.append(bg)
sys.stdout.write("\033[%sm%s\033[0m" %(";".join(lst),string))
def redBrightPrint(self, string):
"""Печатает яркое красное сообщение"""
self.colorPrint("1","31","",string)
def greenBrightPrint(self, string):
"""Печатает яркое зеленое сообщение"""
self.colorPrint("1","32","",string)
def yellowBrightPrint(self, string):
"""Печатает яркое желтое сообщение"""
self.colorPrint("1","33","",string)
def blueBrightPrint(self, string):
"""Печатает яркое cинее сообщение"""
self.colorPrint("1","34","",string)
def lenString(self, string):
"""Получаем длинну строки"""
stringUnicode = cl_utils._toUNICODE(string)
lenString = len(stringUnicode)
return lenString
def defaultPrint(self, string):
sys.stdout.write(string)
sys.stdout.flush()
def printLine(self, argL, argR, offsetL=0, printBR=True):
"""Печатает справа и слева консоли цветные сообщения"""
#Допустимые цвета
colorDict = {\
# цвет по умолчанию
'':self.defaultPrint,
# ярко зеленый
'greenBr':self.greenBrightPrint,
# ярко голубой
'blueBr':self.blueBrightPrint,
# ярко красный
'redBr':self.redBrightPrint,
# ярко желтый
'yellowBr':self.yellowBrightPrint,
}
# cмещение от левого края консоли
#offsetL = 0
for color,leftString in argL:
offsetL += self.lenString(leftString)
if color in colorDict:
# печатаем и считаем смещение
colorDict[color](leftString)
else:
colorDict[''](leftString)
# cмещение от правого края консоли
offsetR = 0
for color,rightString in argR:
offsetR += self.lenString(rightString)
# Добавляем пробелы
if offsetR:
self.printRight(offsetL, offsetR)
for color,rightString in argR:
if color in colorDict:
# печатаем и считаем смещение
colorDict[color](rightString)
else:
colorDict[''](rightString)
if printBR:
print("")
def printNotOK(self, string, offsetL=0, printBR=True):
"""Вывод на печать в случае сбоя"""
self.printLine((('greenBr',' * '),
('',string),
),
(('blueBr','['),
('redBr',' !! '),
('blueBr',']'),
), offsetL, printBR)
def printOnlyNotOK(self, string, offsetL=0, printBR=True):
"""Вывод на печать в случае сбоя"""
self.printLine((('', string),),
(('blueBr','['),
('redBr',' !! '),
('blueBr',']'),
), offsetL, printBR)
def printOK(self, string, offsetL=0, printBR=True):
"""Вывод на печать в случае успеха"""
self.printLine((('greenBr',' * '),
('',string),
),
(('blueBr','['),
('greenBr',' ok '),
('blueBr',']'),
), offsetL, printBR)
def printOnlyOK(self, string, offsetL=0, printBR=True):
"""Вывод на печать в случае успеха"""
self.printLine((('',string),),
(('blueBr','['),
('greenBr',' ok '),
('blueBr',']'),
), offsetL, printBR)
def printWARNING(self, string, offsetL=0, printBR=True):
"""Вывод на печать предупреждения"""
self.printLine((('yellowBr',' * '),
('',string),
),
(('',''),
), offsetL, printBR)
def printERROR(self, string, offsetL=0, printBR=True):
"""Вывод на печать предупреждения"""
self.printLine((('redBr',' * '),
('',string),
),
(('',''),
), offsetL, printBR)
def printSUCCESS(self, string, offsetL=0, printBR=True):
"""Вывод на печать в случае успеха без [ok] справа"""
self.printLine((('greenBr',' * '),
('',string),
),
(('',''),
), offsetL, printBR)

@ -0,0 +1,92 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 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.
#Допустимые ключи значений
# mode - режим переменной r-не переназначается из командной строки,
# w-переназначается из командной строки
# type - тип переменной состоит из двух элементов(что это и для чего
# это)
# value - значение переменной
class Data:
# имя компьютера
os_net_hostname = {'mode':"w"}
# разрешенные сети
os_net_allow = {}
# ip на всех интерфейсах
os_net_ip = {}
#короткое название системы (CLD)
os_linux_shortname = {}
#домен
os_net_domain = {'mode':"w"}
# Пути к ini файлам
cl_env_path = {'value':['/var/calculate/remote/calculate.env',
'/var/calculate/calculate.env',
'/etc/calculate/calculate.env',
'/var/lib/calculate/calculate.env']}
# локаль (прим: ru_RU.UTF-8)
os_locale_locale = {}
# язык (прим: ru_RU)
os_locale_lang = {}
# язык (прим: ru)
os_locale_language = {}
# раскладка клавиатуры для X
os_locale_xkb = {}
# названия используемых раскладок клавиатуры для X
os_locale_xkbname = {}
# архитектура компьютера (i686,x86_64)
os_arch_machine = {}
#проход при наложении профилей 1,2,3,4,5 и.т д
cl_pass_step = {'mode':"w"}
# обрабатываемый файл профиля
cl_pass_file = {'mode':"w"}
# корневой раздел файловой системы
os_root_dev = {}
# тип носителя (ram, hdd, usb-hdd, livecd)
os_root_type = {}
# полное название системы
os_linux_name = {}
# постфикс к названию системы
os_linux_subname = {}
# название виртуальной машины (virtualbox, vmware, qemu)
hr_virtual = {}
# версия системы
os_linux_ver = {}
# Тип профиля
cl_pass_type = {'mode':"w"}
# Действие программы
cl_pass_run = {'mode':"w"}
#Логин пользователя
ur_login = {'mode':"w"}

@ -253,24 +253,24 @@ class Data:
ld_samba_hash = {} ld_samba_hash = {}
# Директория настроек пользователя windows # Директория настроек пользователя windows
sr_samba_winprof_path = {\ sr_samba_winprof_path = \
'value':'/var/calculate/server-data/samba/profiles/win'} {'value':'/var/calculate/server-data/samba/profiles/win'}
# Директория хранения настроек пользователя linux # Директория хранения настроек пользователя linux
sr_samba_linprof_path = {\ sr_samba_linprof_path = \
'value':'/var/calculate/server-data/samba/profiles/unix'} {'value':'/var/calculate/server-data/samba/profiles/unix'}
# Домашняя директория # Домашняя директория
sr_samba_home_path = {\ sr_samba_home_path = \
'value':'/var/calculate/server-data/samba/home'} {'value':'/var/calculate/server-data/samba/home'}
# Директория netlogon # Директория netlogon
sr_samba_winlogon_path = {\ sr_samba_winlogon_path = \
'value':'/var/calculate/server-data/samba/netlogon'} {'value':'/var/calculate/server-data/samba/netlogon'}
# Директория share # Директория share
sr_samba_share_path = {\ sr_samba_share_path = \
'value':'/var/calculate/server-data/samba/share'} {'value':'/var/calculate/server-data/samba/share'}
# Настроен или нет сервис Samba # Настроен или нет сервис Samba
sr_samba_set = {'mode':"w", sr_samba_set = {'mode':"w",

File diff suppressed because it is too large Load Diff

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление статического хоста в DHСP # Добавление статического хоста в DHСP

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Удаление статического хоста # Удаление статического хоста

@ -29,8 +29,8 @@ if __name__ == "__main__":
optObj = cl_ldap.tsOpt(ldapObj,[],False,False,True) optObj = cl_ldap.tsOpt(ldapObj,[],False,False,True)
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt and optObj.params.has_key('service'): if not optObj.opt and 'service' in optObj.params:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Модификация сети # Модификация сети

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление cети # Добавление cети

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Удаление сети # Удаление сети

@ -30,8 +30,8 @@ if __name__ == "__main__":
optObj = cl_ldap.tsOpt(ldapObj,[],False,False,True) optObj = cl_ldap.tsOpt(ldapObj,[],False,False,True)
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt and optObj.params.has_key('service'): if not optObj.opt and 'service' in optObj.params:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Модификация сети # Модификация сети

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление записи в DNS # Добавление записи в DNS

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление записи в DNS # Добавление записи в DNS

@ -30,8 +30,8 @@ if __name__ == "__main__":
optObj = cl_ldap.tsOpt(ldapObj,[],False,False,True) optObj = cl_ldap.tsOpt(ldapObj,[],False,False,True)
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt and optObj.params.has_key('service'): if not optObj.opt and 'service' in optObj.params:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление записи в DNS # Добавление записи в DNS

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление записи в DNS # Добавление записи в DNS

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление записи в DNS # Добавление записи в DNS

@ -31,7 +31,7 @@ if __name__ == "__main__":
flagError = False flagError = False
# Вывод помощи если нет параметров командной строки # Вывод помощи если нет параметров командной строки
if not optObj.opt: if not optObj.opt:
print ldapObj.getHelp(ldapObj.relOptions['h']) print(ldapObj.getHelp(ldapObj.relOptions['h']))
optObj.flagHelp = True optObj.flagHelp = True
if not optObj.flagHelp: if not optObj.flagHelp:
# Добавление записи в DNS # Добавление записи в DNS

@ -30,8 +30,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-groupadd") ldapObj = cl_ldap.cl_ldap("cl-groupadd")
optObj = cl_ldap.tsOpt(ldapObj,['group']) optObj = cl_ldap.tsOpt(ldapObj,['group'])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and \ if not optObj.flagHelp and 'service' in optObj.params and \
optObj.params.has_key('group'): 'group' in optObj.params:
flagError = True flagError = True
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()

@ -29,8 +29,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-groupdel") ldapObj = cl_ldap.cl_ldap("cl-groupdel")
optObj = cl_ldap.tsOpt(ldapObj,['group']) optObj = cl_ldap.tsOpt(ldapObj,['group'])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
optObj.params.has_key('group'): 'group' in optObj.params:
flagError = True flagError = True
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()
@ -38,7 +38,7 @@ if __name__ == "__main__":
if obj.delGroupUnixServer(optObj.params['group'], if obj.delGroupUnixServer(optObj.params['group'],
optObj.opt): optObj.opt):
flagError = False flagError = False
elif optObj.params['service'] == "samba": elif optObj.params['service'] == "samba":
obj = cl_ldap.servSamba() obj = cl_ldap.servSamba()
# Удаляем группу # Удаляем группу
if obj.delGroupSambaServer(optObj.params['group'], if obj.delGroupSambaServer(optObj.params['group'],

@ -29,8 +29,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-groupmod") ldapObj = cl_ldap.cl_ldap("cl-groupmod")
optObj = cl_ldap.tsOpt(ldapObj,['group'],True,True) optObj = cl_ldap.tsOpt(ldapObj,['group'],True,True)
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
optObj.params.has_key('group'): 'group' in optObj.params:
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()
# Модифицируем группу # Модифицируем группу

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-info") ldapObj = cl_ldap.cl_ldap("cl-info")
optObj = cl_ldap.tsOpt(ldapObj,[]) optObj = cl_ldap.tsOpt(ldapObj,[])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
not optObj.errorOpt: not optObj.errorOpt:
# Информация о сервисах и пользователях # Информация о сервисах и пользователях
flagError = True flagError = True

@ -29,8 +29,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-passwd") ldapObj = cl_ldap.cl_ldap("cl-passwd")
optObj = cl_ldap.tsOpt(ldapObj,['user']) optObj = cl_ldap.tsOpt(ldapObj,['user'])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
optObj.params.has_key('user'): 'user' in optObj.params:
flagError = True flagError = True
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-replication") ldapObj = cl_ldap.cl_ldap("cl-replication")
optObj = cl_ldap.tsOpt(ldapObj,[]) optObj = cl_ldap.tsOpt(ldapObj,[])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
not optObj.errorOpt: not optObj.errorOpt:
# Настройка сервера LDAP # Настройка сервера LDAP
flagError = True flagError = True

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-setup") ldapObj = cl_ldap.cl_ldap("cl-setup")
optObj = cl_ldap.tsOpt(ldapObj,[]) optObj = cl_ldap.tsOpt(ldapObj,[])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service'): if not optObj.flagHelp and 'service' in optObj.params:
# Настройка сервера LDAP # Настройка сервера LDAP
flagError = True flagError = True
if optObj.params['service'] == "ldap" and \ if optObj.params['service'] == "ldap" and \

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-update-server") ldapObj = cl_ldap.cl_ldap("cl-update-server")
optObj = cl_ldap.tsOpt(ldapObj,[]) optObj = cl_ldap.tsOpt(ldapObj,[])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
not optObj.errorOpt: not optObj.errorOpt:
# Настройка сервера LDAP # Настройка сервера LDAP
flagError = True flagError = True

@ -29,8 +29,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-useradd") ldapObj = cl_ldap.cl_ldap("cl-useradd")
optObj = cl_ldap.tsOpt(ldapObj,['user']) optObj = cl_ldap.tsOpt(ldapObj,['user'])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
optObj.params.has_key('user'): 'user' in optObj.params:
flagError = True flagError = True
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()

@ -29,8 +29,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-userdel") ldapObj = cl_ldap.cl_ldap("cl-userdel")
optObj = cl_ldap.tsOpt(ldapObj,['user']) optObj = cl_ldap.tsOpt(ldapObj,['user'])
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
optObj.params.has_key('user'): 'user' in optObj.params:
flagError = True flagError = True
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()

@ -30,8 +30,8 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-usermod") ldapObj = cl_ldap.cl_ldap("cl-usermod")
optObj = cl_ldap.tsOpt(ldapObj,['user'],True,True) optObj = cl_ldap.tsOpt(ldapObj,['user'],True,True)
flagError = False flagError = False
if not optObj.flagHelp and optObj.params.has_key('service') and\ if not optObj.flagHelp and 'service' in optObj.params and\
optObj.params.has_key('user'): 'user' in optObj.params:
flagError = True flagError = True
if optObj.params['service'] == "unix": if optObj.params['service'] == "unix":
obj = cl_ldap.servUnix() obj = cl_ldap.servUnix()

@ -45,12 +45,12 @@ if __name__ == "__main__":
os.setgid(gid) os.setgid(gid)
os.setuid(uid) os.setuid(uid)
except: except:
print _("ERROR: Can not set owner") + \ print(_("ERROR: Can not set owner") + \
" (dhcp:dhcp uid=%s,gid=%s) "%(uid, gid) +\ " (dhcp:dhcp uid=%s,gid=%s) "%(uid, gid) +\
_("the this process") _("the this process"))
sys.exit(1) sys.exit(1)
if os.getuid() != uid: if os.getuid() != uid:
print _("ERROR: Owner this process not dhcp or root") print(_("ERROR: Owner this process not dhcp or root"))
sys.exit(1) sys.exit(1)
if os.access(logFullFile, os.W_OK): if os.access(logFullFile, os.W_OK):
logObj = cl_log.log(logFile) logObj = cl_log.log(logFile)

@ -24,6 +24,7 @@ from os.path import join as pathjoin, exists as pathexists
from shutil import copy as copyfile, move as movefile from shutil import copy as copyfile, move as movefile
from optparse import OptionParser from optparse import OptionParser
from threading import Lock from threading import Lock
from functools import reduce
# fix ecre in email module # fix ecre in email module
email.header.ecre = re.compile(r''' email.header.ecre = re.compile(r'''
@ -63,7 +64,7 @@ class Logger:
self.logfile.flush() self.logfile.flush()
except: except:
sys.stderr.write(strftime("%Y%m%d%H%M%S ") + sys.stderr.write(strftime("%Y%m%d%H%M%S ") +
"".join(apply(traceback.format_exception, sys.exc_info()))) "".join(traceback.format_exception(*sys.exc_info())))
self.lock.release() self.lock.release()
def printDEBUG(self,s): def printDEBUG(self,s):
@ -96,7 +97,7 @@ class Logger:
def dbg_except(): def dbg_except():
"""Debug function, for try-except block""" """Debug function, for try-except block"""
Logger().printLOG(strftime("%Y%m%d%H%M%S ") + Logger().printLOG(strftime("%Y%m%d%H%M%S ") +
"".join(apply(traceback.format_exception, sys.exc_info()))) "".join(traceback.format_exception(*sys.exc_info())))
def strstime(format="%Y-%m-%d_%H:%M",seconds=0): def strstime(format="%Y-%m-%d_%H:%M",seconds=0):
return strftime(format, localtime(seconds)) return strftime(format, localtime(seconds))
@ -119,7 +120,7 @@ class Letter:
self.cacheReceiver = None self.cacheReceiver = None
# letter by filename # letter by filename
if file: if file:
content = open(file,"r").read() content = open(file, "r").read()
self.filepath = file self.filepath = file
self.mail = message_from_string(content) self.mail = message_from_string(content)
# letter by content # letter by content
@ -158,7 +159,8 @@ class Letter:
resent_to = self.getResentTo() resent_to = self.getResentTo()
delivered_to = self.getDeliveredTo() delivered_to = self.getDeliveredTo()
if resent_to and delivered_to: if resent_to and delivered_to:
order_field = self.mail.keys() order_field = list(self.mail.keys())
#TODO probably will be bugged in py3: order of keys in dict changed
if order_field.index("Delivered-To") < order_field.index("Resent-To"): if order_field.index("Delivered-To") < order_field.index("Resent-To"):
receiver_emails = delivered_to receiver_emails = delivered_to
else: else:
@ -184,9 +186,9 @@ class Letter:
charset = self.mail.get_charsets() charset = self.mail.get_charsets()
# if charset specified and it is not utf-8 # if charset specified and it is not utf-8
try: try:
if charset and charset[0] and not charset[0].lower() in ['utf-8','utf8']: if charset and charset[0] and not charset[0].lower() in ['utf-8', 'utf8']:
letter_text = letter_text.decode(charset[0]).encode('utf-8') letter_text = letter_text.decode(charset[0]).encode('utf-8')
except Exception,e: except Exception as e:
Logger().printDEBUG("wrong decode from %s: %s" % (charset[0], e)) Logger().printDEBUG("wrong decode from %s: %s" % (charset[0], e))
return letter_text return letter_text
@ -357,7 +359,7 @@ class MailBox:
def fixMtime(self): def fixMtime(self):
# fix mtime of mailbox directory by date (latest letter) # fix mtime of mailbox directory by date (latest letter)
os.utime(self.getDirectory(),(self.date,)*2) os.utime(self.getDirectory(),(self.date,) * 2)
def getDirectory(self): def getDirectory(self):
"""Get full path to mail box""" """Get full path to mail box"""
@ -384,7 +386,7 @@ class MailBox:
class MailKeeper: class MailKeeper:
"""Object which keep mailboxes (mailboxes union)""" """Object which keep mailboxes (mailboxes union)"""
def __init__(self,storagedir=None,domains=[],errordir=None): def __init__(self,storagedir=None, domains=None, errordir=None):
# root directory for mail keeper # root directory for mail keeper
self.root = storagedir self.root = storagedir
# root directory for mail keeper # root directory for mail keeper
@ -396,7 +398,7 @@ class MailKeeper:
# create directory for error letters # create directory for error letters
mkdir_force(self.errordir) mkdir_force(self.errordir)
#self.initMailBoxes() #self.initMailBoxes()
self.domains = domains self.domains = domains if domains is not None else []
self.reInDomain = re.compile(r"@([^@]+)?(%s)$"%"|".join(self.domains),re.S) self.reInDomain = re.compile(r"@([^@]+)?(%s)$"%"|".join(self.domains),re.S)
self.iNum = 2 self.iNum = 2
if "unknown" not in self.mailboxes: if "unknown" not in self.mailboxes:
@ -541,7 +543,7 @@ class SortMilter(Milter.Milter):
def close(self): def close(self):
"""Execute after end of connect (include error disconnect)""" """Execute after end of connect (include error disconnect)"""
return Milter.CONTINUE return Milter.CONTINUE
def getMailFromFolder(dir): def getMailFromFolder(dir):
# find all files in specified directory and generate list of Letter # find all files in specified directory and generate list of Letter
for root, dirs, files in os.walk(dir): for root, dirs, files in os.walk(dir):
@ -580,24 +582,24 @@ def main(argv):
help="Directory for letters with error"), help="Directory for letters with error"),
parser.add_option("--domain", parser.add_option("--domain",
action="append", action="append",
default=[], default= [],
dest="domains", dest="domains",
metavar="DOMAIN", metavar="DOMAIN",
help="Owner mail domain"), help="Owner mail domain"),
parser.add_option("--letters-dir", parser.add_option("--letters-dir",
action="append", action="append",
default = [], default=[],
dest="letters_dir", dest="letters_dir",
metavar="DIR", metavar="DIR",
help="Directory which contains letter for performing"), help="Directory which contains letter for performing"),
parser.add_option("--remove-success", parser.add_option("--remove-success",
action="store_true", action="store_true",
default = False, default=False,
dest="remove_success", dest="remove_success",
help="Remove letters from directory if processed success"), help="Remove letters from directory if processed success"),
parser.add_option("--letter-file", parser.add_option("--letter-file",
action="append", action="append",
default = [], default=[],
dest="letter_file", dest="letter_file",
metavar="FILE", metavar="FILE",
help="Letter file for performing"), help="Letter file for performing"),

@ -25,6 +25,9 @@ from distutils.command.build_scripts import build_scripts
from distutils.command.install_scripts import install_scripts from distutils.command.install_scripts import install_scripts
from distutils.command.install_data import install_data from distutils.command.install_data import install_data
def cmp(a, b):
return (a > b) - (b < a)
data_files = [] data_files = []
var_data_files = [("/var/calculate/server-profile",[]), var_data_files = [("/var/calculate/server-profile",[]),
@ -44,24 +47,24 @@ def scanDirs(profilesDirs):
self.baseDir = False self.baseDir = False
self.dirs = [] self.dirs = []
self.files = [] self.files = []
def getFilesDir(dirP, dirname,names):
if '/.svn' in dirname:
return False
for nameFile in names:
absNameFile = dirname + "/" + nameFile
if '/.svn' in absNameFile:
continue
if os.path.isfile(absNameFile):
dirP.files.append(absNameFile)
elif os.path.isdir(absNameFile):
dirP.dirs.append(absNameFile)
return True
for profileDir in profilesDirs: for profileDir in profilesDirs:
if profileDir: if profileDir:
dirP = dirProf() dirP = dirProf()
dirP.baseDir = profileDir dirP.baseDir = profileDir
for dirname, dirs, files in os.walk(profileDir):
if '/.svn' in dirname:
return False
for nameFile in files:
absNameFile = dirname + "/" + nameFile
if '/.svn' in absNameFile:
continue
dirP.files.append(absNameFile)
for nameDir in dirs:
absNameDir = dirname + "/" + nameDir
if '/.svn' in absNameDir:
continue
dirP.dirs.append(absNameDir)
dirs.append(dirP) dirs.append(dirP)
os.path.walk(profileDir,getFilesDir, dirP)
return dirs return dirs
def create_data_files (data_dirs, prefix=""): def create_data_files (data_dirs, prefix=""):
@ -82,7 +85,7 @@ def create_data_files (data_dirs, prefix=""):
break break
for files_obj_dir in files_obj_dirs: for files_obj_dir in files_obj_dirs:
obj.dirs.remove(files_obj_dir) obj.dirs.remove(files_obj_dir)
files_obj_dirs.sort(lambda x, y: cmp(len(y), len(x))) files_obj_dirs.sort(key=len, reverse=True)
for dir_name in files_obj_dirs: for dir_name in files_obj_dirs:
wr_sp = (prefix+dir_name,[]) wr_sp = (prefix+dir_name,[])
file_dirs = [] file_dirs = []
@ -103,8 +106,8 @@ def create_data_files (data_dirs, prefix=""):
test1_files = test2_files + test1_files test1_files = test2_files + test1_files
return test1_files return test1_files
data_files += create_data_files (data_dirs_local) data_files += create_data_files(data_dirs_local)
data_files += create_data_files (data_dirs_share, share_calculate_dir) data_files += create_data_files(data_dirs_share, share_calculate_dir)
data_files += [('/etc/conf.d', ['data/sortmilter.conf']), data_files += [('/etc/conf.d', ['data/sortmilter.conf']),
('/etc/init.d', ['data/sortmilter.init'])] ('/etc/init.d', ['data/sortmilter.init'])]
@ -115,7 +118,7 @@ class cl_build_scripts(build_scripts):
'./scripts/execserv', './scripts/execserv',
'./scripts/execsamba'] './scripts/execsamba']
backup_build_dir = self.build_dir backup_build_dir = self.build_dir
backup_scripts = filter(lambda x: not x in scripts, self.scripts) backup_scripts = [x for x in self.scripts if x not in scripts]
self.scripts = scripts self.scripts = scripts
self.build_dir = self.build_dir + "-bin" self.build_dir = self.build_dir + "-bin"
build_scripts.run(self) build_scripts.run(self)
@ -140,15 +143,11 @@ class cl_install_data(install_data):
def run (self): def run (self):
install_data.run(self) install_data.run(self)
data_file = \ data_file = \
[("/etc/init.d/sortmilter.init","sortmilter",0755), [("/etc/init.d/sortmilter.init","sortmilter",0o755),
("/etc/conf.d/sortmilter.conf","sortmilter",None)] ("/etc/conf.d/sortmilter.conf","sortmilter",None)]
data_find = \ data_find = \
dict( dict(
map(lambda x:(os.path.basename(x[0]), [(os.path.basename(x[0]), [list(reversed([y for y in x[0].split("/") if y])), x[1],x[2]]) for x in data_file])
[list(reversed(filter(lambda y:y,x[0].split("/")))),
x[1],
x[2]]),
data_file))
for path in self.get_outputs(): for path in self.get_outputs():
nameFile = os.path.split(path)[1] nameFile = os.path.split(path)[1]

Loading…
Cancel
Save