#-*- 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 __utf8Translate(self, *arg, **argv): """Изменение кодировки переведенной строки на UTF-8""" return self.ugettext(*arg , **argv).encode("UTF-8") 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) transl.__utf8Translate =\ lang.__utf8Translate.__get__(transl) module._ = transl.__utf8Translate #module._ = transl.ugettext 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__]) ############################################################################## import cl_profile class iniParser(cl_profile._error): """Класс для работы с ini файлами """ def __init__(self, iniFile): # название ini файла self.iniFile = iniFile # права создаваемого ini-файла self.mode = 0644 def setMode(self, mode): """установка прав создаваемого ini-файла""" self.mode = mode def openIniFile(self): 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") textIni = FD.read() FD.close() return textIni def writeIniFile(self, txtConfig): 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 textIni == False: 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 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 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 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 ############################################################################## 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 ############################################################################### class objValue(object): '''Объект "Переменная окружения"''' G_shr_path="/usr/calculate" G_rshr_path="/var/calculate/remote" G_path=cl_utils.getpathenv() G_calcname="Calculate" # значение переменной окружения __value = None # режим записи (атрибут mode) v_mode="r" # тип переменной (атрибут type) v_type=() # тип значения переменной (определяется по value) v_vtype=None # список допустимых значений переменных (select) v_select=None # переменная для внутреннего использования (official) v_official=False # печатаемое значение v_printval=None # переменная заполнена? - ее значение можно в последствии # получить сразу из __value __alreadyFill = False # переменная была установлена методом Set # ini файл, коммандная строка, внутри программы, # значение по умолчанию __wasSet = False # переменная постоянно пересчитывается при обращении __dynamicValue = False # список переменных окружения, которые должные обновляться # если изменилось значение этой переменной # строится автоматически __ichangethey = set([]) # атрибут класса содержащий текущий стек вызовов get из переменных # используется для построения зависимости переменных __getstack = set([]) def isPure(self): '''Переменная не установлена и не заполнялась''' return not (self.__wasSet or self.__alreadyFill) def SetOutdated(self): '''Устанавливает переменную в состояние устарела''' self.__alreadyFill = False def SetDynamic(self, state=True): '''Устанавливает переменную в состояние динамическая, то есть если переменная не устанавливается в ручную, то она постоянно пересчитывается''' self.__dynamicValue = state #Вернуть результат выполнения команды ОС def _runos(self,cmd,ret_first=None): return cl_utils.runOsCommand(cmd, None, ret_first) def get_stack(self): '''Получить значение атрибута класса''' return self.__class__._objValue__getstack def set_stack(self, value): '''Установить занчение атрибута класса''' self.__class__._objValue__getstack = value '''Свойство содержащее стек вызовов''' getstack = property( get_stack, set_stack ) def simpleget(self): '''Метод заполения значения переменной''' return self.__value def simpleset(self,value): '''Метод установки значения переменной Метод должен вернуть значение которое он устанавливает. ''' return value def indirectfilling(self,val): '''Сторонняя установка значение, используется при установке значения переменной из другой функции заполения''' # значение устанавливаем, только в том случае, если переменная не # установлена вручную if not self.__wasSet: # устанавливаем состояние переменной - заполнена self.__alreadyFill = True # если значение меняется if val != self.__value: # обнавляем все зависимые переменные self.updatelinkvalue() self.__value = val def getvalue(self): '''Функция диспетчер вызова при обращении к значению переменной. Если значение для нее не было установлено вручную, то оно заполняется по своему алгоритму, попутно для всех переменных на основе значений которые вычисляется занчение этой переменной строится список зависимостей, после вычисления переменной при дальнейшем обращении к ее значению - оно берется из переменной __value''' # сохраняем текущий список вызовов get - это объекты, которые # тоже должны изменить если эта переменная изменится if self.getstack: self.__ichangethey = self.__ichangethey.union(self.getstack) # если переменная не заполненная и не установленная if (self.__dynamicValue or not self.__alreadyFill) and not self.__wasSet: # устанавливаем флаг, что оно вычилсенно, для избежания # бесконечных рекурсий self.__alreadyFill = True #помещаем себя в список переменных, которые вызывают get self.getstack.add(self) # вызываем метод заполения переменной val = self.simpleget() if self.__dynamicValue: if val != self.__value: self.updatelinkvalue() self.__value = val # удаляем себя из списка переменных вызывающих get self.getstack.remove(self) # возвращаем значение переменной либо вычисленное либо из "кэша" return self.__value def updatelinkvalue(self): '''Установить всем переменным, значение которых зависит от этой состояние незаполнены''' # пробегаем по всем переменных, которые зависят от этой переменной for i in self.__ichangethey: # пропускаем рекурсивный вызов if i == self: continue # условия, чтобы обновление объектов не вошло в бесконечную # рекурсию. Таким образом объекты будут оповещать # другие объекты только в том случае если сами считают # себя заполненными if i._objValue__alreadyFill: # устанавливаем им значение что заполение не вызывалось # для обновления значения, если переменная установлена вручную # то она не будет заполняться по условию __wasSet i._objValue__alreadyFill = False # сообщаем объекту, что он должен сообщить об изменениях # объектам, которые от него значение ставили i.updatelinkvalue() def setvalue(self,value): # взводим флаг "переменная установлена вручную" self.__wasSet = True # если значение изменилось, то обновляем все зависимые переменные if value != self.__value: self.updatelinkvalue() # вызов метода установки переменной self.__value = self.simpleset(value) # связываем значение переменной окуржения с двумя функциями: заполнения # и установки v_value = property(getvalue,setvalue) value = property(getvalue,setvalue) matching={'mode' :'v_mode', 'type' :'v_type', 'vtype' :'v_vtype', 'value' :'v_value', 'select' :'v_select', 'official' :'v_official'} def __init__(self,**argv): # перебираем все установленные атрибуты dic = object.__getattribute__(self,'matching') for atname,avalue in argv.items(): # если это методы заполения и установки переменной, то # связываем их с этой переменной object.__setattr__(self,'_objValue__ichangethey',set([])) if atname == 'Setself': object.__setattr__(self,'simpleset',avalue.__get__(self)) elif atname == 'Getself': object.__setattr__(self,'simpleget',avalue.__get__(self)) else: if atname in dic: atname = dic[atname] object.__setattr__(self,atname,avalue) def Set(self,name,value): self.__ichangethey.add(self.Get(name,True)) self.SetIndirect(name,value) def __getattribute__(self, instance): '''Возвращаем None, при обращении к несуществующему атрибуту''' dic = object.__getattribute__(self,'matching') if instance in dic: instance = dic[instance] return object.__getattribute__(self, instance) def __setattr__(self, atname, value): '''Метод добавляет псевдонимы к атрибутам, и следит, чтобы не были добавлены дополнительные''' if self.matching.has_key(atname): object.__setattr__(self,self.matching[atname], value) elif atname in self.__class__.__dict__: object.__setattr__(self,atname, value) else: print _('not attribute') class fillVars: G_shr_path="/usr/calculate" G_rshr_path="/var/calculate/remote" G_path=cl_utils.getpathenv() G_calcname="Calculate" def __init__(self, objvar=None): if objvar: self._objvar=objvar #Вернуть результат выполнения команды ОС @classmethod def __runos(cls,cmd,ret_first=None): return cl_utils.runOsCommand(cmd, None, ret_first) #***************************************************************************** #Заполнения переменных для Hardware #***************************************************************************** def get_hrd_pc_vendor(self): '''Получим производителя PC''' if os.path.exists('/sys/class/dmi/id/chassis_vendor'): vendor= self._runos( '%s cat /sys/class/dmi/id/chassis_vendor' % self.G_path) if re.search('^\s+$',vendor) or\ re.search('Chassis Manufacture',vendor): vendor='Chassis Manufacture' return vendor def get_hrd_laptop_vendor(self): '''Получим производителя ноутбука''' cm = self._runos if os.path.exists('/sys/class/dmi/id/board_name'): s= self._runos( '%s cat /sys/class/dmi/id/board_name | grep "Portable PC"'%\ self.G_path) if s: return s.lower() def get_hrd_laptop_model(self): '''Получить модель ноутбука''' if self.Get('hrd_laptop_vendor'): s=self._runos( '%s cat /sys/class/dmi/id/product_name' % self.G_path) if s: return s def get_hrd_board_model(self): '''Получить модель платы''' if not self.Get('hrd_laptop_vendor'): if os.path.exists('/sys/class/dmi/id/board_name'): return self._runos('%s cat /sys/class/dmi/id/board_name' %\ self.G_path) else: return "" def get_hrd_board_vendor(self): '''Получить производителя платы''' if not self.Get('hrd_laptop_vendor'): if os.path.exists('/sys/class/dmi/id/board_vendor'): return self._runos('%s cat /sys/class/dmi/id/board_vendor' %\ self.G_path) def set_setup_march(self,value): '''Установить архитектуру процессора''' march=self._runos('%s uname -m' % self.G_path) if march != value: self.Set('dif_march', True) return value def get_setup_march(self): '''Получить архитектуру процессора''' return self._runos('%s uname -m' % self.G_path) def get_setup_unmask(self): '''Получить маску нестабильных файлов''' march = self.Get('setup_march') if march == 'i686': return '~x86' elif march == 'x86_64': return '~amd64' def get_hrd_cpu_num(self): '''Определить количество процессоров''' cpucnt=0 if os.path.exists('/proc/cpuinfo'): for record in open('/proc/cpuinfo','rb').readlines(): try: param, pval=record.split(":") except: continue if param.strip()=='processor': cpucnt+=1 return cpucnt def get_hrd_video_drv(self): '''Определить драйвер видеокарты''' nvdrv=('nVidia Aladdin TNT2','GeForce 6200','GeForce DDR',\ 'GeForce2','GeForce4','Quadro2','Quadro4','RIVA TNT2','Vanta') videoname = self.Get('hrd_video_name') if type(videoname) == types.StringType: if "Intel" in videoname: return 'i810' elif "nVidia" in videoname: if videoname not in nvdrv: return "nvidia" else: return "vesa" elif "VMware" in videoname: return "vmware" return "vesa" def get_hrd_opengl_set(self): '''Определить название для openglset''' nvdrv=('nVidia Aladdin TNT2','GeForce 6200','GeForce DDR',\ 'GeForce2','GeForce4','Quadro2','Quadro4','RIVA TNT2','Vanta') videoname = self.Get('hrd_video_name') if type(videoname) == types.StringType: if "Intel" in videoname: return 'xorg-x11' elif "nVidia" in videoname: if videoname not in nvdrv: return "nvidia" def get_hrd_video_name(self): '''Определить название видео карты''' suppdrv=("nvidia", "i810", "vesa", "vmware") nvdrv=('nVidia Aladdin TNT2','GeForce 6200','GeForce DDR',\ 'GeForce2','GeForce4','Quadro2','Quadro4','RIVA TNT2','Vanta') cards=cl_devices.Video().getcards() if cards: video=cards[0] if re.search('GeForce',video) or \ re.search('nVidia',video): if re.search('\[([^\]]+)\]',video): model="nVidia "+re.search('\[([^\]]+)\]',video).groups()[0] return model elif re.search('(GeForce.+) nForce',video): model="nVidia" model+=re.search('(GeForce.+) nForce',video).groups()[0] return model else: return "nVidia GeForce" elif re.search('Intel', video): res=re.search("Intel Corporation ([^\s]+)\s", video) if res: return "Intel "+res.groups()[0] else: return "Intel" elif re.search('VMware', video): return "VMware" def get_cmd_run_opengl(self): '''Определить команду запуска opengl cmd_run_opengl''' hrd_opengl_set = self.Get('hrd_opengl_set') if hrd_opengl_set: return "/usr/bin/eselect opengl set %s"%(self.Get('hrd_opengl_set')) def get_hrd_video_res(self): '''Определить разрешение экрана hrd_video_res''' xlog = "/var/log/Xorg.0.log" def_res = "1024x768" if os.path.exists(xlog): f=open(xlog, "rb") sf=f.read() f.close() fstr="Virtual screen size determined to be ([0-9]+)\s*x\s*([0-9]+)" if re.search(fstr, sf): res=re.search(fstr, sf).groups() resol=res[0]+"x"+res[1] return resol elif re.search('Setting mode \"([0-9\@x]+)\"',sf): res=re.search('Setting mode \"([0-9\@x]+)\"',sf).groups() return res[0] elif re.search('Virtual size is ([0-9\@x]+) ',sf): res=re.search('Virtual size is ([0-9\@x]+) ',sf).groups() return res[0] elif re.search('Modeline "([0-9\@x]+)"',sf): res=re.search('Modeline "([0-9\@x]+)"',sf).groups() return res[0] return def_res @classmethod def findusbdevice(cls,devicename): '''Функция поиска имени устройства в списке выводимом lsusb''' cm = cls.__runos res=cm('%s lsusb 2>/dev/null' % cls.G_path) sstr='^Bus [0-9]+ Device [0-9]+: ID [0-9a-f]+:[0-9a-f]+ ([^\s].+)$' if res: for i in res: sres=re.search(sstr,i) if sres: val=sres.group(1) if re.search(devicename,val): return True def get_hrd_usb_hp(self): '''Узнать подключены ли Hewlett-Packard устройства''' return fillVars.findusbdevice('Hewlett-Packard') def get_hrd_usb_bluetooth(self): '''Узнать подключены ли Bluetooth устройства''' return fillVars.findusbdevice('Bluetooth') def get_setup_path_install(self): value_setup_pass = self.Get('setup_pass') if value_setup_pass == 'builder': return '/mnt/builder' elif value_setup_pass == 'install': return "/mnt/install" else: return '/' #***************************************************************************** #Заполнение переменных для Builder #***************************************************************************** def get_setup_gentoo_mirrors(self): '''Определить ссылки на исходинки программ''' return "http://mirror.yandex.ru/gentoo-distfiles \ http://distfiles.gentoo.org \ http://distro.ibiblio.org/pub/linux/distributions/gentoo" def get_setup_gentoo_release(self): return "2007.0" def get_setup_path_portagepkg(self): portagepath="/usr/calculate/snapshots/" if not os.path.exists(portagepath): self._runos(self.G_path+" mkdir "+portagepath) else: rdir=os.listdir(portagepath) last=0 for i in rdir: res=re.search('^portage\-([0-9]+)\.tar\.bz2$',i) if not res: continue else: if int(res.groups()[0])>last: last=int(res.groups()[0]) if last: return "%sportage-%s.tar.bz2"%\ (portagepath,last) def get_setup_path_stagepkg(self): march=self.Get('setup_march') stagepath="/usr/calculate/stages/" if march=='i686': val="stage3-i686-%s.tar.bz2"%(self.Get('setup_gentoo_release')) if os.path.exists(stagepath+val): return stagepath+val elif march=='x86_64': val="stage3-amd64-%s.tar.bz2" %(self.Get('setup_gentoo_release')) if os.path.exists(stagepath+val): return stagepath+val def get_setup_run_user(self): try: f=open('/etc/passwd') PASSWD=f.readlines() f.close() except: print _("Error opening file") + ": passwd" try: f=open('/etc/group') GROUP=f.readlines() f.close() except: print _("Error opening file") + ": group" if PASSWD: uval="" for pline in PASSWD: user=[i.strip() for i in pline.split(":")] #извлечем пользователей, добавленных после установки системы if int(user[2])>=500 and\ int(user[2])<6500 and\ int(user[2])!=99: grp="" for gline in GROUP: group=[i.strip() for i in gline.split(":")] gusers=None if group[-1]: gusers=group[-1].split(",") if gusers: if user[0] in gusers: if not grp: grp=group[0] else: grp=grp+","+group[0] groups="" if grp: groups="--groups "+grp val="\n/usr/sbin/useradd --uid %s --gid %s --home-dir %s"%\ (user[2],user[3],user[5]) val+=" --shell %s %s %s" %\ (user[6], groups, user[0]) uval+=val return uval def get_setup_ata(self): '''Сформировать хэш конвертации устаревшего формата hda на sda''' dev_list=cl_devices.block_dev() disks={'removable':[],'sata':[],'ata':[]} for dev in dev_list.get_listdev(): if dev_list.isremovable(dev): val=disks['removable'] disks['removable']=val+[dev] else: if dev[:2]=='sd': val=disks['sata'] disks['sata']=val+[dev] else: val=disks['ata'] disks['ata']=val+[dev] sata=None ata={} if len(disks['ata'])>0: devs=[] devkey=disks['sata']; devkey.sort() devs+=devkey devkey=disks['ata']; devkey.sort() devs+=devkey devkey=disks['removable']; devkey.sort() devs+=devkey for i in devs: if not sata: sata='sda' else: val=re.search('sd([a-z])',i) if val: val=val.groups()[0] else: val=re.search('sd([a-z])',sata).groups()[0] sata='sd'+(chr(ord(val)+1)) ata[i]=sata return ata def fillBuilder(self): G_path=Get('setup_path_env') #--------------------------------------------------------------------- # Определим запущенные сервисы CDS #--------------------------------------------------------------------- for i in ('ldap','mail','ftp'): if getini("up.%s"%i)=="on": Set('sys_set_%s'%i,True,True) else: Set('sys_set_%s'%i,False,True) #***************************************************************************** #Заполнение переменных для LDAP #***************************************************************************** @classmethod def gethashfrom_slappasswd(cls,value_G_path,value_password, \ value_encrypt): cstr='%s slappasswd -s %s -h %s'%\ (value_G_path, value_password, value_encrypt) res=cls.__runos(cstr) if res: return res.strip() def get_setup_path_profinstall(self): profpath = '/usr/lib/calculate/calculate-server/profile' if os.path.exists(profpath): return [profpath] def get_setup_path_profuser(self): profpath = '/var/calculate/profile/server' if os.path.exists(profpath): return [profpath] def get_soft_samba_domain(self): return "CDS" def get_soft_ldap_root(self): return "calculate" def get_soft_samba_netbios(self): return "PDC-CDS" def get_soft_ldap_base(self): return "dc=%s"%(self.Get('soft_ldap_root')) def get_soft_ldap_sevices_dn(self): return "ou=%s,%s"\ %(self.Get('soft_ldap_sevices_dn_name'), self.Get('soft_ldap_base')) def get_soft_ldap_hash_encrypt(self): return "{SSHA}" def get_soft_ldap_bindname(self): return "proxyuser" def get_soft_ldap_bind(self): return "cn=%s,%s"% (self.Get('soft_ldap_bindname'), self.Get('soft_ldap_base')) def get_soft_ldap_bindpw(self): return "calculate" def get_soft_ldap_bindpw_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_bindpw'), self.Get('soft_ldap_hash_encrypt')) def get_soft_ldap_admin_tmp(self): return "cn=ldaproot,%s"%self.Get('soft_ldap_base') def get_soft_ldap_adminpw_tmp(self): return cl_utils.genpassword().strip() def get_soft_ldap_adminpw_tmp_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_adminpw_tmp'), self.Get('soft_ldap_hash_encrypt')) def get_soft_ldap_adminname(self): return "ldapadmin" def get_soft_ldap_admin(self): return "cn=%s,%s"% (self.Get('soft_ldap_adminname'), self.Get('soft_ldap_base')) def get_soft_ldap_adminpw_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_adminpw'), self.Get('soft_ldap_hash_encrypt')) def get_soft_ldap_adminpw(self): '''Заполнение переменной soft_ldap_adminpw постоянный пользователь root, прописываемый в базу при первой загрузке с одновременным удалением временного root-а ''' return cl_utils.genpassword().strip() def get_soft_ldap_admin_jabber_name(self): return "Jabber" def get_soft_ldap_admin_jabber(self): return "ou=Jabber,%s" % self.Get('soft_ldap_sevices_dn') def get_soft_ldap_admin_jabberpw(self): return cl_utils.genpassword().strip() def get_soft_ldap_admin_jabberpw_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_admin_jabberpw'), self.Get('soft_ldap_hash_encrypt')) def get_soft_ldap_admin_unix_name(self): return "Unix" def get_soft_ldap_admin_unix(self): return "ou=Unix,%s" % self.Get('soft_ldap_sevices_dn') def get_soft_ldap_admin_unixpw(self): return cl_utils.genpassword().strip() def get_soft_ldap_admin_unixpw_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_admin_unixpw'), self.Get('soft_ldap_hash_encrypt')) def get_soft_ldap_admin_samba_name(self): return "Samba" def get_soft_ldap_admin_samba(self): return "ou=Samba,%s" % self.Get('soft_ldap_sevices_dn') def get_soft_ldap_admin_sambapw(self): return cl_utils.genpassword().strip() def get_soft_ldap_admin_sambapw_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_admin_sambapw'), self.Get('soft_ldap_hash_encrypt')) def get_soft_ldap_admin_mail_name(self): return "Mail" def get_soft_ldap_admin_mail(self): return "ou=Mail,%s" % self.Get('soft_ldap_sevices_dn') def get_soft_ldap_admin_mailpw(self): return cl_utils.genpassword().strip() def get_soft_ldap_admin_mailpw_hash(self): return fillVars.gethashfrom_slappasswd(self.G_path, self.Get('soft_ldap_admin_mailpw'), self.Get('soft_ldap_hash_encrypt')) #***************************************************************************** #Заполнение глобальных переменных #***************************************************************************** def get_setup_path_env(self): '''Установка переменной setup_path_env''' if not os.path.exists(self.G_shr_path): print _("Not found Calculate dir") + ": " +self.G_shr_path sys.exit(0) if self.G_path: return self.G_path else: print _("Not found path for execute commands") sys.exit(0) def set_setup_installdev(self): if re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev')): val=re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev')) if val: vals=val.groups() self.g_install_dev=vals[0] self.g_install_num=vals[1] return vals[0]+vals[1] else: print _("Incorrect partition") sys.exit(0) def isroot(self): '''Проверим пользователь, запустивший скрипт - root''' if os.getegid()!=0: print _("Only root can perform system installation") sys.exit(0) def get_setup_sys_shortname(self): '''Получить переменную короткого названия системы''' path = '/etc/issue' sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)""" res=self._runos('%scat %s | grep "Welcome to "'%\ (self.G_path,\ path)) if res: if re.search(sp,res): vals=re.search(sp,res).groups() issuename=vals[0] ver=self.Get('setup_dist_ver') for i in ver.keys(): if ver[i]==issuename: return i spl=issuename.split(" ") nname="" if len(spl)>1: for i in spl: nname+=i[1] return nname else: return issuename return "CLD" def get_setup_sys_fullname(self): '''Заполнить переменную с полным именем системы''' ver = self.Get('setup_dist_ver') sh_name = str(self.Get('setup_sys_shortname')) if sh_name.upper() in ver: return ver[sh_name.upper()] else: path='/etc/issue' #если файл с версией системы найден, определим версию sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)""" res=self._runos('%s cat %s | grep "Welcome to "'%\ (self.G_path, path)) if res: if re.search(sp,res): vals=re.search(sp,res).groups() return vals[0] # TODO: значение по умолчанию для fullname если не удалось # заполнить (например файл не открылся) return "" def get_sys_linux_type(self): '''Получить тип системы (настрольная/серверная)''' if re.search('server',str(self.Get('setup_sys_fullname')), re.I): return "server" else: return "desktop" def get_setup_name(self): '''Установить имя установщика''' return self.G_calcname+" "+self.Get('setup_ver') def get_cmd_exec_host(self): '''Определить путь до запуска утилиты host (cmd_exec_host)''' if not os.system("which host >/dev/null 2>&1"): res=os.popen("which host").readlines() return res[0].rstrip() def get_cmd_exec_nmap(self): '''Определить путь до запуска утилиты nmap (cmd_exec_nmap)''' if not os.system("which nmap >/dev/null 2>&1"): res=os.popen("which nmap").readlines() return res[0].rstrip() def get_sys_load(self): ''' Установим значение load в значение ram в случае загрузки с CD/DVD''' if self._runos("""mount | grep "/dev/loop/0 on / type" """): return "ram" else: return "" def get_net_host(self): '''Считать имя компьютера net_host''' hostname=self._runos("""%s hostname -s 2>&1"""%self.G_path) #Set('net_host',hostname, True) #упрощенный вариант, следует выполнять только если не указан домен #в системе if re.search("^hostname: ",hostname): hostname=self._runos("""%s hostname 2>&1"""%self.G_path) if re.search("^hostname: ",hostname): return self.Get('setup_sys_shortname') else: if hostname=='livecd': return self.Get('setup_sys_shortname') return hostname def get_sys_domain(self): ''' Определим домен''' domain=self._runos("%s hostname -d 2>&1"%self.G_path) if re.search("^hostname: ",domain): return "local" else: return domain def get_net_gw(self): '''Определить сетевой шлюз''' route=self._runos("""%sroute -n | grep "^0.0.0.0" """%self.G_path) route=re.split("\s+",route) if route: self.Set('net_gw_dev', route[7]) return route[1] def get_net_gw_dev(self): '''Определить сетевой адаптер для шлюза''' route=self._runos("""%sroute -n | grep "^0.0.0.0" """%self.G_path) route=re.split("\s+",route) if route: self.Set('net_gw', route[1]) return route[7] @classmethod def common_netfunc(cls, value_net_gw,value_net_gw_dev): ''' Общие действия выполняемые для заполнения шлюз, локальные интерфейсы, локальные сети, настройки /etc/conf.d/net, сетевые устройства net_conf, net_hosts_allow, net_networks Входные параметры: value_net_gw значение переменной окружения net_gw value_net_gw_dev значение переменной окружения net_gw_dev ''' cm = cls.__runos net={'255.255.0.0':'/16',\ '255.255.255.0':'/24',\ '255.255.255.128':'/25',\ '255.255.255.252':'/30',\ '255.255.255.255':''} netpath='/sys/class/net/' nets={} net_if=cl_utils.getdirlist(netpath) for i in net_if: if i=='lo': continue res=cm("cat %s%s/operstate"%(netpath,i)) if res=='up': nets[i]=True elif res=='down': nets[i]=False else: nets[i]=None ip={} host_allow="" networks="" netconf="" gateway_dhcp=0 dev_open=0 for i in nets.keys(): res=cm("/sbin/ifconfig %s"%i) #res=cm("ifconfig %s"%i) sline="""""" for j in res: s_ip=re.search('addr:([0-9\.]+).+Bcast:.+Mask:([0-9\.]+)'\ ,j) if s_ip: ip, netmask=s_ip.groups() host_allow+=ip+net[netmask]+"" ipd=ip ip=ip.split('.'); if ip[0]=='10' or\ (ip[0]=='172' and int(ip[1])>=16 and int(ip[1])<=31)or\ (ip[0]=='192' and ip[1]=='168'): if netmask=='255.255.255.255': networks+=ip+" " elif netmask=='255.255.255.252': networks+=ip[0]+"."+ip[1]+"."+ip[2]+"."+"252"+\ net[netmask] elif netmask=='255.255.255.128': networks+=ip[0]+"."+ip[1]+"."+ip[2]+"."+"128"+\ net[netmask] elif netmask=='255.255.255.0': networks+=ip[0]+"."+ip[1]+"."+ip[2]+"."+"0"+\ net[netmask] elif netmask=='255.255.0.0': networks+=ip[0]+"."+ip[1]+".0.0"+net[netmask] #определим получен ли IP через DHCP #print host_allow,networks if not os.path.exists(\ '/var/lib/dhcpcd/dhcpcd-%s.info'%i) and\ not (os.path.exists(\ '/var/lib/dhcp/dhclient.leases') and \ cm('grep %s /var/lib/dhcp/dhclient.leases'%i)): netconf+="\nconfig_%s=(\"%s\")"%(i,ipd\ +net[netmask]) else: netconf+="\nconfig_%s=(\"dhcp\")"%(i) if i==value_net_gw_dev: gateway_dhcp+=1 nets[i]=True else: netconf+="\nconfig_%s=(\"%s%s\")"%(i,\ ipd,net[netmask]) dev_open=1 netconf+="\nmodules_eth0=( \"!plug\" )" if dev_open==0: nets[i]=False if value_net_gw_dev and gateway_dhcp==0: netconf+="\nroutes_%s=(\"default gw %s\" )"%\ (value_net_gw_dev, value_net_gw) n_key = nets.keys() n_key.sort() return gateway_dhcp, n_key, networks, host_allow, netconf def get_net_conf(self): '''Получить конфигурацию сети''' gateway_dhcp, n_key, networks, host_allow, netconf= \ fillVars.common_netfunc(self.Get('net_gw'), self.Get('net_gw_dev')) self.Set('net_hosts_allow',host_allow) self.Set('net_networks',networks) if n_key: self.Set('net_lan', n_key[0]) return netconf def get_net_hosts_allow(self): '''Получить список hosts_allow''' gateway_dhcp, n_key, networks, host_allow, netconf= \ fillVars.common_netfunc(self.Get('net_gw'), self.Get('net_gw_dev')) self.Set('net_networks',networks) self.Set('net_conf',netconf) if n_key: self.Set('net_lan', n_key[0]) return host_allow def get_net_networks(self): '''Получить сети''' gateway_dhcp, n_key, networks, host_allow, netconf= \ fillVars.common_netfunc(self.Get('net_gw'), self.Get('net_gw_dev')) self.Set('net_hosts_allow',host_allow) self.Set('net_conf',netconf) if n_key: self.Set('net_lan', n_key[0]) return networks def get_net_lan(self): '''Получить сетевой интерфейс''' gateway_dhcp, n_key, networks, host_allow, netconf= \ fillVars.common_netfunc(self.Get('net_gw'), self.Get('net_gw_dev')) self.Set('net_networks',networks) self.Set('net_hosts_allow',host_allow) self.Set('net_conf',netconf) if n_key: return n_key[0] def get_net_nfs(self): '''Определить наличие сетевой файловой системы''' sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM) value_sys_domain = self.Get('sys_domain') if self.Get('cmd_exec_host') and\ value_sys_domain and\ self._runos('%s nfs.%s | grep "has address"'%\ (self.Get('cmd_exec_host'),\ value_sys_domain)) and\ sock.connect_ex(('nfs.%s' % value_sys_domain,2049))==0: return 'nfs.%s' % value_sys_domain @classmethod def commonproxyfunc(cls,value_cmd_exec_host, value_sys_domain): ret_net_proxy = None ret_net_proxy_port = None if value_cmd_exec_host and value_sys_domain and \ cls.__runos('%s proxy.%s | grep "has address"'% (value_cmd_exec_host, value_sys_domain)): ports=[3128,8080] for port in ports: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) arg_addr=('proxy.%s'%value_sys_domain,port) if sock.connect_ex(arg_addr)==0: if not ret_net_proxy: ret_net_proxy = 'proxy.%s'%value_sys_domain if not ret_net_proxy_port: ret_net_proxy_port = str(port) return ret_net_proxy, ret_net_proxy_port def get_net_proxy(self): '''Определить прокси-сервер''' ret_net_proxy, ret_net_proxy_port = \ fillVars.commonproxyfunc(self.Get('cmd_exec_host'), self.Get('sys_domain')) self.Set('net_proxy_port', ret_net_proxy_port) return ret_net_proxy def get_net_proxy_port(self): '''Определить порт прокси-сервера''' ret_net_proxy, ret_net_proxy_port = \ fillVars.commonproxyfunc(self.Get('cmd_exec_host'), self.Get('sys_domain')) self.Set('net_proxy', ret_net_proxy) return ret_net_proxy_port def get_net_proxy_url(self): '''Получить url прокси''' if self.Get('net_proxy') and self.Get('net_proxy_port'): return "http://%s:%s" % (self.Get('net_proxy'), self.Get('net_proxy_port')) def get_net_ntp(self): '''Определить наличие локального сервера времени net_ntp ''' if self.Get('cmd_exec_host') and\ self.Get('sys_domain') and\ self._runos('%s ntp.%s | grep "has address"'%\ (self.Get('cmd_exec_host'),\ self.Get('sys_domain'))): return 'ntp.%s'%self.Get('sys_domain') else: return 'ntp0.zenon.net' def get_net_cds(self): '''Определить наличие CDS сервера net_cds ''' if self.Get('sys_domain'): return 'cds.%s' % self.Get('sys_domain') else: return 'cds' @classmethod def commonsplitissue(cls): '''Получить содержимое /etc/issue и разбить его согласно регулярному выражению''' sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)""" if os.path.exists('/etc/issue'): cline=""" """ res=cls.__runos('%s cat /etc/issue | grep "Welcome to "'% cls.G_path) if res: par=re.search(sp,res).groups() res_n=par[1].split("-") return par[1] def get_setup_os_current(self): '''Получить название системы из под которой запущена программа''' sp = """Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)""" if os.path.exists('/etc/issue'): cline=" " res= self._runos('%s cat /etc/issue | grep "Welcome to "'% self.G_path) if res: par = re.search(sp,res).groups() if not par[0]: return "Calculate" return par[0] if os.path.exists('/etc/gentoo-release'): return "Gentoo Linux" else: return "Old Linux" def get_sys_patchcur(self): '''Получить текущий sys''' parone = fillVars.commonsplitissue() if parone: res_n = parone.split("-") self.Set('sys_current_ver', res_n[0]) if parone: self.Set('setup_ospatchsplit',"-") if len(res_n)>1: return res_n[1] else: return 0 def get_sys_current_ver(self): '''Получить текущий sys_current_ver''' parone = fillVars.commonsplitissue() if parone: res_n = parone.split("-") if parone: self.Set('setup_ospatchsplit',"-") if len(res_n)>1: self.Set('sys_patchcur', res_n[1]) return res_n[0] def get_setup_ospatchsplit(self): '''Получить текущий setup_patchcur''' parone = fillVars.commonsplitissue() if parone: res_n = parone.split("-") self.Set('sys_current_ver', res_n[0]) if len(res_n)>1: self.Set('sys_pathcur', res_n[1]) if parone: return "-" def get_setup_mestitle(self): '''Установить заголовок setup_mestitle ''' return "# " + _("Changed by")+ " " + self.G_calcname + " " + \ self.Get('setup_ver') def get_setup_mesline(self): '''Установить разделяющую линию setup_mesline ''' return "#"+"-"*78 def get_sys_loaddev(self): '''Определить раздел с которого загрузились''' for record in open('/proc/cmdline','rb').readlines(): re_res=re.search('^root=\/dev\/([a-z]+[0-9]).*',record.strip()) if re_res: return re_res.group(1) def get_setup_installdev(self): '''Определить устройство для установки''' res = self.Get('sys_loaddev') if res: fstr="^([a-z]{3})([0-9]+)" fres=re.search(fstr, res) if fres: vals=fres.groups() g_load_dev=vals[0] g_load_num=vals[1] try: g_load_num = int(g_load_num) except: return None if g_load_num == 2: if not os.path.exists("/dev/%s3"%g_load_dev): print _("Incorrect partition") sys.exit(0) return g_load_dev + "3" elif g_load_num == 3: if not os.path.exists("/dev/%s3"%g_load_dev): print _("Incorrect partition") sys.exit(0) return g_load_dev + "2" @classmethod def splitdev2devnum(cls,devname): '''Разбить устройство (sba1) на имя и номер''' fstr="^([a-z]{3})([0-9]+)" try: # пытаемся получить две сооставляющие диска (назв, номер) g_install_dev, g_install_num = \ re.search(fstr, devname).groups() return g_install_dev, g_install_num except AttributeError: return None,None def get_setup_formatfs(self): '''Получить файловую систему на которую устанавливаем ОС''' format="" value_setup_path_install = self.Get('setup_path_install') cstr="%s mkdir -p %s" % (self.G_path, value_setup_path_install) self._runos(cstr) # получаем диск на который ставим систему g_install_dev, g_install_num = \ fillVars.splitdev2devnum(self.Get('setup_installdev')) if g_install_dev == None: return None # пытаемся подмонтировать раздел на который будем ставить ОС cstr="%s mount /dev/%s%s %s &>/dev/null"\ % (self.G_path,\ g_install_dev,\ g_install_num,\ value_setup_path_install) # если удалось (код возврата 0) if not os.system(cstr): # получаем из список подмонтированных файловых систем # строку нашего раздела cstr="%s mount | grep /dev/%s%s"\ %(self.G_path,\ g_install_dev,\ g_install_num) format=self._runos(cstr,True) # отмонтируем ресурс cstr="%s umount %s"%(self.G_path, value_setup_path_install) os.system(cstr) else: # удалим директорию, так как раздел подмонтировать не удалось cstr="%s rmdir %s"%(self.G_path, value_setup_path_install) # os.system(cstr) if format: fses = ['reiserfs', 'xfs', 'ext3', 'ext2'] for i in fses: if re.search( ' %s ' % i, format.strip()): return i mkfses = [ ('/sbin/mkfs.reiserfs', 'reiserfs'), ('/sbin/mkfs.xfs', 'xfs'), ('/sbin/mkfs.ext3', 'ext3'), ('/sbin/mkfs.ext2', 'ext2') ] for fspath, fsname in mkfses: if os.path.exists(fspath): return fsname print _("Formatting utility not found") sys.exit(0) def get_cmd_run_format(self): '''Получить команду для форматирования''' formatrun={"reiserfs":'"/sbin/mkfs.reiserfs -f"',\ "xfs":"/sbin/mkfs.xfs -f",\ "ext3":"/sbin/mkfs.ext3",\ "ext2":"/sbin/mkfs.ext2"} if self.Get('setup_formatfs') in formatrun.keys() and\ os.path.exists("/sbin/mkfs.%s"%(self.Get('setup_formatfs'))): return formatrun[self.Get('setup_formatfs')] @classmethod def commongrubfunc(cls, value_setup_installdev, value_sys_loaddev): '''Общая функция для заполнения переменных grub.''' sdir="/sys/block/" ldir=cl_utils.getdirlist(sdir) grub_dev=[] #определим неизвлекаемые устройства if ldir: for dev in ldir: if re.search('^(sd|hd)',dev): cstr="%s cat %s%s/removable" %(cls.G_path, sdir, dev) val=cls.__runos(cstr) if val: if int(val[0].strip())==0: grub_dev.append(dev.strip()) grub_dev.sort() num = 0 grub_map = {} g_install_dev, g_install_num = \ fillVars.splitdev2devnum(value_setup_installdev) g_load_dev, g_load_num = \ fillVars.splitdev2devnum(value_sys_loaddev) value_boot_grub_setupdev = None value_boot_grub_loaddev = None for dev in grub_dev: grub_map['hd'+str(num)]=dev if g_install_dev==dev: value_boot_grub_setupdev = 'hd'+str(num) if g_load_dev==dev: value_boot_grub_loaddev = 'hd'+str(num) num+=1 return value_boot_grub_setupdev, value_boot_grub_loaddev,\ grub_map def get_boot_grub_loadnum(self): '''Получить переменную boot_grub_loadnum''' g_load_dev, g_load_num = \ fillVars.splitdev2devnum(self.Get('sys_loaddev')) if not g_load_num is None: return str(int(g_load_num)-1) def get_boot_grub_setupnum(self): '''Получить переменную boot_grub_loadnum''' g_install_dev, g_install_num = \ fillVars.splitdev2devnum(self.Get('setup_installdev')) if not g_install_num is None: return str(int(g_install_num)-1) def get_boot_grub_map(self): '''Запонить переменную boot_grub_map''' value_boot_grub_setupdev, value_boot_grub_loaddev, grub_map = \ fillVars.commongrubfunc(self.Get('setup_installdev'), self.Get('sys_loaddev')) self.Set( "boot_grub_setupdev", value_boot_grub_setupdev) self.Set( "boot_grub_loaddev", value_boot_grub_loaddev ) return grub_map def get_boot_grub_setupdev(self): '''Запонить переменную boot_grub_map''' value_boot_grub_setupdev, value_boot_grub_loaddev, grub_map = \ fillVars.commongrubfunc(self.Get('setup_installdev'), self.Get('sys_loaddev')) self.Set( "boot_grub_loaddev", value_boot_grub_loaddev ) self.Set( "boot_grub_map", grub_map ) return value_boot_grub_setupdev def get_boot_grub_loaddev(self): '''Запонить переменную boot_grub_map''' value_boot_grub_setupdev, value_boot_grub_loaddev, grub_map = \ fillVars.commongrubfunc(self.Get('setup_installdev'), self.Get('sys_loaddev')) self.Set( "boot_grub_setupdev", value_boot_grub_setupdev) self.Set( "boot_grub_map", grub_map ) return value_boot_grub_loaddev def get_boot_devicemap(self): '''Заполнить переменную boot_devicemap''' g_grubmap = self.Get('boot_grub_map') grubkeys = g_grubmap.keys() grubkeys.sort() devmap = "" for dev in grubkeys: devmap+="%s /dev/%s\n" % (dev, g_grubmap[dev]) # заполняем переменную boot_devicemap_old псевдовручную self._objValue__value = devmap.strip() self.Get('boot_devicemap_old') return devmap.strip() def get_boot_devicemap_old(self): # псевдо заполнение, реализуется следующая логика # объект при попытке его заполнить сразу ставит себе # флаг, что он заполнен в ручную и не обновляется # в последсвии, а значение он получает от первого # заполнения boot_devicemap, в котором есть принудительный # вызов заполнения self._objValue__wasSet = True return self.Get('boot_devicemap') def get_boot_grub_another(self): ''' Считаем меню граба grub.conf для переноса настроек boot_grub_another ''' if self.Get('sys_load')!='ram': grub="/boot/grub/grub.conf" if os.path.exists(grub): f=open(grub,"rb") fstr=f.readlines() f.close() config="" record="" skip=None for line in fstr: if re.search('^\s*title[\s|=]+',line): if record and not skip: config+=record record=line skip=0 else: if re.search('[^\s]', line) and record: sstr="^\s*kernel .*root=\/dev\/%s" %\ self.Get('setup_installdev') if self.Get('setup_installdev') and\ re.search(sstr,line): skip+=1 record+=line if record and not skip: config+=record return config else: oldmarch=self._runos("%s uname -m"%self.G_path) curos=None if self.Get('sys_current_ver'): curos=self.Get('sys_current_ver') val ="\ntitle %s %s %s\n" %\ (self.Get('setup_os_current'),\ curos,\ oldmarch.strip()) val+="root (%s,%s)\n" %\ (self.Get('boot_grub_loaddev'),\ self.Get('boot_grub_loadnum')) val+="kernel /boot/vmlinuz root=/dev/%s%s" %\ (self.Get('load_dev'),\ self.Get('load_num')) return val def get_setup_set_mbr(self): '''Установлена ли mbr setup_set_mbr ?????? ''' return False #if not Get('setup_set_mbr'): # Set('setup_set_mbr',True,True) #else: # Set('setup_set_mbr',False,True) def get_sys_swap_dev(self): ''' Определим раздел свопа sys_swap_dev ''' res = self._runos('%s tail -n 1 /proc/swaps' % self.G_path) if res: return re.search('^\/dev\/([^\s]+)',res).group(1) if self.Get('install_dev'): scm='LANG=C fdisk -l /dev/%s 2>&1 | grep "Linux swap"' %\ (self.Get('install_dev')) res=self._runos(scm) if res: val=re.search('^\/dev\/([^\s]+)',res) if val: return val.group(1) def set_sys_swap_dev(self, value): '''Если переменная задана с /dev - удаляем эту приставку к пути''' res=re.search('^\/dev\/(.+)$',value) if res: val=res.group(1) return val else: return value def get_sys_swap_line(self): '''Заполнить переменную sys_swap_line''' return '/dev/%s\tnone\t\tswap\tsw\t\t\t0 0'%self.Get('sys_swap_dev') @classmethod def getdisk_fstab(cls, lines, param, value_sys_swap_dev): '''Вернуть список переносимых путей при монтировании''' mount_dev=[] mount_dir=[] mount_line=[] sch1='^\s*(\/dev\/[^\s]+)\s+([^\s]+)\s+([^\s]+)\s+\ ([^\s]+)\s+([0-9])\s+([0-9])\s*$' sch2='^\s*([A-Za-z0-9\.]+:[^\s]+)\s+([^\s]+)\s+\ ([^\s]+)\s+([^\s]+)\s+([0-9])\s+ ([0-9])\s*$' sch3='^\s*(\/[^\s]+)\s+(\/[^\s]+)\s+([^\s]+)\s+\ (bind)\s+([0-9])\s+([0-9])\s*$' for line in lines: if re.search('^\s*#',line): continue res=re.search(sch1,line) if not res: res=re.search(sch2,line) if not res: res=re.search(sch3,line) if res: vals=res.groups() if vals[0]=='/dev/%s%s'%(param['load_dev'],\ param['load_num']): continue if vals[0]=='/dev/%s%s'%(param['install_dev'],\ param['install_num']): continue res2=re.search('%s'%value_sys_swap_dev,vals[0]) if res2: continue res2=re.search('^\/dev\/loop[0-9]$',vals[0]) if res2: continue mount_dev.append(vals[0]) mount_dir.append(vals[1]) val3=" ".join(vals[2:]) mount_line.append(val3) return [mount_dev,mount_dir,mount_line] @classmethod def commonsysmount(cls, value_setup_installdev, value_sys_loaddev, \ value_sys_swap_dev ): if os.path.exists('/etc/fstab'): f=open('/etc/fstab',"rb") lines=f.readlines() f.close() g_install_dev, g_install_num = \ cls.splitdev2devnum(value_setup_installdev) g_load_dev, g_load_num = \ cls.splitdev2devnum(value_sys_loaddev) param_t={'load_dev':g_load_dev, 'install_dev':g_install_dev, 'load_num':g_load_num, 'install_num':g_install_num} res = cls.getdisk_fstab(lines, param_t, value_sys_swap_dev) return res def get_sys_mount_dev(self): '''Заполнить переменную sys_mount_dev, а также sys_path_mounts, sys_mount_line''' res = fillVars.commonsysmount( self.Get('setup_installdev'), self.Get('sys_loaddev'), self.Get('sys_swap_dev')) if res: if len(res[0])>0: self.Set('sys_path_mounts', res[1]) self.Set('sys_mount_line', res[2]) return res[0] self.Set('sys_path_mounts', "") self.Set('sys_mount_line', "") return "" def get_sys_path_mounts(self): '''Заполнить переменную sys_mount_dev, а также sys_path_mounts, sys_mount_line''' res = fillVars.commonsysmount( self.Get('setup_installdev'), self.Get('sys_loaddev'), self.Get('sys_swap_dev')) if res: if len(res[0])>0: self.Set('sys_mount_dev',res[0]) self.Set('sys_mount_line', res[2]) return res[1] self.Set('sys_mount_dev',"") self.Set('sys_mount_line', "") return "" def get_sys_mount_line(self): '''Заполнить переменную sys_mount_dev, а также sys_path_mounts, sys_mount_line''' res = fillVars.commonsysmount( self.Get('setup_installdev'), self.Get('sys_loaddev'), self.Get('sys_swap_dev')) if res: if len(res[0])>0: self.Set('sys_mount_dev',res[0]) self.Set('sys_path_mounts', res[1]) return res[2] self.Set('sys_mount_dev',"") self.Set('sys_path_mounts', "") return "" def get_setup_linuxpkg(self): '''Определим версию последнего доступного образа системы, собираемого образа''' # TODO: образы системы будут находится в другом месте if os.path.exists("%s/share/linux"%(self.G_shr_path)) and\ self.Get('sys_load')!='ram': find="(%s\-.*\-%s\.tar\.lzma)" %\ (self.Get('setup_sys_shortname').lower(),\ self.Get('setup_march')) scm=self.G_path+" find -L %s/share/linux"%(self.G_shr_path) f_res=self._runos(scm) if not isinstance(f_res, types.ListType): f_res=[f_res] retres = None for i in f_res: res=re.search('(%s)'%find, i.strip()) if res: retres = res.groups()[0] return retres elif self.Get('sys_load')=='ram' and os.path.exists('/mnt/livecd'): self.Set('setup_linux_ver',self.Get('sys_current_ver')) return "livecd" def get_setup_linux_ver(self): ver = self.Get('setup_linuxpkg') if ver == "livecd": return self.Get('sys_current_ver') if ver: val=re.search('\-([\d\.]+)\-.*',ver) if val: return val.group(1) def get_setup_iso_name(self): return "%s-%s-%s.iso" % (self.Get('setup_sys_shortname').lower(), self.Get('setup_linux_ver'), self.Get('setup_march')) def get_setup_path_patch(self): '''Получить путь с списку патчей''' if self.Get('sys_current_ver'): if os.path.exists(self.G_rshr_path): return self.G_rshr_path+"/patch" def get_sys_patchlast(self): value_get_setup_patches = self.Get('setup_patches') if value_get_setup_patches == None: return None else: dcalculate=self.Get('setup_sys_shortname') dlinuxver=self.Get('setup_linux_ver') fstr="^%s\-%s\-([0-9]+)$"%(dcalculate,dlinuxver) recomp = re.compile(fstr) patchlast = 0 for i in value_get_setup_patches: res = recomp.search(i) if not res: continue val = int(res.groups()[0]) if patchlast < val: patchlast = val return patchlast def get_setup_patches(self): g_patches = None rdir = os.listdir(self.Get('setup_path_patch')) value_sys_patchcur = self.Get('sys_patchcur') if self.Get('sys_patchlast'): value_sys_patchlast = self.Get('sys_patchlast') else: value_sys_patchlast = None if g_patches is None: g_patches = [] patchlast = value_sys_patchlast if not patchlast: patchlast = 0 dcalculate=self.Get('setup_sys_shortname') dlinuxver=self.Get('setup_linux_ver') for i in rdir: fstr='^%s\-%s\-([0-9]+)$'%(dcalculate, dlinuxver) res=re.search(fstr, i) if not res: continue val=int(res.groups()[0]) if not value_sys_patchcur: value_sys_patchcur = 0 if val > int(value_sys_patchcur): g_patches.append(i) if patchlast < val: patchlast = val value_sys_patchlast self.Set('sys_patchlast', value_sys_patchlast) return g_patches def get_setup_path_linuxpkg(self): '''Получить путь к архивам систем''' return "%s/share/linux"%(self.G_rshr_path) def get_setup_path_tmp(self): '''Определить директорию временных файлов setup_path_tmp ''' return '/tmp/calculate' def get_setup_makeopts(self): '''Определить makeopts setup_makeopts ''' if int(self.Get('hrd_cpu_num'))==1: makecpu = 1 else: makecpu = int(self.Get('hrd_cpu_num'))+1 return "-j%s"%makecpu def get_setup_path_portage(self): '''Определить каталог portage setup_path_portage ''' if os.path.exists('/usr/calculate/portage'): return "/usr/calculate/portage" def get_setup_path_distfiles(self): '''Определить каталог distfiles setup_path_distfiles ''' if os.path.exists('/usr/calculate/distfiles'): return "/usr/calculate/distfiles" def get_setup_path_pkg(self): '''Определить каталог pkg setup_path_pkg ''' pkgpath="/usr/calculate/packages/%s/%s/%s"%\ (self.Get('setup_sys_shortname'),\ self.Get('setup_linux_ver'),\ self.Get('setup_march')) if os.path.exists(pkgpath): return pkgpath def get_cmd_run_emerge1(self): '''Команда emerge с указанием OVERLAY и MAKEOPTS cmd_run_emerge1 ''' if self.Get('setup_path_portage'): return 'PORTDIR_OVERLAY="%s" MAKEOPTS="%s"'%\ (self.Get('setup_path_portage'),\ self.Get('setup_makeopts')) def get_cmd_run_emerge2(self): '''cmd_run_emerge''' return "" # от flGlobal #packages=(G_inst_path+"/builder/packages",\ #self.G_shr_path+"/builder/packages") #Set('setup_path_constpkg',packages,True) @classmethod def getProfileList(cls, path, Get): _ex=os.path.exists profPath=path if not os.path.exists(profPath): return "" else: Prof_gr1=[] Prof_gr2='' Prof_gr3='' listProf=cl_utils.getdirlist(profPath) #создадим список профилей в порядке их наложения #профили 1*, сборки и для имени хоста ver=Get('setup_dist_ver') re_ver="|".join(ver.keys()) i=0 for i in xrange(len(listProf)): el=listProf[i] if re.search('^[0-9]+[^\.]\w+',el): listProf[i]='' Prof_gr1.append(profPath+el) elif re.search('^(%s)$'%re_ver,el): if el==Get('setup_sys_shortname'): Prof_gr2=profPath+el listProf[i]='' elif re.search(\ '^[0-9]{,3}\.[0-9]{,3}\.[0-9]{,3}\.[0-9]{,3}$',el): if Get('net_hosts_allow').split('/')[0]==el: Prof_gr3=profPath+el listProf[i]='' i+=1 #профили для DNS зоны sdn=Get('sys_domain').split(".") sdn.reverse() Prof_gr4=[] i=0 for i in xrange(len(sdn)): if i==0: el=sdn[i] else: el=sdn[i]+"."+el j=0 if el in listProf: Prof_gr4.append(profPath+el) listProf.remove(el) #профиль для ip компьютера pcip=str(Get('net_host')) if pcip in listProf: Prof_gr4.append(profPath+pcip) listProf.remove(pcip) #компонуем профили Prof_gr1.sort() if Prof_gr2: Prof_gr1+=[Prof_gr2] if len(Prof_gr4)>0: Prof_gr1+=Prof_gr4 if Prof_gr3: Prof_gr1+=[Prof_gr3] if len(Prof_gr1)>0: return Prof_gr1 else: return "" #def get_setup_path_profuser(self): #''' Определим профили установки или сборки''' #prof=fillVars.getProfileList('/usr/calculate/profile/install/', #self.Get) #if prof: #return prof def get_setup_path_profinst(self): '''Определим профили установки''' prof=fillVars.getProfileList('/usr/lib/calculate-install/profile', self.Get) if prof: return prof class CLError(Exception): def __init__(self, value): self.value=value def __str__(self): return repr(self.msg+self.value) class VarNameError(CLError): msg="Incorrect name of a variable: " class VarValueError(CLError): msg="Incorrect value of a variable: " class DataVars: 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')) sys.path.insert(0,os.path.abspath('/home/okovalenko/Home/Calculate\ /pvars')) __modlist={'Global':'cl_vars', 'Server':'cl_vars_server', 'Builder':'cl_vars_builder'} def __init__(self, modsname='Global'): '''Загрузка указанной конфигурации переменных. Параметры: modname - имя конфигурации (Global,Server,Builder) Если в модуле конфигурации переменных будет неправильно указана одна из переменных, то конфигурация сбрасывается и объект не будет содержать ни одной переменной окружения. ''' self.__implist=[] self.__varslist={} # хранит словарь близки по отошению к модулю # конфигурации self.__typelist=() self.flVars = fillVars(self) # проверка правильно указанного имени конфигурации переменных окружения if type(modsname) == types.StringType: modsname = [modsname] for modname in modsname: if modname and self.__modlist.has_key(modname): self.initializemodules(modname) else: print _("Unsupported module vars") + ": %s"%(modname) sys.exit(0) def initializemodules(self, modname): '''Инициализация переменных DataVars, переменными из файла модуля содержащего описание переменных''' if modname in self.__implist: return self.__implist.append(modname) modname=self.__modlist[modname] # импортирем модуль с переменными окружения exec ("import %s" % (modname)) #создаем экземпляр импортированного модуля exec ("obj=%s.Data" %(modname)) #проходимся по переменным класса и готовим объект for idnt in obj.__dict__: #отбрасываем служебные переменные if re.search("\__.*",idnt): continue #получаем значение переменной exec("vals=obj.%s"%idnt) #если значение переменной некорректно то убиваем все окружение #и вываливаемся с пустым объектом if self.__checkVarsValue(vals)==False: msg='The variable: %s in the module: %s is incorrectly\ described' % (idnt, modname) raise CLError(msg) del(self) return # получаем тип значений по умолчанию (проверяем, чтобы # это была либо словарь либо список в противном случае # тип является не заданным if vals.has_key('value'): if isinstance(vals['value'], types.ListType) or\ isinstance(vals['value'], types.DictType): vtype=type(vals['value']) else: vtype=None else: vtype=None #добавляем имя переменной в общий список self.__varslist[idnt]={} # переносим атрибуты переменной в общий список, при этом # исключаем значение по умолчанию for p,val in vals.items(): if p=='value': continue self.__varslist[idnt][p]=val # заместо значение по умолчанию устанавливаем атрибут тип # переменной self.__varslist[idnt]['vtype']=vtype if 'get_'+idnt in fillVars.__dict__: vals['Getself'] = getattr(fillVars,'get_'+idnt) if 'set_'+idnt in fillVars.__dict__: vals['Setself'] = getattr(fillVars,'set_'+idnt) vals['Get'] = self.Get vals['SetIndirect'] = self.__IndirectFilling #оформляем значение переменной в виде объекта objparam=objValue(**vals) #инициализируем переменную exec ("""self.%s=objparam"""%(idnt)) #проверить импортируемое значение def __checkVarsValue(self, pvar): ''' Проверить атрибут на допустмость содержания''' if pvar is None: return False #обязательные значения полей для переменной # содержимое переменно словарь if not isinstance(pvar, types.DictType): return False # в словаре присутствуют атрибуты mode, type if not pvar.has_key('mode') or not pvar.has_key('type'): return False # mode, type заданы if pvar['mode']==None or pvar['type']==None: return False # содержимое mode допусткает r или w if pvar['mode'].upper() not in ['R','W']: return False return True def __IndirectFilling(self,vname,val): '''Функция необходима для вызова функции непрямого заполнения (когда при заполнении одной переменной происходит заполнение другой переменной)''' # если запрошенная переменная не найдена поднимаем исключение # "ошибка имени переменной" if not self.__varslist.has_key(vname): raise VarNameError(vname) # получаем текущую переменную в виде объекта valobj=getattr(self, vname)#.__getVarValue(vname, True) # если получить переменную не удалось - возврат провал if valobj is False: return False # если среди типов переменных bool, то в случае пустого значения # устанавливается значение False if 'bool' in valobj.v_type: if val is None: val=False valobj.indirectfilling(val) # возвращаем "успех" return True def Set(self, vname, val, force=False): '''Установить значение переменной окружения Параметры: vname имя переменной val значение переменной force принудительная установка переменной на случай если установлен режим только для чтения. ''' self.__addVarValue(vname, val, force) def Get(self, vname, objformat=None): '''Получить значение переменной окружения Параметры: vname имя получаемой переменной окружения objformat если указан, то будет возвращено не значение переменной, а объект, содержащий полную информацию о переменной окружения. Возвращаемые значения: Значение или объект запрашиваемой переменной окружения. В случае неудачи возвращает False ''' return self.__getVarValue(vname, objformat) def __getCurrentHeaderName(self): '''Получить рабочую секцию ини файла.''' if 'Server' in self.__implist: return 'calculate-server' elif 'Builder' in self.__implist: return 'calculate-builder' elif 'Install' in self.__implist: return 'calculate-install' else: return 'default' def __writeVarValue(self, vname, val): '''Записать значение в calculate.ini Параметры: vname имя переменной val значение переменной Возвращаемые значение: True запись успешна False запись не удалсь ''' # получаем полный путь до файла ini name_calculate_ini = os.path.join(self.Get('setup_path_install'), self.Get('sys_calculate_ini')) # извлекаем из полного имени файла путь 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) header = self.__getCurrentHeaderName() return config.setVar(header,{vname: cl_utils.convertStrListDict(val)}) def Write(self, vname, val, force=False): '''Установить и записать значение переменной в ini файл Параметры: vname имя переменной val значение переменной force "принудительный режим" ''' if self.__addVarValue(vname, val, force): self.__writeVarValue(vname, val) return True return False def flIniFile(self): '''Заместить значение переменных значениями из ини файла Возвращаемые значения: True переменные считаны False файл не был обнаружен ''' calculate_ini = [] # получаем полный путь до удаленного файла ini calculate_ini.append(os.path.join('/', self.Get('sys_calculate_ini_remote'))) # получаем полный путь до локального файла ini calculate_ini.append(os.path.join('/', self.Get('sys_calculate_ini_local'))) # получаем полный путь до файла ini calculate_ini.append(os.path.join('/', self.Get('sys_calculate_ini'))) for name_calculate_ini in calculate_ini: # проверить сущестование ini файла if os.path.exists(name_calculate_ini): # получить объект настроенный на ini config = iniParser(name_calculate_ini) # получить все переменные из рабочей секции allvars = config.getAreaVars(self.__getCurrentHeaderName()) if allvars == False: return False # принудительно переписать все переменные окружения # полученные из ini for (k,v) in allvars.items(): self.Set(k, cl_utils.convertStrListDict(v), True) return True def flServer(self, **args): '''Заполнить конфигурацию переменных, для ldap''' # заполнить переменные окружения алгоритмом по умолнанию self.addVars("Server") def flBuilder(self, **args): '''Заполнить конфигурацию переменных, для билдера''' self.Set('setup_pass','builder',True) # заполнить переменные окружения алгоритмом по умолнанию self.addVars("Builder") def flInstall(self, **args): '''Заполнить конфигурацию переменных для инсталятора''' self.Set('setup_pass','install',True) def flFromCmdParam(self, s ): '''Заполнить переменные окружения посредством параметра командной строки. Параметры: s строка вида <параметра>=<значение>[:<пар>=<знач>] Возвращаемые значения: True строка правильная и все параметры установлены False строка неправильная или запрошены на установку параметры "только для чтения" ''' # заполнить полученную конфигурацию парметрами из командной строки dict = {} # разбирать входящую строку с параметрами и устанавливить в словарь # (проверка на корректный синтаксис) for par in s.split(':'): try: parts = par.split('=') # проверить, что бы части состояли из 2 частей if len(parts) != 2: return False key, value = parts # проверить что бы все параметры были доступны для записи if 'r' in self.Get(key,True).v_mode: return False dict[key] = value except VarNameError: return False # установить параметры for (k,v) in dict.items(): if self.Set(k,v) == False: return False return True def isRewrite(self, vname): '''Доступна ли переменная для изменения Параметры: vname имя переменной Возвращаемые занчения: True переменная доступна для перезаписи Flase переменная не доступна для перезаписи ''' mode=self.Get(vname,True).v_mode if mode=='w': return True else: return False #Получить значение переменной в чистом виде или в виде объекта def __getVarValue(self, vname, objformat=None, printval=None): '''Получить значение переменной в чистом виде или в виде объекта. Параметры: vname имя переменной окружения objformat флаг "вернуть в виде объекта" printval флаг "вернуть значение для печати" Возвращаемые значения: Значение переменной/ значение в виде объекта. В случае если переменная неинициализирована и возврат осуществляется в виде значение вернется False ''' if not vname in self.__varslist.keys(): raise VarNameError(vname) try: #если переменная уже инициализирована exec ("val=self.%s"%(vname)) # если нужно вернуть значение if objformat is None: # если нужно вернуть выводимое значение if printval: return val.v_printval return val.v_value else: return val except: #если переменная не инициализирована if objformat: #если режим возврата в виде объекта par=self.__varslist[vname] objpar=par #objpar['value']=None if 'get_'+vname in fillVars.__dict__: objpar['Getself'] = getattr(fillVars,'get_'+vname) if 'set_'+vname in fillVars.__dict__: objpar['Setself'] = getattr(fillVars,'set_'+vname) objpar['Get'] = self.Get objpar['Set'] = self.__IndirectFilling obj=objValue(**objpar) if obj: return obj return False #установить значение переменной #не даем переписывать значения переменной у которых режим "r" #но можно перезаписать в режиме force=True def __addVarValue(self, vname, val, force=False, printval=None): '''Установить значение переменной, не давать переписывать значение переменной у которых режим 'r'(только для чтения), если не включен принудительный режим Параметры: vname имя переменной окружения val устанавливаемое значение переменной force принудительный режим, при True можно изменить пременные "только для чтения" printval если нужно изменить значение для вывода Возвращаемые значения: True значение установлено False значение не установлено (провал) ''' # если запрошенная переменная не найдена поднимаем исключение # "ошибка имени переменной" if not self.__varslist.has_key(vname): raise VarNameError(vname) # получаем текущую переменную в виде объекта valobj=self.__getVarValue(vname, True) # если получить переменную не удалось - возврат провал if valobj is False: return False # если переменная "только для чтения" и не включен принудительный режим # вывести предупреждающее сообщение и вернуть провал if valobj.v_mode=="r" and force==False: print "Attempt to rewrite a variable for reading: %s"%vname return False # если тип значений поддерживаемых для этой переменной не совпадает # с устанавливаемым, то поднимаем исключение "ошибка значения" # тип None означает, что поддерживается любой тип if self.__varslist[vname]['vtype']: if type(val)!=self.__varslist[vname]['vtype']: raise VarValueError(vname) # если среди типов переменных bool, то в случае пустого значения # устанавливается значение False if 'bool' in valobj.v_type: if val is None: val=False # если меняем значение для печати if printval: valobj.v_printval=val # если меняем значение переменной else: valobj.v_value=val # устанавливаем новое значение для переменной окружения exec("self.%s=valobj"%(vname)) # возвращаем "успех" return True def __checkType(self, tvar, tcheck): '''Проверить входит ли тип в указанный список типов Параметры: tvar сравниваемый список tcheck проверяемый список Возвращаемые значение: True Успех False Провал ''' # для сравнения используем объект множество и сравниваем пересечения return set(tcheck) == set(tcheck).intersection(tvar) # lvar=len(tcheck) # flag=0 # for i in tvar: # if i in tcheck: # flag+=1 # if flag !=lvar: # return False # return True # Вернуть список переменных # type_names - список типов, переменные которых необходимо вернуть def getVars(self, type_names=None): '''Получить список переменных всех, или указанного типа Параметры: type_names список типов переменных для указания фильтра Возвращаемые параметры: Словарь с переменными. ''' ret={} for i in self.__varslist.keys(): try: val=None exec ("val=self.%s"%i) if type_names: if not self.__checkType(val.v_type,type_names): continue ret[i]=val except: param=self.__varslist[i] # TODO: must test, was reconstructed vals = {} if 'get_'+i in fillVars.__dict__: vals['Getself'] = getattr(fillVars,'get_'+i) if 'set_'+i in fillVars.__dict__: vals['Setself'] = getattr(fillVars,'set_'+i) vals['Get'] = self.Get vals['Set'] = self.__IndirectFilling nobj=objValue(v_mode=param['mode'],v_type=param['type'],v_value=None, **vals) if type_names: if not self.__checkType(val.v_type,type_names): continue ret[i]=nobj 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.v_type))>mlen_type: mlen_type=len(str(j.v_type)) vtype=str(type(var[i].v_value)).split(" ")[1][1] if not '[' in var[i].v_mode: if vtype in ['d','l']: mode="[%s%s]"%(var[i].v_mode.lower(),vtype) else: mode="[%s]"%(var[i].v_mode.lower()) var[i].v_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("-",mlen_type) + " " +\ cl_utils.fillstr("-",10) print "The list of variables:" print "var name".center(mlen_name),\ "Mode",\ "Type".center(mlen_type),\ "Value" print br for i in plist: if var[i].v_value is None and var[i].v_printval is None: continue elif var[i].v_printval is None: p_val=var[i].v_value else: p_val=var[i].v_printval if var[i].v_official: continue cl_utils.columnWrite( i, mlen_name, var[i].v_mode.lower(), mlen_mode, str(var[i].v_type), mlen_type, p_val) print br def addVars(self, objvars, force=False): '''Добавить к списку переменных переменные из модуля. Параметры: objvars "Server", "Global", "Builder" ''' self.initializemodules( objvars ) def defined(self, vname): if vname: if self.__dict__.has_key(vname): return True return False #вернуть список переменных с параметрами def getVarsList(self): vlist=self.__varslist.keys() vlist.sort() return vlist ##############################################################################