diff --git a/pym/cl_base.py b/pym/cl_base.py index 5d40667..a59d93d 100644 --- a/pym/cl_base.py +++ b/pym/cl_base.py @@ -163,6 +163,10 @@ class lang: 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. @@ -190,9 +194,12 @@ class lang: la.append(self.__l) if gettext.find(nameDomain,self.__catalog,la): """Если найден словарь то инициализируем переводчик""" - transl = gettext.translation(nameDomain, - self.__catalog,la) - module._ = transl.gettext + transl = gettext.translation(nameDomain\ + ,self.__catalog,la) + + transl.__utf8Translate =\ + lang.__utf8Translate.__get__(transl) + module._ = transl.__utf8Translate #module._ = transl.ugettext ret = 1 else: @@ -228,6 +235,7 @@ tr = lang() tr.setLocalDomain('cl_lib') tr.setLanguage(sys.modules[__name__]) ############################################################################## + import cl_profile class iniParser(cl_profile._error): """Класс для работы с ini файлами @@ -391,173 +399,333 @@ class opt: pass ############################################################################### -class fillVars: + +class objValue(object): + '''Объект "Переменная окружения"''' 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 + # значение переменной окружения + __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): + def _runos(self,cmd,ret_first=None): return cl_utils.runOsCommand(cmd, None, ret_first) - 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 + 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: - return None + 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: - return None + print _('not attribute') - #вернуть список переносимых путей при монтировании - 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] +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 +#Заполнения переменных для 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} - #--------------------------------------------------------------------- + def get_hrd_pc_vendor(self): + '''Получим производителя PC''' if os.path.exists('/sys/class/dmi/id/chassis_vendor'): - vendor=cm('%s cat /sys/class/dmi/id/chassis_vendor' % self.G_path) + 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' - Set('hrd_pc_vendor',vendor,True) + return vendor + + def get_hrd_laptop_vendor(self): + '''Получим производителя ноутбука''' + cm = self._runos 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) + s= self._runos( + '%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' %\ + 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) - 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} - #---------------------------------------------------------------------- + + 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') @@ -565,52 +733,36 @@ class fillVars: if cards: video=cards[0] if re.search('GeForce',video) or \ - re.search('nVidia',video): + re.search('nVidia',video): if re.search('\[([^\]]+)\]',video): model="nVidia "+re.search('\[([^\]]+)\]',video).groups()[0] - Set('hrd_video_name',model,True) + return model elif re.search('(GeForce.+) nForce',video): model="nVidia" model+=re.search('(GeForce.+) nForce',video).groups()[0] - Set('hrd_video_name',model,True) + return model 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) + return "nVidia GeForce" elif re.search('Intel', video): - res=re.search("Intel Corporation ([^\s]+)\s") + res=re.search("Intel Corporation ([^\s]+)\s", video) if res: - model="Intel "+res.groups()[0] + return "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) + return "Intel" 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} - #--------------------------------------------------------------------- + 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 not Get('hrd_video_res') and os.path.exists(xlog): + if os.path.exists(xlog): f=open(xlog, "rb") sf=f.read() f.close() @@ -618,112 +770,102 @@ class fillVars: if re.search(fstr, sf): res=re.search(fstr, sf).groups() resol=res[0]+"x"+res[1] - Set('hrd_video_res',resol,True) + return resol 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) + return res[0] 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) + return res[0] 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) + 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('Hewlett-Packard',val): - Set('hrd_usb_hp', True, True) - elif re.search('Bluetooth', val): - Set('hrd_usb_bluetooth', True, True) + 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' + else: + return '/' #***************************************************************************** #Заполнение переменных для 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 \ + 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" - 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) - - #---------------------------------------------------------------------- - # Команда создания учетных записей пользователей - #---------------------------------------------------------------------- + + 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" + print _("Error opening file") + ": passwd" try: f=open('/etc/group') GROUP=f.readlines() f.close() except: - print "Error opening file: group" + print _("Error opening file") + ": group" if PASSWD: uval="" for pline in PASSWD: @@ -752,19 +894,10 @@ http://distro.ibiblio.org/pub/linux/distributions/gentoo" 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) + return uval - #--------------------------------------------------------------------- - # Сформируем хэш конвертации устаревшего формата hda на sda - #--------------------------------------------------------------------- + def get_setup_ata(self): + '''Сформировать хэш конвертации устаревшего формата hda на sda''' dev_list=cl_devices.block_dev() disks={'removable':[],'sata':[],'ata':[]} for dev in dev_list.get_listdev(): @@ -799,514 +932,612 @@ http://distro.ibiblio.org/pub/linux/distributions/gentoo" val=re.search('sd([a-z])',sata).groups()[0] sata='sd'+(chr(ord(val)+1)) ata[i]=sata - Set('setup_ata',ata,True) + 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 #***************************************************************************** - 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=%s"%(Get('soft_ldap_root')),True) - #-------------------------------------------------------------------- - # DN всех сервисов - #-------------------------------------------------------------------- - Set("soft_ldap_sevices_dn","ou=%s,%s"\ - %(Get('soft_ldap_sevices_dn_name'),Get('soft_ldap_base')), - 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',"calculate",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_admin_tmp', "cn=ldaproot,%s"%Get('soft_ldap_base'),\ - True) - Set('soft_ldap_adminpw_tmp',cl_utils.genpassword().strip(),True) + @classmethod + def gethashfrom_slappasswd(cls,value_G_path,value_password, \ + value_encrypt): cstr='%s slappasswd -s %s -h %s'%\ - (self.G_path,\ - Get('soft_ldap_adminpw_tmp'),\ - Get('soft_ldap_hash_encrypt') - ) - res=cm(cstr) + (value_G_path, value_password, value_encrypt) + res=cls.__runos(cstr) if res: - Set('soft_ldap_adminpw_tmp_hash',res.strip(),True) - #постоянный пользователь root, прописываемый в базу при первой загрузке - #с одновременным удалением временного root-а - Set('soft_ldap_adminname',"ldapadmin",True) - Set('soft_ldap_admin',"cn=%s,%s"%\ - (Get('soft_ldap_adminname'),\ - Get('soft_ldap_base')\ - ),True) + 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 = '/usr/calculate/profile/server' + if os.path.exists(profpath): + return [profpath] + + def get_soft_samba_domain(self): + return "CDS" + + 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_services_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(self): + '''Заполнение переменной soft_ldap_adminpw + постоянный пользователь root, прописываемый в базу при первой загрузке + с одновременным удалением временного root-а + ''' 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) + res=self._runos(cstr) rs=re.search('[^=]+="(.+)"',res.strip()) if rs: - Set('soft_ldap_adminpw',rs.group(1),True) - if not Get('soft_ldap_adminpw') or\ - Get('soft_ldap_adminpw')=="secret": - Set('soft_ldap_adminpw',cl_utils.genpassword().strip(),True) - cstr='%s slappasswd -s %s -h %s'%\ - (self.G_path,\ - Get('soft_ldap_adminpw'),\ - Get('soft_ldap_hash_encrypt')\ - ) - res=cm(cstr) - if res: - Set('soft_ldap_adminpw_hash',res.strip(),True) - - #Cервис Unix - self.__fillServiceDN('Unix', - 'soft_ldap_admin_unix_name', - 'soft_ldap_admin_unix', - 'soft_ldap_admin_unixpw', - 'soft_ldap_admin_unixpw_hash') - #Cервис Samba - self.__fillServiceDN('Samba', - 'soft_ldap_admin_samba_name', - 'soft_ldap_admin_samba', - 'soft_ldap_admin_sambapw', - 'soft_ldap_admin_sambapw_hash') - #Cервис Mail - self.__fillServiceDN('Mail', - 'soft_ldap_admin_mail_name', - 'soft_ldap_admin_mail', - 'soft_ldap_admin_mailpw', - 'soft_ldap_admin_mailpw_hash') - - #Cервис Jabber - self.__fillServiceDN('Jabber', - 'soft_ldap_admin_jabber_name', - 'soft_ldap_admin_jabber', - 'soft_ldap_admin_jabberpw', - 'soft_ldap_admin_jabberpw_hash') - - - - def __fillServiceDN(self, dnName, varName, varDN, varPwd, varPwdHash): - """Заполняет переменные сервиса - - dnName - название сервиса в LDAP (Unix,Samba и.т. д) - varName - переменная сервиса в LDAP (Unix,Samba и.т. д) - varService - переменная (полный DN cервиса) - varPwd - переменная пароль сервиса - varPwdHash - переменная хеш пароля сервиса - На вход подаем название сервиса, DN сервиса относительно DN сервисов и - соответствующие названия переменных и они заполняются - нужными значениями - """ - obj=self._objvar - if not obj: - return False - #сокращенные имена для вызовов - cm=self.__runos - Get=obj.Get - Set=obj.Set - Set(varName, dnName, True) - Set(varDN, "ou=%s,%s" %(dnName,Get('soft_ldap_sevices_dn')), - True) - Set(varPwd,cl_utils.genpassword().strip(),True) - cstr='%s slappasswd -s %s -h %s'%\ - (self.G_path,\ - Get(varPwd),\ - Get('soft_ldap_hash_encrypt') - ) - res=cm(cstr) - if res: - Set(varPwdHash,res.strip(),True) + if rs.group(1) != "secret": + return rs.group(1) + else: + 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 fillGlobal(self): - obj=self._objvar - cm=self.__runos - Get=obj.Get - Set=obj.Set - getini=self.__getini - #получим путь для выполнения команд + 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: - Set('setup_path_env',self.G_path,True) + return self.G_path 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 + print _("Not found path for execute commands") sys.exit(0) - #********************************************** - #checkerrors - #********************************************** - g_install_dev="" - g_install_num="" - if Get('setup_installdev') and\ - re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev')): + + 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() - 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" + self.g_install_dev=vals[0] + self.g_install_num=vals[1] + return vals[0]+vals[1] + else: + print _("Incorrect partition") sys.exit(0) - #--------------------------------------------------------------------- - # Проверим id пользователя, запустившего скрипт - #--------------------------------------------------------------------- + + def isroot(self): + '''Проверим пользователь, запустивший скрипт - root''' if os.getegid()!=0: - print "Only root can perform system installation" + 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) + 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=cm('%scat %s | grep "Welcome to "'%\ - (self.G_path,\ - path)) + 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() - 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) + 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: - Set('sys_linux_type','desktop',True) + return "desktop" - #--------------------------------------------------------------------- - #одетектим устройства - self.__fillHardware() - #--------------------------------------------------------------------- - Set('setup_name',self.G_calcname+" "+Get('setup_ver'),True) - #--------------------------------------------------------------------- - # Выполним проверки доступности необходимых программ и определим пути - # exec_host, exec_nmap - #--------------------------------------------------------------------- + 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() - Set('cmd_exec_host',res[0].rstrip(),True) + 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() - 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) + 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: - 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 + 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=(\"%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'))): + 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'%Get('sys_domain'),port) + 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 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) + 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=cm('%s cat /etc/issue | grep "Welcome to "'%self.G_path) + res=cls.__runos('%s cat /etc/issue | grep "Welcome to "'% + cls.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) + 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]: - 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) + return "Calculate" + return par[0] + if os.path.exists('/etc/gentoo-release'): + return "Gentoo Linux" 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) - - #--------------------------------------------------------------------- - # Определим диск, с которого загружена система - #--------------------------------------------------------------------- + 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: - res=re_res.group(1) - break - g_load_dev="" - g_load_num="" + 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) @@ -1314,97 +1545,96 @@ http://distro.ibiblio.org/pub/linux/distributions/gentoo" 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) - + 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 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) + 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')] - #--------------------------------------------------------------------- - # Хэш доступных grub-у дисков, диск и раздел для установки в grub - #--------------------------------------------------------------------- + @classmethod + def commongrubfunc(cls, value_setup_installdev, value_sys_loaddev): + '''Общая функция для заполнения переменных grub.''' sdir="/sys/block/" ldir=cl_utils.getdirlist(sdir) grub_dev=[] @@ -1412,50 +1642,100 @@ http://distro.ibiblio.org/pub/linux/distributions/gentoo" 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) + 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={} + 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: - Set('boot_grub_setupdev','hd'+str(num),True) + value_boot_grub_setupdev = 'hd'+str(num) if g_load_dev==dev: - Set('boot_grub_loaddev','hd'+str(num),True) + value_boot_grub_loaddev = 'hd'+str(num) 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': + 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") @@ -1473,255 +1753,325 @@ http://distro.ibiblio.org/pub/linux/distributions/gentoo" else: if re.search('[^\s]', line) and record: sstr="^\s*kernel .*root=\/dev\/%s" %\ - Get('setup_installdev') - if Get('setup_installdev') and\ + 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 - Set('boot_grub_another',config,True) + return config else: - oldmarch=cm("%s uname -m"%self.G_path) + oldmarch=self._runos("%s uname -m"%self.G_path) curos=None - if Get('sys_current_ver'): - curos=Get('sys_current_ver') + if self.Get('sys_current_ver'): + curos=self.Get('sys_current_ver') val ="\ntitle %s %s %s\n" %\ - (Get('setup_os_current'),\ + (self.Get('setup_os_current'),\ curos,\ oldmarch.strip()) val+="root (%s,%s)\n" %\ - (Get('boot_grub_loaddev'),\ - Get('boot_grub_loadnum')) + (self.Get('boot_grub_loaddev'),\ + self.Get('boot_grub_loadnum')) val+="kernel /boot/vmlinuz root=/dev/%s%s" %\ - (Get('load_dev'),\ - Get('load_num')) - Set('boot_grub_another',val,True) + (self.Get('load_dev'),\ + self.Get('load_num')) + return val - 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'): + 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"' %\ - (Get('install_dev')) - res=cm(scm) + (self.Get('install_dev')) + res=self._runos(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) + 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() - 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) + 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 - #--------------------------------------------------------------------- - # Определим версию последнего доступного образа системы, либо версию - # собираемого образа, имя файла с образом, имя 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) + 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: - 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_rshr_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_rshr_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) + 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 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 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 fillFromCmdParam(self,s): - '''Заполнить переменные окружения посредством параметра командной - строки. - Параметры: - s строка вида <параметра>=<значение>[:<пар>=<знач>] + 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" - Возвращаемые значения: - True строка правильная и все параметры установлены - False строка неправильная или запрошены на установку параметры - "только для чтения" + 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_path_install(self): + '''Определить директорию установки setup_path_install ''' + return "/mnt/install" + + def get_setup_makeopts(self): + '''Определить makeopts + setup_makeopts ''' - dict = {} - # разбирать входящую строку с параметрами и устанавливить в словарь - # (проверка на корректный синтаксис) - for par in s.split(':'): - try: - parts = par.split('=') - # проверить, что бы части состояли из 2 частей - if len(parts) != 2: - return False - key, value = parts - # проверить что бы все параметры были доступны для записи - if 'r' in self._objvar.Get(key,True).v_mode: - return False - dict[key] = value - except VarNameError: - return False - - # установить параметры - for (k,v) in dict.items(): - if self._objvar.Set(k,v) == False: - return False - return True - - - def getProfileList(self, path): - obj=self._objvar - Get=obj.Get - Set=obj.Set + 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): @@ -1783,6 +2133,19 @@ http://distro.ibiblio.org/pub/linux/distributions/gentoo" 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): @@ -1797,42 +2160,6 @@ class VarNameError(CLError): 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: @@ -1852,7 +2179,7 @@ class DataVars: 'Server':'cl_vars_server', 'Builder':'cl_vars_builder'} - def __init__(self, modname='Global'): + def __init__(self, modsname='Global'): '''Загрузка указанной конфигурации переменных. Параметры: @@ -1866,57 +2193,76 @@ class DataVars: self.__varslist={} # хранит словарь близки по отошению к модулю # конфигурации self.__typelist=() + self.flVars = fillVars(self) # проверка правильно указанного имени конфигурации переменных окружения - 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 + 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 + 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 - #добавляем имя переменной в общий список - 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) + 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): @@ -1938,6 +2284,28 @@ class DataVars: 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): '''Установить значение переменной окружения @@ -2015,26 +2383,6 @@ class DataVars: return True return False - def flServer(self, **args): - '''Заполнить конфигурацию переменных, используемую для настройки - сервера. - ''' - self.Set('setup_sys_shortname','CDS',True) - # заполнить переменные окружения алгоритмом по умолнанию - self.flGlobal() - # проверить не заполнялись ли переменные "серверным" алгоритмом - if 'Server' in self.__implist: - return - # в список загруженных переменных добавить значение Server - self.__implist.append('Server') - # получить конфигурацию переменных окружения Server - objvar=DataVars("Server") - # объединить конфигурацию по умолчанию с конфигурацией для сервера - self.joinVars(objvar) - #print objvar.getVarsList() - # заполнить полученную конфигурацию алгоритмом для сервера - fillVars(self).fillLDAP(**args) - def flIniFile(self,**args): '''Заместить значение переменных значениями из ини файла @@ -2060,45 +2408,15 @@ class DataVars: else: return False - def flGlobal(self,**args): - '''Заполнить конфигурацию переменные, по общему алгоритму''' - # проверить не заполнялись ли переменные общим алгоритмом - if 'Global' in self.__implist: - return - # в список загруженных переменных добавить значение Global - 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 - # в список загруженных переменных добавить значение Global - self.__implist.append('Builder') - # получить конфигурацию переменных окружения Builder - objvar=DataVars("Builder") - # объединить конфигурацию по умолчанию с конфигурацией для сервера - self.joinVars(objvar) - # заполнить полученную конфигурацию алгоритмом для билдера - fillVars(self).fillBuilder(**args) + self.addVars("Builder") def flInstall(self, **args): '''Заполнить конфигурацию переменных для инсталятора''' self.Set('setup_pass','install',True) - # заполнить переменные окружения алгоритмом по умолнанию - self.flGlobal() - # проверить не заполнялись ли переменные "инсталляционным" алгоритмом - if 'Install' in self.__implist: - return - # в список загруженных переменных добавить значение Install - self.__implist.append('Install') - # заполнить полученную конфигурацию алгоритмом для инсталлятора - fillVars(self).fillInstall(**args) def flFromCmdParam(self, s ): '''Заполнить переменные окружения посредством параметра командной @@ -2113,7 +2431,28 @@ class DataVars: "только для чтения" ''' # заполнить полученную конфигурацию парметрами из командной строки - return fillVars(self).fillFromCmdParam(s) + 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): '''Доступна ли переменная для изменения @@ -2165,6 +2504,13 @@ class DataVars: 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 @@ -2269,7 +2615,16 @@ class DataVars: ret[i]=val except: param=self.__varslist[i] - nobj=objValue(param['mode'],param['type'], None) + # 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 @@ -2289,10 +2644,11 @@ class DataVars: 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()) + 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) @@ -2323,24 +2679,13 @@ class DataVars: mlen_mode, str(var[i].v_type), mlen_type, p_val) print br - #объеденить два объекта с переменными - 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() and 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 addVars(self, objvars, force=False): + '''Добавить к списку переменных переменные из модуля. + + Параметры: + objvars "Server", "Global", "Builder" + ''' + self.initializemodules( objvars ) def defined(self, vname): if vname: