#-*- coding: utf-8 -*- #Copyright 2008 Calculate Pack, http://www.calculate-linux.ru # # 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 import cl_devices import imp ############################################################################## _expand_lang = gettext._expand_lang 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 = 0644 # Cоответствует ли формат файла нужному self.checkIni = None def setMode(self, mode): """установка прав создаваемого ini-файла""" self.mode = mode def openIniFile(self): if not os.path.exists(self.iniFile): 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 None 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: '''Объект "Переменная окружения"''' # название сервиса которому принадлежит переменная #(Global, Builder, Client, Server итд) service = None # значение переменной value = None # режим записи (атрибут 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 self.value == None: 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): # добавляем пути к модулям если они не добавлены 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(): print _("Unsupported section %s")%section exit(1) modVar = self.__modlist[section][0] modFill = self.__modlist[section][1] # Импортируем класс описания переменных и класс заполнения try: exec ("import %s" % (modVar)) except ImportError, e: print _("Error in import module %s")%modVar print _("error") + ": " +str(e) exit(1) flagFindFillModule = True try: exec ("import %s" % (modFill)) except ImportError, e: if "No module named" in str(e): flagFindFillModule = False else: print _("Error in import module %s")%modFill print _("error") + ": " +str(e) exit(1) 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: print _("Not found variable %s")%nameVar if e: print _("error") + ": " +str(e) exit(1) 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)): print _("error initalize variable %s, incorrect data")%nameVar exit(1) for nameAttr in dict.keys(): setattr(var,nameAttr, dict[nameAttr]) return True def __Get(self, nameVar): ret = None self.__LevelsVar.append((self.__levelNumber, nameVar)) self.__levelNumber += 1 #nameMethod = "get_" + nameVar if self.__dict__.has_key(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() else: ret = None 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(): #print name for nameLink in links[name].keys(): val = self.__getattribute__(nameLink).Get() self.__getattribute__(name).dependValues[nameLink] = val return ret def Get(self, nameVar): return self.__Get(nameVar) def __Set(self, nameVar, value, force=False): nameMethod = "get_" +nameVar if not self.__dict__.has_key(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 self.__dict__.has_key(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] = None return links def __getPathCalculateIni(self): """Получить пути до ini файлов""" return self.Get('cl_env_path') def __getSection(self, vname): """секция для записи в ini файл переменной vname - имя переменной """ if self.__dict__.has_key(vname): if self.__dict__[vname].service == 'Global': return 'calculate' else: return self.__dict__[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): '''Удалить переменную в calculate.ini Параметры: vname имя переменной location расположение ini файла ('default', 'local', 'remote') Возвращаемые значение: 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) # Получаем секцию конфигурационного файла header = self.__getSection(vname) # Удаляем переменную retDelVar = config.delVar(header, vname) retDelArea = True if not config.getAreaVars(header): retDelArea = config.delArea(header) if retDelArea and retDelArea: 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: self.__writeVarValue(vname, val, location, header) return True return False def Delete(self, vname, location='default'): '''Удалить переменную в calculate.ini Параметры: vname имя переменной location расположение ini файла ('default', 'local', 'remote') Возвращаемые значение: True удалено успешна False удаление не удалсь ''' return self.__deleteVarValue(vname, location) 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): '''Заместить значение переменных значениями из ини файла Возвращаемые значения: True переменные считаны False файл не был обнаружен ''' calculate_ini = self.__getPathCalculateIni() # активные секции (секции из которых будут использованы переменные) act_section = self.__getActiveSections() set_act_section = set(act_section) 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) # получаем все переменные из всех секций for section in act_sect: allvars = config.getAreaVars(section) #allvars = config.getAreaVars(self.__getCurrentHeaderName()) if allvars == False: return False # принудительно переписать все переменные окружения # полученные из ini for (k,v) in allvars.items(): k = k.encode("UTF-8") v = v.encode("UTF-8") self.Set(k, cl_utils.convertStrListDict(v), True) return True 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): #if vname: #if self.__dict__.has_key(vname): #return True #return False def defined(self, vname): return True 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: """Глобальные аттрибуты для методов заполнения переменных""" path_env = cl_utils.getpathenv() def _runos(self,cmd,ret_first=None): """Вернуть результат выполнения команды ОС""" return cl_utils.runOsCommand(cmd, None, ret_first)