#-*- 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 ############################################################################## _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 возвращает полученное значение без изменеsmfprjadnwний""" 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 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.getopt() 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() 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 fillVars: G_shr_path="/usr/calculate" G_path=cl_utils.getpathenv() G_calcname="Calculate" def __init__(self, objvar=None): if objvar: self._objvar=objvar #Вернуть результат выполнения команды ОС def __runos(self,cmd,ret_first=None): res=None res=os.popen(cmd).readlines() if res: if len(res)>1: if ret_first: return res[0] return res else: return res[0].strip() def __getinifile(self,fname,def_sect): s=ConfigParser.ConfigParser() try: s.read(fname) return s except ConfigParser.MissingSectionHeaderError: f=open(fname,"rb") s.add_section(def_sect) for i in f.readlines(): t=i.strip().split('=',1) if len(t)==1: s.set(def_sect,t[0],None) elif len(t)>=2: s.set(def_sect,t[0],t[1]) else: print 'Error parsing ini file' return s def __getini(self, param): inipath="/etc/calculate/calculate.ini" if os.path.exists(inipath): def_sect='default' par=self.__getinifile(inipath,def_sect) if par: res={} for i in par.options(def_sect): res[i]=par.get(def_sect, i) if res: if res.has_key(param): return res[param] else: return None else: return None else: return None #вернуть список переносимых путей при монтировании def __getdisk_fstab(self, obj, lines, param): g_load_dev=param['load_dev'] g_install_dev=param['install_dev'] Get=obj.Get 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'%Get('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] #***************************************************************************** #Заполнение переменных для Hardware #***************************************************************************** def __fillHardware(self): obj=self._objvar cm=self.__runos Get=obj.Get Set=obj.Set #--------------------------------------------------------------------- # Получим производителя оборудования # $data{vendor}, $data{laptop}, $data{laptop_model} # $data{board_model}, $data{board_vendor} #--------------------------------------------------------------------- if os.path.exists('/sys/class/dmi/id/chassis_vendor'): vendor=cm('%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' Set('hrd_pc_vendor',vendor,True) if os.path.exists('/sys/class/dmi/id/board_name'): s=cm('%s cat /sys/class/dmi/id/board_name | grep "Portable PC"' % \ self.G_path) if s: Set('hrd_laptop_vendor',s.lower,True) s=cm('%s cat /sys/class/dmi/id/product_name' % self.G_path) if s: Set('hrd_laptop_model',s,True) elif os.path.exists('/sys/class/dmi/id/board_vendor'): if os.path.exists('/sys/class/dmi/id/board_name'): bmodel=cm('%s cat /sys/class/dmi/id/board_name' %\ self.G_path) else: bmodel='' bvendor=cm('%s cat /sys/class/dmi/id/board_vendor' %\ self.G_path) Set('hrd_board_model',bmodel, True) Set('hrd_board_vendor',bvendor, True) #---------------------------------------------------------------------- # Получим архитектуру процессора, файл stage, маску нестабильных файлов # $data{march}, $data{stage}, $data{unmask} #---------------------------------------------------------------------- march=cm('%s uname -m' % self.G_path) if Get('setup_march') and (Get('setup_march')!=march): Set('dif_march',True,True) elif not Get('setup_march'): Set('setup_march',march,True) march=Get('setup_march') if march=='i686': Set('setup_unmask',"~x86",True) elif march=='x86_64': Set('setup_unmask',"~amd64",True) #---------------------------------------------------------------------- # Определим кодичество процессоров # $data{cpus} #---------------------------------------------------------------------- if not Get('hrd_cpu_num'): 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 Set('hrd_cpu_num',cpucnt) #---------------------------------------------------------------------- # Определим видеоадаптер # $data{video}, $data{video_drv} #---------------------------------------------------------------------- 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] Set('hrd_video_name',model,True) elif re.search('(GeForce.+) nForce',video): model="nVidia" model+=re.search('(GeForce.+) nForce',video).groups()[0] Set('hrd_video_name',model,True) else: Set('hrd_video_name',"nVidia GeForce",True) video=Get('hrd_video_name') if video not in nvdrv: if not Get('hrd_video_drv'): Set('hrd_video_drv','nvidia',True) if not Get('hrd_opengl_set'): Set('hrd_opengl_set','nvidia',True) else: if not Get('hrd_video_drv'): Set('hrd_video_drv','vesa',True) elif re.search('Intel', video): res=re.search("Intel Corporation ([^\s]+)\s") if res: model="Intel "+res.groups()[0] else: model="Intel" if not Get('hrd_video_drv'): Set('hrd_video_drv','i810',True) if not Get('hrd_opengl_set'): Set('hrd_opengl_set','xorg-x11',True) elif re.search('VMware', video): if not Get('hrd_video_drv'): Set('hrd_video_drv','vmware',True) else: if not Get('hrd_video_drv'): Set('hrd_video_drv','vesa',True) if Get('hrd_opengl_set') and not Get('cmd_run_opengl'): val="/usr/bin/eselect opengl set %s"%(Get('hrd_opengl_set')) Set('cmd_run_opengl',val,True) #--------------------------------------------------------------------- # Определим разрешение экрана # $data{resolution} #--------------------------------------------------------------------- xlog = "/var/log/Xorg.0.log" def_res = "1024x768" if not Get('hrd_video_res') and 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] Set('hrd_video_res',resol,True) elif re.search('Setting mode \"([0-9\@x]+)\"',sf): res=re.search('Setting mode \"([0-9\@x]+)\"',sf).groups() Set('hrd_video_res',res[0],True) elif re.search('Virtual size is ([0-9\@x]+) ',sf): res=re.search('Virtual size is ([0-9\@x]+) ',sf).groups() Set('hrd_video_res',res[0],True) elif re.search('Modeline "([0-9\@x]+)"',sf): res=re.search('Modeline "([0-9\@x]+)"',sf).groups() Set('hrd_video_res',res[0],True) else: Set('hrd_video_res',def_res,True) if not Get('hrd_video_res'): Set('hrd_video_res',def_res,True) #---------------------------------------------------------------------- # Определим USB устройства # $data{usb_*} #---------------------------------------------------------------------- res=cm('%s lsusb 2>/dev/null' % self.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('Hewlett-Packard',val): Set('hrd_usb_hp', True, True) elif re.search('Bluetooth', val): Set('hrd_usb_bluetooth', True, True) #***************************************************************************** #Заполнение переменных для Builder #***************************************************************************** def fillBuilder(self): obj=self._objvar cm=self.__runos Get=obj.Get Set=obj.Set getini=self.__getini G_path=Get('setup_path_env') Set('setup_path_install',"/mnt/builder",True) #Set('setup_pass','builder',True) #---------------------------------------------------------------------- # Определим ссылки на исходники программ #---------------------------------------------------------------------- if not Get('setup_gentoo_mirrors'): val="http://mirror.yandex.ru/gentoo-distfiles \ http://distfiles.gentoo.org \ http://distro.ibiblio.org/pub/linux/distributions/gentoo" Set('setup_gentoo_mirrors',val,True) #--------------------------------------------------------------------- # Версию портежей #--------------------------------------------------------------------- if not Get('setup_gentoo_release'): Set('setup_gentoo_release',"2007.0",True) #--------------------------------------------------------------------- # Определим наличие stage, portage #--------------------------------------------------------------------- if not Get('setup_path_portagepkg'): portagepath="/usr/calculate/snapshots/" if not os.path.exists(portagepath): cm(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: Set('setup_path_portagepkg', "%sportage-%s.tar.bz2"%\ (portagepath,last),True) #---------------------------------------------------------------------- # путь к stages #---------------------------------------------------------------------- if not Get('setup_path_stagepkg'): march=Get('setup_march') stagepath="/usr/calculate/stages/" if march=='i686': val="stage3-i686-%s.tar.bz2"%s(Get('setup_gentoo_release')) if os.path.exists(stagepath+val): Set('setup_path_stagepkg',stagepath+val,True) elif march=='x86_64': val="stage3-amd64-%s.tar.bz2" %(Get('setup_gentoo_release')) if os.path.exists(stagepath+val): Set('setup_path_stagepkg',stagepath+val,True) #---------------------------------------------------------------------- # Команда создания учетных записей пользователей #---------------------------------------------------------------------- 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 Set('setup_run_user',uval,True) #--------------------------------------------------------------------- # Определим запущенные сервисы 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) #--------------------------------------------------------------------- # Сформируем хэш конвертации устаревшего формата 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 Set('setup_ata',ata,True) #***************************************************************************** #Заполнение переменных для LDAP #***************************************************************************** def fillLDAP(self): obj=self._objvar if not obj: return False #сокращенные имена для вызовов cm=self.__runos Get=obj.Get Set=obj.Set getini=self.__getini prinst=['/usr/lib/calculate/calculate-server/profile'] pruser=['/usr/calculate/profile/server'] if not os.path.exists(prinst[0]): prinst='' if not os.path.exists(pruser[0]): pruser='' Set('setup_path_install','/',True) Set('setup_path_profinstall',\ prinst,True) Set('setup_path_profuser',\ pruser,True) #переменные необходимые для работы g_hostname=Get('net_host') g_domain=Get('sys_domain') #-------------------------------------------------------------------- # Настройки PDC #-------------------------------------------------------------------- Set('soft_samba_domain',"CDS",True) Set('soft_samba_netbios',"PDC-CDS",True) #---------------------------------------------------------------------- # Определим путь к LDAP-записям пользователей #---------------------------------------------------------------------- #базовый суффикс Set('soft_ldap_base',"dc=CDS",True) #алгоритм шифрования паролей Set('soft_ldap_hash_encrypt',"{SSHA}",True) #пользовательский доступ к базе с доступом только для чтения Set('soft_ldap_bindname',"proxyuser",True) Set('soft_ldap_bind',"cn=%s,%s"%\ (Get('soft_ldap_bindname'),\ Get('soft_ldap_base'))\ ,True) Set('soft_ldap_bindpw',"CDS",True) val="%s slappasswd -s %s -h %s"%\ (self.G_path,\ Get('soft_ldap_bindpw'),\ Get('soft_ldap_hash_encrypt')) res=cm(val) if res: Set('soft_ldap_bindpw_hash',res,True) #временный пользователь root для инициализации базы данных Set('soft_ldap_root_tmp', "cn=ldaproot,%s"%Get('soft_ldap_base'),\ True) Set('soft_ldap_rootpw_tmp',cl_utils.genpassword().strip(),True) cstr='%s slappasswd -s %s -h %s'%\ (self.G_path,\ Get('soft_ldap_rootpw_tmp'),\ Get('soft_ldap_hash_encrypt') ) res=cm(cstr) if res: Set('soft_ldap_rootpw_tmp_hash',res.strip(),True) #постоянный пользователь root, прописываемый в базу при первой загрузке #с одновременным удалением временного root-а Set('soft_ldap_rootname',"ldapadmin",True) Set('soft_ldap_root',"cn=%s,%s"%\ (Get('soft_ldap_rootname'),\ Get('soft_ldap_base')\ ),True) if os.path.exists('/etc/smbldap-tools/smbldap_bind.conf'): cstr='%s cat /etc/smbldap-tools/smbldap_bind.conf | grep masterPw'\ % self.G_path res=cm(cstr) rs=re.search('[^=]+="(.+)',res.strip()) if rs: Set('soft_ldap_rootpw',rs.group(1),True) if not Get('soft_ldap_rootpw') or\ Get('soft_ldap_rootpw')=='secret': Set('soft_ldap_rootpw',cl_utils.genpassword().strip(),True) cstr='%s slappasswd -s %s -h %s'%\ (self.G_path,\ Get('soft_ldap_rootpw'),\ Get('soft_ldap_hash_encrypt')\ ) res=cm(cstr) if res: Set('soft_ldap_rootpw_hash',res.strip(),True) #***************************************************************************** #Заполнение глобальных переменных #***************************************************************************** def fillGlobal(self): obj=self._objvar cm=self.__runos Get=obj.Get Set=obj.Set getini=self.__getini #получим путь для выполнения команд if self.G_path: Set('setup_path_env',self.G_path,True) else: print "Not found path for execute commands" sys.exit(0) if not os.path.exists(self.G_shr_path): print "Not found Calculate dir: %s"%self.G_shr_path sys.exit(0) #********************************************** #checkerrors #********************************************** g_install_dev="" g_install_num="" if Get('setup_installdev') and\ re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev')): val=re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev')) if val: vals=val.groups() g_install_dev=vals[0] g_install_num=vals[1] Set('setup_installdev',vals[0]+vals[1],True) if Get('setup_installdev') and\ (not g_install_dev or\ not g_install_num or\ not os.path.exists('/dev/%s%s'%\ (g_install_dev,\ g_install_num))): print "Incorrect partition" sys.exit(0) #--------------------------------------------------------------------- # Проверим id пользователя, запустившего скрипт #--------------------------------------------------------------------- if os.getegid()!=0: print "Only root can perform system installation" sys.exit(0) if Get('setup_sys_shortname'): sh_name=Get('setup_sys_shortname') ver=Get('setup_dist_ver') if ver.has_key(sh_name.upper()): Set('setup_sys_fullname',ver[sh_name.upper()],True) if not Get('setup_sys_shortname'): #Set('setup_pass','install',True) path='/etc/issue' #если файл с версией системы найден, определим версию sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)""" res=cm('%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=Get('setup_dist_ver') for i in ver.keys(): if ver[i]==issuename: Set('setup_sys_shortname',i,True) Set('setup_sys_fullname',ver[i],True) break #если имя не определено, но оно новое и мы его уже #передали параметром --configure if not Get('setup_sys_shortname'): Set('setup_sys_fullname',issuename,True) spl=issuename.split(" ") nname="" if len(spl)>1: for i in spl: nname+=i[1] Set('setup_sys_shortname',nname,True) else: Set('setup_sys_shortname',issuename,True) #устанавливаемая или собираемая система по умолчанию if not Get('setup_sys_shortname'): Set('setup_sys_shortname',"CLD",True) val=Get('setup_dist_ver')['CLD'] Set('setup_sys_fullname',val,True) #---------------------------------------------------------------------- # Получим тип системы #---------------------------------------------------------------------- if re.search('server',Get('setup_sys_fullname')): Set('sys_linux_type','server',True) else: Set('sys_linux_type','desktop',True) #--------------------------------------------------------------------- #одетектим устройства self.__fillHardware() #--------------------------------------------------------------------- Set('setup_name',self.G_calcname+" "+Get('setup_ver'),True) #--------------------------------------------------------------------- # Выполним проверки доступности необходимых программ и определим пути # exec_host, exec_nmap #--------------------------------------------------------------------- if not os.system("which host >/dev/null 2>&1"): res=os.popen("which host").readlines() Set('cmd_exec_host',res[0].rstrip(),True) if not os.system("which nmap >/dev/null 2>&1"): res=os.popen("which nmap").readlines() Set('cmd_exec_nmap',res[0].rstrip(),True) #--------------------------------------------------------------------- # Установим значение переменной в ram, в случае если установка профиля # производится в оперативную память (настройка сеанса CDROM), а также # load - носитель в значение ram в случае загрузки с CD/DVD #--------------------------------------------------------------------- Set('sys_load',"", True) if cm("""mount | grep "/dev/loop/0 on / type" """): Set('sys_load',"ram", True) #--------------------------------------------------------------------- # Считаем имя компьютера #--------------------------------------------------------------------- if Get('net_host') is None: hostname=cm("""%s hostname -s 2>&1"""%self.G_path) Set('net_host',hostname, True) #упрощенный вариант, следует выполнять только если не указан домен #в системе if re.search("^hostname: ",hostname): hostname=cm("""%s hostname 2>&1"""%self.G_path) if re.search("^hostname: ",hostname): Set('net_host',Get('setup_sys_shortname'), True) else: if hostname=='livecd': Set('net_host',Get('setup_sys_shortname'), True) #---------------------------------------------------------------------- # Определим домен #---------------------------------------------------------------------- if not Get('sys_domain'): domain=cm("%s hostname -d 2>&1"%self.G_path) Set('sys_domain',domain, True) if re.search("^hostname: ",domain): Set('sys_domain',"local", True) #---------------------------------------------------------------------- # Определим сетевые настройки: # шлюз, локальные интерфейсы, локальные сети, настройки #/etc/conf.d/net, # сетевые устройства #---------------------------------------------------------------------- if not Get('net_gw'): Set('net_conf',"",True) Set('net_hosts_allow',"",True) Set('net_networks',"",True) route=cm("""%sroute -n | grep "^0.0.0.0" """%self.G_path) route=re.split("\s+",route) if route: Set('net_gw', route[1],True) Set('net_gw_dev', route[7],True) 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==Get('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 Get('net_gw_dev') and gateway_dhcp==0: netconf+="\nroutes_%s=(\"default gw %s\" )"%\ (Get('net_gw_dev'), Get('net_gw')) n_key=nets.keys() n_key.sort() if n_key: Set('net_lan',n_key[0],True) tval=Get('net_networks') Set('net_networks',tval+networks,True) tval=Get('net_hosts_allow') Set('net_hosts_allow',tval+host_allow,True) tval=Get('net_conf') Set('net_conf',tval+netconf,True) #--------------------------------------------------------------------- # Определим сетевые сервисы #--------------------------------------------------------------------- #определим прокси-сервер if Get('cmd_exec_host') and\ Get('sys_domain') and\ cm('%s proxy.%s | grep "has address"'%\ (Get('cmd_exec_host'), \ Get('sys_domain'))): ports=[3128,8080] for port in ports: sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM) arg_addr=('proxy.%s'%Get('sys_domain'),port) if sock.connect_ex(arg_addr)==0: if not Get('net_proxy'): Set('net_proxy','proxy.%s'%Get('sys_domain'),True) if not Get('net_proxy_port'): Set('net_proxy_port',str(port),True) if not Get('net_proxy_url'): val="http://%s:%s"%\ (Get('net_proxy'),\ Get('net_proxy_port')) Set('net_proxy_url',val,True) #определим наличие сетевой файловой системы sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM) if Get('cmd_exec_host') and\ not Get('net_nfs') and\ Get('sys_domain') and\ cm('%s nfs.%s | grep "has address"'%\ (Get('cmd_exec_host'),\ Get('sys_domain'))) and\ sock.connect_ex(('nfs.%s'%Get('sys_domain'),2049))==0: Set('net_nfs','nfs.%s'%Get('sys_domain'),True) #определим наличие локального сервера времени if not Get('net_ntp'): if Get('cmd_exec_host') and\ Get('sys_domain') and\ cm('%s ntp.%s | grep "has address"'%\ (Get('cmd_exec_host'),\ Get('sys_domain'))): Set('net_ntp','ntp.%s'%Get('sys_domain'),True) else: Set('net_ntp','ntp0.zenon.net',True) #--------------------------------------------------------------------- # Определим наличие сервера CDS #--------------------------------------------------------------------- if not Get('net_cds'): if Get('sys_domain'): Set('net_cds','cds.%s'%Get('sys_domain'),True) else: Set('net_cds','cds',True) #--------------------------------------------------------------------- # Получим версию обновляемой, наличие обновлений, название # устанавливаемой системы #--------------------------------------------------------------------- sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)""" if os.path.exists('/etc/issue'): cline=""" """ res=cm('%s cat /etc/issue | grep "Welcome to "'%self.G_path) if res: par=re.search(sp,res).groups() Set('setup_os_current',par[0],True) res_n=par[1].split("-") patch="" osn="" if len(res_n)>1: patch=res_n[1] Set('sys_patchcur',patch,True) Set('sys_current_ver',res_n[0],True) if not par[0]: Set('setup_os_current','Calculate',True) if par[1]: Set('setup_ospatchsplit',"-",True) elif os.path.exists('/etc/gentoo-release'): Set('setup_os_current',"Gentoo Linux",True) else: Set('setup_os_current',"Old Linux",True) #--------------------------------------------------------------------- # Заголовок изменённых файлов #--------------------------------------------------------------------- #Changed by installator if not Get('setup_mestitle'): val='# Изменено %s %s' % (self.G_calcname, Get('setup_ver')) Set('setup_mestitle',val,True) if not Get('setup_mesline'): val="#------------------------------------------------------------\ ------------------" Set('setup_mesline',val,True) #--------------------------------------------------------------------- # Определим диск, с которого загружена система #--------------------------------------------------------------------- for record in open('/proc/cmdline','rb').readlines(): re_res=re.search('^root=\/dev\/([a-z]+[0-9]).*',record.strip()) if re_res: res=re_res.group(1) break g_load_dev="" g_load_num="" 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] #--------------------------------------------------------------------- # Определим диск и номер раздела для установки #--------------------------------------------------------------------- #выберем альтернативный диск для установки if not Get('setup_installdev') and\ getini('install.from'): res=getini('install.from') Set('setup_installdev',res,True) val=re.search('^([a-z]+)([0-9]+)$',res) if val: vals=val.groups() g_install_dev=vals[0] g_install_num=vals[1] elif not Get('setup_installdev') and\ not g_install_dev and\ not g_install_num and\ g_load_dev: g_install_dev=g_load_dev if int(g_load_num)==2: g_install_num=3 elif int(g_load_num)==3: g_install_num=2 Set('setup_installdev',g_install_dev+\ str(g_install_num),True) #проверим на существование диска if not os.path.exists("/dev/%s"%Get('setup_installdev')): print "Incorrect partition" sys.exit(0) #--------------------------------------------------------------------- # Выберем доступную утилиту форматирования #--------------------------------------------------------------------- if not Get('setup_formatfs'): #попытаемся подмонтировать, чтобы получить информацию о #файловом формате format="" cstr="%s mkdir -p %s" % (self.G_path, Get('setup_path_install')) cm(cstr) cstr="%s mount /dev/%s%s %s &>/dev/null"\ % (self.G_path,\ g_install_dev,\ g_install_num,\ Get('setup_path_install')) if not os.system(cstr): cstr="%s mount | grep /dev/%s%s"\ %(self.G_path,\ g_install_dev,\ g_install_num) format=cm(cstr,True) cstr="%s umount %s"%(self.G_path, Get('setup_path_install')) os.system(cstr) else: cstr="%s rmdir %s"%(self.G_path, Get('setup_path_install')) os.system(cstr) if format: fs=None if re.search(' reiserfs ',format.strip()): fs='reiserfs' elif re.search(' xfs ',format.strip()): fs='xfs' elif re.search(' ext3 ',format.strip()): fs='ext3' elif re.search(' ext2 ',format.strip()): fs='ext2' Set('setup_formatfs',fs,True) formatrun={"reiserfs":'"/sbin/mkfs.reiserfs -f"',\ "xfs":"/sbin/mkfs.xfs -f",\ "ext3":"/sbin/mkfs.ext3",\ "ext2":"/sbin/mkfs.ext2"} if Get('setup_formatfs') in formatrun.keys() and\ os.path.exists("/sbin/mkfs.%s"%(Get('setup_formatfs'))): val=formatrun[Get('setup_formatfs')] Set('cmd_run_format',val,True) else: if os.path.exists('/sbin/mkfs.reiserfs'): Set('setup_formatfs','reiserfs',True) elif os.path.exists('/sbin/mkfs.xfs'): Set('setup_formatfs','xfs',True) elif os.path.exists('/sbin/mkfs.ext3'): Set('setup_formatfs','ext3',True) elif os.path.exists('/sbin/mkfs.ext2'): Set('setup_formatfs','ext2',True) else: print "Formatting utility not found" sys.exit(0) #--------------------------------------------------------------------- # Хэш доступных grub-у дисков, диск и раздел для установки в 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" %(self.G_path,\ sdir,\ dev) val=cm(cstr) if val: if int(val[0].strip())==0: grub_dev.append(dev.strip()) grub_dev.sort() num=0 grub_map={} for dev in grub_dev: grub_map['hd'+str(num)]=dev if g_install_dev==dev: Set('boot_grub_setupdev','hd'+str(num),True) if g_load_dev==dev: Set('boot_grub_loaddev','hd'+str(num),True) num+=1 g_grub_map=grub_map if g_install_num: install_num=int(g_install_num)-1 Set('boot_grub_setupnum',str(install_num),True) if g_load_num: load_num=int(g_load_num)-1 Set('boot_grub_loadnum',load_num,True) Set('boot_grub_map',g_grub_map,True) #--------------------------------------------------------------------- # Диски файла devicemap для grub-а #--------------------------------------------------------------------- if not Get('boot_devicemap'): grubmap=g_grub_map grubkeys=grubmap.keys() grubkeys.sort() devmap="" for dev in grubkeys: devmap+="%s /dev/%s\n" % (dev, grubmap[dev]) Set('boot_devicemap',devmap.strip(),True) #Скопируем карту устройств для установки граба. Новая карта на libata #может отличаться Set('boot_devicemap_old',Get('boot_devicemap'),True) #-------------------------------------------------------------------- # Считаем меню граба grub.conf для переноса настроек #-------------------------------------------------------------------- if 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" %\ Get('setup_installdev') if Get('setup_installdev') and\ re.search(sstr,line): skip+=1 record+=line if record and not skip: config+=record Set('boot_grub_another',config,True) else: oldmarch=cm("%s uname -m"%self.G_path) curos=None if Get('sys_current_ver'): curos=Get('sys_current_ver') val ="\ntitle %s %s %s\n" %\ (Get('setup_os_current'),\ curos,\ oldmarch.strip()) val+="root (%s,%s)\n" %\ (Get('boot_grub_loaddev'),\ Get('boot_grub_loadnum')) val+="kernel /boot/vmlinuz root=/dev/%s%s" %\ (Get('load_dev'),\ Get('load_num')) Set('boot_grub_another',val,True) if not Get('setup_set_mbr'): Set('setup_set_mbr',True,True) else: Set('setup_set_mbr',False,True) #--------------------------------------------------------------------- # Определим раздел свопа # $data{swap} #--------------------------------------------------------------------- if not Get('sys_swap_dev'): res=cm('%s tail -n 1 /proc/swaps' % self.G_path) if res: val=re.search('^\/dev\/([^\s]+)',res).group(1) Set('sys_swap_dev',val,True) elif Get('sys_swap_dev'): res=re.search('^\/dev\/(.+)$',Get('sys_swap_dev')) if res: val=res.group(1) Set('sys_swap_dev',val,True) if not Get('sys_swap_dev') and Get('install_dev'): scm='LANG=C fdisk -l /dev/%s 2>&1 | grep "Linux swap"' %\ (Get('install_dev')) res=cm(scm) if res: val=re.search('^\/dev\/([^\s]+)',res) if val: Set('sys_swap_dev',val.group(1),True) if Get('sys_swap_dev'): val='/dev/%s\tnone\t\tswap\tsw\t\t\t0 0'%(Get('sys_swap_dev')) Set('sys_swap_line',val,True) #--------------------------------------------------------------------- # С текущей системы определим дополнительные монтируемые диски # (в том числе сетевые), пути монтирования #--------------------------------------------------------------------- if os.path.exists('/etc/fstab'): f=open('/etc/fstab',"rb") lines=f.readlines() f.close() param_t={'load_dev':g_load_dev,'install_dev':g_install_dev,\ 'load_num':g_load_num,'install_num':g_install_num} res=self.__getdisk_fstab(obj, lines, param_t) if len(res[0])>0: Set('sys_mount_dev',res[0],True) Set('sys_path_mounts',res[1],True) Set('sys_mount_line',res[2],True) else: Set('sys_mount_dev',"",True) Set('sys_path_mounts',"",True) Set('sys_mount_line',"",True) #--------------------------------------------------------------------- # Определим версию последнего доступного образа системы, либо версию # собираемого образа, имя файла с образом, имя ISO-файла, который можно # собрать #--------------------------------------------------------------------- #установка системы if os.path.exists("%s/linux"%(self.G_shr_path)) and\ Get('sys_load')!='ram': find="(%s\-.*\-%s\.tar\.bz2)" %\ (Get('setup_sys_shortname').lower(),\ Get('setup_march')) scm=self.G_path+" find -L %s/linux"%(self.G_shr_path) f_res=cm(scm) if not isinstance(f_res, types.ListType): f_res=[f_res] for i in f_res: res=re.search('(%s)'%find, i.strip()) if res: ver=res.groups()[0] linux=Get('setup_linuxpkg') if not linux: Set('setup_linuxpkg',ver,True) ver=Get('setup_linuxpkg') if ver: val=re.search('\-([\d\.]+)\-.*',ver) if val: Set('setup_linux_ver',val.group(1),True) if not Get('setup_iso_name'): val="%s-%s-%s.iso" % (Get('setup_sys_shortname').lower(), Get('setup_linux_ver'), Get('setup_march')) Set('setup_iso_name',val,True) elif Get('sys_load')=='ram' and os.path.exists('/mnt/livecd'): Set('setup_linux_ver',Get('sys_current_ver'), True) Set('setup_linuxpkg','livecd', True) #--------------------------------------------------------------------- # Пути к архиву образа #--------------------------------------------------------------------- #пути к архивам систем Set('setup_path_linuxpkg',"%s/linux"%(self.G_shr_path),True) #---------------------------------------------------------------------- # Определим и проверим директорию установки, директорию временных #файлов #---------------------------------------------------------------------- if not Get('setup_path_tmp'): Set('setup_path_tmp','/tmp/calculate',True) if not Get('setup_path_install'): Set('setup_path_install',"/mnt/install",True) #---------------------------------------------------------------------- # Получим список доступных патчей #---------------------------------------------------------------------- g_patches=None if Get('sys_current_ver'): if not Get('setup_path_patch'): val=self.G_shr_path+"/patch" Set('setup_path_patch',val,True) if not Get('sys_patchlast'): Set('sys_patchlast',Get('sys_patchcur'),True) if not os.path.exists(Get('setup_path_patch')): print "Not found patch dir: %s"%(Get('setup_path_patch')) #sys.exit(0) else: rdir=os.listdir(Get('setup_path_patch')) if not g_patches: g_patches=[] patchlast=Get('sys_patchlast') if not patchlast: patchlast=0 for i in rdir: dcalculate=Get('setup_sys_shortname') dlinuxver=Get('setup_linux_ver') fstr='^%s\-%s\-([0-9]+)$'%(dcalculate, dlinuxver) res=re.search(fstr, i) if not res: continue val=int(res.groups()[0]) if not Get('sys_patchcur'): Set('sys_patchcur',0, True) if val > int(Get('sys_patchcur')): g_patches.append(i) if patchlast < val: Set('sys_patchlast',val,True) Set('setup_patches',g_patches,True) #--------------------------------------------------------------------- # Определим переменные окружения emerge и команду запуска emerge #--------------------------------------------------------------------- if not Get('setup_makeopts'): makecpu="" if int(Get('hrd_cpu_num'))==1: makecpu=1 else: makecpu=int(Get('hrd_cpu_num'))+1 Set('setup_makeopts',"-j%s"%makecpu,True) if not Get('setup_path_portage'): if os.path.exists('/usr/calculate/portage'): Set('setup_path_portage',"/usr/calculate/portage",True) if not Get('setup_path_distfiles'): if os.path.exists('/usr/calculate/distfiles'): Set('setup_path_distfiles',"/usr/calculate/distfiles",True) if not Get('setup_path_pkg'): pkgpath="/usr/calculate/packages/%s/%s/%s"%\ (Get('setup_sys_shortname'),\ Get('setup_linux_ver'),\ Get('setup_march')) if os.path.exists(pkgpath): Set('setup_path_pkg',pkgpath,True) if Get('setup_path_portage'): Set('cmd_run_emerge1','PORTDIR_OVERLAY="%s" MAKEOPTS="%s"'%\ (Get('setup_path_portage'),\ Get('setup_makeopts')),\ True) Set('cmd_run_emerge2',"",True) #---------------------------------------------------------------------- # Пути к директориям пакетов сборки #---------------------------------------------------------------------- #packages=(G_inst_path+"/builder/packages",\ #self.G_shr_path+"/builder/packages") #Set('setup_path_constpkg',packages,True) def fillInstall(self): #--------------------------------------------------------------------- # Определим профили установки или сборки #--------------------------------------------------------------------- prof=self.getProfileList('/usr/calculate/profile/install/') if prof: self._objvar.Set('setup_path_profuser',prof,True) prof=self.getProfileList('/usr/lib/calculate-install/profile/') if prof: self._objvar.Set('setup_path_profinst',prof,True) def getProfileList(self, path): obj=self._objvar Get=obj.Get Set=obj.Set _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 "" 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 objValue: v_mode="r" v_type=() v_vtype=None v_value=None v_select=None v_official=False v_printval=None def __init__(self,**args): for atname,avalue in args.items(): self.__setattr__(atname,avalue) def __getattribute__(self, instance): try: return object.__getattribute__(self, instance) except: return None def __setattr__(self, atname, value): matching={'mode' :'v_mode', 'type' :'v_type', 'vtype' :'v_vtype', 'value' :'v_value', 'select' :'v_select', 'official' :'v_official'} if matching.has_key(atname): self.__dict__[matching[atname]]=value return if not self.__class__.__dict__.has_key(atname): print 'not attribute' else: self.__dict__[atname]=value 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'} __implist=[] def __init__(self, modname='Global'): self.__varslist={} self.__typelist=() if modname and self.__modlist.has_key(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 #оформляем значение переменной в виде объекта objparam=objValue(**vals) #инициализируем переменную exec ("""self.%s=objparam"""%(idnt)) else: print "Unsupported module vars: %s"%(modname) sys.exit(0) #проверить импортируемое значение def __checkVarsValue(self, pvar): if pvar is None: return False #обязательные значения полей для переменной if not isinstance(pvar, types.DictType): return False if not pvar.has_key('mode') or not pvar.has_key('type'): return False if pvar['mode']==None or pvar['type']==None: return False if pvar['mode'].upper() not in ['R','W']: return false return True #установить значение переменной def Set(self, vname, val, force=False): self.__addVarValue(vname, val, force) #получить значение переменной def Get(self, vname, objformat=None): return self.__getVarValue(vname, objformat) def flServer(self, **args): self.Set('setup_sys_shortname','CDS',True) self.flGlobal() if 'Server' in self.__implist: return self.__implist.append('Server') objvar=DataVars("Server") self.joinVars(objvar) fillVars(self).fillLDAP(**args) def flGlobal(self,**args): if 'Global' in self.__implist: return self.__implist.append('Global') fillVars(self).fillGlobal(**args) def flBuilder(self, **args): self.Set('setup_pass','builder',True) self.flGlobal() if 'Builder' in self.__implist: return self.__implist.append('Builder') objvar=DataVars("Builder") self.joinVars(objvar) fillVars(self).fillBuilder(**args) def flInstall(self, **args): self.Set('setup_pass','install',True) self.flGlobal() fillVars(self).fillInstall(**args) def isRewrite(self, vname): mode=self.Get(vname,True).v_mode if mode=='w': return True else: return False #Получить значение переменной в чистом виде или в виде объекта def __getVarValue(self, vname, objformat=None, printval=None): 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 obj=objValue(**objpar) if obj: return obj return False #установить значение переменной #не даем переписывать значения переменной у которых режим "r" #но можно перезаписать в режиме force=True def __addVarValue(self, vname, val, force=False, printval=None): 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 if self.__varslist[vname]['vtype']: if type(val)!=self.__varslist[vname]['vtype']: raise VarValueError(vname) 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): 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): 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] nobj=objValue(param['mode'],param['type'], None) if type_names: if not self.__checkType(val.vtype,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 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() print "The list of variables:" print "var name".center(mlen_name),\ "Mode",\ "Type".center(mlen_type),\ "Value" print cl_utils.fillstr("-",mlen_name),\ cl_utils.fillstr("-",mlen_mode),\ cl_utils.fillstr("-",mlen_type),\ cl_utils.fillstr("-",10) 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 print i.ljust(mlen_name),\ var[i].v_mode.lower().ljust(mlen_mode),\ str(var[i].v_type).ljust(mlen_type),\ ":",\ p_val print cl_utils.fillstr("-",mlen_name),\ cl_utils.fillstr("-",mlen_mode),\ cl_utils.fillstr("-",mlen_type),\ cl_utils.fillstr("-",10) #объеденить два объекта с переменными def joinVars(self, objvars, force=False): #Принимаем на вход только экземпляры текущего класса if not isinstance(objvars, DataVars): raise CLError('The object of incorrect type is transferred') #Делаем копию текущего объекта и дальше работаем с копией old_self=copy.deepcopy(self) for var in objvars.__varslist.keys(): #если нет режима замещения то вываливаемся if var in old_self.__dict__.keys(): if force==False: raise CLError('Duplication of a variable: %s'% var) else: old_self.__varslist[var]=objvars.__varslist[var] val=objvars.__getVarValue(var, True) if val: old_self.__addVarValue(var,val.v_value, True) #если все успешно тогда вносим изменения self.__dict__=old_self.__dict__ 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 ##############################################################################