Merge branch 'master', remote branch 'origin/develop'

Conflicts:
	pym/cl_base.py
	pym/cl_profile.py
	pym/cl_utils2.py
develop
Самоукин Алексей 14 years ago
commit 91b1f33f93

@ -14,432 +14,18 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import gettext
import os
import getopt
import sys
##############################################################################
import re
import copy
import types
import string
#import os
import filecmp
import ConfigParser
import time
import socket
#import sys
import random
import string
import cl_utils
##############################################################################
from cl_lang import lang
from cl_template import iniParser
from cl_string import columnWrite
_expand_lang = gettext._expand_lang
def exit(codeExit):
"""Метод выхода из программы"""
sys.exit(codeExit)
def __findFileMO(domain, localedir=None, languages=None, all=0):
# Модифицинрованный метод модуля gettext ищет файл перевода
if localedir is None:
localedir = _default_localedir
if languages is None:
languages = []
for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
val = os.environ.get(envar)
if val:
languages = val.split(':')
break
if 'C' not in languages:
languages.append('C')
# now normalize and expand the languages
nelangs = []
for lang in languages:
for nelang in _expand_lang(lang):
if nelang not in nelangs:
nelangs.append(nelang)
# select a language
if all:
result = []
else:
result = None
for lang in nelangs:
if lang == 'C':
break
mofile = os.path.join(localedir, '%s_%s.mo' % (domain,lang))
if os.path.exists(mofile):
if all:
result.append(mofile)
else:
return mofile
return result
gettext.find = __findFileMO
class GlobalParam(type):
""" Метакласс для глобальных параметров
"""
def __init__(cls, *args):
cls.GP = []
cls.GP.append("")
class lang:
"""Класс многоязыковой поддержки lang для перевода сообщений программ на
другие языки.
Типичное использование:
import sys
import lang
# язык сообщений английский
tr = lang.lang(en)
# язык определяется системой
#tr = lang.lang()
#Установка домена переводаldap
# в последующем можно не использовать - задается глобально
tr.setGlobalDomain('calc')
# задается локально для одного файла
#tr.setLocalDomain('calc')
# Установка метода перевода для текущего модуля
tr.setLanguage(sys.modules[__name__])
Где:
tr -- объект перевода
'en' -- язык выводимых сообщений
sys.modules[__name__] -- модуль сообщения которого переводятся
calc - домен перевода - имя файла перевода без расширения
Если файл перевода не найден то сообщения не переводятся
Если в модуле сообщения которого переводим, экспортируются другие модули то
они тоже переводятся.
По умолчанию директория в которой находятся переводы: 'lang/i18h' относительно
исполняемого файла названия файлов перевода совпадают с названиями модулей
если не определен методом setDomainTranslate() - домен перевода.
"""
__metaclass__ = GlobalParam
def __init__(self,l=''):
self.nameDomain = self.GP[0]
#self.nameDomain = ''
""" Название файла перевода (Домен) если используется 1 файл перевода
"""
self.__catalog = os.path.abspath('/usr/share/calculate/i18n')
""" Путь к каталогу переводов (в этом каталоге
ru_RU/LC_MESSAGES в котором файл перевода)
"""
env = os.environ
if l == "" and env.has_key('LANG'):
l = env['LANG'].split('.')[0].split("_")[0]
""" Определение языка """
self.__modnames = {}
""" Словарь переведенных модулей
ключ --- имя модуля
значение --- был ли модуль переведен (1 или 0)
"""
self.__l = l
"""Язык перевода для всех модулей"""
def __translate(self,message):
"""Метод translate возвращает полученное значение без
изменений"""
return message
def setLanguage(self,module):
""" Установка языка перевода для модуля module.
параметр --- экспортируемый модуль python
если в этом модуле экспортируются другие модули
то язык устанавливается и для них
Метод запускается после экспорта модуля который будем переводить
"""
t = vars(module)
for i in dir(module):
q = str(t[i])
if 'module' in q and not '__' in i and not '/usr/lib' in q\
and not 'built-in' in q :
mod = vars(module)[i]
self.__setLang(mod)
return self.__setLang(module)
def __setLang(self,module):
""" Установка языка перевода для модуля module.
В случае нахождения файла перевода возвращает истину.
Во всех случаях устанавливает метод перевода для модуля.
Если нет файла перевода метод перевода возвращает то же
значение что получает
"""
if module.__name__ in self.__modnames.keys():
return True
if self.nameDomain == '':
if module.__name__ == "__main__":
nameDomain = module.__file__.split('.')[0]
else:
nameDomain = module.__name__
else:
nameDomain = self.nameDomain
if self.__l == 'en':
module._ = self.__translate
ret = 1
else:
la = []
la.append(self.__l)
if gettext.find(nameDomain,self.__catalog,la):
"""Если найден словарь то инициализируем переводчик"""
transl = gettext.translation(nameDomain\
,self.__catalog,la)
#module._ = transl.ugettext
module._ = transl.gettext
ret = 1
else:
module._ = self.__translate
ret = 0
self.__modnames[module.__name__] = ret
return ret
def getTranslatorByName(self,namemodule):
""" Метод который по имени модуля определяет, был ли модуль с этим
именем переведен
"""
if self.__modnames.has_key(namemodule):
return self.__modnames[namemodule]
return 0
def setGlobalDomain(self, nameDomain):
""" Метод для установки домена перевода (глобально для всех файлов)
"""
self.GP[0] = nameDomain
self.nameDomain = self.GP[0]
return True
def setLocalDomain(self, nameDomain):
""" Метод для установки домена перевода (локально для одного файла)
"""
self.nameDomain = nameDomain
return True
##############################################################################
# Перевод модуля на другой язык
tr = lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
##############################################################################
class opt:
def __init__(self,shortOpt,longOpt = []):
""" Длинные и короткие опции командной строки допустимые в программе
a - короткая опция
>program -a
a: - короткая опциия со значением
>program -a 10
a:: - короткая опциия у которой может быть или не быть значение
>program -a
>program -a 15
"ha:" - значение параметра shortOpt
две опции h - без значения, a - со значением
help - длинная опция без значения
test= - длинная опция со значением
["help","test="] - значение парамера longOpt
>program -a
две опции help - без значения, test - со значением
"""
self.shortOpt = shortOpt
self.longOpt = longOpt
self.sysArgv = sys.argv[1:]
def getopt(self):
try:
opts, args = getopt.getopt(self.sysArgv,self.shortOpt,self.longOpt)
except getopt.GetoptError:
self.handlerErrOpt()
sys.exit(1)
for option, value in opts:
if len(option) == 2:
option = option[1:]
else:
option = option[2:]
self.handlerOpt(option,value)
for param in args:
self.handlerParam(param)
def handlerErrOpt(self):
# Обработчик в случае неправильных параметров
pass
def handlerOpt(self,option,value):
# Обработчик (параметр значение)
pass
def handlerParam(self,param):
# Обработчик хвостов (значение)
pass
###############################################################################
import cl_profile
class iniParser(cl_profile._error):
"""Класс для работы с ini файлами
"""
def __init__(self, iniFile):
# название ini файла
self.iniFile = iniFile
# права создаваемого ini-файла
self.mode = 0640
# Cоответствует ли формат файла нужному
self.checkIni = None
def setMode(self, mode):
"""установка прав создаваемого ini-файла"""
self.mode = mode
def openIniFile(self):
if not os.access(self.iniFile, os.R_OK):
return ""
FD = open(self.iniFile, "r")
textIni = FD.read()
FD.close()
return textIni
def writeIniFile(self, txtConfig):
if not os.path.exists(self.iniFile):
fd = os.open(self.iniFile, os.O_CREAT)
os.close(fd)
os.chmod(self.iniFile, self.mode)
if not os.path.exists(self.iniFile):
self.setError(_("Unable to create file") + ": " + self.iniFile)
return False
FD = open(self.iniFile, "r+")
FD.truncate(0)
FD.seek(0)
FD.write(txtConfig)
FD.close()
def setVar(self, strHeader, dictVar):
"""Заменяет или добавляет область и переменные
Добавляет область в ini-файл или объединяет с существующей
strHeader - имя области
dictVar - словарь переменных
"""
textIni = self.openIniFile()
if not self.checkIniFile(textIni):
return False
# создаем объект типа samba и записываем в него содержимое ini-файла
objIni = cl_profile.samba(textIni)
# создаем текст в формате samba из строки заголовка и
# словаря переменных области
txtConfig = objIni.createTxtConfig(strHeader, dictVar)
# создаем объект типа samba и записываем в него текст
objIniAdd = cl_profile.samba(txtConfig)
# объединяем объекты для получения результирующего текста
objIni.join(objIniAdd)
# получаем текст
txtConfig = objIni.getConfig().encode("UTF-8")
# записываем его в ini файл
self.writeIniFile(txtConfig)
return True
def isEmptyFile(self, textIni):
"""Является ли файл пустым"""
if not textIni.strip():
return True
else:
return False
def checkIniFile(self, textIni):
"""Проверка на правильность формата файла"""
if self.checkIni == None:
# Ошибка
if textIni == False:
self.checkIni = False
return False
self.checkIni = True
# В файле есть данные
if not self.isEmptyFile(textIni):
objIni = cl_profile.samba(textIni)
xmlBody = objIni.docObj.getNodeBody()
if not xmlBody.firstChild:
self.checkIni = False
return self.checkIni
def delVar(self, strHeader, nameVar):
"""Удаляем переменную из ini файла"""
delNameVar = "!%s" %(nameVar)
dictVar = {delNameVar:"del"}
res = self.setVar(strHeader, dictVar)
return res
def delArea(self, strHeader):
"""Удаляем область из ini файла"""
delStrHeader = "!%s" %(strHeader)
dictVar = {"del":"del"}
res = self.setVar(delStrHeader, dictVar)
return res
def getVar(self, strHeader, nameVar):
"""Получаем значение переменной из ini-файла"""
textIni = self.openIniFile()
if not self.checkIniFile(textIni):
return False
# создаем объект типа samba и записываем в него содержимое ini-файла
objIni = cl_profile.samba(textIni)
# получаем ноду body
xmlBody = objIni.docObj.getNodeBody()
# находим в области переменную
res = objIni.docObj.getAreaFieldValues(strHeader, nameVar, xmlBody)
if res == False:
return ""
else:
return res
def getAreaVars(self,strHeader):
"""Получаем все переменнные области из ini-файла"""
textIni = self.openIniFile()
if not self.checkIniFile(textIni):
return False
# создаем объект типа samba и записываем в него содержимое ini-файла
objIni = cl_profile.samba(textIni)
# получаем ноду body
xmlBody = objIni.docObj.getNodeBody()
# если находим область то выдаем словарем все переменные иначе False
res = objIni.docObj.getAreaFields(strHeader, xmlBody)
if res == False:
return {}
else:
return res
def getAllSectionNames(self):
"""Получаем все имена секций определенных в ini файле"""
textIni = self.openIniFile()
if not self.checkIniFile(textIni):
return False
# создаем объект типа samba и записываем в него содержимое ini-файла
objIni = cl_profile.samba(textIni)
# получаем ноду body
xmlBody = objIni.docObj.getNodeBody()
xmlNodes = objIni.docObj.getFieldsArea(xmlBody)
# Имена секций ini файла
namesSection = []
for xmlNode in xmlNodes:
if xmlNode.tagName == "area":
nSect = objIni.docObj.getNameArea(xmlNode)
if nSect:
namesSection.append(nSect)
return namesSection
##############################################################################
class var:
'''Объект "Переменная окружения"'''
# название сервиса которому принадлежит переменная
@ -1016,13 +602,13 @@ class DataVars(object):
p_val=var[i].value
if var[i].official:
continue
cl_utils.columnWrite( i, mlen_name, var[i].mode.lower(),
columnWrite( i, mlen_name, var[i].mode.lower(),
mlen_mode,
#str(var[i].type),
#mlen_type,
p_val)
print br
##############################################################################
class glob_attr:
"""Глобальные аттрибуты для методов заполнения переменных"""

@ -17,10 +17,11 @@
import re
import os
import types
from cl_overriding import exit
import cl_utils
import cl_base
import cl_data
class fillVars(object, cl_base.glob_attr):
class fillVars(object, cl_data.glob_attr):
def get_os_net_domain(self):
''' Определим домен'''
@ -28,7 +29,7 @@ class fillVars(object, cl_base.glob_attr):
if not domain:
print _("Error:") + " " +_("Not found domain name")
print _("Command 'hostname -d' returns an empty value")
cl_base.exit(1)
exit(1)
elif re.search("^hostname: ",domain):
return "local"
else:
@ -99,7 +100,7 @@ class fillVars(object, cl_base.glob_attr):
systemVersion = ""
flagGentoo = False
if os.path.exists(gentooFile):
gentooLink = "/etc/make.profile"
gentooLink = "/etc/make.template"
if os.path.islink(gentooLink):
systemVersion = os.readlink(gentooLink).rpartition("/")[2]
flagGentoo = True

@ -14,54 +14,65 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import getopt
import sys
import struct
import termios
import fcntl
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, e:
self.setError(e[0]['desc'])
from cl_string import prettyColumnStr
pcs = prettyColumnStr
class opt:
def __init__(self,shortOpt,longOpt = []):
""" Длинные и короткие опции командной строки допустимые в программе
a - короткая опция
>program -a
a: - короткая опциия со значением
>program -a 10
def __ldapConnect(self, dnUser, password, host):
"""Соединение с LDAP сервером"""
conLdap = ldap.initialize('ldap://%s'%host)
conLdap.simple_bind_s(dnUser, password)
return conLdap
a:: - короткая опциия у которой может быть или не быть значение
>program -a
>program -a 15
def ldapSearch(self,baseDN, searchScope, searchFilter, retrieveAttributes):
"ha:" - значение параметра shortOpt
две опции h - без значения, a - со значением
help - длинная опция без значения
test= - длинная опция со значением
["help","test="] - значение парамера longOpt
>program -a
две опции help - без значения, test - со значением
"""
self.shortOpt = shortOpt
self.longOpt = longOpt
self.sysArgv = sys.argv[1:]
def getopt(self):
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
opts, args = getopt.getopt(self.sysArgv,self.shortOpt,self.longOpt)
except getopt.GetoptError:
self.handlerErrOpt()
sys.exit(1)
for option, value in opts:
if len(option) == 2:
option = option[1:]
else:
option = option[2:]
self.handlerOpt(option,value)
for param in args:
self.handlerParam(param)
def handlerErrOpt(self):
# Обработчик в случае неправильных параметров
pass
def handlerOpt(self,option,value):
# Обработчик (параметр значение)
pass
pcs = cl_utils.prettyColumnStr
def handlerParam(self,param):
# Обработчик хвостов (значение)
pass
class cl_help:
"""Объект для работы со справкой, и обработкой параметров.
@ -361,203 +372,4 @@ class cl_help:
par["longOption"] == option) or \
par["shortOption"] == option:
return par["shortOption"]
break
return ""
class cl_smartcon(object):
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 colorDict.has_key(color):
# печатаем и считаем смещение
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 colorDict.has_key(color):
# печатаем и считаем смещение
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,168 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os, gettext
from cl_overriding import __findFileMO
class GlobalParam(type):
""" Метакласс для глобальных параметров
"""
def __init__(cls, *args):
cls.GP = []
cls.GP.append("")
gettext.find = __findFileMO
class lang:
"""Класс многоязыковой поддержки lang для перевода сообщений программ на
другие языки.
Типичное использование:
import sys
import lang
# язык сообщений английский
tr = lang.lang(en)
# язык определяется системой
#tr = lang.lang()
#Установка домена переводаldap
# в последующем можно не использовать - задается глобально
tr.setGlobalDomain('calc')
# задается локально для одного файла
#tr.setLocalDomain('calc')
# Установка метода перевода для текущего модуля
tr.setLanguage(sys.modules[__name__])
Где:
tr -- объект перевода
'en' -- язык выводимых сообщений
sys.modules[__name__] -- модуль сообщения которого переводятся
calc - домен перевода - имя файла перевода без расширения
Если файл перевода не найден то сообщения не переводятся
Если в модуле сообщения которого переводим, экспортируются другие модули то
они тоже переводятся.
По умолчанию директория в которой находятся переводы: 'lang/i18h' относительно
исполняемого файла названия файлов перевода совпадают с названиями модулей
если не определен методом setDomainTranslate() - домен перевода.
"""
__metaclass__ = GlobalParam
def __init__(self,l=''):
self.nameDomain = self.GP[0]
#self.nameDomain = ''
""" Название файла перевода (Домен) если используется 1 файл перевода
"""
self.__catalog = os.path.abspath('/usr/share/calculate/i18n')
""" Путь к каталогу переводов (в этом каталоге
ru_RU/LC_MESSAGES в котором файл перевода)
"""
env = os.environ
if l == "" and env.has_key('LANG'):
l = env['LANG'].split('.')[0].split("_")[0]
""" Определение языка """
self.__modnames = {}
""" Словарь переведенных модулей
ключ --- имя модуля
значение --- был ли модуль переведен (1 или 0)
"""
self.__l = l
"""Язык перевода для всех модулей"""
def __translate(self,message):
"""Метод translate возвращает полученное значение без
изменений"""
return message
def setLanguage(self,module):
""" Установка языка перевода для модуля module.
параметр --- экспортируемый модуль python
если в этом модуле экспортируются другие модули
то язык устанавливается и для них
Метод запускается после экспорта модуля который будем переводить
"""
t = vars(module)
for i in dir(module):
q = str(t[i])
if 'module' in q and not '__' in i and not '/usr/lib' in q\
and not 'built-in' in q :
mod = vars(module)[i]
self.__setLang(mod)
return self.__setLang(module)
def __setLang(self,module):
""" Установка языка перевода для модуля module.
В случае нахождения файла перевода возвращает истину.
Во всех случаях устанавливает метод перевода для модуля.
Если нет файла перевода метод перевода возвращает то же
значение что получает
"""
if module.__name__ in self.__modnames.keys():
return True
if self.nameDomain == '':
if module.__name__ == "__main__":
nameDomain = module.__file__.split('.')[0]
else:
nameDomain = module.__name__
else:
nameDomain = self.nameDomain
if self.__l == 'en':
module._ = self.__translate
ret = 1
else:
la = []
la.append(self.__l)
if gettext.find(nameDomain,self.__catalog,la):
"""Если найден словарь то инициализируем переводчик"""
transl = gettext.translation(nameDomain\
,self.__catalog,la)
#module._ = transl.ugettext
module._ = transl.gettext
ret = 1
else:
module._ = self.__translate
ret = 0
self.__modnames[module.__name__] = ret
return ret
def getTranslatorByName(self,namemodule):
""" Метод который по имени модуля определяет, был ли модуль с этим
именем переведен
"""
if self.__modnames.has_key(namemodule):
return self.__modnames[namemodule]
return 0
def setGlobalDomain(self, nameDomain):
""" Метод для установки домена перевода (глобально для всех файлов)
"""
self.GP[0] = nameDomain
self.nameDomain = self.GP[0]
return True
def setLocalDomain(self, nameDomain):
""" Метод для установки домена перевода (локально для одного файла)
"""
self.nameDomain = nameDomain
return True

@ -0,0 +1,58 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ldap
from cl_utils import _error
class ldapFun(_error):
'''Объект для работы с LDAP сервером
подключение к серверу и поиск данных
'''
def __init__(self, dnUser, password, host="localhost"):
self.conLdap = False
# Получаем соединение с LDAP
try:
self.conLdap = self.__ldapConnect(dnUser, password, host)
except ldap.LDAPError, e:
self.setError(e[0]['desc'])
def __ldapConnect(self, dnUser, password, host):
"""Соединение с LDAP сервером"""
conLdap = ldap.initialize('ldap://%s'%host)
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

@ -0,0 +1,40 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
from cl_utils import removeDir
from cl_print import color_print
import cl_lang
tr = cl_lang.lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
class shareFile(color_print):
"""Общие методы для работы с файлами"""
def removeDir(self, rmDir):
"""Рекурсивное удаление директории
входной параметр директория или результат сканирования файлов (объект)
"""
try:
removeDir(rmDir)
except (OSError, Exception), e:
print e
self.printERROR(_("Can not delete dir: " ) + rmDir)
return False
return True

@ -0,0 +1,86 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
import os
import hashlib
import crypt
import string
from random import choice
from base64 import urlsafe_b64encode as b64encode
from cl_print import color_print
import cl_lang
tr = cl_lang.lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
class shareServer(color_print):
"""Класс хранения общих методов используемых для настройки сервисов"""
def __GenCryptSalt__(self):
"""Генерация соли для хеширования пароля (CRYPT)"""
chars = string.letters + string.digits+ "./"
salt = ""
for i in range(2):
salt = salt + choice(chars)
return salt
def getHashPasswd(self, password, crypt):
"""Генерация хеша пароля,
Поддерживаемые алгоритмы шифрования пароля:
plain, md5, smd5, crypt, sha, ssha
"""
if not password:
self.printERROR(_("ERROR") + " getHashPasswd: " +\
_("password empty"))
return False
hashPwd = ""
if crypt == "plain":
hashPwd = password
elif crypt == "md5":
h = hashlib.md5(password)
hashPwd = "{MD5}" + b64encode(h.digest())
elif crypt == "smd5":
salt = os.urandom(4)
h = hashlib.md5(password)
h.update(salt)
hashPwd = "{SMD5}" + b64encode(h.digest() + salt)
elif crypt == "crypt":
salt = self.__GenCryptSalt__()
hashPwd = "{CRYPT}" + crypt.crypt(password, salt)
elif crypt == "sha":
h = hashlib.sha1(password)
hashPwd = "{SHA}" + b64encode(h.digest())
elif crypt == "ssha":
salt = os.urandom(4)
h = hashlib.sha1(password)
h.update(salt)
hashPwd = "{SSHA}" + b64encode(h.digest() + salt)
else:
self.printERROR(_("ERROR") + " getHashPasswd: " +\
_("Can not support '%s' crypto algoritm")%crypt)
return False
return hashPwd

@ -13,6 +13,7 @@
# 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

@ -0,0 +1,58 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os,sys,gettext
def __findFileMO(domain, localedir=None, languages=None, all=0):
"""Модифицированный метод, ищет файл перевода
замена gettext.find"""
if localedir is None:
localedir = _default_localedir
if languages is None:
languages = []
for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
val = os.environ.get(envar)
if val:
languages = val.split(':')
break
if 'C' not in languages:
languages.append('C')
# now normalize and expand the languages
nelangs = []
for lang in languages:
for nelang in gettext._expand_lang(lang):
if nelang not in nelangs:
nelangs.append(nelang)
# select a language
if all:
result = []
else:
result = None
for lang in nelangs:
if lang == 'C':
break
mofile = os.path.join(localedir, '%s_%s.mo' % (domain,lang))
if os.path.exists(mofile):
if all:
result.append(mofile)
else:
return mofile
return result
def exit(codeExit):
"""Метод выхода из программы"""
sys.exit(codeExit)

@ -0,0 +1,217 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys, struct, termios, fcntl
from cl_utils import _toUNICODE
class color_print(object):
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 = _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 colorDict.has_key(color):
# печатаем и считаем смещение
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 colorDict.has_key(color):
# печатаем и считаем смещение
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)

File diff suppressed because it is too large Load Diff

@ -0,0 +1,254 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from re import search, compile, S
from cl_utils import _toUNICODE
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 xrange(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.encode('utf8')
def columnStr(*cols):
'''Вывод данных по колонкам, причем, если данные не вмещаются в указнаную
колонку, то они переносятся на следующую строку в нужную колонку. В строку.
Параметры:
cols множестово пар: текст, ширина колонки, причем, если у последней
колонки не указывать ширину, то она будет выведена вся.
Возвращаемые параметры:
строка, которую можно использовать для вывода на экран
Пример: columnWrite( "Some text", 10, "Next column", 20 )
'''
retstr = ""
# перевести кортеж в список, т.к. изменяется
cols = list(cols)
# перевести текст в юникод, заодно перевести числа в строку
for i in xrange(0,len(cols),2):
cols[i] = (str(cols[i])).decode('utf8')
# флаг "есть еще текст для вывода"
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])).encode('utf8') \
+ " "
# остальную часть строки оставить на следующую итерацию
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 xrange(0,len(cols),2):
cols[i] = (str(cols[i])).decode('utf8')
# флаг "есть еще текст для вывода"
repeat = True
while repeat:
# сбросить итератор на первый элемент
q = 0
repeat = False
# пока не закончили перебирать параметры (перебираем по парам)
while q < len(cols):
# если это последний параметр, и для него не указана ширина
if q == len(cols)-1:
# выводим его полностью не смотря на ширину окна
print cols[q].encode('utf8'),
cols[q] = ''
else:
# вывести часть строки не больше указанной ширины колонки
print (cols[q][:cols[q+1]].ljust(cols[q+1])).encode('utf8'),
# остальную часть строки оставить на следующую итерацию
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.decode( 'utf-8' )
# пропуск если это не 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.encode('utf-8')

File diff suppressed because it is too large Load Diff

@ -14,255 +14,20 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import filecmp
import subprocess
import string
from random import choice
from re import search, compile, S
import os
import types
import subprocess
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 xrange(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.encode('utf8')
def columnStr(*cols):
'''Вывод данных по колонкам, причем, если данные не вмещаются в указнаную
колонку, то они переносятся на следующую строку в нужную колонку. В строку.
Параметры:
cols множестово пар: текст, ширина колонки, причем, если у последней
колонки не указывать ширину, то она будет выведена вся.
Возвращаемые параметры:
строка, которую можно использовать для вывода на экран
Пример: columnWrite( "Some text", 10, "Next column", 20 )
'''
retstr = ""
# перевести кортеж в список, т.к. изменяется
cols = list(cols)
# перевести текст в юникод, заодно перевести числа в строку
for i in xrange(0,len(cols),2):
cols[i] = (str(cols[i])).decode('utf8')
import stat
# флаг "есть еще текст для вывода"
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])).encode('utf8') \
+ " "
# остальную часть строки оставить на следующую итерацию
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 xrange(0,len(cols),2):
cols[i] = (str(cols[i])).decode('utf8')
# флаг "есть еще текст для вывода"
repeat = True
while repeat:
# сбросить итератор на первый элемент
q = 0
repeat = False
# пока не закончили перебирать параметры (перебираем по парам)
while q < len(cols):
# если это последний параметр, и для него не указана ширина
if q == len(cols)-1:
# выводим его полностью не смотря на ширину окна
print cols[q].encode('utf8'),
cols[q] = ''
else:
# вывести часть строки не больше указанной ширины колонки
print (cols[q][:cols[q+1]].ljust(cols[q+1])).encode('utf8'),
# остальную часть строки оставить на следующую итерацию
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.decode( 'utf-8' )
# пропуск если это не 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.encode('utf-8')
def _toUNICODE(val):
"""перевод текста в юникод"""
if type(val) == types.UnicodeType:
return val
else:
return str(val).decode('UTF-8')
def runOsCommand(cmd, inStr=None, ret_first=None, env_dict=None):
"""Выполняет внешнюю программу
@ -299,27 +64,9 @@ def runOsCommand(cmd, inStr=None, ret_first=None, env_dict=None):
else:
return retcode, res
return retcode, None
def genpassword(passlen=9):
'''Вернуть случайный пассворд указанной длины
Параметры:
passlen длина пароля который нужно сгенерировать
Возвращаемые параметры:
Сгенерированный пароль указанной длины
'''
res=''.join([choice(string.ascii_letters+string.digits)\
for i in xrange(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 env.has_key('PATH'):
@ -331,134 +78,23 @@ def getpathenv():
lpath=npath+lpath
return ":".join(lpath)
#класс для работы с установленными пакетами
class pakages:
#путь к директории установленнх пакетов
pkgdir="/var/db/pkg/"
#список установленных пакетов
pkglist={}
#Объект содержащий параметры пакета
class pakage(object):
#имя пакета с версией
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 instaledPkg.has_key(fpkg):
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]
def genpassword(passlen=9):
'''Вернуть случайный пароль указанной длины
Параметры:
passlen длина пароля который нужно сгенерировать
#проверить установленн ли пакет
#isinstalled('dev-db/postgresql')
def isinstalled(self, pkgname):
res=self.getinstpkg(pkgname)
if len(res)>0:
return True
else:
return False
Возвращаемые параметры:
Сгенерированный пароль указанной длины
'''
res=''.join([choice(string.ascii_letters+string.digits)\
for i in xrange(passlen)])
return res
#вернуть список объектов 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 not self.pkglist.has_key(pinfo[0]+'/'+pinfo[1]):
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 not self.pkglist.has_key(pinfo[0]+'/'+pinfo[1]):
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 fillstr(char, width):
'''Заполнить строку указанным числом символов. Псеводоним символ*кол-во'''
return str(char) * width
def getListPkg(self):
return self.pkglist
def list2str(list):
'''Функция переводит список в строку'''
@ -502,9 +138,107 @@ def convertStrListDict(val):
else:
return val
def _toUNICODE(val):
"""перевод текста в юникод"""
if type(val) == types.UnicodeType:
return val
else:
return str(val).decode('UTF-8')
def getdirlist(s_path):
"""Получить список директорий по указаному пути"""
return filter(lambda x: os.path.isdir(x), os.listdir(s_path))
class _error:
# Здесь ошибки, если они есть
error = []
def getError(self):
"""Выдать ошибки"""
if not self.error:
return False
error = ""
for e in self.error:
error += e + "\n"
return error
def setError(self, error):
"""Установка ошибки"""
if not error in self.error:
self.error.append(error)
return True
class scan:
"""Класс для сканирования директорий"""
class _dir:
"""Класс для хранения директорий"""
def __init__(self):
# Базовая директория
self.baseDir = False
# Все директории в базовой включая вложенные
self.dirs = []
# Все файлы внутри базовой директории
self.files = []
# Все ссылки внутри базовой директории
self.links = []
# Все сокеты внутри базовой директории
self.sockets = []
def __scanDir(self, scanDir, dirObj, flagDir=False):
"""Сканирование одной директории"""
if flagDir or stat.S_ISDIR(os.stat(scanDir)[stat.ST_MODE]):
for fileOrDir in os.listdir(scanDir):
absPath = os.path.join(scanDir,fileOrDir)
statInfo = os.stat(absPath)[stat.ST_MODE]
if stat.S_ISDIR(statInfo):
dirObj.dirs.append(absPath)
self.__scanDir(absPath, dirObj, True)
elif stat.S_ISLNK(statInfo):
dest = absPath
src = os.readlink(absPath)
dirObj.links.append((src,dest))
elif stat.S_ISREG(statInfo):
dirObj.files.append(absPath)
elif stat.S_ISSOCK(statInfo):
dirObj.sockets.append(absPath)
return dirObj
def scanDirs(self, scanDirs):
"""Сканирование директорий на вход список
Выход список объктов _dirProf
"""
dirs = []
for scanDir in scanDirs:
dirP = scan._dir()
try:
self.__scanDir(scanDir, dirP)
except OSError, e:
print e.strerror, e.filename
return []
dirP.baseDir = scanDir
dirs.append(dirP)
return dirs
def removeDir(rmDir):
"""Рекурсивное удаление директории
входной параметр директория для удаления
Ошибки по except
"""
if not os.path.exists(rmDir):
raise Exception(_("Not found remove dir %s") %rmDir)
fileObj = scan()
# Сканируем директорию
scanObjs = fileObj.scanDirs([rmDir])
for socketRm in scanObjs[0].sockets:
# Удаляем сокеты
if os.path.exists(socketRm):
os.remove(socketRm)
for linkRm in scanObjs[0].links:
# Удаляем ссылки
os.unlink(linkRm[1])
for fileRm in scanObjs[0].files:
# Удаляем файлы
os.remove(fileRm)
scanObjs[0].dirs.sort(lambda x, y: cmp(len(y), len(x)))
for dirRm in scanObjs[0].dirs:
# Удаляем директории
os.rmdir(dirRm)
if os.path.exists(rmDir):
os.rmdir(rmDir)
return True

@ -14,6 +14,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#Допустимые ключи значений
# mode - режим переменной r-не переназначается из командной строки,
# w-переназначается из командной строки
@ -57,10 +58,10 @@ class Data:
# архитектура компьютера (i686,x86_64)
os_arch_machine = {}
#проход при наложении профилей 1,2,3,4,5 и.т д
#проход при наложении шаблонов 1,2,3,4,5 и.т д
cl_pass_step = {'mode':"w"}
# обрабатываемый файл профиля
# обрабатываемый файл шаблона
cl_pass_file = {'mode':"w"}
# корневой раздел файловой системы
@ -81,7 +82,7 @@ class Data:
# версия системы
os_linux_ver = {}
# Тип профиля
# Тип шаблона
cl_pass_type = {'mode':"w"}
# Действие программы

@ -0,0 +1,218 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from xml import xpath
from cl_template import blocText, xmlDoc
from format.bind import bind
class apache(bind):
"""Класс для обработки конфигурационного файла типа apache
"""
_comment = "#"
configName = "apache"
configVersion = "0.1"
__headerArea = "[^\<\> \t]+[ \t]+[^\<\> \t]+"
__openArea = "[ \t]*\<%s\>"%(__headerArea)
__closeArea = "[ \t]*\<\/[^\<\>]+\>"
sepFields = "\n"
reOpen = re.compile(__openArea)
reClose = re.compile(__closeArea)
reCloseArea = re.compile(__closeArea + "\s*\Z")
reComment = re.compile("[ \t]*%s"%(_comment))
reSepFields = re.compile(sepFields)
reSeparator = re.compile("[ \t]+")
reHeader = re.compile(__headerArea)
def __init__(self,text):
self.text = text
self.blocTextObj = blocText()
# Объект документ
self.docObj = self.textToXML()
# Создаем поля-массивы
self.docObj.postParserList()
# Создаем поля разделенные массивы
self.docObj.postParserListSeplist(self.docObj.body)
# XML документ
self.doc = self.docObj.doc
def postXML(self):
"""Последующая постобработка XML"""
# Для добавления перевода строки перед закрывающим тегом
# конфигурационного файла
xmlFields = xpath.Evaluate("child::fields", self.docObj.body)
if not (xmlFields and\
self.docObj.getTypeField(xmlFields[-1]) == "br"):
self.docObj.body.appendChild(self.docObj.createField("br",
[],"",[],
False,False))
xmlAreas = xpath.Evaluate("child::area", self.docObj.body)
for xmlArea in xmlAreas:
xmlFields = xpath.Evaluate("child::field", xmlArea)
if not (xmlFields and\
self.docObj.getTypeField(xmlFields[-1]) == "br"):
xmlArea.appendChild(self.docObj.createField("br",
[],"",[],
False,False))
def join(self, apacheObj):
"""Объединяем конфигурации"""
if isinstance(apacheObj, apache):
#print self.docObj.doc.toprettyxml()
self.docObj.joinDoc(apacheObj.doc)
self.postXML()
# Делим область на составные части
def findOpenClose(self, text, reOpen, reClose, reComment, reHeader):
"""Делит область на составные части
начальный текстовый блок,
открывающий блок,
блок-тело,
закрывающий блок
"""
firstBloc = ""
startBloc = ""
bodyBloc = ""
endBloc = ""
textLines = text.splitlines()
findOpen = False
if textLines:
findOpen = reOpen.search(textLines[0])
openBl = reOpen.search(text)
if findOpen and reComment.split(text)[0].strip():
blocA = text[openBl.end():]
firstBloc = ""
startBloc = text[openBl.start():openBl.end()]
headBl = reHeader.search(startBloc)
if headBl:
firstBloc = headBl.group(0)
closeBl = reClose.search(blocA)
endBloc = blocA[closeBl.start():closeBl.end()]
bodyBloc = blocA[:closeBl.start()]
return (firstBloc, startBloc, bodyBloc, endBloc)
else:
return (firstBloc, startBloc, text, endBloc)
# Делим текст на области включая вложенные (areas массив областей)
def splitToAllArea(self, text, areas, reOpen, reClose, reCloseArea,
reComment, reSepFields, reHeader):
"""Делит текст на области включая вложенные
возвращает список объектов областей (переменная areas)
"""
class area:
def __init__(self):
self.header = False
self.start = False
self.fields = []
self.end = False
blocs = self.blocTextObj.splitTxtToBloc(text,reOpen,reClose,
reComment,reSepFields)
for i in blocs:
areaA = area()
first,start,body,end = self.findOpenClose(i, reOpen, reCloseArea,
reComment, reHeader)
areaA.header = first.replace(" ","").replace("\t","")
areaA.start = start
areaA.end = end
if areaA.end:
blocsA = self.blocTextObj.splitTxtToBloc(body,reOpen,reClose,
reComment,reSepFields)
if blocsA and blocsA[0] == body:
areaA.fields.append(body)
areas.append(areaA)
else:
for ar in blocsA:
self.splitToAllArea(ar, areaA.fields, reOpen,
reClose,
reCloseArea, reComment,
reSepFields, reHeader)
areas.append(areaA)
else:
areaA.fields.append(body)
areas.append(areaA)
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
#print "#"+brBloc[z]+"#"
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len (nameValue) == 1:
field.name = ""
field.value = textLine.replace(self.sepFields,"")
field.br = textLine
fields.append(field)
field = fieldData()
if len(nameValue) == 3:
valueList = nameValue[2:]
nameValue =["".join(nameValue[:2])," ".join(valueList)]
if len(nameValue) > 3:
valueList = nameValue[1:]
nameValue =[nameValue[0]," ".join(valueList).replace(\
self.sepFields,"")]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def textToXML(self):
"""Преобразуем тект в XML"""
areas = []
self.splitToAllArea(self.text, areas, self.reOpen, self.reClose,
self.reCloseArea,self.reComment,self.reSepFields,
self.reHeader)
docObj = xmlDoc()
# Создание объекта документ c пустым разделителем между полями
docObj.createDoc(self.configName, self.configVersion)
if not areas:
return docObj
self.createXML(areas, docObj.getNodeBody(), docObj)
return docObj

@ -0,0 +1,315 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from cl_template import objShare, blocText, xmlDoc
class bind(objShare):
"""Класс для обработки конфигурационного файла типа bind
"""
_comment = "//"
configName = "bind"
configVersion = "0.1"
__openArea = "{"
__closeArea = "[ \t]*\}[ \t]*;[ \t]*"
sepFields = ";"
reOpen = re.compile(__openArea)
reClose = re.compile(__closeArea)
reCloseArea = re.compile(__closeArea + "\s*\Z")
reComment = re.compile("[ \t]+%s|^%s|(?<=;)%s"%(_comment,_comment,_comment))
reSepFields = re.compile(sepFields)
reSeparator = re.compile("[ \t]+")
def __init__(self,text):
self.text = text
self.blocTextObj = blocText()
# Объект документ
self.docObj = self.textToXML()
# Создаем поля-массивы
self.docObj.postParserList()
# XML документ
self.doc = self.docObj.doc
# Делим область на составные части
def findOpenClose(self, text, reOpen, reClose, reComment):
"""Делит область на составные части
начальный текстовый блок,
открывающий блок,
блок-тело,
закрывающий блок
"""
firstBloc = ""
startBloc = ""
bodyBloc = ""
endBloc = ""
textLines = text.splitlines()
findOpen = False
if textLines:
findOpen = reOpen.search(textLines[0])
openBl = reOpen.search(text)
if findOpen and reComment.split(text)[0].strip():
blocA = text[openBl.end():]
firstBloc = text[:openBl.start()]
startBloc = text[openBl.start():openBl.end()]
closeBl = reClose.search(blocA)
endBloc = blocA[closeBl.start():closeBl.end()]
bodyBloc = blocA[:closeBl.start()]
return (firstBloc, startBloc, bodyBloc, endBloc)
else:
return (firstBloc, startBloc, text, endBloc)
# Делим текст на области включая вложенные (areas массив областей)
def splitToAllArea(self, text, areas, reOpen, reClose, reCloseArea,
reComment, reSepFields):
"""Делит текст на области включая вложенные
возвращает список объектов областей (переменная areas)
"""
class area:
def __init__(self):
self.header = False
self.start = False
self.fields = []
self.end = False
blocs = self.blocTextObj.splitTxtToBloc(text,reOpen,reClose,
reComment,reSepFields)
for i in blocs:
areaA = area()
first,start,body,end = self.findOpenClose(i, reOpen, reCloseArea,
reComment)
areaA.header = first.replace(" ","").replace("\t","")
areaA.start = first + start
areaA.end = end
if areaA.end:
blocsA = self.blocTextObj.splitTxtToBloc(body,reOpen,reClose,
reComment,reSepFields)
if blocsA and blocsA[0] == body:
areaA.fields.append(body)
areas.append(areaA)
else:
for ar in blocsA:
self.splitToAllArea(ar, areaA.fields, reOpen,
reClose,
reCloseArea, reComment,
reSepFields)
areas.append(areaA)
else:
areaA.fields.append(body)
areas.append(areaA)
return areas
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len (nameValue) == 1:
field.name = ""
field.value = textLine.replace(self.sepFields,"")
field.br = textLine
fields.append(field)
field = fieldData()
if len(nameValue) > 2:
valueList = nameValue[1:]
nameValue =[nameValue[0]," ".join(valueList).replace(\
self.sepFields,"")]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def createCaptionTerm(self, header, start, end, docObj):
"""Создание пустой области с заголовком
при создании области проверяется первый символ заголовка
и добавляется тег action
"!" - <action>drop</action>
"-" - <action>replace</action>
"""
areaAction = False
if header:
if header[0] == "!":
docObj.createCaption(header[1:], [start,
end.replace("\n","")])
areaAction = "drop"
elif header[0] == "-":
docObj.createCaption(header[1:], [start,
end.replace("\n","")])
areaAction = "replace"
else:
docObj.createCaption(header, [start,
end.replace("\n","")])
else:
docObj.createCaption(header, [start,
end.replace("\n","")])
areaXML = docObj.createArea()
if areaAction:
docObj.setActionArea(areaXML, areaAction)
return areaXML
def createXML(self, areas, rootNode, docObj):
"""Создаем из массивов областей XML"""
for i in areas:
if str(i.__class__.__name__) == "area":
if i.header and i.start:
areaXML = self.createCaptionTerm(i.header, i.start,
i.end.replace("\n",""),
docObj)
else:
areaXML = rootNode
for f in i.fields:
if str(f.__class__.__name__) == "area":
if f.header and f.start:
areaXMLChild = self.createCaptionTerm(f.header,
f.start,
f.end.replace("\n",""),
docObj)
self.createXML(f.fields, areaXMLChild, docObj)
areaXML.appendChild(areaXMLChild)
else:
self.createXML(f.fields, areaXML, docObj)
if "\n" in f.end:
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
areaXML.appendChild(fieldXMLBr)
else:
if not f:
continue
fields = self.splitToFields(f)
for field in fields:
if field.name != False:
fieldXML = self.createFieldTerm(field.name,
field.value,
field.br, docObj)
areaXML.appendChild(fieldXML)
if field.br[-1] == "\n":
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
areaXML.appendChild(fieldXMLBr)
elif field.comment != False:
fieldXML = docObj.createField("comment",
[field.comment],
"", [],
False, False)
areaXML.appendChild(fieldXML)
elif field.br != False:
brText = field.br.replace("\n","")
if brText:
fieldXML = docObj.createField('br',
[brText],
"", [],
False, False)
else:
fieldXML = docObj.createField('br',
[],
"", [],
False, False)
areaXML.appendChild(fieldXML)
if i.header and i.start:
rootNode.appendChild(areaXML)
if "\n" in i.end:
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
rootNode.appendChild(fieldXMLBr)
else:
fields = self.splitToFields(i)
for field in fields:
if field.name != False:
fieldXML = self.createFieldTerm(field.name,
field.value,
field.br, docObj)
rootNode.appendChild(fieldXML)
if field.br[-1] == "\n":
fieldXMLBr = docObj.createField("br",[],"", [],
False, False)
rootNode.appendChild(fieldXMLBr)
elif field.comment != False:
fieldXML = docObj.createField("comment",
[field.comment],
"", [],
False, False)
rootNode.appendChild(fieldXML)
elif field.br != False:
brText = field.br.replace("\n","")
if brText:
fieldXML = docObj.createField('br', [brText],"",[],
False, False)
else:
fieldXML = docObj.createField('br', [], "", [],
False, False)
rootNode.appendChild(fieldXML)
#rootNode.appendChild(areaXML)
def textToXML(self):
"""Преобразуем текст в XML"""
areas = []
if self.text.strip():
self.splitToAllArea(self.text, areas, self.reOpen, self.reClose,
self.reCloseArea,self.reComment,self.reSepFields)
docObj = xmlDoc()
# Создание объекта документ c пустым разделителем между полями
docObj.createDoc(self.configName, self.configVersion)
if not areas:
return docObj
self.createXML(areas, docObj.getNodeBody(), docObj)
return docObj
def join(self, bindObj):
"""Объединяем конфигурации"""
if isinstance(bindObj, bind):
self.docObj.joinDoc(bindObj.doc)

@ -0,0 +1,41 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from format.samba import samba
class compiz(samba):
"""Класс для обработки конфигурационного файла типа compiz
"""
_comment = "#"
configName = "compiz"
configVersion = "0.1"
reHeader = re.compile("^[\t ]*\[[^\[\]]+\].*\n",re.M)
reBody = re.compile(".+",re.M|re.S)
reComment = re.compile("\s*%s.*"%(_comment))
reSeparator = re.compile("\s*=\s*")
sepFields = "\n"
reSepFields = re.compile(sepFields)
def __init__(self,text):
samba.__init__(self,text)
def join(self, compizObj):
"""Объединяем конфигурации"""
if isinstance(compizObj, compiz):
self.docObj.joinDoc(compizObj.doc)
self.postXML()

@ -0,0 +1,100 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from format.bind import bind
class dhcp(bind):
"""Класс для обработки конфигурационного файла типа dhcp
"""
_comment = "#"
configName = "dhcp"
configVersion = "0.1"
__openArea = "{"
__closeArea = "[ \t]*\}[ \t]*"
sepFields = ";"
reOpen = re.compile(__openArea)
reClose = re.compile(__closeArea)
reCloseArea = re.compile(__closeArea + "\s*\Z")
reComment = re.compile("^[ \t]*%s"%(_comment))
reSepFields = re.compile(sepFields)
reSeparator = re.compile("[ \t]+")
def __init__(self,text):
bind.__init__(self,text)
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len (nameValue) == 1:
field.name = textLine.replace(self.sepFields,"").strip()
field.value = ""
field.br = textLine
fields.append(field)
field = fieldData()
if len(nameValue) > 2:
nameCheck = nameValue[0]
if nameValue[0][:1] in ["+","-","!"]:
nameCheck = nameValue[0][1:]
if nameCheck == "option" or nameCheck == "hardware" or\
nameCheck == "set":
valueList = nameValue[2:]
nameValue =[nameValue[0]+nameValue[1],
" ".join(valueList).replace(\
self.sepFields,"")]
else:
valueList = nameValue[1:]
nameValue =[nameValue[0]," ".join(valueList).replace(\
self.sepFields,"")]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def join(self, dhcpObj):
"""Объединяем конфигурации"""
if isinstance(dhcpObj, dhcp):
self.docObj.joinDoc(dhcpObj.doc)

@ -0,0 +1,65 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from xml import xpath
from format.bind import bind
class dovecot(bind):
"""Класс для обработки конфигурационного файла типа dovecot
"""
_comment = "#"
configName = "dovecot"
configVersion = "0.1"
__openArea = "{"
__closeArea = "[ \t]*\}[ \t]*"
sepFields = "\n"
reOpen = re.compile(__openArea)
reClose = re.compile(__closeArea)
reCloseArea = re.compile(__closeArea + "\s*\Z")
reComment = re.compile("[ \t]*%s" %(_comment))
reSepFields = re.compile(sepFields)
# разделитель названия и значения переменной
reSeparator = re.compile("\s*=\s*")
def __init__(self, text):
bind.__init__(self,text)
def postXML(self, xmlArea=False):
"""Последующая постобработка XML"""
# Добавляем перевод строки если его нет в конец области
if not xmlArea:
xmlArea = self.docObj.body
xmlFields = xpath.Evaluate("child::field", xmlArea)
if xmlFields and not (\
self.docObj.getTypeField(xmlFields[-1]) == "br" or\
self.docObj.getTypeField(xmlFields[-1]) == "comment"):
xmlArea.appendChild(self.docObj.createField("br",
[],"",[],
False,False))
xmlAreas = xpath.Evaluate("child::area", xmlArea)
for area in xmlAreas:
self.postXML(area)
def join(self, dovecotObj):
"""Объединяем конфигурации"""
if isinstance(dovecotObj, dovecot):
#print self.docObj.doc.toprettyxml()
self.docObj.joinDoc(dovecotObj.doc)
# Для добавления перевода строки перед закрывающим тегом
# конфигурационного файла
self.postXML()

@ -0,0 +1,160 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from xml import xpath
from cl_template import xmlDoc
from format.samba import samba
class kde(samba):
"""Класс для обработки конфигурационного файла типа kde
"""
_comment = "#"
configName = "kde"
configVersion = "0.1"
reHeader = re.compile("^[\t ]*\[[^\[\]]+\].*\n?",re.M)
reBody = re.compile(".+",re.M|re.S)
reComment = re.compile("^\s*%s.*"%(_comment))
reSeparator = re.compile("=")
sepFields = "\n"
reSepFields = re.compile(sepFields)
def __init__(self,text):
samba.__init__(self,text)
def _textToXML(self):
"""Преобразует текст в XML"""
blTmp = self.blocTextObj.findBloc(self.text,self.reHeader,self.reBody)
blocs = self.getFullAreas(blTmp)
headers = []
startHeaders = []
finHeaders = []
docObj = xmlDoc()
docObj.createDoc(self.configName, self.configVersion)
rootNode = docObj.getNodeBody()
# Если пустой текст то создаем пустой документ
if not blocs:
return docObj
for h in blocs[0]:
reH = re.compile("]\s*$")
#listfinH = h.split("]")
listfinH = reH.split(h)
finH = listfinH[0]
if "[" in finH:
startHeaders.append(finH + "]")
else:
startHeaders.append(finH)
if len(listfinH) == 2:
finHeaders.append(listfinH[1])
else:
finHeaders.append("")
head=finH.replace("][",".").replace("[","").replace("]","").strip()
headers.append(head)
bodys = blocs[1]
z = 0
for h in headers:
if not bodys[z]:
z += 1
continue
areaAction = False
if h:
if h[0] == "!":
docObj.createCaption(h[1:], [startHeaders[z],""])
areaAction = "drop"
elif h[0] == "-":
docObj.createCaption(h[1:], [startHeaders[z],""])
areaAction = "replace"
else:
docObj.createCaption(h, [startHeaders[z],""])
else:
docObj.createCaption(h, [startHeaders[z],""])
if "\n" in blocs[0][z]:
if self.reComment.search(finHeaders[z]):
docObj.createField('comment', [finHeaders[z]])
elif not finHeaders[z].strip() and\
finHeaders[z].replace("\n",""):
docObj.createField('br',
[finHeaders[z].replace("\n","")])
else:
docObj.createField('br')
fields = self._splitToFields(bodys[z])
for f in fields:
if f.name != False and f.value!=False and f.br!=False:
# Обработка условий для samba
if f.name[0] == "!" or f.name[0] == "-" or\
f.name[0] == "+":
qns = self.removeSymbolTerm(f.br)
xmlField = docObj.createField("var",
[qns],
f.name[1:], [f.value])
if f.name[0] == "!":
# Удаляемое в дальнейшем поле
docObj.setActionField(xmlField, "drop")
else:
docObj.createField("var",[f.br.replace("\n","")],
f.name, [f.value])
docObj.createField('br')
elif f.comment != False:
docObj.createField('comment', [f.comment])
elif f.br != False:
docObj.createField('br', [f.br.replace("\n","")])
if h.strip():
area = docObj.createArea()
if areaAction:
docObj.setActionArea(area, areaAction)
rootNode.appendChild(area)
else:
fieldsNodes = docObj.tmpFields.getFields()
for fieldNode in fieldsNodes:
rootNode.appendChild(fieldNode)
docObj.clearTmpFields()
z += 1
#print docObj.doc.toprettyxml()
return docObj
def postXML(self):
"""Последующая постобработка XML"""
# Для добавления перевода строки между областями если его нет
#print self.docObj.body.toprettyxml()
xmlAreas = xpath.Evaluate("child::area", self.docObj.body)
for xmlArea in xmlAreas:
if xmlArea.previousSibling and\
self.docObj.getTypeField(xmlArea.previousSibling) == "br":
continue
firstArea = False
xmlFields = xpath.Evaluate("child::field", xmlArea)
if not (xmlFields and\
(self.docObj.getTypeField(xmlFields[-1]) == "br" or\
self.docObj.getTypeField(xmlFields[-1]) == "comment")):
if xmlArea.nextSibling:
parentNode = xmlArea.parentNode
nextNode = xmlArea.nextSibling
parentNode.insertBefore(self.docObj.createField("br",
[],"",[],
False,False),
nextNode)
def join(self, kdeObj):
"""Объединяем конфигурации"""
if isinstance(kdeObj, kde):
self.docObj.joinDoc(kdeObj.doc)
self.postXML()

@ -0,0 +1,183 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from cl_template import blocText, xmlDoc
from format.samba import samba
class ldap(samba):
"""Класс для обработки конфигурационного файла типа ldap
"""
_comment = "#"
configName = "ldap"
configVersion = "0.1"
# Регулярное выражение для заголовка области
reHeader = re.compile("^[\t ]*(access|syncrepl)[^\n]+\n?")
# Регулярное выражения для области
reArea = re.compile("([\t ]*(access|syncrepl)[^\n]+\
\n([\t ]+[^\n]+\n?)+)",re.M|re.S)
reComment = re.compile("\s*%s.*"%(_comment))
# разделитель между переменной и значением переменной
reSeparator = re.compile("\s+|\s*=\s*")
# разделитель полей
sepFields = "\n"
# регулярное выражение для разделителя полей
reSepFields = re.compile(sepFields)
def __init__(self,text):
self.text = text
self.blocTextObj = blocText()
self._splitToFields = self.splitToFields
# Объект документ
self.docObj = self._textToXML()
# Создаем поля-массивы
self.docObj.postParserList()
# Создаем поля разделенные массивы
self.docObj.postParserListSeplist(self.docObj.body)
# XML документ
self.doc = self.docObj.doc
def join(self, ldapObj):
"""Объединяем конфигурации"""
if isinstance(ldapObj, ldap):
self.docObj.joinDoc(ldapObj.doc)
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len(nameValue) > 2:
valueList = nameValue[2:]
nameValue =[nameValue[0]+nameValue[1]," ".join(valueList)]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def _textToXML(self):
"""Преобразует текст в XML"""
blTmp = self.blocTextObj.findArea(self.text,self.reHeader,self.reArea)
blocs = self.getFullAreas(blTmp)
headers = []
startHeaders = []
finHeaders = []
docObj = xmlDoc()
docObj.createDoc(self.configName, self.configVersion)
rootNode = docObj.getNodeBody()
# Если пустой текст то создаем пустой документ
if not blocs:
return docObj
for h in blocs[0]:
headers.append(h.rstrip())
bodys = blocs[1]
z = 0
for h in headers:
if not bodys[z]:
z += 1
continue
areaAction = False
if h:
if h[0] == "!":
header = self.removeSymbolTerm(h.strip())
headerQuote = self.removeSymbolTerm(h)
docObj.createCaption(header,[headerQuote,""])
areaAction = "drop"
elif h[0] == "-":
header = self.removeSymbolTerm(h.strip())
headerQuote = self.removeSymbolTerm(h)
docObj.createCaption(header,[headerQuote,""])
areaAction = "replace"
else:
docObj.createCaption(h.strip(), [h.rstrip(),""])
else:
docObj.createCaption(h.strip(), [h.rstrip(),""])
if "\n" in blocs[0][z]:
resHead = self.reComment.search(h)
if resHead:
docObj.createField('comment',
blocs[0][z][resHead.start():])
else:
docObj.createField('br')
fields = self._splitToFields(bodys[z])
for f in fields:
if f.name != False and f.value!=False and f.br!=False:
# Обработка условий для samba
if f.name[0] == "!" or f.name[0] == "-" or\
f.name[0] == "+":
qns = self.removeSymbolTerm(f.br)
xmlField = docObj.createField("var",
[qns],
f.name[1:], [f.value])
if f.name[0] == "!":
# Удаляемое в дальнейшем поле
docObj.setActionField(xmlField, "drop")
elif f.name[0] == "+":
# Добавляем уникальное поле
xmlField.setAttribute("type", "seplist")
docObj.setActionField(xmlField, "join")
else:
docObj.createField("var",[f.br.replace("\n","")],
f.name, [f.value])
docObj.createField('br')
elif f.comment != False:
docObj.createField('comment', [f.comment])
elif f.br != False:
docObj.createField('br', [f.br.replace("\n","")])
if h.strip():
area = docObj.createArea()
if areaAction:
docObj.setActionArea(area, areaAction)
rootNode.appendChild(area)
else:
fieldsNodes = docObj.tmpFields.getFields()
for fieldNode in fieldsNodes:
rootNode.appendChild(fieldNode)
docObj.clearTmpFields()
z += 1
#print docObj.doc.toprettyxml()
return docObj

@ -0,0 +1,597 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
import types
import copy
from xml import xpath
from cl_template import xmlDoc
from format.samba import samba
class xmlDocPlasma:
"""Класс для замены метода joinArea в xmlDoc для plasma"""
# заменяемый метод для xmlDoc
def joinArea(self, baseNode, xmlNewArea):
"""Объединяет область c областью Body (xmlNewArea c baseNode)"""
def appendArea(baseNode, xmlNewArea):
fieldsRemove = xpath.Evaluate(\
"descendant::field[child::action='drop']", xmlNewArea)
for rmNode in fieldsRemove:
parentNode = rmNode.parentNode
parentNode.removeChild(rmNode)
captionAreasRemove = xpath.Evaluate(\
"descendant::area/child::caption[child::action='drop']",
xmlNewArea)
for rmNodeCapt in captionAreasRemove:
rmNode = rmNodeCapt.parentNode
parentNode = rmNode.parentNode
parentNode.removeChild(rmNode)
self.setActionArea(xmlNewArea, "append")
# Добавляем разделитель областей во вложенные области
areaNodes = xpath.Evaluate('descendant::area',xmlNewArea)
for areaNode in areaNodes:
self.setActionArea(areaNode,"append")
parentNode = areaNode.parentNode
parentNode.insertBefore(self.sepAreas.cloneNode(True),
areaNode)
baseNode.appendChild(xmlNewArea)
# Добавляем разделитель областей
baseNode.insertBefore(self.sepAreas.cloneNode(True), xmlNewArea)
nodesNames = xpath.Evaluate('child::area/caption/name',baseNode)
nodesNewArea = xpath.Evaluate('child::caption/name',xmlNewArea)
if not nodesNames:
# Добавляем область
if nodesNewArea:
newAreaAction = self.getActionArea(xmlNewArea)
if not (newAreaAction == "drop"):
appendArea(baseNode, xmlNewArea)
return True
if not nodesNames or not nodesNewArea:
return False
nameArea = ""
if nodesNewArea[0].firstChild:
nameArea = nodesNewArea[0].firstChild.nodeValue.strip()
flagFindArea = False
baseNodes = []
for oName in nodesNames:
newAreaAction = self.getActionArea(xmlNewArea)
oArea = oName.parentNode.parentNode
oNameTxt = ""
if oName.firstChild:
oNameTxt = oName.firstChild.nodeValue
if nameArea == oNameTxt:
flagFindArea = True
# При использовании удаления
if newAreaAction == "drop":
prevNode = oName.parentNode.parentNode.previousSibling
removePrevNodes = []
while (prevNode) and self.getTypeField(prevNode) == "br":
removePrevNodes.append(prevNode)
prevNode = prevNode.previousSibling
for removeNode in removePrevNodes:
baseNode.removeChild(removeNode)
baseNode.removeChild(oName.parentNode.parentNode)
continue
elif newAreaAction == "replace":
oldAreaNode = oName.parentNode.parentNode
newAreaCaption = xpath.Evaluate('child::caption',
xmlNewArea)[0]
oldAreaCaption = xpath.Evaluate('child::caption',
oldAreaNode)[0]
if newAreaCaption and oldAreaCaption:
xmlNewArea.replaceChild(oldAreaCaption,newAreaCaption)
self.setActionArea(xmlNewArea,"replace")
baseNode.replaceChild(xmlNewArea,
oldAreaNode)
continue
baseNodes.append(oName.parentNode.parentNode)
# Заменяем QUOTE
oldAreaNode = oName.parentNode.parentNode
oldAreaQuote = xpath.Evaluate('child::caption/quote',
oldAreaNode)[0]
if oldAreaQuote and\
not oldAreaQuote.firstChild:
newAreaQuote = xpath.Evaluate('child::caption/quote',
xmlNewArea)[0]
oldAreaCaption = xpath.Evaluate('child::caption',
oldAreaNode)[0]
if newAreaQuote and oldAreaCaption:
oldAreaCaption.replaceChild(newAreaQuote, oldAreaQuote)
newFields = xpath.Evaluate('child::field',xmlNewArea)
joinNewFields = xpath.Evaluate(\
"child::field[child::action='join']"
,xmlNewArea)
self.addNewFielsOldArea(newFields, joinNewFields, oArea)
if not flagFindArea:
# Добавляем область
if not (newAreaAction == "drop"):
appendArea(baseNode, xmlNewArea)
else:
tmpXmlNewAreas = xpath.Evaluate('child::area',xmlNewArea)
for na in tmpXmlNewAreas:
for bn in baseNodes:
self.joinArea(bn, na)
return True
class plasma(samba):
"""Класс для обработки конфигурационного файла типа kde
"""
_comment = "#"
configName = "plasma"
configVersion = "0.1"
reHeader = re.compile("^[\t ]*\[[^\[\]]+\].*\n?",re.M)
reBody = re.compile(".+",re.M|re.S)
reComment = re.compile("^\s*%s.*"%(_comment))
reSeparator = re.compile("=")
sepFields = "\n"
reSepFields = re.compile(sepFields)
def __init__(self,text):
samba.__init__(self,text)
# Делим текст на области включая вложенные (areas массив областей)
def splitToAllArea(self, text, areas):
"""Делит текст на области включая вложенные
возвращает список объектов областей (переменная areas)
"""
class area:
def __init__(self):
self.header = False
self.start = False
self.fields = []
self.end = False
def findPathArea(listPath, areaF):
"""Ищет путь в области
areaF - объект area
listPath - cписок названий областей
"""
ret = False
if not listPath:
return ret
flagList = False
if type(areaF) == types.ListType:
fields = areaF
flagList = True
else:
fields = areaF.fields
if areaF.header == listPath[0]:
ret = areaF
else:
return ret
for i in fields:
if str(i.__class__.__name__) == "area":
add = False
if not flagList:
add = listPath.pop(0)
if not listPath:
break
ret = False
if i.header == listPath[0]:
ret = findPathArea(listPath, i)
break
else:
if add:
listPath.insert(0,add)
if ret == areaF and len(listPath)>1:
ret = False
return ret
blTmp = self.blocTextObj.findBloc(self.text,self.reHeader,self.reBody)
blocs = self.getFullAreas(blTmp)
reH = re.compile("\[([^\[\]]+)\]")
# Список имен блоков
namesBlockList = []
# Временные поля
fieldsTmp = []
# Добавляем заголовки
z = 0
for h in blocs[0]:
if not h:
if blocs[1][z] == "":
fieldsTmp.append("")
#fieldsTmp.append("\n")
else:
fieldsTmp.append(blocs[1][z])
#print '"' + blocs[1][z] + '"'
z += 1
continue
#print '"' + blocs[1][z] + '"'
z += 1
slpNamesBlock = reH.split(h)
# Отступ слева для заголовка
indentionLeft = slpNamesBlock[0]
namesBlock = filter(lambda x: x.strip(), slpNamesBlock)
#namesBlock = map(lambda x: self.removeSymbolTerm(x), namesBlock)
findArea = findPathArea(copy.copy(namesBlock), areas)
namesBlockList.append(namesBlock)
if findArea:
if len(namesBlock) > 1:
namesBlockView = map(lambda x: self.removeSymbolTerm(x),
namesBlock)
else:
namesBlockView = namesBlock
findArea.start = indentionLeft + "[" + \
"][".join(namesBlockView) + "]"
else:
i = 0
lenNamesBlock = len(namesBlock)
namesBlockTmp = []
for nameB in namesBlock:
namesBlockTmp.append(nameB)
findArea = findPathArea(copy.copy(namesBlockTmp), areas)
i += 1
if not findArea:
areaNew = area()
areaNew.header = nameB
if lenNamesBlock == i:
if len(namesBlock) > 1:
namesBlockView = map(\
lambda x: self.removeSymbolTerm(x),
namesBlock)
else:
namesBlockView = namesBlock
areaNew.start = indentionLeft + "[" + \
"][".join(namesBlockView) + "]"
else:
areaNew.start = ""
areaNew.end = ""
if i == 1:
if lenNamesBlock == i:
areas += fieldsTmp
areas.append(areaNew)
findAreaPrev = areas[-1]
else:
if lenNamesBlock == i:
findAreaPrev.fields += fieldsTmp
findAreaPrev.fields.append(areaNew)
findAreaPrev = findAreaPrev.fields[-1]
else:
findAreaPrev = findArea
fieldsTmp = []
i = 0
delt = 0
# Добавляем тела
for body in blocs[1]:
#print "#" + body + "#"
#print
if not blocs[0][i]:
i += 1
delt +=1
continue
## В случае последнего комментария не добавляем перевод строки
#if self.reComment.search(body.splitlines()[-1]):
body = "\n" + body
namesBlock = namesBlockList[i-delt]
findArea = findPathArea(copy.copy(namesBlock), areas)
if findArea:
#if findArea.fields:
#if type(findArea.fields[0]) == types.StringType:
#findArea.fields.pop(0)
findArea.fields.insert(0, body)
i += 1
#eee = 1
#def prAreas(ar, eee):
#for a in ar:
#if type(a) == types.StringType:
#print 'field', a
#else:
#print "--------------------"
#print "HEADER =", a.header
#print "START =", a.start
#print "FIELDS =", a.fields
#print "LEVEL", eee
#if type(a) != types.StringType:
#if a.fields:
#eee += 1
#prAreas(a.fields, eee)
#prAreas(areas, eee)
return areas
def createCaptionTerm(self, header, start, end, docObj):
"""Создание пустой области с заголовком
при создании области проверяется первый символ заголовка
и добавляется тег action
"!" - <action>drop</action>
"-" - <action>replace</action>
"""
areaAction = False
if header:
if header[0] == "!":
docObj.createCaption(header[1:], [start,
end.replace("\n","")])
areaAction = "drop"
elif header[0] == "-":
docObj.createCaption(header[1:], [start,
end.replace("\n","")])
areaAction = "replace"
else:
docObj.createCaption(header, [start,
end.replace("\n","")])
else:
docObj.createCaption(header, [start,
end.replace("\n","")])
areaXML = docObj.createArea()
if areaAction:
docObj.setActionArea(areaXML, areaAction)
return areaXML
def createXML(self, areas, rootNode, docObj):
"""Создаем из массивов областей XML"""
for i in areas:
if str(i.__class__.__name__) == "area":
if i.header:
areaXML = self.createCaptionTerm(i.header, i.start,
i.end.replace("\n",""),
docObj)
for f in i.fields:
if str(f.__class__.__name__) == "area":
if f.header:
areaXMLChild = self.createCaptionTerm(f.header,
f.start,
f.end.replace("\n",""),
docObj)
self.createXML(f.fields, areaXMLChild, docObj)
areaXML.appendChild(areaXMLChild)
else:
self.createXML(f.fields, areaXML, docObj)
if "\n" in f.end:
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
areaXML.appendChild(fieldXMLBr)
else:
if not f:
continue
fields = self.splitToFields(f)
for field in fields:
if field.name != False:
fieldXML = self.createFieldTerm(field.name,
field.value,
field.br, docObj)
areaXML.appendChild(fieldXML)
if field.br[-1] == "\n":
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
areaXML.appendChild(fieldXMLBr)
elif field.comment != False:
fieldXML = docObj.createField("comment",
[field.comment],
"", [],
False, False)
areaXML.appendChild(fieldXML)
elif field.br != False:
brText = field.br.replace("\n","")
if brText:
fieldXML = docObj.createField('br',
[brText],
"", [],
False, False)
else:
fieldXML = docObj.createField('br',
[],
"", [],
False, False)
if areaXML:
areaXML.appendChild(fieldXML)
if i.header:
rootNode.appendChild(areaXML)
if "\n" in i.end:
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
rootNode.appendChild(fieldXMLBr)
else:
if not i:
continue
fields = self.splitToFields(i)
for field in fields:
if field.name != False:
fieldXML = self.createFieldTerm(field.name,
field.value,
field.br, docObj)
rootNode.appendChild(fieldXML)
if field.br[-1] == "\n":
fieldXMLBr = docObj.createField("br",[],"", [],
False, False)
rootNode.appendChild(fieldXMLBr)
elif field.comment != False:
fieldXML = docObj.createField("comment",
[field.comment],
"", [],
False, False)
rootNode.appendChild(fieldXML)
elif field.br != False:
brText = field.br.replace("\n","")
if brText:
fieldXML = docObj.createField('br', [brText],"",[],
False, False)
else:
fieldXML = docObj.createField('br', [], "", [],
False, False)
rootNode.appendChild(fieldXML)
#rootNode.appendChild(areaXML)
def _textToXML(self):
"""Преобразуем текст в XML"""
areas = []
if self.text.strip():
self.splitToAllArea(self.text, areas)
#docObj = xmlDoc()
# Создаем новый класс xmlDoc с измененным методом joinArea
newClass = type("newXmlDocPlalma",(xmlDocPlasma,xmlDoc,object),{})
# Создаем экземпляр нового класса
docObj = newClass()
# Создание объекта документ c пустым разделителем между полями
docObj.createDoc(self.configName, self.configVersion)
if not areas:
return docObj
self.createXML(areas, docObj.getNodeBody(), docObj)
return docObj
def postXML(self):
"""Последующая постобработка XML"""
# Для добавления перевода строки между областями если его нет
#print self.docObj.body.toprettyxml()
def getQuotesArea(xmlArea):
quotes = []
xmlQuotes = xpath.Evaluate('child::caption/quote',xmlArea)
for node in xmlQuotes:
if node.firstChild:
quotes.append(node.firstChild.nodeValue)
if len(quotes) == 0:
quotes.append("")
quotes.append("")
elif len(quotes) == 1:
quotes.append("")
return quotes
xmlAreas = xpath.Evaluate("descendant::area", self.docObj.body)
#print "-------------------------------------------------------"
#print xmlAreas
#if xmlAreas:
#prXmlArea = xmlAreas[0]
for xmlArea in xmlAreas:
# Перед пустой областью и после нее удаляем переводы строк
if getQuotesArea(xmlArea) == ["",""]:
#areaTXT = xpath.Evaluate("child::caption/name", xmlArea)[0]
#print "CL_AREA", areaTXT.firstChild
if xmlArea.previousSibling and\
self.docObj.getTypeField(xmlArea.previousSibling) == "br":
parentNode = xmlArea.previousSibling.parentNode
if xmlArea.previousSibling.previousSibling and\
self.docObj.getTypeField(xmlArea.previousSibling.previousSibling) == "br":
parentNode.removeChild(\
xmlArea.previousSibling.previousSibling)
parentNode.removeChild(xmlArea.previousSibling)
if xmlArea.nextSibling and\
self.docObj.getTypeField(xmlArea.nextSibling) == "br":
parentNode = xmlArea.nextSibling.parentNode
if xmlArea.nextSibling.nextSibling and\
self.docObj.getTypeField(xmlArea.nextSibling.nextSibling) == "br":
parentNode.removeChild(xmlArea.nextSibling.nextSibling)
parentNode.removeChild(xmlArea.nextSibling)
continue
# Собираем поля в кучку
xmlChildAreas = xpath.Evaluate("child::area", xmlArea)
if xmlChildAreas:
childNodes = self.docObj.getFieldsArea(xmlArea)
firstChildArea = xmlChildAreas[0]
if firstChildArea.previousSibling and\
self.docObj.getTypeField(firstChildArea.previousSibling)=="br":
if firstChildArea.previousSibling.previousSibling:
if self.docObj.getTypeField(\
firstChildArea.previousSibling.previousSibling)=="br":
firstChildArea = firstChildArea.previousSibling
flagFoundArea = False
it = 0
lenChild = len(childNodes)
for node in childNodes:
it += 1
if node.tagName == "area":
flagFoundArea = True
continue
if flagFoundArea and node.tagName == "field":
if self.docObj.getTypeField(node) == "var":
xmlArea.insertBefore(node, firstChildArea)
if it < lenChild:
if self.docObj.getTypeField(childNodes[it])==\
"br":
xmlArea.insertBefore(childNodes[it],
firstChildArea)
# Добавляем BR если его нет первым полем
xmlFields = xpath.Evaluate("child::field", xmlArea)
if not (xmlFields and\
(self.docObj.getTypeField(xmlFields[0]) == "br" or\
self.docObj.getTypeField(xmlFields[0]) == "comment")):
if xmlFields:
xmlArea.insertBefore(self.docObj.createField("br",
[],"",[],
False,False),
xmlFields[0])
# Если последним полем BR, удаляем его
if xmlFields and self.docObj.getTypeField(xmlFields[-1]) == "br":
#print "DEL_BR", xmlFields[-1].nextSibling
#and\
if not xmlFields[-1].nextSibling:
xmlArea.removeChild(xmlFields[-1])
# Если предыдущим полем не (BR или комментарий) - добавляем BR
if xmlArea.previousSibling and\
not (self.docObj.getTypeField(xmlArea.previousSibling) == "br" or\
self.docObj.getTypeField(xmlArea.previousSibling) == "comment"):
parentNode = xmlArea.parentNode
parentNode.insertBefore(self.docObj.createField("br",
[],"",[],
False,False),
xmlArea)
# Если есть предыдущее поле, и поле предыдущеее предыдущему
# не равно BR или комментарий то добавляем BR
if xmlArea.previousSibling:
prPrSibling = xmlArea.previousSibling.previousSibling
if prPrSibling and\
not (self.docObj.getTypeField(prPrSibling) == "br" or\
self.docObj.getTypeField(prPrSibling) == "comment"):
parentNode = xmlArea.parentNode
parentNode.insertBefore(self.docObj.createField("br",
[],"",[],
False,False),
xmlArea)
# Если после есть BR а за ним ничего нет, удаляем BR
if xmlArea.nextSibling and\
self.docObj.getTypeField(xmlArea.nextSibling) == "br":
if not xmlArea.nextSibling.nextSibling:
parentNode = xmlArea.nextSibling.parentNode
parentNode.removeChild(xmlArea.nextSibling)
#xmlName = xpath.Evaluate("child::caption/name", xmlArea)[0]
#print "------------------------------------"
#print "Name =", xmlName.firstChild
#if xmlArea.previousSibling:
#print "PR_TYPE =", self.docObj.getTypeField(xmlArea.previousSibling)
def join(self, kdeObj):
"""Объединяем конфигурации"""
if isinstance(kdeObj, plasma):
self.docObj.joinDoc(kdeObj.doc)
self.postXML()

@ -0,0 +1,117 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from cl_template import xmlDoc
from format.apache import apache
class postfix(apache):
"""Класс для обработки конфигурационного файла типа postfix
"""
_comment = "#"
configName = "postfix"
configVersion = "0.1"
sepFields = "\n"
reComment = re.compile("[ \t]*%s"%(_comment))
reSepFields = re.compile(sepFields)
# разделитель названия и значения переменной
reSeparator = re.compile("\s*=\s*")
def __init__(self,text):
self.text = text
# Объект документ
self.docObj = self.textToXML()
# Создаем поля разделенные массивы
self.docObj.postParserListSeplist(self.docObj.body)
# XML документ
self.doc = self.docObj.doc
def join(self, postfixObj):
"""Объединяем конфигурации"""
if isinstance(postfixObj, postfix):
self.docObj.joinDoc(postfixObj.doc)
def textToXML(self):
"""Преобразуем текст в XML"""
class area:
def __init__(self):
self.header = False
self.start = False
self.fields = []
self.end = False
areas = []
oneArea = area()
oneArea.header = ""
oneArea.start = ""
oneArea.fields = [self.text]
oneArea.end = ""
areas.append(oneArea)
docObj = xmlDoc()
# Создание объекта документ c пустым разделителем между полями
docObj.createDoc(self.configName, self.configVersion)
if not areas:
return docObj
self.createXML(areas, docObj.getNodeBody(), docObj)
return docObj
def setDataField(self, txtLines, endtxtLines):
"""Cоздаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
#print "#"+brBloc[z]+"#"
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len (nameValue) == 1:
field.name = ""
field.value = textLine.replace(self.sepFields,"")
field.br = textLine
fields.append(field)
field = fieldData()
if len(nameValue) > 2:
valueList = nameValue[1:]
nameValue =[nameValue[0],"=".join(valueList).replace(\
self.sepFields,"")]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields

@ -0,0 +1,115 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from cl_template import objShare, xmlDoc
class procmail(objShare):
"""Класс для обработки конфигурационного файла типа procmail
"""
_comment = "#"
configName = "procmail"
configVersion = "0.1"
sepFields = "\n"
reComment = re.compile("[ \t]*%s" %(_comment))
reSepFields = re.compile(sepFields)
# разделитель названия и значения переменной
reSeparator = re.compile("=")
def __init__(self, text):
self.text = text
self.docObj = self.textToXML()
self.doc = self.docObj.doc
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def textToXML(self):
docObj = xmlDoc()
docObj.createDoc(self.configName, self.configVersion)
if self.text:
nodeBody = docObj.getNodeBody()
fields = self.splitToFields(self.text)
for field in fields:
if field.name != False:
fieldXML = self.createFieldTerm(field.name,
field.value,
field.br, docObj)
nodeBody.appendChild(fieldXML)
if field.br[-1] == "\n":
fieldXMLBr = docObj.createField("br",[],
"",[],
False, False)
nodeBody.appendChild(fieldXMLBr)
elif field.comment != False:
fieldXML = docObj.createField("comment",
[field.comment],
"", [],
False, False)
nodeBody.appendChild(fieldXML)
elif field.br != False:
brText = field.br.replace("\n","")
if brText:
fieldXML = docObj.createField('br',
[brText],
"", [],
False, False)
else:
fieldXML = docObj.createField('br',
[],
"", [],
False, False)
nodeBody.appendChild(fieldXML)
return docObj
def join(self, procmailObj):
"""Объединяем конфигурации"""
if isinstance(procmailObj, procmail):
#print self.docObj.doc.toprettyxml()
self.docObj.joinDoc(procmailObj.doc)

@ -0,0 +1,261 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from xml import xpath
from cl_template import objShare, blocText, xmlDoc
class samba(objShare):
"""Класс для обработки конфигурационного файла типа samba
"""
_comment = "#"
configName = "samba"
configVersion = "0.1"
reHeader = re.compile("^[\t ]*\[[^\[\]]+\].*\n",re.M)
reBody = re.compile(".+",re.M|re.S)
reComment = re.compile("\s*%s.*|\s*;.*"%(_comment))
reSeparator = re.compile("\s*=\s*")
sepFields = "\n"
reSepFields = re.compile(sepFields)
def __init__(self,text):
self.text = text
self.blocTextObj = blocText()
self._splitToFields = self.splitToFields
# Объект документ
self.docObj = self._textToXML()
# XML документ
self.doc = self.docObj.doc
def postXML(self):
"""Последующая постобработка XML"""
# Для добавления перевода строки между областями если его нет
#print self.docObj.body.toprettyxml()
xmlAreas = xpath.Evaluate("child::area", self.docObj.body)
for xmlArea in xmlAreas:
if xmlArea.previousSibling and\
self.docObj.getTypeField(xmlArea.previousSibling) == "br":
continue
firstArea = False
xmlFields = xpath.Evaluate("child::field", xmlArea)
if not (xmlFields and\
(self.docObj.getTypeField(xmlFields[-1]) == "br" or\
self.docObj.getTypeField(xmlFields[-1]) == "comment")):
if xmlArea.nextSibling:
parentNode = xmlArea.parentNode
nextNode = xmlArea.nextSibling
parentNode.insertBefore(self.docObj.createField("br",
[],"",[],
False,False),
nextNode)
def join(self, sambaObj):
"""Объединяем конфигурации"""
if isinstance(sambaObj, samba):
self.docObj.joinDoc(sambaObj.doc)
self.postXML()
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
z += 1
findComment = self.reComment.search(textLine)
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
elif findComment:
field.comment = textLine
fields.append(field)
field = fieldData()
else:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len(nameValue) > 2:
valueList = nameValue[1:]
nameValue =[nameValue[0],"=".join(valueList)]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def splitCleanBloc(self, txtBloc):
"""Делим блок на две части (переменные, пустые строки в конце)"""
txtLines = txtBloc.split("\n")
firstBloc = []
nextBloc = []
txtLines.reverse()
z = 0
for txtLine in txtLines:
if not txtLine.strip():
nextBloc.append(txtLine)
else:
break
z += 1
txtLines.reverse()
firstBloc = txtLines[:-z]
nextBloc.reverse()
if nextBloc:
firstBloc.append("")
if nextBloc and "\n".join(nextBloc):
return ("\n".join(firstBloc), "\n".join(nextBloc))
else:
return False
def getFullAreas(self, blocs):
"""Делит текст на области, (Заголовок, тело)
Возвращает два списка: заголовки, тела
"""
headsAreas = []
bodyAreas = []
if not blocs:
return []
lenBlocs = len(blocs[0])
for i in range(lenBlocs):
txtBloc = blocs[1][i]
clean = self.splitCleanBloc(txtBloc)
if clean:
headsAreas.append(blocs[0][i])
bodyAreas.append(clean[0])
headsAreas.append("")
bodyAreas.append(clean[1])
else:
headsAreas.append(blocs[0][i])
bodyAreas.append(blocs[1][i])
return (headsAreas, bodyAreas)
def createTxtConfig(self, strHeader, dictVar):
"""Cоздает область с заголовком
создает текст конфигурационного файла в формате samba из
заголовка (строка) и словаря переменных
"""
if not strHeader:
return ""
outTxt = "[" + strHeader + "]\n"
for key in dictVar.keys():
outTxt += "%s = %s\n" %(key,dictVar[key])
return outTxt
def _textToXML(self):
"""Преобразует текст в XML"""
blTmp = self.blocTextObj.findBloc(self.text,self.reHeader,self.reBody)
blocs = self.getFullAreas(blTmp)
headers = []
startHeaders = []
finHeaders = []
docObj = xmlDoc()
docObj.createDoc(self.configName, self.configVersion)
rootNode = docObj.getNodeBody()
# Если пустой текст то создаем пустой документ
if not blocs:
return docObj
for h in blocs[0]:
listfinH = h.split("]")
finH = listfinH[0]
if "[" in finH:
startHeaders.append(finH + "]")
else:
startHeaders.append(finH)
if len(listfinH) == 2:
finHeaders.append(listfinH[1])
else:
finHeaders.append("")
headers.append(finH.replace("[","").replace("]","").strip())
bodys = blocs[1]
z = 0
for h in headers:
if not bodys[z]:
z += 1
continue
areaAction = False
if h:
if h[0] == "!":
docObj.createCaption(h[1:], [startHeaders[z],""])
areaAction = "drop"
elif h[0] == "-":
docObj.createCaption(h[1:], [startHeaders[z],""])
areaAction = "replace"
else:
docObj.createCaption(h, [startHeaders[z],""])
else:
docObj.createCaption(h, [startHeaders[z],""])
if "\n" in blocs[0][z]:
if self.reComment.search(finHeaders[z]):
docObj.createField('comment', [finHeaders[z]])
elif not finHeaders[z].strip() and\
finHeaders[z].replace("\n",""):
docObj.createField('br',
[finHeaders[z].replace("\n","")])
else:
docObj.createField('br')
fields = self._splitToFields(bodys[z])
for f in fields:
if f.name != False and f.value!=False and f.br!=False:
# Обработка условий для samba
if f.name[0] == "!" or f.name[0] == "-" or\
f.name[0] == "+":
qns = self.removeSymbolTerm(f.br)
xmlField = docObj.createField("var",
[qns],
f.name[1:], [f.value])
if f.name[0] == "!":
# Удаляемое в дальнейшем поле
docObj.setActionField(xmlField, "drop")
else:
docObj.createField("var",[f.br.replace("\n","")],
f.name, [f.value])
docObj.createField('br')
elif f.comment != False:
docObj.createField('comment', [f.comment])
elif f.br != False:
docObj.createField('br', [f.br.replace("\n","")])
if h.strip():
area = docObj.createArea()
if areaAction:
docObj.setActionArea(area, areaAction)
rootNode.appendChild(area)
else:
fieldsNodes = docObj.tmpFields.getFields()
for fieldNode in fieldsNodes:
rootNode.appendChild(fieldNode)
docObj.clearTmpFields()
z += 1
#print docObj.doc.toprettyxml()
return docObj

@ -0,0 +1,86 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from format.procmail import procmail
class squid(procmail):
"""Класс для обработки конфигурационного файла типа squid
"""
configName = "squid"
configVersion = "0.1"
# разделитель названия и значения переменной
reSeparator = re.compile(" ")
def __init__(self, text):
procmail.__init__(self, text)
# Создаем поля-массивы
self.docObj.postParserList()
# Создаем поля разделенные массивы
self.docObj.postParserListSeplist(self.docObj.body)
def setDataField(self, txtLines, endtxtLines):
"""Создаем список объектов с переменными"""
class fieldData:
def __init__(self):
self.name = False
self.value = False
self.comment = False
self.br = False
fields = []
field = fieldData()
z = 0
for k in txtLines:
textLine = k + endtxtLines[z]
z += 1
findComment = self.reComment.search(textLine)
flagVariable = True
if not textLine.strip():
field.br = textLine
fields.append(field)
field = fieldData()
flagVariable = False
elif findComment:
if textLine[:findComment.start()].strip():
field.comment = textLine[findComment.start():]
textLine = textLine[:findComment.start()]
else:
field.comment = textLine
flagVariable = False
fields.append(field)
field = fieldData()
if flagVariable:
pars = textLine.strip()
nameValue = self.reSeparator.split(pars)
if len(nameValue) > 2:
valueList = nameValue[1:]
nameValue =[nameValue[0]," ".join(valueList)]
if len(nameValue) == 2:
name = nameValue[0]
value = nameValue[1].replace(self.sepFields,"")
field.name = name.replace(" ","").replace("\t","")
field.value = value
field.br = textLine
fields.append(field)
field = fieldData()
return fields
def join(self, squidObj):
"""Объединяем конфигурации"""
if isinstance(squidObj, squid):
#print squidObj.getConfig()
self.docObj.joinDoc(squidObj.doc)

@ -0,0 +1,262 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
import time
from xml import xpath
import xml.dom.minidom
from format.xml_xfce import xml_xfce
# Перевод cообщений модуля
from cl_lang import lang
tr = lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
class xml_gconf(xml_xfce):
"""Класс для объединения gconf-xml файлов"""
# root нода
rootNode = False
# body нода
bodyNode = False
# Документ
doc = False
# Текст шаблона
text = ""
# Текущее время в секундах
currentTime = ""
# Комментарий
_comment = ("<!--","-->")
# поддерживаемые аттрибуты тега entry. Пример <entry type="int"/>
supportEntryTypes = ("int", "bool", "float", "string", "list", "pair")
def __init__(self, text):
self.text = text
# Создаем пустой объект
self.docObj = type("_empty_class", (object,), {})()
# Названия аттрибутов для пустого объекта
emptyMethods = ["getNodeBody","removeComment","insertBRtoBody",
"insertBeforeSepAreas"]
# Добавляем необходимые аттрибуты пустому объекту
for method in emptyMethods:
setattr(self.docObj, method, self.emptyMethod)
# Пустой метод (не нужно имя файла для корневой ноды)
setattr(self, "setNameBodyNode", self.emptyMethod)
# Создаем XML документ
self.doc = self.textToXML()
def getCurrentTime(self):
"""Получение текущего времени в секундах"""
return str(int(time.time()))
def textToXML(self):
"""Создание из текста XML документа
Храним xml в своем формате
"""
if not self.text.strip():
self.text = '''<?xml version="1.0"?><gconf></gconf>'''
try:
self.doc = xml.dom.minidom.parseString(self.text)
except:
self.setError(_("Can not text template is XML"))
return False
self.rootNode = self.doc.documentElement
self.bodyNode = self.rootNode
return self.doc
def cmpListsNodesEntry(self, listXmlA, listXmlB):
"""Сравнение содержимого двух списков XML нод"""
getTextsNodes = lambda y: map(lambda x:\
x.toxml().replace(" ","").replace("\t","").replace("\n",""),
map(lambda x: x.removeAttribute("mtime") or x,
map(lambda x: x.cloneNode(True),
filter(lambda x: x.nodeType==x.ELEMENT_NODE, y))))
if set(getTextsNodes(listXmlA))==set(getTextsNodes(listXmlB)):
return True
return False
def _join(self, xmlNewNode, xmlOldNode, flagRootNode=True, levelNumber=0):
"""Объединение корневой ноды шаблона и корневой ноды файла"""
if levelNumber>1:
return True
xmlNode = xmlNewNode
childNodes = xmlNode.childNodes
nextOldNode = xmlOldNode
flagError = False
if xmlNode.nodeType == xmlNode.ELEMENT_NODE:
n = xmlNode
tagName = n.tagName
nAction = u''
nName = u''
nType = u''
nValue = u''
attrName = ''
attrType = ''
if flagRootNode:
if not tagName == "gconf":
self.setError(_("The text is not a valid gconf-XML format \
(not found '<gconf>...</gconf>')"))
return False
else:
if not tagName == "entry":
self.setError(_("The text is not a valid gconf-XML format \
(found '<gconf><%s>..</%s></gconf>'")%(tagName,tagName))
return False
if not n.hasAttribute("name"):
self.setError(_('Not found arrtibute "name" in tag entry'))
return False
if not n.hasAttribute("type"):
self.setError(_('Not found arrtibute "type" in tag entry'))
return False
nName = n.getAttribute("name")
attrName = u"attribute::name='%s'"%nName
nType = n.getAttribute("type")
# Проверка правильности аттрибута type
if not nType in self.supportEntryTypes:
self.setError(\
_('Incorrect arrtibute "type" - <entry type="%s"/>')%nType)
return False
attrType = u"attribute::type='%s'"%nType
if n.hasAttribute("value"):
nValue = n.getAttribute("value")
if n.hasAttribute("action"):
nAction = n.getAttribute("action")
if not nAction in ("join","replace","drop"):
textError = _('''In the text, XML template, look \
for a reserved attribute 'action' with the incorrect value.\n\
Valid values attribute 'action': \
(action="join", action="replace", action="drop")''')
self.setError(textError)
return False
if xmlOldNode.parentNode:
findStr = u"child::%s"%tagName
strAttr = [attrName, attrType]
findAttr = filter(lambda x: x, strAttr)
findAttrStr = ''
if findAttr:
strAttr = u' and '.join(findAttr)
findAttrStr = "[%s]"%strAttr
findPath = u"child::%s%s"%(tagName,findAttrStr)
# Рабочая нода
if flagRootNode:
workNode = xmlOldNode.parentNode
else:
workNode = xmlOldNode
oldNodes = xpath.Evaluate(findPath, workNode)
# Новая нода список
flagArray = False
if nType == "list" or nType == "pair":
flagArray = True
flagDrop = False
flagJoin = True
flagReplace = False
if nType=="string" or nAction=="replace":
flagJoin = False
flagReplace = True
elif nAction == "drop":
flagJoin = False
flagDrop = True
if flagRootNode:
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if oldNodes:
if len(oldNodes)>1:
textError = _("The uncertainty in this template are \
the same nodes at one level")
self.setError(textError)
return False
nextOldNode = oldNodes[0]
# Замещаем ноду в случае массива
if flagArray and not flagDrop:
replaceXmlNode = xmlNode.cloneNode(True)
# Сравнение содержимого нод
if not self.cmpListsNodesEntry([replaceXmlNode],
[nextOldNode]):
replaceXmlNode.setAttribute("mtime",
self.currentTime)
if nAction:
replaceXmlNode.removeAttribute("action")
workNode.replaceChild(replaceXmlNode,
nextOldNode)
flagJoin = False
flagReplace = False
childNodes = False
# Объединение нод
if flagJoin:
if nextOldNode.hasAttribute("value"):
oValue = nextOldNode.getAttribute("value")
if nValue != oValue:
nextOldNode.setAttribute("mtime",
self.currentTime)
nextOldNode.setAttribute("value",nValue)
# Замещение ноды
elif flagReplace:
replaceXmlNode = xmlNode.cloneNode(True)
# Сравнение содержимого нод
if not self.cmpListsNodesEntry([replaceXmlNode],
[nextOldNode]):
replaceXmlNode.setAttribute("mtime",
self.currentTime)
if not\
self._removeDropNodesAndAttrAction(\
replaceXmlNode):
return False
workNode.replaceChild(replaceXmlNode,
nextOldNode)
childNodes = False
# Удаление ноды
elif flagDrop:
workNode.removeChild(nextOldNode)
childNodes = False
else:
# Добавление ноды
childNodes = False
if not flagDrop:
appendXmlNode = xmlNode.cloneNode(True)
appendXmlNode.setAttribute("mtime", self.currentTime)
if not\
self._removeDropNodesAndAttrAction(appendXmlNode):
return False
workNode.appendChild(appendXmlNode)
if childNodes:
for node in childNodes:
levelNumber +=1
if not self._join(node, nextOldNode, False, levelNumber):
flagError = True
break
levelNumber -= 1
if flagError:
return False
return True
def join(self, xml_gconfObj):
"""Объединяем конфигурации"""
# Получаем текущее время
self.currentTime = self.getCurrentTime()
if isinstance(xml_gconfObj, xml_gconf):
try:
self.joinDoc(xml_gconfObj.doc)
except:
self.setError(_("Can not join template"))
return False
return True
def getConfig(self):
"""Получение текстового файла из XML документа"""
data = self.doc.toprettyxml().split("\n")
data = filter(lambda x: x.strip(), data)
return "\n".join(data).replace("\t"," ")

@ -0,0 +1,268 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
from xml import xpath
import xml.dom.minidom
from cl_utils import _error
# Перевод cообщений модуля
from cl_lang import lang
tr = lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
class xml_xfce(_error):
"""Класс для объединения xfce-xml файлов"""
# root нода
rootNode = False
# body нода
bodyNode = False
# Документ
doc = False
# Текст шаблона
text = ""
# Комментарий
_comment = ("<!--","-->")
def __init__(self, text):
self.text = text
# Создаем пустой объект
self.docObj = type("_empty_class", (object,), {})()
# Названия аттрибутов для пустого объекта
emptyMethods = ["getNodeBody","removeComment","insertBRtoBody",
"insertBeforeSepAreas"]
# Добавляем необходимые аттрибуты пустому объекту
for method in emptyMethods:
setattr(self.docObj, method, self.emptyMethod)
# Создаем XML документ
self.doc = self.textToXML()
def emptyMethod(self, *arg , **argv):
"""Пустой метод"""
return True
def setNameBodyNode(self, name):
"""Устанавливает название для корневой ноды документа"""
if not self.bodyNode:
return False
self.bodyNode.setAttribute("name", name)
return True
def textToXML(self):
"""Создание из текста XML документа
Храним xml в своем формате
"""
if not self.text.strip():
self.text = '''<?xml version="1.0" encoding="UTF-8"?>
<channel version="1.0">
</channel>'''
try:
self.doc = xml.dom.minidom.parseString(self.text)
except:
self.setError(_("Can not text template is XML"))
return False
self.rootNode = self.doc.documentElement
self.bodyNode = self.rootNode
return self.doc
def join(self, xml_xfceObj):
"""Объединяем конфигурации"""
if isinstance(xml_xfceObj, xml_xfce):
try:
self.joinDoc(xml_xfceObj.doc)
except:
self.setError(_("Can not join template"))
return False
return True
def _removeDropNodesAndAttrAction(self, xmlNode):
"""Удаляет ноды с аттрибутом action='drop'
Также удаляет аттрибут action у всех нод
"""
flagError = False
childNodes = xmlNode.childNodes
if xmlNode.nodeType ==xmlNode.ELEMENT_NODE:
if xmlNode.hasAttribute("action"):
nAction = xmlNode.getAttribute("action")
if not nAction in ("join","replace","drop"):
textError = _('''In the text, XML template, look \
for a reserved attribute 'action' with the incorrect value.\n\
Valid values attribute 'action': \
(action="join", action="replace", action="drop")''')
self.setError(textError)
return False
xmlNode.removeAttribute("action")
if nAction == "drop":
parentNode = xmlNode.parentNode
if parentNode:
parentNode.removeChild(xmlNode)
if childNodes:
for node in childNodes:
if not self._removeDropNodesAndAttrAction(node):
flagError = True
break
if flagError:
return False
return True
def postXML(self):
"""Последующая постобработка XML"""
# Удаляем теги action и удаляемые ноды
self._removeDropNodesAndAttrAction(self.bodyNode)
def _join(self, xmlNewNode, xmlOldNode, flagRootNode=True):
"""Объединение корневой ноды шаблона и корневой ноды файла"""
xmlNode = xmlNewNode
childNodes = xmlNode.childNodes
nextOldNode = xmlOldNode
flagError = False
if xmlNode.nodeType ==xmlNode.ELEMENT_NODE:
n = xmlNode
path = u''
nName = u''
nType = u''
nValue = u''
nAction = u''
attrName = ''
attrType = ''
path = n.tagName
if n.hasAttribute("name"):
nName = n.getAttribute("name")
attrName = u"attribute::name='%s'"%nName
if n.hasAttribute("type"):
nType = n.getAttribute("type")
attrType = u"attribute::type='%s'"%nType
if n.hasAttribute("value"):
nValue = n.getAttribute("value")
if n.hasAttribute("action"):
nAction = n.getAttribute("action")
if not nAction in ("join","replace","drop"):
textError = _('''In the text, XML template, look \
for a reserved attribute 'action' with the incorrect value.\n\
Valid values attribute 'action': \
(action="join", action="replace", action="drop")''')
self.setError(textError)
return False
if xmlOldNode.parentNode:
findStr = u"child::%s"%path
strAttr = [attrName, attrType]
findAttr = filter(lambda x: x, strAttr)
findAttrStr = ''
if findAttr:
strAttr = u' and '.join(findAttr)
findAttrStr = "[%s]"%strAttr
findPath = u"child::%s%s"%(path,findAttrStr)
# Рабочая нода
if flagRootNode:
workNode = xmlOldNode.parentNode
else:
workNode = xmlOldNode
oldNodes = xpath.Evaluate(findPath, workNode)
#print findPath
#print workNode
#print "----------------------------"
# Новая нода список
flagArray = False
if nType == "array":
flagArray = True
flagDrop = False
flagJoin = True
flagReplace = False
if nAction == "replace":
flagJoin = False
flagReplace = True
elif nAction == "drop":
flagJoin = False
flagDrop = True
if flagRootNode:
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if oldNodes:
if len(oldNodes)>1:
textError = _("The uncertainty in this template are \
the same nodes at one level")
self.setError(textError)
return False
nextOldNode = oldNodes[0]
# Замещаем ноду в случае массива
if flagArray and not flagDrop:
replaceXmlNode = xmlNode.cloneNode(True)
if nAction:
replaceXmlNode.removeAttribute("action")
workNode.replaceChild(replaceXmlNode,
nextOldNode)
flagJoin = False
flagReplace = False
childNodes = False
# Объединение нод
if flagJoin:
if nextOldNode.hasAttribute("value"):
oValue = nextOldNode.getAttribute("value")
if nValue != oValue:
nextOldNode.setAttribute("value",nValue)
# Замещение ноды
elif flagReplace:
replaceXmlNode = xmlNode.cloneNode(True)
if not\
self._removeDropNodesAndAttrAction(replaceXmlNode):
return False
workNode.replaceChild(replaceXmlNode,
nextOldNode)
childNodes = False
# Удаление ноды
elif flagDrop:
workNode.removeChild(nextOldNode)
childNodes = False
else:
# Добавление ноды
childNodes = False
if not flagDrop:
appendXmlNode = xmlNode.cloneNode(True)
if not\
self._removeDropNodesAndAttrAction(appendXmlNode):
return False
workNode.appendChild(appendXmlNode)
if childNodes:
for node in childNodes:
if not self._join(node, nextOldNode, False):
flagError = True
break
if flagError:
return False
return True
def joinDoc(self, doc):
"""Объединение документа шаблона и документа файла"""
if not self.doc:
self.setError(_("Can not text file is XML"))
return False
if not doc:
self.setError(_("Can not text template is XML"))
return False
# Импортируем корневую ноду нового документа в текущий документ
#newImportBodyNode = self.doc.importNode(doc.documentElement, True)
# Объединение корневой ноды шаблона и корневой ноды файла
if not self._join(doc.documentElement, self.bodyNode):
return False
return True
def getConfig(self):
"""Получение текстового файла из XML документа"""
data = self.doc.toprettyxml(encoding='UTF-8').split("\n")
data = filter(lambda x: x.strip(), data)
return "\n".join(data).replace("\t"," ").decode("UTF-8")

@ -0,0 +1,199 @@
#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
from xml import xpath
import xml.dom.minidom
from format.xml_xfce import xml_xfce
# Перевод cообщений модуля
from cl_lang import lang
tr = lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
class xml_xfcepanel(xml_xfce):
"""Класс для объединения xfce-panel файлов"""
def __init__(self, text):
xml_xfce.__init__(self, text)
self.panelNumbers = {}
def textToXML(self):
"""Создание из текста XML документа
Храним xml в своем формате
"""
if not self.text.strip():
self.text = '''<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE config SYSTEM "config.dtd">
<panels>
</panels>'''
try:
self.doc = xml.dom.minidom.parseString(self.text)
except:
self.setError(_("Can not text profile is XML"))
return False
self.rootNode = self.doc.documentElement
self.bodyNode = self.rootNode
return self.doc
def setNameBodyNode(self, name):
"""Пустой метод"""
return True
def _join(self, xmlNewNode, xmlOldNode, flagRootNode=True, levelNumber=0):
"""Объединение корневой ноды профиля и корневой ноды файла"""
xmlNode = xmlNewNode
childNodes = xmlNode.childNodes
nextOldNode = xmlOldNode
flagError = False
if xmlNode.nodeType ==xmlNode.ELEMENT_NODE:
n = xmlNode
path = u''
nName = u''
flagArray = False
nValue = u''
nAction = u''
attrName = ''
attrType = ''
path = n.tagName
if path == "items":
flagArray = True
if not flagArray:
if n.hasAttribute("name"):
nName = n.getAttribute("name")
attrName = u"attribute::name='%s'"%nName
if n.hasAttribute("value"):
nValue = n.getAttribute("value")
if n.hasAttribute("action"):
nAction = n.getAttribute("action")
if not nAction in ("join","replace","drop"):
textError = _('''In the text, XML profile, look \
for a reserved attribute 'action' with the incorrect value.\n\
Valid values attribute 'action': \
(action="join", action="replace", action="drop")''')
self.setError(textError)
return False
if xmlOldNode.parentNode:
findStr = u"child::%s"%path
findAttrStr = ""
if attrName:
findAttrStr = "[%s]"%attrName
findPath = u"child::%s%s"%(path,findAttrStr)
# Рабочая нода
if flagRootNode:
workNode = xmlOldNode.parentNode
else:
workNode = xmlOldNode
oldNodes = xpath.Evaluate(findPath, workNode)
flagDrop = False
flagJoin = True
flagReplace = False
flagAppend = False
if nAction == "replace":
flagJoin = False
flagReplace = True
elif nAction == "drop":
flagJoin = False
flagDrop = True
if flagRootNode:
textError = _('Incorrect action="drop" in root node')
self.setError(textError)
return False
if path == "panel":
flagJoin = False
if levelNumber in self.panelNumbers.keys():
self.panelNumbers[levelNumber] += 1
else:
self.panelNumbers[levelNumber] = 0
if oldNodes:
if len(oldNodes)>1 and path != "panel":
textError = _("The uncertainty in this profile are \
the same nodes at one level")
self.setError(textError)
return False
if path == "panel":
if len(oldNodes)<=self.panelNumbers[levelNumber]:
nextOldNode = oldNodes[-1]
# Добавляем ноду
if not flagDrop:
flagAppend = True
flagReplace = False
childNodes = False
else:
nextOldNode=oldNodes[self.panelNumbers[levelNumber]]
else:
nextOldNode = oldNodes[0]
# Замещаем ноду в случае массива
if flagArray and not flagDrop:
replaceXmlNode = xmlNode.cloneNode(True)
if nAction:
replaceXmlNode.removeAttribute("action")
workNode.replaceChild(replaceXmlNode,
nextOldNode)
flagJoin = False
flagReplace = False
childNodes = False
# Объединение нод
if flagJoin:
if nextOldNode.hasAttribute("value"):
oValue = nextOldNode.getAttribute("value")
if nValue != oValue:
nextOldNode.setAttribute("value",nValue)
# Замещение ноды
elif flagReplace:
replaceXmlNode = xmlNode.cloneNode(True)
if not\
self._removeDropNodesAndAttrAction(replaceXmlNode):
return False
workNode.replaceChild(replaceXmlNode,
nextOldNode)
childNodes = False
# Удаление ноды
elif flagDrop:
workNode.removeChild(nextOldNode)
childNodes = False
else:
flagAppend = True
flagDrop = False
if flagAppend and not flagDrop:
# Добавление ноды
childNodes = False
if not flagDrop:
appendXmlNode = xmlNode.cloneNode(True)
if not\
self._removeDropNodesAndAttrAction(appendXmlNode):
return False
workNode.appendChild(appendXmlNode)
if childNodes:
for node in childNodes:
levelNumber +=1
if not self._join(node, nextOldNode, False, levelNumber):
flagError = True
break
levelNumber -= 1
if flagError:
return False
return True
def join(self, xml_xfceObj):
"""Объединяем конфигурации"""
if isinstance(xml_xfceObj, xml_xfcepanel):
try:
self.joinDoc(xml_xfceObj.doc)
except:
self.setError(_("Can not join profile"))
return False
return True

@ -2,7 +2,7 @@
# setup.py --- Setup script for calculate-server
#Copyright 2008 Calculate Pack, http://www.calculate-linux.org
# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@ -23,14 +23,14 @@ from distutils.core import setup
setup(
name = 'calculate-lib',
version = "2.1.4",
version = "2.2.0",
description = "The library for Calculate 2",
author = "Mir Calculate Ltd.",
author_email = "support@calculate.ru",
url = "http://calculate-linux.org",
license = "http://www.apache.org/licenses/LICENSE-2.0",
package_dir = {'calculate-lib': "."},
packages = ['calculate-lib.pym'],
packages = ['calculate-lib.pym','calculate-lib.pym.format'],
data_files = [("/usr/share/calculate/i18n",['i18n/cl_lib_ru.mo']),
("/var/calculate/remote",[])],
)

Loading…
Cancel
Save