calculate
/
calculate-utils-2.1-lib
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8d32480d79'
${ noResults }
calculate-utils-2.1-lib/pym/cl_base.py

1927 lines
80 KiB
Raw Normal View History Unescape

git-svn-id: http://svn.calculate.ru/calculate2/calculate-lib/trunk@1 c91db197-33c1-4113-bf15-f8a5c547ca64
16 years ago
#-*- coding: utf-8 -*-
#Copyright 2008 Calculate Pack, http://www.calculate-linux.ru
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import gettext
import os
import getopt
import sys
##############################################################################
import re
import copy
import types
import string
#import os
import filecmp
import ConfigParser
import time
import socket
#import sys
import random
import string
import cl_utils
import cl_devices
##############################################################################
_expand_lang = gettext._expand_lang
def __findFileMO(domain, localedir=None, languages=None, all=0):
# Модифицинрованный метод модуля gettext ищет файл перевода
if localedir is None:
localedir = _default_localedir
if languages is None:
languages = []
for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
val = os.environ.get(envar)
if val:
languages = val.split(':')
break
if 'C' not in languages:
languages.append('C')
# now normalize and expand the languages
nelangs = []
for lang in languages:
for nelang in _expand_lang(lang):
if nelang not in nelangs:
nelangs.append(nelang)
# select a language
if all:
result = []
else:
result = None
for lang in nelangs:
if lang == 'C':
break
mofile = os.path.join(localedir, '%s_%s.mo' % (domain,lang))
if os.path.exists(mofile):
if all:
result.append(mofile)
else:
return mofile
return result
gettext.find = __findFileMO
class GlobalParam(type):
""" Метакласс для глобальных параметров
"""
def __init__(cls, *args):
cls.GP = []
cls.GP.append("")
class lang:
"""Класс многоязыковой поддержки lang для перевода сообщений программ на
другие языки.
Типичное использование:
import sys
import lang
# язык сообщений английский
tr = lang.lang(en)
# язык определяется системой
#tr = lang.lang()
#Установка домена переводаldap
# в последующем можно не использовать - задается глобально
tr.setGlobalDomain('calc')
# задается локально для одного файла
#tr.setLocalDomain('calc')
# Установка метода перевода для текущего модуля
tr.setLanguage(sys.modules[__name__])
Где:
tr -- объект перевода
'en' -- язык выводимых сообщений
sys.modules[__name__] -- модуль сообщения которого переводятся
calc - домен перевода - имя файла перевода без расширения
Если файл перевода не найден то сообщения не переводятся
Если в модуле сообщения которого переводим, экспортируются другие модули то
они тоже переводятся.
По умолчанию директория в которой находятся переводы: 'lang/i18h' относительно
исполняемого файла названия файлов перевода совпадают с названиями модулей
если не определен методом setDomainTranslate() - домен перевода.
"""
__metaclass__ = GlobalParam
def __init__(self,l=''):
self.nameDomain = self.GP[0]
#self.nameDomain = ''
""" Название файла перевода (Домен) если используется 1 файл перевода
"""
self.__catalog = os.path.abspath('/usr/share/calculate/i18n')
""" Путь к каталогу переводов (в этом каталоге
ru_RU/LC_MESSAGES в котором файл перевода)
"""
env = os.environ
if l == "" and env.has_key('LANG'):
l = env['LANG'].split('.')[0].split("_")[0]
""" Определение языка """
self.__modnames = {}
""" Словарь переведенных модулей
ключ --- имя модуля
значение --- был ли модуль переведен (1 или 0)
"""
self.__l = l
"""Язык перевода для всех модулей"""
def __translate(self,message):
"""Метод translate возвращает полученное значение без
изменеsmfprjadnwний"""
return message
def setLanguage(self,module):
""" Установка языка перевода для модуля module.
параметр --- экспортируемый модуль python
если в этом модуле экспортируются другие модули
то язык устанавливается и для них
Метод запускается после экспорта модуля который будем переводить
"""
t = vars(module)
for i in dir(module):
q = str(t[i])
if 'module' in q and not '__' in i and not '/usr/lib' in q\
and not 'built-in' in q :
mod = vars(module)[i]
self.__setLang(mod)
return self.__setLang(module)
def __setLang(self,module):
""" Установка языка перевода для модуля module.
В случае нахождения файла перевода возвращает истину.
Во всех случаях устанавливает метод перевода для модуля.
Если нет файла перевода метод перевода возвращает то же
значение что получает
"""
if module.__name__ in self.__modnames.keys():
return True
if self.nameDomain == '':
if module.__name__ == "__main__":
nameDomain = module.__file__.split('.')[0]
else:
nameDomain = module.__name__
else:
nameDomain = self.nameDomain
if self.__l == 'en':
module._ = self.__translate
ret = 1
else:
la = []
la.append(self.__l)
if gettext.find(nameDomain,self.__catalog,la):
"""Если найден словарь то инициализируем переводчик"""
transl = gettext.translation(nameDomain\
,self.__catalog,la)
module._ = transl.ugettext
ret = 1
else:
module._ = self.__translate
ret = 0
self.__modnames[module.__name__] = ret
return ret
def getTranslatorByName(self,namemodule):
""" Метод который по имени модуля определяет, был ли модуль с этим
именем переведен
"""
if self.__modnames.has_key(namemodule):
return self.__modnames[namemodule]
return 0
def setGlobalDomain(self, nameDomain):
""" Метод для установки домена перевода (глобально для всех файлов)
"""
self.GP[0] = nameDomain
self.nameDomain = self.GP[0]
return True
def setLocalDomain(self, nameDomain):
""" Метод для установки домена перевода (локально для одного файла)
"""
self.nameDomain = nameDomain
return True
##############################################################################
# Перевод модуля на другой язык
tr = lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
##############################################################################
class opt:
def __init__(self,shortOpt,longOpt = []):
""" Длинные и короткие опции командной строки допустимые в программе
a - короткая опция
>program -a
a: - короткая опциия со значением
>program -a 10
a:: - короткая опциия у которой может быть или не быть значение
>program -a
>program -a 15
"ha:" - значение параметра shortOpt
две опции h - без значения, a - со значением
help - длинная опция без значения
test= - длинная опция со значением
["help","test="] - значение парамера longOpt
>program -a
две опции help - без значения, test - со значением
"""
self.shortOpt = shortOpt
self.longOpt = longOpt
self.getopt()
self.sysArgv = sys.argv[1:]
def getopt(self):
try:
opts, args = getopt.getopt(self.sysArgv,self.shortOpt,self.longOpt)
except getopt.GetoptError:
self.handlerErrOpt()
sys.exit()
for option, value in opts:
if len(option) == 2:
option = option[1:]
else:
option = option[2:]
self.handlerOpt(option,value)
for param in args:
self.handlerParam(param)
def handlerErrOpt(self):
# Обработчик в случае неправильных параметров
pass
def handlerOpt(self,option,value):
# Обработчик (параметр значение)
pass
def handlerParam(self,param):
# Обработчик хвостов (значение)
pass
###############################################################################
class fillVars:
G_shr_path="/usr/calculate"
G_path=cl_utils.getpathenv()
G_calcname="Calculate"
def __init__(self, objvar=None):
if objvar:
self._objvar=objvar
#Вернуть результат выполнения команды ОС
def __runos(self,cmd,ret_first=None):
res=None
res=os.popen(cmd).readlines()
if res:
if len(res)>1:
if ret_first:
return res[0]
return res
else:
return res[0].strip()
def __getinifile(self,fname,def_sect):
s=ConfigParser.ConfigParser()
try:
s.read(fname)
return s
except ConfigParser.MissingSectionHeaderError:
f=open(fname,"rb")
s.add_section(def_sect)
for i in f.readlines():
t=i.strip().split('=',1)
if len(t)==1:
s.set(def_sect,t[0],None)
elif len(t)>=2:
s.set(def_sect,t[0],t[1])
else:
print 'Error parsing ini file'
return s
def __getini(self, param):
inipath="/etc/calculate/calculate.ini"
if os.path.exists(inipath):
def_sect='default'
par=self.__getinifile(inipath,def_sect)
if par:
res={}
for i in par.options(def_sect):
res[i]=par.get(def_sect, i)
if res:
if res.has_key(param):
return res[param]
else:
return None
else:
return None
else:
return None
#вернуть список переносимых путей при монтировании
def __getdisk_fstab(self, obj, lines, param):
g_load_dev=param['load_dev']
g_install_dev=param['install_dev']
Get=obj.Get
mount_dev=[]
mount_dir=[]
mount_line=[]
sch1='^\s*(\/dev\/[^\s]+)\s+([^\s]+)\s+([^\s]+)\s+\
([^\s]+)\s+([0-9])\s+([0-9])\s*$'
sch2='^\s*([A-Za-z0-9\.]+:[^\s]+)\s+([^\s]+)\s+\
([^\s]+)\s+([^\s]+)\s+([0-9])\s+ ([0-9])\s*$'
sch3='^\s*(\/[^\s]+)\s+(\/[^\s]+)\s+([^\s]+)\s+\
(bind)\s+([0-9])\s+([0-9])\s*$'
for line in lines:
if re.search('^\s*#',line):
continue
res=re.search(sch1,line)
if not res:
res=re.search(sch2,line)
if not res:
res=re.search(sch3,line)
if res:
vals=res.groups()
if vals[0]=='/dev/%s%s'%(param['load_dev'],\
param['load_num']):
continue
if vals[0]=='/dev/%s%s'%(param['install_dev'],\
param['install_num']):
continue
res2=re.search('%s'%Get('sys_swap_dev'),vals[0])
if res2:
continue
res2=re.search('^\/dev\/loop[0-9]$',vals[0])
if res2:
continue
mount_dev.append(vals[0])
mount_dir.append(vals[1])
val3=" ".join(vals[2:])
mount_line.append(val3)
return [mount_dev,mount_dir,mount_line]
#*****************************************************************************
#Заполнение переменных для Hardware
#*****************************************************************************
def __fillHardware(self):
obj=self._objvar
cm=self.__runos
Get=obj.Get
Set=obj.Set
#---------------------------------------------------------------------
# Получим производителя оборудования
# $data{vendor}, $data{laptop}, $data{laptop_model}
# $data{board_model}, $data{board_vendor}
#---------------------------------------------------------------------
if os.path.exists('/sys/class/dmi/id/chassis_vendor'):
vendor=cm('%s cat /sys/class/dmi/id/chassis_vendor' % self.G_path)
if re.search('^\s+$',vendor) or\
re.search('Chassis Manufacture',vendor):
vendor='Chassis Manufacture'
Set('hrd_pc_vendor',vendor,True)
if os.path.exists('/sys/class/dmi/id/board_name'):
s=cm('%s cat /sys/class/dmi/id/board_name | grep "Portable PC"' % \
self.G_path)
if s:
Set('hrd_laptop_vendor',s.lower,True)
s=cm('%s cat /sys/class/dmi/id/product_name' % self.G_path)
if s:
Set('hrd_laptop_model',s,True)
elif os.path.exists('/sys/class/dmi/id/board_vendor'):
if os.path.exists('/sys/class/dmi/id/board_name'):
bmodel=cm('%s cat /sys/class/dmi/id/board_name' %\
self.G_path)
else:
bmodel=''
bvendor=cm('%s cat /sys/class/dmi/id/board_vendor' %\
self.G_path)
Set('hrd_board_model',bmodel, True)
Set('hrd_board_vendor',bvendor, True)
#----------------------------------------------------------------------
# Получим архитектуру процессора, файл stage, маску нестабильных файлов
# $data{march}, $data{stage}, $data{unmask}
#----------------------------------------------------------------------
march=cm('%s uname -m' % self.G_path)
if Get('setup_march') and (Get('setup_march')!=march):
Set('dif_march',True,True)
elif not Get('setup_march'):
Set('setup_march',march,True)
march=Get('setup_march')
if march=='i686':
Set('setup_unmask',"~x86",True)
elif march=='x86_64':
Set('setup_unmask',"~amd64",True)
#----------------------------------------------------------------------
# Определим кодичество процессоров
# $data{cpus}
#----------------------------------------------------------------------
if not Get('hrd_cpu_num'):
cpucnt=0
if os.path.exists('/proc/cpuinfo'):
for record in open('/proc/cpuinfo','rb').readlines():
try:
param, pval=record.split(":")
except:
continue
if param.strip()=='processor':
cpucnt+=1
Set('hrd_cpu_num',cpucnt)
#----------------------------------------------------------------------
# Определим видеоадаптер
# $data{video}, $data{video_drv}
#----------------------------------------------------------------------
suppdrv=("nvidia", "i810", "vesa", "vmware")
nvdrv=('nVidia Aladdin TNT2','GeForce 6200','GeForce DDR',\
'GeForce2','GeForce4','Quadro2','Quadro4','RIVA TNT2','Vanta')
cards=cl_devices.Video().getcards()
if cards:
video=cards[0]
if re.search('GeForce',video) or \
re.search('nVidia',video):
if re.search('\[([^\]]+)\]',video):
model="nVidia "+re.search('\[([^\]]+)\]',video).groups()[0]
Set('hrd_video_name',model,True)
elif re.search('(GeForce.+) nForce',video):
model="nVidia"
model+=re.search('(GeForce.+) nForce',video).groups()[0]
Set('hrd_video_name',model,True)
else:
Set('hrd_video_name',"nVidia GeForce",True)
video=Get('hrd_video_name')
if video not in nvdrv:
if not Get('hrd_video_drv'):
Set('hrd_video_drv','nvidia',True)
if not Get('hrd_opengl_set'):
Set('hrd_opengl_set','nvidia',True)
else:
if not Get('hrd_video_drv'):
Set('hrd_video_drv','vesa',True)
elif re.search('Intel', video):
res=re.search("Intel Corporation ([^\s]+)\s")
if res:
model="Intel "+res.groups()[0]
else:
model="Intel"
if not Get('hrd_video_drv'):
Set('hrd_video_drv','i810',True)
if not Get('hrd_opengl_set'):
Set('hrd_opengl_set','xorg-x11',True)
elif re.search('VMware', video):
if not Get('hrd_video_drv'):
Set('hrd_video_drv','vmware',True)
else:
if not Get('hrd_video_drv'):
Set('hrd_video_drv','vesa',True)
if Get('hrd_opengl_set') and not Get('cmd_run_opengl'):
val="/usr/bin/eselect opengl set %s"%(Get('hrd_opengl_set'))
Set('cmd_run_opengl',val,True)
#---------------------------------------------------------------------
# Определим разрешение экрана
# $data{resolution}
#---------------------------------------------------------------------
xlog = "/var/log/Xorg.0.log"
def_res = "1024x768"
if not Get('hrd_video_res') and os.path.exists(xlog):
f=open(xlog, "rb")
sf=f.read()
f.close()
fstr="Virtual screen size determined to be ([0-9]+)\s*x\s*([0-9]+)"
if re.search(fstr, sf):
res=re.search(fstr, sf).groups()
resol=res[0]+"x"+res[1]
Set('hrd_video_res',resol,True)
elif re.search('Setting mode \"([0-9\@x]+)\"',sf):
res=re.search('Setting mode \"([0-9\@x]+)\"',sf).groups()
Set('hrd_video_res',res[0],True)
elif re.search('Virtual size is ([0-9\@x]+) ',sf):
res=re.search('Virtual size is ([0-9\@x]+) ',sf).groups()
Set('hrd_video_res',res[0],True)
elif re.search('Modeline "([0-9\@x]+)"',sf):
res=re.search('Modeline "([0-9\@x]+)"',sf).groups()
Set('hrd_video_res',res[0],True)
else:
Set('hrd_video_res',def_res,True)
if not Get('hrd_video_res'):
Set('hrd_video_res',def_res,True)
#----------------------------------------------------------------------
# Определим USB устройства
# $data{usb_*}
#----------------------------------------------------------------------
res=cm('%s lsusb 2>/dev/null' % self.G_path)
sstr='^Bus [0-9]+ Device [0-9]+: ID [0-9a-f]+:[0-9a-f]+ ([^\s].+)$'
if res:
for i in res:
sres=re.search(sstr,i)
if sres:
val=sres.group(1)
if re.search('Hewlett-Packard',val):
Set('hrd_usb_hp', True, True)
elif re.search('Bluetooth', val):
Set('hrd_usb_bluetooth', True, True)
#*****************************************************************************
#Заполнение переменных для Builder
#*****************************************************************************
def fillBuilder(self):
obj=self._objvar
cm=self.__runos
Get=obj.Get
Set=obj.Set
getini=self.__getini
G_path=Get('setup_path_env')
Set('setup_path_install',"/mnt/builder",True)
#Set('setup_pass','builder',True)
#----------------------------------------------------------------------
# Определим ссылки на исходники программ
#----------------------------------------------------------------------
if not Get('setup_gentoo_mirrors'):
val="http://mirror.yandex.ru/gentoo-distfiles \
http://distfiles.gentoo.org \
http://distro.ibiblio.org/pub/linux/distributions/gentoo"
Set('setup_gentoo_mirrors',val,True)
#---------------------------------------------------------------------
# Версию портежей
#---------------------------------------------------------------------
if not Get('setup_gentoo_release'):
Set('setup_gentoo_release',"2007.0",True)
#---------------------------------------------------------------------
# Определим наличие stage, portage
#---------------------------------------------------------------------
if not Get('setup_path_portagepkg'):
portagepath="/usr/calculate/snapshots/"
if not os.path.exists(portagepath):
cm(self.G_path+" mkdir "+portagepath)
else:
rdir=os.listdir(portagepath)
last=0
for i in rdir:
res=re.search('^portage\-([0-9]+)\.tar\.bz2$',i)
if not res:
continue
else:
if int(res.groups()[0])>last:
last=int(res.groups()[0])
if last:
Set('setup_path_portagepkg', "%sportage-%s.tar.bz2"%\
(portagepath,last),True)
#----------------------------------------------------------------------
# путь к stages
#----------------------------------------------------------------------
if not Get('setup_path_stagepkg'):
march=Get('setup_march')
stagepath="/usr/calculate/stages/"
if march=='i686':
val="stage3-i686-%s.tar.bz2"%s(Get('setup_gentoo_release'))
if os.path.exists(stagepath+val):
Set('setup_path_stagepkg',stagepath+val,True)
elif march=='x86_64':
val="stage3-amd64-%s.tar.bz2" %(Get('setup_gentoo_release'))
if os.path.exists(stagepath+val):
Set('setup_path_stagepkg',stagepath+val,True)
#----------------------------------------------------------------------
# Команда создания учетных записей пользователей
#----------------------------------------------------------------------
try:
f=open('/etc/passwd')
PASSWD=f.readlines()
f.close()
except:
print "Error opening file: passwd"
try:
f=open('/etc/group')
GROUP=f.readlines()
f.close()
except:
print "Error opening file: group"
if PASSWD:
uval=""
for pline in PASSWD:
user=[i.strip() for i in pline.split(":")]
#извлечем пользователей, добавленных после установки системы
if int(user[2])>=500 and\
int(user[2])<6500 and\
int(user[2])!=99:
grp=""
for gline in GROUP:
group=[i.strip() for i in gline.split(":")]
gusers=None
if group[-1]:
gusers=group[-1].split(",")
if gusers:
if user[0] in gusers:
if not grp:
grp=group[0]
else:
grp=grp+","+group[0]
groups=""
if grp:
groups="--groups "+grp
val="\n/usr/sbin/useradd --uid %s --gid %s --home-dir %s"%\
(user[2],user[3],user[5])
val+=" --shell %s %s %s" %\
(user[6], groups, user[0])
uval+=val
Set('setup_run_user',uval,True)
#---------------------------------------------------------------------
# Определим запущенные сервисы CDS
#---------------------------------------------------------------------
for i in ('ldap','mail','ftp'):
if getini("up.%s"%i)=="on":
Set('sys_set_%s'%i,True,True)
else:
Set('sys_set_%s'%i,False,True)
#---------------------------------------------------------------------
# Сформируем хэш конвертации устаревшего формата hda на sda
#---------------------------------------------------------------------
dev_list=cl_devices.block_dev()
disks={'removable':[],'sata':[],'ata':[]}
for dev in dev_list.get_listdev():
if dev_list.isremovable(dev):
val=disks['removable']
disks['removable']=val+[dev]
else:
if dev[:2]=='sd':
val=disks['sata']
disks['sata']=val+[dev]
else:
val=disks['ata']
disks['ata']=val+[dev]
sata=None
ata={}
if len(disks['ata'])>0:
devs=[]
devkey=disks['sata']; devkey.sort()
devs+=devkey
devkey=disks['ata']; devkey.sort()
devs+=devkey
devkey=disks['removable']; devkey.sort()
devs+=devkey
for i in devs:
if not sata:
sata='sda'
else:
val=re.search('sd([a-z])',i)
if val:
val=val.groups()[0]
else:
val=re.search('sd([a-z])',sata).groups()[0]
sata='sd'+(chr(ord(val)+1))
ata[i]=sata
Set('setup_ata',ata,True)
#*****************************************************************************
#Заполнение переменных для LDAP
#*****************************************************************************
def fillLDAP(self):
obj=self._objvar
if not obj:
return False
#сокращенные имена для вызовов
cm=self.__runos
Get=obj.Get
Set=obj.Set
getini=self.__getini
prinst=['/usr/lib/calculate/calculate-server/profile']
pruser=['/usr/calculate/profile/server']
if not os.path.exists(prinst[0]):
prinst=''
if not os.path.exists(pruser[0]):
pruser=''
Set('setup_path_install','/',True)
Set('setup_path_profinstall',\
prinst,True)
Set('setup_path_profuser',\
pruser,True)
#переменные необходимые для работы
g_hostname=Get('net_host')
g_domain=Get('sys_domain')
#--------------------------------------------------------------------
# Настройки PDC
#--------------------------------------------------------------------
Set('soft_samba_domain',"CDS",True)
Set('soft_samba_netbios',"PDC-CDS",True)
#----------------------------------------------------------------------
# Определим путь к LDAP-записям пользователей
#----------------------------------------------------------------------
#базовый суффикс
Set('soft_ldap_base',"dc=CDS",True)
#алгоритм шифрования паролей
Set('soft_ldap_hash_encrypt',"{SSHA}",True)
#пользовательский доступ к базе с доступом только для чтения
Set('soft_ldap_bindname',"proxyuser",True)
Set('soft_ldap_bind',"cn=%s,%s"%\
(Get('soft_ldap_bindname'),\
Get('soft_ldap_base'))\
,True)
Set('soft_ldap_bindpw',"CDS",True)
val="%s slappasswd -s %s -h %s"%\
(self.G_path,\
Get('soft_ldap_bindpw'),\
Get('soft_ldap_hash_encrypt'))
res=cm(val)
if res:
Set('soft_ldap_bindpw_hash',res,True)
#временный пользователь root для инициализации базы данных
Set('soft_ldap_root_tmp', "cn=ldaproot,%s"%Get('soft_ldap_base'),\
True)
Set('soft_ldap_rootpw_tmp',cl_utils.genpassword().strip(),True)
cstr='%s slappasswd -s %s -h %s'%\
(self.G_path,\
Get('soft_ldap_rootpw_tmp'),\
Get('soft_ldap_hash_encrypt')
)
res=cm(cstr)
if res:
Set('soft_ldap_rootpw_tmp_hash',res.strip(),True)
#постоянный пользователь root, прописываемый в базу при первой загрузке
#с одновременным удалением временного root-а
Set('soft_ldap_rootname',"ldapadmin",True)
Set('soft_ldap_root',"cn=%s,%s"%\
(Get('soft_ldap_rootname'),\
Get('soft_ldap_base')\
),True)
if os.path.exists('/etc/smbldap-tools/smbldap_bind.conf'):
cstr='%s cat /etc/smbldap-tools/smbldap_bind.conf | grep masterPw'\
% self.G_path
res=cm(cstr)
rs=re.search('[^=]+="(.+)',res.strip())
if rs:
Set('soft_ldap_rootpw',rs.group(1),True)
if not Get('soft_ldap_rootpw') or\
Get('soft_ldap_rootpw')=='secret':
Set('soft_ldap_rootpw',cl_utils.genpassword().strip(),True)
cstr='%s slappasswd -s %s -h %s'%\
(self.G_path,\
Get('soft_ldap_rootpw'),\
Get('soft_ldap_hash_encrypt')\
)
res=cm(cstr)
if res:
Set('soft_ldap_rootpw_hash',res.strip(),True)
#*****************************************************************************
#Заполнение глобальных переменных
#*****************************************************************************
def fillGlobal(self):
obj=self._objvar
cm=self.__runos
Get=obj.Get
Set=obj.Set
getini=self.__getini
#получим путь для выполнения команд
if self.G_path:
Set('setup_path_env',self.G_path,True)
else:
print "Not found path for execute commands"
sys.exit(0)
if not os.path.exists(self.G_shr_path):
print "Not found Calculate dir: %s"%self.G_shr_path
sys.exit(0)
#**********************************************
#checkerrors
#**********************************************
g_install_dev=""
g_install_num=""
if Get('setup_installdev') and\
re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev')):
val=re.search('^([a-z]+)([0-9]+)$',Get('setup_installdev'))
if val:
vals=val.groups()
g_install_dev=vals[0]
g_install_num=vals[1]
Set('setup_installdev',vals[0]+vals[1],True)
if Get('setup_installdev') and\
(not g_install_dev or\
not g_install_num or\
not os.path.exists('/dev/%s%s'%\
(g_install_dev,\
g_install_num))):
print "Incorrect partition"
sys.exit(0)
#---------------------------------------------------------------------
# Проверим id пользователя, запустившего скрипт
#---------------------------------------------------------------------
if os.getegid()!=0:
print "Only root can perform system installation"
sys.exit(0)
if Get('setup_sys_shortname'):
sh_name=Get('setup_sys_shortname')
ver=Get('setup_dist_ver')
if ver.has_key(sh_name.upper()):
Set('setup_sys_fullname',ver[sh_name.upper()],True)
if not Get('setup_sys_shortname'):
#Set('setup_pass','install',True)
path='/etc/issue'
#если файл с версией системы найден, определим версию
sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)"""
res=cm('%scat %s | grep "Welcome to "'%\
(self.G_path,\
path))
if res:
if re.search(sp,res):
vals=re.search(sp,res).groups()
issuename=vals[0]
ver=Get('setup_dist_ver')
for i in ver.keys():
if ver[i]==issuename:
Set('setup_sys_shortname',i,True)
Set('setup_sys_fullname',ver[i],True)
break
#если имя не определено, но оно новое и мы его уже
#передали параметром --configure
if not Get('setup_sys_shortname'):
Set('setup_sys_fullname',issuename,True)
spl=issuename.split(" ")
nname=""
if len(spl)>1:
for i in spl:
nname+=i[1]
Set('setup_sys_shortname',nname,True)
else:
Set('setup_sys_shortname',issuename,True)
#устанавливаемая или собираемая система по умолчанию
if not Get('setup_sys_shortname'):
Set('setup_sys_shortname',"CLD",True)
val=Get('setup_dist_ver')['CLD']
Set('setup_sys_fullname',val,True)
#----------------------------------------------------------------------
# Получим тип системы
#----------------------------------------------------------------------
if re.search('server',Get('setup_sys_fullname')):
Set('sys_linux_type','server',True)
else:
Set('sys_linux_type','desktop',True)
#---------------------------------------------------------------------
#одетектим устройства
self.__fillHardware()
#---------------------------------------------------------------------
Set('setup_name',self.G_calcname+" "+Get('setup_ver'),True)
#---------------------------------------------------------------------
# Выполним проверки доступности необходимых программ и определим пути
# exec_host, exec_nmap
#---------------------------------------------------------------------
if not os.system("which host >/dev/null 2>&1"):
res=os.popen("which host").readlines()
Set('cmd_exec_host',res[0].rstrip(),True)
if not os.system("which nmap >/dev/null 2>&1"):
res=os.popen("which nmap").readlines()
Set('cmd_exec_nmap',res[0].rstrip(),True)
#---------------------------------------------------------------------
# Установим значение переменной в ram, в случае если установка профиля
# производится в оперативную память (настройка сеанса CDROM), а также
# load - носитель в значение ram в случае загрузки с CD/DVD
#---------------------------------------------------------------------
Set('sys_load',"", True)
if cm("""mount | grep "/dev/loop/0 on / type" """):
Set('sys_load',"ram", True)
#---------------------------------------------------------------------
# Считаем имя компьютера
#---------------------------------------------------------------------
if Get('net_host') is None:
hostname=cm("""%s hostname -s 2>&1"""%self.G_path)
Set('net_host',hostname, True)
#упрощенный вариант, следует выполнять только если не указан домен
#в системе
if re.search("^hostname: ",hostname):
hostname=cm("""%s hostname 2>&1"""%self.G_path)
if re.search("^hostname: ",hostname):
Set('net_host',Get('setup_sys_shortname'), True)
else:
if hostname=='livecd':
Set('net_host',Get('setup_sys_shortname'), True)
#----------------------------------------------------------------------
# Определим домен
#----------------------------------------------------------------------
if not Get('sys_domain'):
domain=cm("%s hostname -d 2>&1"%self.G_path)
Set('sys_domain',domain, True)
if re.search("^hostname: ",domain):
Set('sys_domain',"local", True)
#----------------------------------------------------------------------
# Определим сетевые настройки:
# шлюз, локальные интерфейсы, локальные сети, настройки
#/etc/conf.d/net,
# сетевые устройства
#----------------------------------------------------------------------
if not Get('net_gw'):
Set('net_conf',"",True)
Set('net_hosts_allow',"",True)
Set('net_networks',"",True)
route=cm("""%sroute -n | grep "^0.0.0.0" """%self.G_path)
route=re.split("\s+",route)
if route:
Set('net_gw', route[1],True)
Set('net_gw_dev', route[7],True)
net={'255.255.0.0':'/16',\
'255.255.255.0':'/24',\
'255.255.255.128':'/25',\
'255.255.255.252':'/30',\
'255.255.255.255':''}
netpath='/sys/class/net/'
nets={}
net_if=cl_utils.getdirlist(netpath)
for i in net_if:
if i=='lo':
continue
res=cm("cat %s%s/operstate"%(netpath,i))
if res=='up':
nets[i]=True
elif res=='down':
nets[i]=False
else:
nets[i]=None
ip={}
host_allow=""
networks=""
netconf=""
gateway_dhcp=0
dev_open=0
for i in nets.keys():
res=cm("/sbin/ifconfig %s"%i)
#res=cm("ifconfig %s"%i)
sline=""""""
for j in res:
s_ip=re.search('addr:([0-9\.]+).+Bcast:.+Mask:([0-9\.]+)'\
,j)
if s_ip:
ip, netmask=s_ip.groups()
host_allow+=ip+net[netmask]+""
ipd=ip
ip=ip.split('.');
if ip[0]=='10' or\
(ip[0]=='172' and int(ip[1])>=16 and int(ip[1])<=31)or\
(ip[0]=='192' and ip[1]=='168'):
if netmask=='255.255.255.255':
networks+=ip+" "
elif netmask=='255.255.255.252':
networks+=ip[0]+"."+ip[1]+"."+ip[2]+"."+"252"+\
net[netmask]
elif netmask=='255.255.255.128':
networks+=ip[0]+"."+ip[1]+"."+ip[2]+"."+"128"+\
net[netmask]
elif netmask=='255.255.255.0':
networks+=ip[0]+"."+ip[1]+"."+ip[2]+"."+"0"+\
net[netmask]
elif netmask=='255.255.0.0':
networks+=ip[0]+"."+ip[1]+".0.0"+net[netmask]
#определим получен ли IP через DHCP
#print host_allow,networks
if not os.path.exists(\
'/var/lib/dhcpcd/dhcpcd-%s.info'%i) and\
not (os.path.exists(\
'/var/lib/dhcp/dhclient.leases') and \
cm('grep %s /var/lib/dhcp/dhclient.leases'%i)):
netconf+="\nconfig_%s=(\"%s\")"%(i,ipd\
+net[netmask])
else:
netconf+="\nconfig_%s=(\"dhcp\")"%(i)
if i==Get('net_gw_dev'):
gateway_dhcp+=1
nets[i]=True
else:
netconf+="\nconfig_%s=(\"%s%s\")"%(i,\
ipd,net[netmask])
dev_open=1
netconf+="\nmodules_eth0=( \"!plug\" )"
if dev_open==0:
nets[i]=False
if Get('net_gw_dev') and gateway_dhcp==0:
netconf+="\nroutes_%s=(\"default gw %s\" )"%\
(Get('net_gw_dev'), Get('net_gw'))
n_key=nets.keys()
n_key.sort()
if n_key:
Set('net_lan',n_key[0],True)
tval=Get('net_networks')
Set('net_networks',tval+networks,True)
tval=Get('net_hosts_allow')
Set('net_hosts_allow',tval+host_allow,True)
tval=Get('net_conf')
Set('net_conf',tval+netconf,True)
#---------------------------------------------------------------------
# Определим сетевые сервисы
#---------------------------------------------------------------------
#определим прокси-сервер
if Get('cmd_exec_host') and\
Get('sys_domain') and\
cm('%s proxy.%s | grep "has address"'%\
(Get('cmd_exec_host'), \
Get('sys_domain'))):
ports=[3128,8080]
for port in ports:
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
arg_addr=('proxy.%s'%Get('sys_domain'),port)
if sock.connect_ex(arg_addr)==0:
if not Get('net_proxy'):
Set('net_proxy','proxy.%s'%Get('sys_domain'),True)
if not Get('net_proxy_port'):
Set('net_proxy_port',str(port),True)
if not Get('net_proxy_url'):
val="http://%s:%s"%\
(Get('net_proxy'),\
Get('net_proxy_port'))
Set('net_proxy_url',val,True)
#определим наличие сетевой файловой системы
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if Get('cmd_exec_host') and\
not Get('net_nfs') and\
Get('sys_domain') and\
cm('%s nfs.%s | grep "has address"'%\
(Get('cmd_exec_host'),\
Get('sys_domain'))) and\
sock.connect_ex(('nfs.%s'%Get('sys_domain'),2049))==0:
Set('net_nfs','nfs.%s'%Get('sys_domain'),True)
#определим наличие локального сервера времени
if not Get('net_ntp'):
if Get('cmd_exec_host') and\
Get('sys_domain') and\
cm('%s ntp.%s | grep "has address"'%\
(Get('cmd_exec_host'),\
Get('sys_domain'))):
Set('net_ntp','ntp.%s'%Get('sys_domain'),True)
else:
Set('net_ntp','ntp0.zenon.net',True)
#---------------------------------------------------------------------
# Определим наличие сервера CDS
#---------------------------------------------------------------------
if not Get('net_cds'):
if Get('sys_domain'):
Set('net_cds','cds.%s'%Get('sys_domain'),True)
else:
Set('net_cds','cds',True)
#---------------------------------------------------------------------
# Получим версию обновляемой, наличие обновлений, название
# устанавливаемой системы
#---------------------------------------------------------------------
sp="""Welcome to \\\\n.\\\\O \(([a-zA-Z ]+) ([^\s\)]+)"""
if os.path.exists('/etc/issue'):
cline=""" """
res=cm('%s cat /etc/issue | grep "Welcome to "'%self.G_path)
if res:
par=re.search(sp,res).groups()
Set('setup_os_current',par[0],True)
res_n=par[1].split("-")
patch=""
osn=""
if len(res_n)>1:
patch=res_n[1]
Set('sys_patchcur',patch,True)
Set('sys_current_ver',res_n[0],True)
if not par[0]:
Set('setup_os_current','Calculate',True)
if par[1]:
Set('setup_ospatchsplit',"-",True)
elif os.path.exists('/etc/gentoo-release'):
Set('setup_os_current',"Gentoo Linux",True)
else:
Set('setup_os_current',"Old Linux",True)
#---------------------------------------------------------------------
# Заголовок изменённых файлов
#---------------------------------------------------------------------
#Changed by installator
if not Get('setup_mestitle'):
val='# Изменено %s %s' % (self.G_calcname, Get('setup_ver'))
Set('setup_mestitle',val,True)
if not Get('setup_mesline'):
val="#------------------------------------------------------------\
------------------"
Set('setup_mesline',val,True)
#---------------------------------------------------------------------
# Определим диск, с которого загружена система
#---------------------------------------------------------------------
for record in open('/proc/cmdline','rb').readlines():
re_res=re.search('^root=\/dev\/([a-z]+[0-9]).*',record.strip())
if re_res:
res=re_res.group(1)
break
g_load_dev=""
g_load_num=""
if res:
fstr="^([a-z]{3})([0-9]+)"
fres=re.search(fstr, res)
if fres:
vals=fres.groups()
g_load_dev=vals[0]
g_load_num=vals[1]
#---------------------------------------------------------------------
# Определим диск и номер раздела для установки
#---------------------------------------------------------------------
#выберем альтернативный диск для установки
if not Get('setup_installdev') and\
getini('install.from'):
res=getini('install.from')
Set('setup_installdev',res,True)
val=re.search('^([a-z]+)([0-9]+)$',res)
if val:
vals=val.groups()
g_install_dev=vals[0]
g_install_num=vals[1]
elif not Get('setup_installdev') and\
not g_install_dev and\
not g_install_num and\
g_load_dev:
g_install_dev=g_load_dev
if int(g_load_num)==2:
g_install_num=3
elif int(g_load_num)==3:
g_install_num=2
Set('setup_installdev',g_install_dev+\
str(g_install_num),True)
#проверим на существование диска
if not os.path.exists("/dev/%s"%Get('setup_installdev')):
print "Incorrect partition"
sys.exit(0)
#---------------------------------------------------------------------
# Выберем доступную утилиту форматирования
#---------------------------------------------------------------------
if not Get('setup_formatfs'):
#попытаемся подмонтировать, чтобы получить информацию о
#файловом формате
format=""
cstr="%s mkdir -p %s" % (self.G_path, Get('setup_path_install'))
cm(cstr)
cstr="%s mount /dev/%s%s %s &>/dev/null"\
% (self.G_path,\
g_install_dev,\
g_install_num,\
Get('setup_path_install'))
if not os.system(cstr):
cstr="%s mount | grep /dev/%s%s"\
%(self.G_path,\
g_install_dev,\
g_install_num)
format=cm(cstr,True)
cstr="%s umount %s"%(self.G_path, Get('setup_path_install'))
os.system(cstr)
else:
cstr="%s rmdir %s"%(self.G_path, Get('setup_path_install'))
os.system(cstr)
if format:
fs=None
if re.search(' reiserfs ',format.strip()):
fs='reiserfs'
elif re.search(' xfs ',format.strip()):
fs='xfs'
elif re.search(' ext3 ',format.strip()):
fs='ext3'
elif re.search(' ext2 ',format.strip()):
fs='ext2'
Set('setup_formatfs',fs,True)
formatrun={"reiserfs":'"/sbin/mkfs.reiserfs -f"',\
"xfs":"/sbin/mkfs.xfs -f",\
"ext3":"/sbin/mkfs.ext3",\
"ext2":"/sbin/mkfs.ext2"}
if Get('setup_formatfs') in formatrun.keys() and\
os.path.exists("/sbin/mkfs.%s"%(Get('setup_formatfs'))):
val=formatrun[Get('setup_formatfs')]
Set('cmd_run_format',val,True)
else:
if os.path.exists('/sbin/mkfs.reiserfs'):
Set('setup_formatfs','reiserfs',True)
elif os.path.exists('/sbin/mkfs.xfs'):
Set('setup_formatfs','xfs',True)
elif os.path.exists('/sbin/mkfs.ext3'):
Set('setup_formatfs','ext3',True)
elif os.path.exists('/sbin/mkfs.ext2'):
Set('setup_formatfs','ext2',True)
else:
print "Formatting utility not found"
sys.exit(0)
#---------------------------------------------------------------------
# Хэш доступных grub-у дисков, диск и раздел для установки в grub
#---------------------------------------------------------------------
sdir="/sys/block/"
ldir=cl_utils.getdirlist(sdir)
grub_dev=[]
#определим неизвлекаемые устройства
if ldir:
for dev in ldir:
if re.search('^(sd|hd)',dev):
cstr="%s cat %s%s/removable" %(self.G_path,\
sdir,\
dev)
val=cm(cstr)
if val:
if int(val[0].strip())==0:
grub_dev.append(dev.strip())
grub_dev.sort()
num=0
grub_map={}
for dev in grub_dev:
grub_map['hd'+str(num)]=dev
if g_install_dev==dev:
Set('boot_grub_setupdev','hd'+str(num),True)
if g_load_dev==dev:
Set('boot_grub_loaddev','hd'+str(num),True)
num+=1
g_grub_map=grub_map
if g_install_num:
install_num=int(g_install_num)-1
Set('boot_grub_setupnum',str(install_num),True)
if g_load_num:
load_num=int(g_load_num)-1
Set('boot_grub_loadnum',load_num,True)
Set('boot_grub_map',g_grub_map,True)
#---------------------------------------------------------------------
# Диски файла devicemap для grub-а
#---------------------------------------------------------------------
if not Get('boot_devicemap'):
grubmap=g_grub_map
grubkeys=grubmap.keys()
grubkeys.sort()
devmap=""
for dev in grubkeys:
devmap+="%s /dev/%s\n" % (dev, grubmap[dev])
Set('boot_devicemap',devmap.strip(),True)
#Скопируем карту устройств для установки граба. Новая карта на libata
#может отличаться
Set('boot_devicemap_old',Get('boot_devicemap'),True)
#--------------------------------------------------------------------
# Считаем меню граба grub.conf для переноса настроек
#--------------------------------------------------------------------
if Get('sys_load')!='ram':
grub="/boot/grub/grub.conf"
if os.path.exists(grub):
f=open(grub,"rb")
fstr=f.readlines()
f.close()
config=""
record=""
skip=None
for line in fstr:
if re.search('^\s*title[\s|=]+',line):
if record and not skip:
config+=record
record=line
skip=0
else:
if re.search('[^\s]', line) and record:
sstr="^\s*kernel .*root=\/dev\/%s" %\
Get('setup_installdev')
if Get('setup_installdev') and\
re.search(sstr,line):
skip+=1
record+=line
if record and not skip:
config+=record
Set('boot_grub_another',config,True)
else:
oldmarch=cm("%s uname -m"%self.G_path)
curos=None
if Get('sys_current_ver'):
curos=Get('sys_current_ver')
val ="\ntitle %s %s %s\n" %\
(Get('setup_os_current'),\
curos,\
oldmarch.strip())
val+="root (%s,%s)\n" %\
(Get('boot_grub_loaddev'),\
Get('boot_grub_loadnum'))
val+="kernel /boot/vmlinuz root=/dev/%s%s" %\
(Get('load_dev'),\
Get('load_num'))
Set('boot_grub_another',val,True)
if not Get('setup_set_mbr'):
Set('setup_set_mbr',True,True)
else:
Set('setup_set_mbr',False,True)
#---------------------------------------------------------------------
# Определим раздел свопа
# $data{swap}
#---------------------------------------------------------------------
if not Get('sys_swap_dev'):
res=cm('%s tail -n 1 /proc/swaps' % self.G_path)
if res:
val=re.search('^\/dev\/([^\s]+)',res).group(1)
Set('sys_swap_dev',val,True)
elif Get('sys_swap_dev'):
res=re.search('^\/dev\/(.+)$',Get('sys_swap_dev'))
if res:
val=res.group(1)
Set('sys_swap_dev',val,True)
if not Get('sys_swap_dev') and Get('install_dev'):
scm='LANG=C fdisk -l /dev/%s 2>&1 | grep "Linux swap"' %\
(Get('install_dev'))
res=cm(scm)
if res:
val=re.search('^\/dev\/([^\s]+)',res)
if val:
Set('sys_swap_dev',val.group(1),True)
if Get('sys_swap_dev'):
val='/dev/%s\tnone\t\tswap\tsw\t\t\t0 0'%(Get('sys_swap_dev'))
Set('sys_swap_line',val,True)
#---------------------------------------------------------------------
# С текущей системы определим дополнительные монтируемые диски
# (в том числе сетевые), пути монтирования
#---------------------------------------------------------------------
if os.path.exists('/etc/fstab'):
f=open('/etc/fstab',"rb")
lines=f.readlines()
f.close()
param_t={'load_dev':g_load_dev,'install_dev':g_install_dev,\
'load_num':g_load_num,'install_num':g_install_num}
res=self.__getdisk_fstab(obj, lines, param_t)
if len(res[0])>0:
Set('sys_mount_dev',res[0],True)
Set('sys_path_mounts',res[1],True)
Set('sys_mount_line',res[2],True)
else:
Set('sys_mount_dev',"",True)
Set('sys_path_mounts',"",True)
Set('sys_mount_line',"",True)
#---------------------------------------------------------------------
# Определим версию последнего доступного образа системы, либо версию
# собираемого образа, имя файла с образом, имя ISO-файла, который можно
# собрать
#---------------------------------------------------------------------
#установка системы
if os.path.exists("%s/linux"%(self.G_shr_path)) and\
Get('sys_load')!='ram':
find="(%s\-.*\-%s\.tar\.bz2)" %\
(Get('setup_sys_shortname').lower(),\
Get('setup_march'))
scm=self.G_path+" find -L %s/linux"%(self.G_shr_path)
f_res=cm(scm)
if not isinstance(f_res, types.ListType):
f_res=[f_res]
for i in f_res:
res=re.search('(%s)'%find, i.strip())
if res:
ver=res.groups()[0]
linux=Get('setup_linuxpkg')
if not linux:
Set('setup_linuxpkg',ver,True)
ver=Get('setup_linuxpkg')
if ver:
val=re.search('\-([\d\.]+)\-.*',ver)
if val:
Set('setup_linux_ver',val.group(1),True)
if not Get('setup_iso_name'):
val="%s-%s-%s.iso" % (Get('setup_sys_shortname').lower(),
Get('setup_linux_ver'), Get('setup_march'))
Set('setup_iso_name',val,True)
elif Get('sys_load')=='ram' and os.path.exists('/mnt/livecd'):
Set('setup_linux_ver',Get('sys_current_ver'), True)
Set('setup_linuxpkg','livecd', True)
#---------------------------------------------------------------------
# Пути к архиву образа
#---------------------------------------------------------------------
#пути к архивам систем
Set('setup_path_linuxpkg',"%s/linux"%(self.G_shr_path),True)
#----------------------------------------------------------------------
# Определим и проверим директорию установки, директорию временных
#файлов
#----------------------------------------------------------------------
if not Get('setup_path_tmp'):
Set('setup_path_tmp','/tmp/calculate',True)
if not Get('setup_path_install'):
Set('setup_path_install',"/mnt/install",True)
#----------------------------------------------------------------------
# Получим список доступных патчей
#----------------------------------------------------------------------
g_patches=None
if Get('sys_current_ver'):
if not Get('setup_path_patch'):
val=self.G_shr_path+"/patch"
Set('setup_path_patch',val,True)
if not Get('sys_patchlast'):
Set('sys_patchlast',Get('sys_patchcur'),True)
if not os.path.exists(Get('setup_path_patch')):
print "Not found patch dir: %s"%(Get('setup_path_patch'))
#sys.exit(0)
else:
rdir=os.listdir(Get('setup_path_patch'))
if not g_patches:
g_patches=[]
patchlast=Get('sys_patchlast')
if not patchlast:
patchlast=0
for i in rdir:
dcalculate=Get('setup_sys_shortname')
dlinuxver=Get('setup_linux_ver')
fstr='^%s\-%s\-([0-9]+)$'%(dcalculate, dlinuxver)
res=re.search(fstr, i)
if not res:
continue
val=int(res.groups()[0])
if not Get('sys_patchcur'):
Set('sys_patchcur',0, True)
if val > int(Get('sys_patchcur')):
g_patches.append(i)
if patchlast < val:
Set('sys_patchlast',val,True)
Set('setup_patches',g_patches,True)
#---------------------------------------------------------------------
# Определим переменные окружения emerge и команду запуска emerge
#---------------------------------------------------------------------
if not Get('setup_makeopts'):
makecpu=""
if int(Get('hrd_cpu_num'))==1:
makecpu=1
else:
makecpu=int(Get('hrd_cpu_num'))+1
Set('setup_makeopts',"-j%s"%makecpu,True)
if not Get('setup_path_portage'):
if os.path.exists('/usr/calculate/portage'):
Set('setup_path_portage',"/usr/calculate/portage",True)
if not Get('setup_path_distfiles'):
if os.path.exists('/usr/calculate/distfiles'):
Set('setup_path_distfiles',"/usr/calculate/distfiles",True)
if not Get('setup_path_pkg'):
pkgpath="/usr/calculate/packages/%s/%s/%s"%\
(Get('setup_sys_shortname'),\
Get('setup_linux_ver'),\
Get('setup_march'))
if os.path.exists(pkgpath):
Set('setup_path_pkg',pkgpath,True)
if Get('setup_path_portage'):
Set('cmd_run_emerge1','PORTDIR_OVERLAY="%s" MAKEOPTS="%s"'%\
(Get('setup_path_portage'),\
Get('setup_makeopts')),\
True)
Set('cmd_run_emerge2',"",True)
#----------------------------------------------------------------------
# Пути к директориям пакетов сборки
#----------------------------------------------------------------------
#packages=(G_inst_path+"/builder/packages",\
#self.G_shr_path+"/builder/packages")
#Set('setup_path_constpkg',packages,True)
def fillInstall(self):
#---------------------------------------------------------------------
# Определим профили установки или сборки
#---------------------------------------------------------------------
prof=self.getProfileList('/usr/calculate/profile/install/')
if prof:
self._objvar.Set('setup_path_profuser',prof,True)
prof=self.getProfileList('/usr/lib/calculate-install/profile/')
if prof:
self._objvar.Set('setup_path_profinst',prof,True)
def getProfileList(self, path):
obj=self._objvar
Get=obj.Get
Set=obj.Set
_ex=os.path.exists
profPath=path
if not os.path.exists(profPath):
return ""
else:
Prof_gr1=[]
Prof_gr2=''
Prof_gr3=''
listProf=cl_utils.getdirlist(profPath)
#создадим список профилей в порядке их наложения
#профили 1*, сборки и для имени хоста
ver=Get('setup_dist_ver')
re_ver="|".join(ver.keys())
i=0
for i in xrange(len(listProf)):
el=listProf[i]
if re.search('^[0-9]+[^\.]\w+',el):
listProf[i]=''
Prof_gr1.append(profPath+el)
elif re.search('^(%s)$'%re_ver,el):
if el==Get('setup_sys_shortname'):
Prof_gr2=profPath+el
listProf[i]=''
elif re.search(\
'^[0-9]{,3}\.[0-9]{,3}\.[0-9]{,3}\.[0-9]{,3}$',el):
if Get('net_hosts_allow').split('/')[0]==el:
Prof_gr3=profPath+el
listProf[i]=''
i+=1
#профили для DNS зоны
sdn=Get('sys_domain').split(".")
sdn.reverse()
Prof_gr4=[]
i=0
for i in xrange(len(sdn)):
if i==0:
el=sdn[i]
else:
el=sdn[i]+"."+el
j=0
if el in listProf:
Prof_gr4.append(profPath+el)
listProf.remove(el)
#профиль для ip компьютера
pcip=str(Get('net_host'))
if pcip in listProf:
Prof_gr4.append(profPath+pcip)
listProf.remove(pcip)
#компонуем профили
Prof_gr1.sort()
if Prof_gr2:
Prof_gr1+=[Prof_gr2]
if len(Prof_gr4)>0:
Prof_gr1+=Prof_gr4
if Prof_gr3:
Prof_gr1+=[Prof_gr3]
if len(Prof_gr1)>0:
return Prof_gr1
else:
return ""
class CLError(Exception):
def __init__(self, value):
self.value=value
def __str__(self):
return repr(self.msg+self.value)
class VarNameError(CLError):
msg="Incorrect name of a variable: "
class VarValueError(CLError):
msg="Incorrect value of a variable: "
class objValue:
v_mode="r"
v_type=()
v_vtype=None
v_value=None
v_select=None
v_official=False
v_printval=None
def __init__(self,**args):
for atname,avalue in args.items():
self.__setattr__(atname,avalue)
def __getattribute__(self, instance):
try:
return object.__getattribute__(self, instance)
except:
return None
def __setattr__(self, atname, value):
matching={'mode' :'v_mode',
'type' :'v_type',
'vtype' :'v_vtype',
'value' :'v_value',
'select' :'v_select',
'official' :'v_official'}
if matching.has_key(atname):
self.__dict__[matching[atname]]=value
return
if not self.__class__.__dict__.has_key(atname):
print 'not attribute'
else:
self.__dict__[atname]=value
class DataVars:
if not os.path.abspath(\
'/usr/lib/calculate/calculate-server/pym') in sys.path:
sys.path.insert(0,os.path.abspath(\
'/usr/lib/calculate/calculate-server/pym'))
if not os.path.abspath(\
'/usr/lib/calculate/calculate-lib/pym') in sys.path:
sys.path.insert(0,os.path.abspath(\
'/usr/lib/calculate/calculate-lib/pym'))
if not os.path.abspath(\
'/usr/lib/calculate/calculate-builder/pym') in sys.path:
sys.path.insert(0,os.path.abspath(\
'/usr/lib/calculate/calculate-builder/pym'))
sys.path.insert(0,os.path.abspath('/home/okovalenko/Home/Calculate\
/pvars'))
__modlist={'Global':'cl_vars',
'Server':'cl_vars_server',
'Builder':'cl_vars_builder'}
__implist=[]
def __init__(self, modname='Global'):
self.__varslist={}
self.__typelist=()
if modname and self.__modlist.has_key(modname):
modname=self.__modlist[modname]
#импортируем модуль с переменными
exec ("import %s" % (modname))
#создаем экземпляр импортированного модуля
exec ("obj=%s.Data" %(modname))
#проходимся по переменным класса и готовим объект
for idnt in obj.__dict__:
#отбрасываем служебные переменные
if re.search("\__.*",idnt):
continue
#получаем значение переменной
exec("vals=obj.%s"%idnt)
#если значение переменной некорректно то убиваем все окружение
#и вываливаемся с пустым объектом
if self.__checkVarsValue(vals)==False:
msg='The variable: %s in the module: %s is incorrectly\
described' % (idnt, modname)
raise CLError(msg)
del(self)
return
#добавляем имя переменной в общий список
if vals.has_key('value'):
if isinstance(vals['value'], types.ListType) or\
isinstance(vals['value'], types.DictType):
vtype=type(vals['value'])
else:
vtype=None
else:
vtype=None
self.__varslist[idnt]={}
for p,val in vals.items():
if p=='value':
continue
self.__varslist[idnt][p]=val
self.__varslist[idnt]['vtype']=vtype
#оформляем значение переменной в виде объекта
objparam=objValue(**vals)
#инициализируем переменную
exec ("""self.%s=objparam"""%(idnt))
else:
print "Unsupported module vars: %s"%(modname)
sys.exit(0)
#проверить импортируемое значение
def __checkVarsValue(self, pvar):
if pvar is None:
return False
#обязательные значения полей для переменной
if not isinstance(pvar, types.DictType):
return False
if not pvar.has_key('mode') or not pvar.has_key('type'):
return False
if pvar['mode']==None or pvar['type']==None:
return False
if pvar['mode'].upper() not in ['R','W']:
return false
return True
#установить значение переменной
def Set(self, vname, val, force=False):
self.__addVarValue(vname, val, force)
#получить значение переменной
def Get(self, vname, objformat=None):
return self.__getVarValue(vname, objformat)
def flServer(self, **args):
self.Set('setup_sys_shortname','CDS',True)
self.flGlobal()
if 'Server' in self.__implist:
return
self.__implist.append('Server')
objvar=DataVars("Server")
self.joinVars(objvar)
fillVars(self).fillLDAP(**args)
def flGlobal(self,**args):
if 'Global' in self.__implist:
return
self.__implist.append('Global')
fillVars(self).fillGlobal(**args)
def flBuilder(self, **args):
self.Set('setup_pass','builder',True)
self.flGlobal()
if 'Builder' in self.__implist:
return
self.__implist.append('Builder')
objvar=DataVars("Builder")
self.joinVars(objvar)
fillVars(self).fillBuilder(**args)
def flInstall(self, **args):
self.Set('setup_pass','install',True)
self.flGlobal()
fillVars(self).fillInstall(**args)
def isRewrite(self, vname):
mode=self.Get(vname,True).v_mode
if mode=='w':
return True
else:
return False
#Получить значение переменной в чистом виде или в виде объекта
def __getVarValue(self, vname, objformat=None, printval=None):
if not vname in self.__varslist.keys():
raise VarNameError(vname)
try:
#если переменная уже инициализирована
exec ("val=self.%s"%(vname))
if objformat is None:
if printval:
return val.v_printval
return val.v_value
else:
return val
except:
#если переменная не инициализирована
if objformat:
#если режим возврата в виде объекта
par=self.__varslist[vname]
objpar=par
#objpar['value']=None
obj=objValue(**objpar)
if obj:
return obj
return False
#установить значение переменной
#не даем переписывать значения переменной у которых режим "r"
#но можно перезаписать в режиме force=True
def __addVarValue(self, vname, val, force=False, printval=None):
if not self.__varslist.has_key(vname):
raise VarNameError(vname)
valobj=self.__getVarValue(vname, True)
if valobj is False:
return False
if valobj.v_mode=="r" and force==False:
print "Attempt to rewrite a variable for reading: %s"%vname
return False
if self.__varslist[vname]['vtype']:
if type(val)!=self.__varslist[vname]['vtype']:
raise VarValueError(vname)
if 'bool' in valobj.v_type:
if val is None:
val=False
if printval:
valobj.v_printval=val
else:
valobj.v_value=val
exec("self.%s=valobj"%(vname))
return True
#проверить входит ли тип в указанный список типов
def __checkType(self, tvar, tcheck):
lvar=len(tcheck)
flag=0
for i in tvar:
if i in tcheck:
flag+=1
if flag !=lvar:
return False
return True
# Вернуть список переменных
# type_names - список типов, переменные которых необходимо вернуть
def getVars(self, type_names=None):
ret={}
for i in self.__varslist.keys():
try:
val=None
exec ("val=self.%s"%i)
if type_names:
if not self.__checkType(val.v_type,type_names):
continue
ret[i]=val
except:
param=self.__varslist[i]
nobj=objValue(param['mode'],param['type'], None)
if type_names:
if not self.__checkType(val.vtype,type_names):
continue
ret[i]=nobj
return ret
#распечатать список переменных с значениями
def printVars(self,type_names=None):
var=None
var=self.getVars(type_names)
mlen_name=0;
mlen_type=0;
mlen_mode=0;
for i,j in var.items():
if len(i)>mlen_name:
mlen_name=len(i)
if len(str(j.v_type))>mlen_type:
mlen_type=len(str(j.v_type))
vtype=str(type(var[i].v_value)).split(" ")[1][1]
if vtype in ['d','l']:
mode="[%s%s]"%(var[i].v_mode.lower(),vtype)
else:
mode="[%s]"%(var[i].v_mode.lower())
var[i].v_mode=mode
if len(mode)>mlen_mode:
mlen_mode=len(mode)
plist=var.keys()
plist.sort()
print "The list of variables:"
print "var name".center(mlen_name),\
"Mode",\
"Type".center(mlen_type),\
"Value"
print cl_utils.fillstr("-",mlen_name),\
cl_utils.fillstr("-",mlen_mode),\
cl_utils.fillstr("-",mlen_type),\
cl_utils.fillstr("-",10)
for i in plist:
if var[i].v_value is None and var[i].v_printval is None:
continue
elif var[i].v_printval is None:
p_val=var[i].v_value
else:
p_val=var[i].v_printval
if var[i].v_official:
continue
print i.ljust(mlen_name),\
var[i].v_mode.lower().ljust(mlen_mode),\
str(var[i].v_type).ljust(mlen_type),\
":",\
p_val
print cl_utils.fillstr("-",mlen_name),\
cl_utils.fillstr("-",mlen_mode),\
cl_utils.fillstr("-",mlen_type),\
cl_utils.fillstr("-",10)
#объеденить два объекта с переменными
def joinVars(self, objvars, force=False):
#Принимаем на вход только экземпляры текущего класса
if not isinstance(objvars, DataVars):
raise CLError('The object of incorrect type is transferred')
#Делаем копию текущего объекта и дальше работаем с копией
old_self=copy.deepcopy(self)
for var in objvars.__varslist.keys():
#если нет режима замещения то вываливаемся
if var in old_self.__dict__.keys():
if force==False:
raise CLError('Duplication of a variable: %s'% var)
else:
old_self.__varslist[var]=objvars.__varslist[var]
val=objvars.__getVarValue(var, True)
if val:
old_self.__addVarValue(var,val.v_value, True)
#если все успешно тогда вносим изменения
self.__dict__=old_self.__dict__
def defined(self, vname):
if vname:
if self.__dict__.has_key(vname):
return True
return False
#вернуть список переменных с параметрами
def getVarsList(self):
vlist=self.__varslist.keys()
vlist.sort()
return vlist
##############################################################################