Merge branch 'py3_forced'

master
commit 9ede582b1e

@ -11,6 +11,14 @@ account required pam_unix.so
account sufficient pam_ldap.so
#?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
#pkg#
#?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.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import cl_base
import cl_utils
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):
"""Получить хеш пароля
@ -30,7 +35,7 @@ class fillVars(object, cl_base.glob_attr):
res = self._runos(runStr)
if res:
return res.strip()
print "Error generate hash (slappasswd)"
print("Error generate hash (slappasswd)")
exit(1)
def get_cl_profile_path(self):
@ -230,7 +235,7 @@ class fillVars(object, cl_base.glob_attr):
for replServer in replServers:
if replServer:
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
dEnd = 3
dMax = 32
@ -470,13 +475,13 @@ class fillVars(object, cl_base.glob_attr):
netAllow = self.Get("sr_proxy_net_allow")
if netAllow:
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)
return netAllow
netAllow = self.Get("os_net_allow")
if netAllow:
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)
return netAllow
return "acl localnet src 127.0.0.1/32"
@ -543,14 +548,14 @@ class fillVars(object, cl_base.glob_attr):
"""Текст в ejabberd.cfg - имена хостов с которыми работает сервис"""
jabberHosts = self.Get("sr_jabber_hosts")
if jabberHosts:
return ", ".join(map(lambda x: '"'+x+'"', jabberHosts.split(",")))
return ", ".join(('"'+x+'"' for x in jabberHosts.split(",")))
return ""
def get_sr_jabber_hosts_yml(self):
"""Текст в ejabberd.cfg - имена хостов с которыми работает сервис"""
jabberHosts = self.Get("sr_jabber_hosts")
if jabberHosts:
return "\n".join(map(lambda x: ' - "%s"' % x, jabberHosts.split(",")))
return "\n".join((' - "%s"' % x for x in jabberHosts.split(",")))
return ""
def get_sr_jabber_user_name(self):
@ -591,7 +596,7 @@ class fillVars(object, cl_base.glob_attr):
break
if not foundLoc:
netAllow.append("127.0.0.1")
netAllow = map(lambda x: "%s;"%x,netAllow)
netAllow = ["%s;" % x for x in netAllow]
netAllow = " ".join(netAllow)
return "listen-on { %s };"%netAllow
netAllow = self.Get("sr_dns_net_allow")
@ -601,3 +606,5 @@ class fillVars(object, cl_base.glob_attr):
if netAllow:
return getNetAllow(netAllow)
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 = {}
# Директория настроек пользователя windows
sr_samba_winprof_path = {\
'value':'/var/calculate/server-data/samba/profiles/win'}
sr_samba_winprof_path = \
{'value':'/var/calculate/server-data/samba/profiles/win'}
# Директория хранения настроек пользователя linux
sr_samba_linprof_path = {\
'value':'/var/calculate/server-data/samba/profiles/unix'}
sr_samba_linprof_path = \
{'value':'/var/calculate/server-data/samba/profiles/unix'}
# Домашняя директория
sr_samba_home_path = {\
'value':'/var/calculate/server-data/samba/home'}
sr_samba_home_path = \
{'value':'/var/calculate/server-data/samba/home'}
# Директория netlogon
sr_samba_winlogon_path = {\
'value':'/var/calculate/server-data/samba/netlogon'}
sr_samba_winlogon_path = \
{'value':'/var/calculate/server-data/samba/netlogon'}
# Директория share
sr_samba_share_path = {\
'value':'/var/calculate/server-data/samba/share'}
sr_samba_share_path = \
{'value':'/var/calculate/server-data/samba/share'}
# Настроен или нет сервис Samba
sr_samba_set = {'mode':"w",

File diff suppressed because it is too large Load Diff

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-info")
optObj = cl_ldap.tsOpt(ldapObj,[])
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:
# Информация о сервисах и пользователях
flagError = True

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

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-replication")
optObj = cl_ldap.tsOpt(ldapObj,[])
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:
# Настройка сервера LDAP
flagError = True

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

@ -29,7 +29,7 @@ if __name__ == "__main__":
ldapObj = cl_ldap.cl_ldap("cl-update-server")
optObj = cl_ldap.tsOpt(ldapObj,[])
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:
# Настройка сервера LDAP
flagError = True

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

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

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

@ -45,12 +45,12 @@ if __name__ == "__main__":
os.setgid(gid)
os.setuid(uid)
except:
print _("ERROR: Can not set owner") + \
print(_("ERROR: Can not set owner") + \
" (dhcp:dhcp uid=%s,gid=%s) "%(uid, gid) +\
_("the this process")
_("the this process"))
sys.exit(1)
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)
if os.access(logFullFile, os.W_OK):
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 optparse import OptionParser
from threading import Lock
from functools import reduce
# fix ecre in email module
email.header.ecre = re.compile(r'''
@ -63,7 +64,7 @@ class Logger:
self.logfile.flush()
except:
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()
def printDEBUG(self,s):
@ -96,7 +97,7 @@ class Logger:
def dbg_except():
"""Debug function, for try-except block"""
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):
return strftime(format, localtime(seconds))
@ -119,7 +120,7 @@ class Letter:
self.cacheReceiver = None
# letter by filename
if file:
content = open(file,"r").read()
content = open(file, "r").read()
self.filepath = file
self.mail = message_from_string(content)
# letter by content
@ -158,7 +159,8 @@ class Letter:
resent_to = self.getResentTo()
delivered_to = self.getDeliveredTo()
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"):
receiver_emails = delivered_to
else:
@ -184,9 +186,9 @@ class Letter:
charset = self.mail.get_charsets()
# if charset specified and it is not utf-8
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')
except Exception,e:
except Exception as e:
Logger().printDEBUG("wrong decode from %s: %s" % (charset[0], e))
return letter_text
@ -357,7 +359,7 @@ class MailBox:
def fixMtime(self):
# 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):
"""Get full path to mail box"""
@ -384,7 +386,7 @@ class MailBox:
class MailKeeper:
"""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
self.root = storagedir
# root directory for mail keeper
@ -396,7 +398,7 @@ class MailKeeper:
# create directory for error letters
mkdir_force(self.errordir)
#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.iNum = 2
if "unknown" not in self.mailboxes:
@ -541,7 +543,7 @@ class SortMilter(Milter.Milter):
def close(self):
"""Execute after end of connect (include error disconnect)"""
return Milter.CONTINUE
def getMailFromFolder(dir):
# find all files in specified directory and generate list of Letter
for root, dirs, files in os.walk(dir):
@ -580,24 +582,24 @@ def main(argv):
help="Directory for letters with error"),
parser.add_option("--domain",
action="append",
default=[],
default= [],
dest="domains",
metavar="DOMAIN",
help="Owner mail domain"),
parser.add_option("--letters-dir",
action="append",
default = [],
default=[],
dest="letters_dir",
metavar="DIR",
help="Directory which contains letter for performing"),
parser.add_option("--remove-success",
action="store_true",
default = False,
default=False,
dest="remove_success",
help="Remove letters from directory if processed success"),
parser.add_option("--letter-file",
action="append",
default = [],
default=[],
dest="letter_file",
metavar="FILE",
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_data import install_data
def cmp(a, b):
return (a > b) - (b < a)
data_files = []
var_data_files = [("/var/calculate/server-profile",[]),
@ -44,24 +47,24 @@ def scanDirs(profilesDirs):
self.baseDir = False
self.dirs = []
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:
if profileDir:
dirP = dirProf()
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)
os.path.walk(profileDir,getFilesDir, dirP)
return dirs
def create_data_files (data_dirs, prefix=""):
@ -82,7 +85,7 @@ def create_data_files (data_dirs, prefix=""):
break
for files_obj_dir in files_obj_dirs:
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:
wr_sp = (prefix+dir_name,[])
file_dirs = []
@ -103,8 +106,8 @@ def create_data_files (data_dirs, prefix=""):
test1_files = test2_files + test1_files
return test1_files
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_local)
data_files += create_data_files(data_dirs_share, share_calculate_dir)
data_files += [('/etc/conf.d', ['data/sortmilter.conf']),
('/etc/init.d', ['data/sortmilter.init'])]
@ -115,7 +118,7 @@ class cl_build_scripts(build_scripts):
'./scripts/execserv',
'./scripts/execsamba']
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.build_dir = self.build_dir + "-bin"
build_scripts.run(self)
@ -140,15 +143,11 @@ class cl_install_data(install_data):
def run (self):
install_data.run(self)
data_file = \
[("/etc/init.d/sortmilter.init","sortmilter",0755),
[("/etc/init.d/sortmilter.init","sortmilter",0o755),
("/etc/conf.d/sortmilter.conf","sortmilter",None)]
data_find = \
dict(
map(lambda x:(os.path.basename(x[0]),
[list(reversed(filter(lambda y:y,x[0].split("/")))),
x[1],
x[2]]),
data_file))
[(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])
for path in self.get_outputs():
nameFile = os.path.split(path)[1]

Loading…
Cancel
Save