Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
calculate-utils-2.1-lib/pym/cl_base.py

1157 řádky
47 KiB

Tento soubor obsahuje nejednoznačné znaky Unicode!

Tento soubor obsahuje nejednoznačné znaky Unicode, které mohou být zaměněny s ostatními v aktuálním prostředí. Pokud je váš případ úmyslný a legitimní, můžete toto varování bezpečně ignorovat. Použijte tlačítko Escape sekvence pro zvýraznění těchto znaků.

#-*- coding: utf-8 -*-
# Copyright 2008-2010 Mir Calculate. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import 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
##############################################################################
_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-2.0/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()
nameFomat = self.checkIniFile(textIni)
if not nameFomat:
return False
if type(strHeader) in (tuple, list):
# формат plasma
classObj = cl_profile.plasma
else:
if nameFomat == "plasma":
self.setError(_("In the file %s (format - 'plasma'), \
write the variable in the format 'samba'")\
%self.iniFile)
return False
# формат samba
classObj = cl_profile.samba
# создаем объект
# и записываем в него содержимое ini-файла
objIni = classObj(textIni)
# создаем текст из строки заголовка и
# словаря переменных области
txtConfig = objIni.createTxtConfig(strHeader, dictVar)
# создаем объект и записываем в него текст
objIniAdd = classObj(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 = "samba"
# В файле есть данные
if not self.isEmptyFile(textIni):
try:
objIni = cl_profile.plasma(textIni)
except:
self.setError(_("Incorrect format file") + ": " + \
self.iniFile)
self.checkIni = False
return self.checkIni
allAreas = objIni.docObj.getAllAreas()
for xmlArea in allAreas:
parentNode = xmlArea.parentNode
if parentNode and parentNode.tagName == "area":
self.checkIni = "plasma"
break
if self.checkIni == "samba":
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 файла"""
if type(strHeader) in (tuple, list):
# Формат plasma
delStrHeader = strHeader[:]
delStrHeader[-1] = "!%s"%delStrHeader[-1]
else:
# Формат samba
delStrHeader = "!%s" %(strHeader)
dictVar = {"del":"del"}
res = self.setVar(delStrHeader, dictVar)
return res
def getVar(self, strHeader, nameVar):
"""Получаем значение переменной из ini-файла"""
textIni = self.openIniFile()
nameFomat = self.checkIniFile(textIni)
if not nameFomat:
return False
formatPlasma = False
if type(strHeader) in (tuple, list):
# формат plasma
classObj = cl_profile.plasma
formatPlasma = True
else:
if nameFomat == "plasma":
self.setError(_("In the file %s (format - 'plasma'), \
get the variable in the format 'samba'")\
%self.iniFile)
return False
# формат samba
classObj = cl_profile.samba
# создаем объект и записываем в него содержимое ini-файла
objIni = classObj(textIni)
# получаем ноду body
xmlBody = objIni.docObj.getNodeBody()
flagFound, xmlBody = self.getLastNode(objIni, xmlBody, strHeader,
formatPlasma)
if flagFound and xmlBody:
if formatPlasma:
strHeader = strHeader[-1]
# находим в области переменную
res = objIni.docObj.getAreaFieldValues(strHeader, nameVar, xmlBody)
else:
res = False
if res is False:
return ""
else:
return res
def getLastNode(self, objIni, xmlBody, strHeader, formatPlasma):
"""Ищет область в XML в которой область с переменными"""
flagFound = True
lenStrHeader = len(strHeader)
if formatPlasma and lenStrHeader>0:
xmlAreas = [xmlBody]
for i in xrange(lenStrHeader-1):
flagFound = False
for xmlArea in xmlAreas:
xmlAreas = objIni.docObj.getArea(strHeader[i], xmlArea)
if xmlAreas:
flagFound = True
break
if xmlAreas:
xmlBody = xmlAreas[0]
return flagFound,xmlBody
def getAreaVars(self, strHeader):
"""Получаем все переменнные области из ini-файла"""
textIni = self.openIniFile()
nameFomat = self.checkIniFile(textIni)
if not nameFomat:
return False
formatPlasma = False
if type(strHeader) in (tuple, list):
# формат plasma
classObj = cl_profile.plasma
formatPlasma = True
else:
if nameFomat == "plasma":
self.setError(_("In the file %s (format - 'plasma'), \
get all variables in the format 'samba'")\
%self.iniFile)
return False
# формат samba
classObj = cl_profile.samba
# создаем объект типа samba и записываем в него содержимое ini-файла
objIni = classObj(textIni)
# получаем ноду body
xmlBody = objIni.docObj.getNodeBody()
flagFound, xmlBody = self.getLastNode(objIni, xmlBody, strHeader,
formatPlasma)
if flagFound and xmlBody:
if formatPlasma:
strHeader = strHeader[-1]
# если находим область то выдаем словарем все переменные иначе False
res = objIni.docObj.getAreaFields(strHeader, xmlBody)
else:
res = False
if res is False:
return {}
else:
return res
def getAllSectionNames(self):
"""Получаем все имена секций определенных в ini файле
Если формат ini файла plasma то имя секции -
имена нескольких секций через запятую
"""
textIni = self.openIniFile()
nameFomat = self.checkIniFile(textIni)
if not nameFomat:
return False
if nameFomat == "samba":
# создаем объект типа samba и записываем в него содержимое ini-файла
objIni = cl_profile.samba(textIni)
elif nameFomat == "plasma":
# создаем объект типа plasma и записываем в него содержимое
# ini-файла
objIni = cl_profile.plasma(textIni)
else:
return []
xmlNodes = objIni.docObj.getAllAreas()
# Имена секций ini файла
namesSection = []
if nameFomat == "plasma":
for xmlNode in xmlNodes:
nSect = objIni.docObj.getNameArea(xmlNode)
if nSect:
namesSect = [nSect]
parentNode = xmlNode.parentNode
while parentNode != objIni.docObj.body:
nameSect = objIni.docObj.getNameArea(parentNode)
if nameSect:
namesSect.append(nameSect)
parentNode = parentNode.parentNode
else:
return []
namesSection.append(",".join(reversed(namesSect)))
elif nameFomat == "samba":
# получаем ноду body
for xmlNode in xmlNodes:
nSect = objIni.docObj.getNameArea(xmlNode)
if nSect:
namesSection.append(nSect)
return namesSection
##############################################################################
class var:
'''Объект "Переменная окружения"'''
# название сервиса которому принадлежит переменная
#(Global, Builder, Client, Server итд)
service = None
# значение переменной
value = ""
# режим записи (атрибут mode)
mode = "r"
# переменная для внутреннего использования (official)
official = False
# количество вызовов метода заполнения
countFill = 0
# объект в котором создан этот объект
parentObj = None
# запускать или нет метод заполнения
fillStart = True
# dynamic = True то переменная динамическая при повтороном запуске
# запускается метод заполнения
# метод заполнения не запускается только если fillStart = False
# (осторожно возможно зацикливание программы если методы заполнения
# переменных используют методы друг друга)
dynamic = False
def __init__(self, parentObj):
# словарь зависимых переменных {имя:значение}
self.dependValues = {}
# тип переменной (атрибут type)
self.type = ('default')
# список допустимых значений переменных (select)
self.select = ()
# объект который создал этот объект
self.parentObj = parentObj
def is_update(self):
#Нужно ли перезапускать метод заполнения (если зависимые переменные
#обновились то нужно)
upd = False
for depVarName in self.dependValues.keys():
value = self.parentObj.__getattribute__(depVarName).Get()
if self.dependValues[depVarName] != value:
self.dependValues[depVarName] =\
self.parentObj.__getattribute__(depVarName).value
upd = True
break
return upd
def Get(self):
"""Получение значения переменной"""
if not self.fillStart:
return self.value
if self.dynamic:
self.value = self.Fill()
return self.value
if not self.value:
if self.countFill>0:
return self.value
self.countFill += 1
self.value = self.Fill()
if self.dependValues and self.is_update():
self.countFill += 1
self.value = self.Fill()
return self.value
def Set(self, value):
"""Запись значения переменной"""
self.value = value
return self.value
def Fill(self):
"""Заполнение переменной в далнейшем заменяем методом заполнения"""
return self.value
class DataVars(object):
class DataVarsError(Exception):
"""Класс ошибок"""
pass
# добавляем пути к модулям если они не добавлены
if not os.path.abspath(\
'/usr/lib/calculate/calculate-server/pym') in sys.path:
sys.path.insert(0,os.path.abspath(\
'/usr/lib/calculate/calculate-server/pym'))
if not os.path.abspath(\
'/usr/lib/calculate/calculate-lib/pym') in sys.path:
sys.path.insert(0,os.path.abspath(\
'/usr/lib/calculate/calculate-lib/pym'))
if not os.path.abspath(\
'/usr/lib/calculate/calculate-builder/pym') in sys.path:
sys.path.insert(0,os.path.abspath(\
'/usr/lib/calculate/calculate-builder/pym'))
# Импортируемые модули - (раздел: модуль переменных, модуль заполнения
#переменных)
__modlist={'Global':('cl_vars','cl_fill'),
'Server':('cl_vars_server','cl_fill_server'),
'Builder':('cl_vars_builder','cl_fill_builder'),
'Client':('cl_vars_client','cl_fill_client'),
}
def __init__(self):
#self.t1 = fillVars()
#self.t1.Get = self.Get
#self.t1.Set = self.Set
# Для нахождения зависимостей переменных
self.__levelNumber = 0
self.__LevelsVar = []
# Для хранения импортированных модулей и объектов
#[(cекция,импортированный модуль переменных, объект заполнения),]
self._importList = []
self._importData("Global")
def _importData(self, section):
"""Импортирует модули с переменными и модули с функциями заполнения
section секция раздела (Global, Server, Client итд)
создает необходимые структуры данных
"""
if not section in self.__modlist.keys():
raise self.DataVarsError(_("Unsupported section %s")%section)
modVar = self.__modlist[section][0]
modFill = self.__modlist[section][1]
# Импортируем класс описания переменных и класс заполнения
try:
exec ("import %s" % (modVar))
except ImportError, e:
err1 = _("Error in import module %s")%modVar
err2 = _("error") + ": " +str(e)
raise self.DataVarsError("%s\n%s"%(err1,err2))
flagFindFillModule = True
try:
exec ("import %s" % (modFill))
except ImportError, e:
if "No module named" in str(e):
flagFindFillModule = False
else:
err1 = _("Error in import module %s")%modFill
err2 = _("error") + ": " +str(e)
raise self.DataVarsError("%s\n%s"%(err1,err2))
if flagFindFillModule:
# Создаем объект с методами заполнения переменных
exec("fillObj = %s.fillVars()" %modFill)
# Подключаем методы получения и записи переменных
fillObj.Get = self.Get
fillObj.Set = self.Set
else:
fillObj = False
# Заполняем self._importList
exec("self._importList.insert(0,(section,%s,fillObj))"%(modVar))
def __findVarData(self, nameVar):
"""Находит данные для создания объекта переменная в модулях и
объектах
"""
# Ищем переменную в модуле
dataVar = False
e = False
for section, moduleVar, fillobj in self._importList:
try:
exec("dataVar=moduleVar.Data.%s"%nameVar)
except AttributeError, e:
pass
if dataVar:
break
if dataVar == False:
err1 = _("Not found variable %s")%nameVar
err2 = ""
if e:
err2 = _("error") + ": " +str(e)
raise self.DataVarsError("%s\n%s"%(err1,err2))
dataVar['service'] = section
# Ищем метод в объекте методов заполнения
nameMethod = "get_" + nameVar
flagFindMetod = False
for section, moduleVar, fillobj in self._importList:
if fillobj:
if nameMethod in dir(fillobj):
flagFindMetod = True
method = fillobj.__getattribute__(nameMethod)
break
if flagFindMetod:
return (dataVar,method)
else:
return (dataVar,False)
def __setAttributesVar(self, var ,nameVar, dict):
"""Установка аттрибутов для созданного объекта var
название аттрибута и его значение берется из словаря dict
"""
dict['type'] = nameVar.split('_')
if not set(dict.keys()) <= set(dir(var)):
raise self.DataVarsError(\
_("error initalize variable %s, incorrect data")%nameVar)
for nameAttr in dict.keys():
setattr(var,nameAttr, dict[nameAttr])
return True
def __Get(self, nameVar):
ret = ""
self.__LevelsVar.append((self.__levelNumber, nameVar))
self.__levelNumber += 1
#nameMethod = "get_" + nameVar
if hasattr(self, nameVar):
ret = self.__getattribute__(nameVar).Get()
elif self.__findVarData(nameVar):
dictVar, methodFill =self.__findVarData(nameVar)
varobj = var(self)
# Устанавливаем аттрибуты
self.__setAttributesVar(varobj, nameVar, dictVar)
if methodFill:
varobj.Fill = methodFill
self.__setattr__(nameVar, varobj)
ret = self.__getattribute__(nameVar).Get()
self.__levelNumber -= 1
if self.__levelNumber == 0 and\
self.__getattribute__(nameVar).fillStart and\
len(self.__LevelsVar)>1:
links = self.__getLinks(self.__LevelsVar)
for name in links.keys():
for nameLink in links[name].keys():
val = self.__getattribute__(nameLink).Get()
self.__getattribute__(name).dependValues[nameLink] = val
if self.__levelNumber == 0:
self.__LevelsVar = []
return ret
def Get(self, nameVar):
return self.__Get(nameVar)
def __Set(self, nameVar, value, force=False):
nameMethod = "get_" +nameVar
if not hasattr(self, nameVar) and self.__findVarData(nameVar):
dictVar, methodFill =self.__findVarData(nameVar)
varobj = var(self)
# Устанавливаем аттрибуты
self.__setAttributesVar(varobj, nameVar, dictVar)
if methodFill:
varobj.Fill = methodFill
self.__setattr__(nameVar, varobj)
if hasattr(self, nameVar):
if not force and "r" in getattr(self, nameVar).mode:
print _("Attempt to rewrite a variable for reading:%s")\
%nameVar
return False
self.__getattribute__(nameVar).fillStart = False
return self.__getattribute__(nameVar).Set(value)
def Set(self, nameVar, value, force=False):
return self.__Set(nameVar, value, force)
def __frame(self, lVar):
"""получить список областей зависимости переменных"""
data = []
if not lVar:
return data
firstLevel = lVar[0][0]
for level, name in lVar[1:]:
if level> firstLevel:
data.append((level, name))
else:
break
return data
def __getLinks(self, lVar):
"""Получить список переменных и от каких переменных они зависят
на вход список [(уровень рекурсии, название переменной),]
"""
links = {}
frames = {}
levelLinks = {}
lVarFr = lVar
for level, name in lVar:
fr = self.__frame(lVarFr)
if not frames.has_key(name):
frames[name] = fr
levelLinks[name] = level+1
lVarFr = lVarFr[1:]
for name in frames.keys():
level = levelLinks[name]
fr = frames[name]
links[name] = {}
for lv, nm in fr:
if level == lv:
links[name][nm] = ""
return links
def __getPathCalculateIni(self):
"""Получить пути до ini файлов"""
return self.Get('cl_env_path')
def __getSection(self, vname):
"""секция для записи в ini файл переменной
vname - имя переменной
"""
if hasattr(self, vname):
if getattr(self, vname).service == 'Global':
return 'calculate'
else:
return getattr(self, vname).service.lower()
def __writeVarValue(self, vname, val, location, header):
'''Записать значение в calculate.ini
Параметры:
vname имя переменной
val значение переменной
location расположение ini файла ('default', 'local', 'remote')
header раздел ini файла ('client', 'server', 'calculate')
Возвращаемые значение:
True запись успешна
False запись не удалсь
'''
# получаем все пути до ini файлов
calculate_ini = self.__getPathCalculateIni()
# получаем полный путь до файла ini
if location == 'default':
name_calculate_ini = calculate_ini[2]
elif location == 'local':
name_calculate_ini = calculate_ini[1]
elif location == 'remote':
name_calculate_ini = calculate_ini[0]
else:
return False
# извлекаем из полного имени файла путь
onlydir = os.path.split(name_calculate_ini)[0]
try:
# проверяем чтобы путь до ини файла существовал
if not os.path.exists(onlydir):
# создаем его если отсутствует
os.makedirs(onlydir)
except OSError (nerr,msg):
print nerr, msg
return False
config = iniParser(name_calculate_ini)
# Получаем секцию конфигурационного файла
if not header:
header = self.__getSection(vname)
return config.setVar(header,{vname: cl_utils.convertStrListDict(val)})
def __deleteVarValue(self, vname, location, header):
'''Удалить переменную в calculate.ini
Параметры:
vname имя переменной
location расположение ini файла ('default', 'local', 'remote')
header раздел ini файла ('client', 'server', 'calculate')
Возвращаемые значение:
True удалено успешно
False удаление не удалсь
'''
# получаем все пути до ini файлов
calculate_ini = self.__getPathCalculateIni()
# получаем полный путь до файла ini
if location == 'default':
name_calculate_ini = calculate_ini[2]
elif location == 'local':
name_calculate_ini = calculate_ini[1]
elif location == 'remote':
name_calculate_ini = calculate_ini[0]
else:
return False
# извлекаем из полного имени файла путь
onlydir = os.path.split(name_calculate_ini)[0]
# проверяем чтобы путь до ини файла существовал
if not os.path.exists(onlydir):
return False
config = iniParser(name_calculate_ini)
# Получаем секцию конфигурационного файла
if not header:
header = self.__getSection(vname)
if not header:
self.Get(vname)
header = self.__getSection(vname)
# Удаляем переменную
retDelVar = config.delVar(header, vname)
retDelArea = True
if not config.getAreaVars(header):
retDelArea = config.delArea(header)
if retDelArea and retDelVar:
return True
else:
return False
def Write(self, vname, val, force=False, location='default',header=False):
'''Установить и записать значение переменной в ini файл
Параметры:
vname имя переменной
val значение переменной
force "принудительный режим"
location расположение ini файла ('default', 'local', 'remote')
header раздел ini файла ('client', 'server', 'calculate')
'''
if self.__Set(vname, val, force)!= False:
if not val.strip():
self.__deleteVarValue(vname, location, header)
self.__writeVarValue(vname, val, location, header)
return True
return False
def Delete(self, vname, location='default', header=False):
'''Удалить переменную в calculate.ini
Параметры:
vname имя переменной
location расположение ini файла ('default', 'local', 'remote')
Возвращаемые значение:
True удалено успешна
False удаление не удалсь
'''
return self.__deleteVarValue(vname, location, header)
def __getActiveSections(self):
"""активные секции в ini файле"""
act_section = []
for service,t,t in self._importList:
if service == "Global":
act_section.append('calculate')
else:
act_section.append(service.lower())
return act_section
def flIniFile(self):
'''Заместить значение переменных значениями из ини файлов
Возвращаемые значения:
оварь импортированных переменных - переменные считаны
False - файл не был обнаружен
'''
#Cловарь переменных из ini файлов
importVars = {}
calculate_ini = self.__getPathCalculateIni()
# активные секции (секции из которых будут использованы переменные)
act_section = self.__getActiveSections()
set_act_section = set(act_section)
i = 0
locations = ['remote','local','default']
for name_calculate_ini in calculate_ini:
# проверить сущестование ini файла
if os.path.exists(name_calculate_ini):
# получить объект настроенный на ini
config = iniParser(name_calculate_ini)
# получаем все секции из конфигурационного файла
allsect = config.getAllSectionNames()
if not allsect:
continue
# находим встречающиеся у обоих секции
act_sect = tuple(set(allsect)& set_act_section)
# словарь переменных для ini - файла
importFileVars = {}
# получаем все переменные из всех секций
for section in act_sect:
allvars = config.getAreaVars(section)
if allvars == False:
return False
# словарь переменных для ini - файла
importFileVars = {}
# принудительно переписать все переменные окружения
# полученные из ini
for (k,v) in allvars.items():
k = k.encode("UTF-8")
value = cl_utils.convertStrListDict(v.encode("UTF-8"))
self.Set(k, value, True)
importFileVars[k] = value
if i < 3:
importVars[locations[i]] = importFileVars
i += 1
return importVars
def flServer(self, **args):
'''Заполнить конфигурацию переменных, для ldap'''
# заполнить переменные окружения алгоритмом по умолнанию
self._importData("Server")
def flClient(self, **args):
'''Заполнить конфигурацию переменных, для клиента'''
# заполнить переменные окружения алгоритмом по умолнанию
self._importData("Client")
def flBuilder(self, **args):
'''Заполнить конфигурацию переменных, для билдера'''
self.Set('setup_pass','builder',True)
# заполнить переменные окружения алгоритмом по умолнанию
self._importData("Builder")
def flInstall(self, **args):
'''Заполнить конфигурацию переменных для инсталятора'''
self.Set('setup_pass','install',True)
def defined(self, vname):
return True
def exists(self, nameVar):
""" Определяет существует ли переменная с таким имененм
"""
if hasattr(self, nameVar):
return True
foundVar = False
# Ищем переменную в импортируемых модулях
for section, moduleVar, fillobj in self._importList:
if moduleVar.Data.__dict__.has_key(nameVar):
foundVar = True
break
return foundVar
def getVars(self, type_names=None):
ret = {}
for section, moduleVar, fillobj in self._importList:
dataVar=moduleVar.Data
dictVars = dir(dataVar)
for nameVar in dictVars:
if not "__" in nameVar:
if not (getattr(dataVar,nameVar).has_key("official") and\
getattr(dataVar,nameVar)['official']):
self.Get(nameVar)
if type_names:
#type_names.sort()
varType =list(getattr(dataVar,nameVar)['type'])
#varType.sort()
#print type_names
#print varType
#print
if not set(type_names)<=set(varType):
continue
ret[nameVar] = getattr(self,nameVar)
return ret
#распечатать список переменных с значениями
def printVars(self,type_names=None):
var=None
var=self.getVars(type_names)
mlen_name=0;
mlen_type=0;
mlen_mode=0;
for i,j in var.items():
if len(i)>mlen_name:
mlen_name=len(i)
#if len(str(j.type))>mlen_type:
#mlen_type=len(str(j.type))
vtype=str(type(var[i].value)).split(" ")[1][1]
if not '[' in var[i].mode:
if vtype in ['d','l']:
mode="[%s%s]"%(var[i].mode.lower(),vtype)
else:
mode="[%s]"%(var[i].mode.lower())
var[i].mode=mode
if len(mode)>mlen_mode:
mlen_mode=len(mode)
plist=var.keys()
plist.sort()
br = cl_utils.fillstr("-",mlen_name) + " " +\
cl_utils.fillstr("-",mlen_mode) + " " + cl_utils.fillstr("-",10)
#cl_utils.fillstr("-",mlen_type) + " " +\
print "The list of variables:"
print "var name".center(mlen_name),\
"Mode","Value"
#"Type".center(mlen_type),\
print br
for i in plist:
#if var[i].value is None:
#continue
p_val=var[i].value
if var[i].official:
continue
cl_utils.columnWrite( i, mlen_name, var[i].mode.lower(),
mlen_mode,
#str(var[i].type),
#mlen_type,
p_val)
print br
##############################################################################
class glob_attr:
"""Глобальные аттрибуты для методов заполнения переменных"""
def _runos(self,cmd, ret_first=None, env={}):
"""Вернуть результат выполнения команды ОС"""
if not env:
envDict = {}
env.update(os.environ.items() + [("PATH",cl_utils.getpathenv())] +\
env.items())
retCode, programOut = cl_utils.runOsCommand(cmd, None, ret_first, env)
if not retCode:
return programOut
return False