calculate-utils-2.1-lib/pym/cl_base.py

#-*- 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'
        elif value_setup_pass == 'install':
            return "/mnt/install"
        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 = '/var/calculate/profile/server'
        if os.path.exists(profpath):
            return [profpath]

    def get_soft_samba_domain(self):
        return "CDS"

    def get_soft_ldap_root(self):
        return "calculate"

    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_sevices_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_hash(self):
        return fillVars.gethashfrom_slappasswd(self.G_path,
                   self.Get('soft_ldap_adminpw'),
                   self.Get('soft_ldap_hash_encrypt'))

    def get_soft_ldap_adminpw(self):
        '''Заполнение переменной soft_ldap_adminpw
        постоянный пользователь root, прописываемый в базу при первой загрузке
        с одновременным удалением временного root-а
        '''
        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_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
	self.__implist.append(modname)
        modname=self.__modlist[modname]
        # импортирем модуль с переменными окружения
        exec ("import %s" % (modname))
        #создаем экземпляр импортированного модуля
        exec ("obj=%s.Data" %(modname))
        #проходимся по переменным класса и готовим объект
        for idnt in obj.__dict__:
            #отбрасываем служебные переменные
            if re.search("\__.*",idnt):
                continue
            #получаем значение переменной
            exec("vals=obj.%s"%idnt)
            #если значение переменной некорректно то убиваем все окружение
            #и вываливаемся с пустым объектом
            if self.__checkVarsValue(vals)==False:
                msg='The variable: %s in the module: %s is incorrectly\
                described' % (idnt, modname)
                raise CLError(msg)
                del(self)
                return
            # получаем тип значений по умолчанию (проверяем, чтобы
            # это была либо словарь либо список в противном случае
            # тип является не заданным
            if vals.has_key('value'):
                if isinstance(vals['value'], types.ListType) or\
                isinstance(vals['value'], types.DictType):
                    vtype=type(vals['value'])
                else:
                    vtype=None
            else:
                vtype=None
            #добавляем имя переменной в общий список
            self.__varslist[idnt]={}
            # переносим атрибуты переменной в общий список, при этом
            # исключаем значение по умолчанию
            for p,val in vals.items():
                if p=='value':
                    continue
                self.__varslist[idnt][p]=val
            # заместо значение по умолчанию устанавливаем атрибут тип
            # переменной
            self.__varslist[idnt]['vtype']=vtype

            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):
        '''Заместить значение переменных значениями из ини файла

        Возвращаемые значения:
        True     переменные считаны
        False    файл не был обнаружен
        '''
        calculate_ini = []
        # получаем полный путь до удаленного файла ini
        calculate_ini.append(os.path.join('/',
                             self.Get('sys_calculate_ini_remote')))
        # получаем полный путь до локального файла ini
        calculate_ini.append(os.path.join('/',
                             self.Get('sys_calculate_ini_local')))
        # получаем полный путь до файла ini
        calculate_ini.append(os.path.join('/',
                             self.Get('sys_calculate_ini')))
        for name_calculate_ini in 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

    def flServer(self, **args):
        '''Заполнить конфигурацию переменных, для ldap'''
        # заполнить переменные окружения алгоритмом по умолнанию
        self.addVars("Server")

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