|
|
#-*- 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
|
|
|
##############################################################################
|
