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