calculate-utils-2.2-lib/pym/cl_fill.py

#-*- coding: utf-8 -*-

# Copyright 2008-2010 Mir Calculate Ltd. http://www.calculate-linux.org
#
#  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 re
import os
import types
import filecmp
import pwd, grp
import cl_overriding
from cl_ldap import ldapUser
from cl_datavars import glob_attr

class clLocale:
    lang = {
    #Belarussian
    'be_BY' : {
                'locale':'be_BY.UTF-8',
                'keymap':'by',
                'dumpkeys_charset': 'koi8-u',
                'consolefont':'Cyr_a8x16',
                'xkblayout':'us,by',
                'language':'ru',
        },
    #Belgian
    'fr_BE' : {
                'locale':'fr_BE.UTF-8',
                'keymap':'be-latin1',
                'dumpkeys_charset':'',
                'consolefont':'lat9w-16',
                'xkblayout':'us,be',
                'language':'en_US',
        },
    #Brazilian Portuguese
    'pt_BR' : {
                'locale':'pt_BR.UTF-8',
                'keymap':'br-abnt2',
                'dumpkeys_charset':'',
                'consolefont':'lat9w-16',
                'xkblayout':'pt,us',
                'language':'pt_BR',
        },
    #Canadian French
    'fr_CA' : {
                'locale':'fr_CA.UTF-8',
                'keymap':'cf',
                'dumpkeys_charset':'',
                'consolefont':'default8x16',
                'xkblayout':'us,ca_enhanced',
                'language':'en_US',
        },
    #Danish
    'da_DK' : {
                'locale':'da_DK.UTF-8',
                'keymap':'dk-latin1',
                'dumpkeys_charset':'',
                'consolefont':'lat0-16',
                'xkblayout':'us,dk',
                'language':'da',
        },
    #French
    'fr_FR' : {
                'locale':'fr_FR.UTF-8',
                'keymap':'fr-latin9',
                'dumpkeys_charset':'',
                'consolefont':'lat0-16',
                'xkblayout':'fr,us',
                'language':'en_US',
        },
    #German
    'de_DE' : {
                'locale':'de_DE.UTF-8',
                'keymap':'de-latin1',
                'dumpkeys_charset':'',
                'consolefont':'lat9w-16',
                'xkblayout':'de,us',
                'language':'de',
        },
    #Icelandic
    'is_IS' : {
                'locale':'is_IS.UTF-8',
                'keymap':'is-latin1',
                'dumpkeys_charset':'',
                'consolefont':'cp850-8x16',
                'xkblayout':'us,is',
                'language':'en_US',
        },
    #Italian
     'it_IT' : {
                'locale':'it_IT.UTF-8',
                'keymap':'it',
                'dumpkeys_charset':'',
                'consolefont':'default8x16',
                'xkblayout':'us,it',
                'language':'it',
        },
    #Norwegian
    'nn_NO' : {
                'locale':'nn_NO.UTF-8',
                'keymap':'no-latin1',
                'dumpkeys_charset':'',
                'consolefont':'lat9w-16',
                'xkblayout':'us,no',
                'language':'nn',
        },
    #Polish
    'pl_PL' : {
                'locale':'pl_PL.UTF-8',
                'keymap':'pl',
                'dumpkeys_charset':'',
                'consolefont':'lat2-16',
                'xkblayout':'us,pl',
                'language':'pl',
        },
    #Russian
    'ru_RU' : {
                'locale':'ru_RU.UTF-8',
                'keymap':'-u ruwin_cplk-UTF-8',
                'dumpkeys_charset':'',
                'consolefont':'ter-k14n',
                'xkblayout':'us,ru(winkeys)',
                'language':'ru',
        },
    #Spanish
    'es_ES' : {
                'locale':'es_ES.UTF-8',
                'keymap':'es euro2',
                'dumpkeys_charset':'',
                'consolefont':'lat0-16',
                'xkblayout':'es,us',
                'language':'es',
        },
    #Swedish
    'sv_SE' : {
                'locale':'sv_SE.UTF-8',
                'keymap':'sv-latin1',
                'dumpkeys_charset':'',
                'consolefont':'lat0-16',
                'xkblayout':'us,se',
                'language':'sv',
        },
    #Ukrainian
    'uk_UA' : {
                'locale':'uk_UA.UTF-8',
                'keymap':'ua-utf',
                'dumpkeys_charset':'koi8-u',
                'consolefont':'ter-v14n',
                'xkblayout':'us,ua(winkeys)',
                'language':'uk',
        },
    #United Kingdom/British
    'en_GB' : {
                'locale':'en_GB.UTF-8',
                'keymap':'uk',
                'dumpkeys_charset':'',
                'consolefont':'LatArCyrHeb-16',
                'xkblayout':'us,gb',
                'language':'en_US',
        },
    #United State/English
    'en_US' : {
                'locale':'en_US.UTF-8',
                'keymap':'us',
                'dumpkeys_charset':'',
                'consolefont':'LatArCyrHeb-16',
                'xkblayout':'us',
                'language':'en_US',
        }
    }

    def getLangs(self):
        return self.lang.keys()

    def isLangExists(self,lang):
        return lang in self.lang.keys()

    def getFields(self,field):
        return [ l[1][field] for l in self.lang.items() ]

    def getFieldByLang(self,field,lang):
        return self.lang.get(lang, self.lang['en_US'])[field]

    def getFieldByKeymap(self,field,keymap):
        return self.lang.get(self.getLangByField('keymap',keymap),
                                self.lang['en_US'])[field]

    def getLangByField(self,field,value):
        langs = [lang[0] for lang in self.lang.items() 
                    if lang[1][field] == value ]
        if not langs:
            return 'en_US'
        else:
            return langs[0]

def getdirlist(s_path):
    #Получить список директорий по указаному пути
    fdir=filecmp.dircmp(s_path, s_path)
    dir_list=fdir.common_dirs
    return dir_list

class fillVars(glob_attr):

    # Объект данных из LDAP
    _ldapUserObject = False
    # Данные о пользователе из LDAP
    _ldapUserData = {}

    def get_cl_env_path(self):
        '''Пути к env файлам'''
        envData = self.Get("cl_env_data")
        if envData:
            return map(lambda x: x[1], envData)
        else:
            cl_overriding.printERROR(_("Error:") + " " +\
                _("Template variable cl_env_data is empty"))
            cl_overriding.exit(1)

    def get_cl_env_location(self):
        '''Алиасы к env файлам'''
        envData = self.Get("cl_env_data")
        if envData:
            return map(lambda x: x[0], envData)
        else:
            cl_overriding.printERROR(_("Error:") + " " +\
                _("Template variable cl_env_data is empty"))
            cl_overriding.exit(1)

    def get_os_net_domain(self):
        '''Определим домен'''
        domain=self._runos("hostname -d 2>&1")
        if not domain:
            cl_overriding.printERROR(_("Error:") + " " +\
                _("Not found domain name"))
            cl_overriding.printERROR(\
                _("Command 'hostname -d' returns an empty value"))
            cl_overriding.exit(1)
        elif re.search("^hostname: ",domain):
            return "local"
        else:
            return domain

    def get_os_linux_shortname(self):
        '''Получить переменную короткого названия системы'''
        path = '/etc/calculate/calculate.ini'
        if os.path.exists(path):
            FD = open(path)
            data = FD.readlines()
            FD.close()
            shortNameList = filter(lambda y:y,
                                   map(lambda x:\
                                       len(x.split("="))==2 and\
                                       x.split("=")[0]=="calculate" and\
                                       x.split("=")[1].strip(), data))
            if shortNameList:
                return shortNameList[0]
        gentooFile = "/etc/gentoo-release"
        shortName = "Linux"
        if os.path.exists(gentooFile):
            shortName = "Gentoo"
        return shortName

    def get_os_linux_name(self):
        """полное название системы"""
        linuxShortName = self.Get("os_linux_shortname")
        if linuxShortName:
            dictLinuxName = {"CLD":"Calculate Linux Desktop",
                             "CLDX":"Calculate Linux Desktop",
                             "CLDG":"Calculate Linux Desktop",
                             "CDS":"Calculate Directory Server",
                             "Gentoo":"Gentoo"}
            if linuxShortName in dictLinuxName.keys():
                return dictLinuxName[linuxShortName]
            else:
                return "Linux"
        else:
            return "Linux"

    def get_os_linux_subname(self):
        """постфикс к названию системы"""
        linuxShortName = self.Get("os_linux_shortname")
        if linuxShortName:
            dictLinuxSubName = {"CLD":"KDE", "CLDX":"XFCE", "CLDG":"GNOME"}
            if linuxShortName in dictLinuxSubName.keys():
                return dictLinuxSubName[linuxShortName]
            else:
                return ""
        else:
            return ""

    def get_os_linux_ver(self):
        '''Получить версию системы'''
        path = '/etc/calculate/calculate.ini'
        if os.path.exists(path):
            FD = open(path)
            data = FD.readlines()
            FD.close()
            shortNameList = filter(lambda y:y,
                                   map(lambda x:\
                                       len(x.split("="))==2 and\
                                       x.split("=")[0]=="linuxver" and\
                                       x.split("=")[1].strip(), data))
            if shortNameList:
                return shortNameList[0]
        gentooFile = "/etc/gentoo-release"
        systemVersion = ""
        flagGentoo = False
        if os.path.exists(gentooFile):
            gentooLink = "/etc/make.profile"
            if os.path.islink(gentooLink):
                systemVersion = os.readlink(gentooLink).rpartition("/")[2]
                flagGentoo = True
        if not flagGentoo:
            kernelVersion=self._runos("uname -r")
            if kernelVersion:
                systemVersion = kernelVersion.partition("-")[0]
        return systemVersion

    def get_os_net_hostname(self):
        '''Считать имя компьютера net_host'''
        hostname=self._runos("hostname -s 2>&1")
        if not hostname:
            return ""
        if re.search("^hostname: ",hostname):
            hostname=self._runos("hostname 2>&1")
            if not hostname:
                return ""
        if re.search("^hostname: ",hostname):
            return self.Get('os_linux_shortname')
        else:
            if hostname=='livecd':
                return self.Get('os_linux_shortname')
        return hostname

    # все ip
    def get_os_net_ip(self):
        """все ip компьютера, разделитель запятая"""
        IPs = []
        netInterfaces=getdirlist("/sys/class/net/")
        for i in netInterfaces:
            res = self._runos("/sbin/ifconfig %s"%i)
            if not res:
                break
            for line in res:
                searchIP = re.search('addr:([0-9\.]+).+Bcast:', line)
                if searchIP:
                    # ip адрес
                    ip = searchIP.groups()[0]
                    IPs.append(ip)
        return ",".join(IPs)

    # Разрешенные сети (в данном случае все сети)
    def get_os_net_allow(self):
        """Разрешенные сети разделитель запятая"""

        def getNet(ip, mask):
            """По ip и маске получаем сеть"""
            octetsMult = (0x1, 0x100, 0x10000, 0x1000000)
            octetsIp = map(lambda x: int(x), ip.split("."))
            octetsMask = map(lambda x: int(x), mask.split("."))
            ipNumb = 0
            for i in octetsMult:
                ipNumb += octetsIp.pop()*i
            maskNumb = 0
            for i in octetsMult:
                maskNumb += octetsMask.pop()*i
            startIpNumber = maskNumb&ipNumb
            x = startIpNumber
            nMask = lambda y: len(filter(lambda x: y >> x &1 ,range(32)))
            return "%s.%s.%s.%s/%s"\
                   %(x>>24, x>>16&255, x>>8&255, x&255, nMask(maskNumb))

        networks=[]
        netInterfaces=getdirlist("/sys/class/net/")
        flagError = False
        for i in netInterfaces:
            res = self._runos("/sbin/ifconfig %s"%i)
            if not res:
                flagError = True
                break
            for j in res:
                s_ip=re.search('addr:([0-9\.]+).+Bcast:.+Mask:([0-9\.]+)' ,j)
                if s_ip:
                    ip, mask = s_ip.groups()
                    networks.append(getNet(ip, mask))
        if flagError:
            return ""
        return ",".join(networks)

    def get_os_locale_xkbname(self):
        """названия используемых раскладок клавиатуры для X"""
        localeXkb = self.Get("os_locale_xkb")
        if localeXkb:
            return localeXkb.split("(")[0]
        return ""

    def get_os_arch_machine(self):
        """архитектура процессора"""
        march = self._runos("uname -m")
        if not march:
            return ""
        return march

    def get_os_root_dev(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)
            else:
                mountLunes = self._runos("mount")
                if not mountLunes:
                    return ""
                if type(mountLunes) == types.ListType:
                    root_dev = mountLunes[0].split("on / type")[0].strip()
                    if root_dev:
                        return root_dev
                return ""

    def get_os_root_type(self):
        """тип носителя (ram, hdd, livecd)"""
        mountLunes = self._runos("mount")
        if not mountLunes:
            return ""
        rootType = "hdd"
        if type(mountLunes) == types.ListType:
            flagCD = False
            for line in mountLunes:
                if "/dev/loop0 on / type" in line:
                    rootType = "ram"
                    break
                elif "/dev/loop0 on /newroot/mnt/livecd type" in line:
                    rootType = "ram"
                    flagCD = True
                    break
            if rootType == "ram":
                if os.path.exists("/mnt/livecd") or flagCD:
                    rootType = "livecd"
                    return rootType
            rootDev = self.Get("os_root_dev")
            if rootType != "ram" and rootDev:
                slpRootDev = rootDev.split("/dev/")
                if len(slpRootDev) == 2:
                    rDev = slpRootDev[1]
                    devLines = os.listdir("/dev/disk/by-id")
                    for name in devLines:
                        path = os.path.join("/dev/disk/by-id", name)
                        if os.path.islink(path):
                            if rDev in os.readlink(path) and "usb-" in name:
                                rootType = "usb-hdd"
                                break
                    if not devLines:
                        return ""
            if rootType == "ram":
                rootType = "hdd"
            return rootType
        else:
            return ""

    def get_hr_virtual(self):
        """Название виртуальной машины (virtualbox, vmware, qemu)"""
        pciLines = self._runos("/usr/sbin/lspci")
        if not pciLines:
            return False
        virtSysDict = {'VirtualBox':'virtualbox',
                       'VMware':'vmware',
                       'Qumranet':'qemu'}
        virtName = ''
        for vName in virtSysDict.keys():
            if filter(lambda x: vName in x, pciLines):
                virtName = virtSysDict[vName]
                break
        return virtName

    def getValueFromConfig(self,config,name):
        """Get value of parameter from bash type file
        
        Parameters:
        config      config file name
        name        param name
        """
        reMatch = re.compile("^%s\s*=\s*\"?(.*)\"?$"%name, re.I)
        try:
            if os.path.exists(config):
                for line in open(config,"r").readlines():
                    match = reMatch.match(line)
                    if match:
                        return group().strip()
        except:
            pass
        return False

    def getValueFromCmdLine(self,option,num):
        """Get value of parameter from boot params
        
        Parameters:
        option      param name
        num         number part of value parameter (, split)
        """
        cmdLine = "/proc/cmdline"
        calculateParam = "calculate"
        # try get timezone from kernel calculate param
        try:
            for param in open(cmdLine,"r").read().split(" "):
                parname,op,value = param.partition("=")
                if parname == calculateParam and op == "=":
                    values = value.split(",")
                    if len(values) > num and values[num].strip():
                        return values[num].strip()
        except IOError,e:
            return ""

    def get_hr_board_model(self):
        """motherboard model"""
        modelFile = "/sys/class/dmi/id/board_name"
        try:
            return open(modelFile,"r").read().strip()
        except:
            return ""

    def get_hr_board_vendor(self):
        """motherboard vendor"""
        vendorFile = "/sys/class/dmi/id/board_vendor"
        try:
            return open(vendorFile,"r").read().strip()
        except:
            return ""

    def get_hr_cpus(self):
        """processors count"""
        cpuinfoFile = "/proc/cpuinfo"
        try:
            return len(["" for line in open(cpuinfoFile,"r").readlines()
                    if "processor" in line])
        except:
            return 1

    def get_os_locale_locale(self):
        """locale (example: ru_RU.UTF-8)"""
        locale = clLocale()
        # get locale from boot calculate param
        localeVal = self.getValueFromCmdLine("calculate",0)
        if locale.isLangExists(localeVal):
            return locale.getFieldByLang('locale',localeVal)
        elif os.environ.has_key("LANG"):
            return os.environ["LANG"]
        else:
            return locale.getFieldByLang("locale","default")

    def get_os_locale_lang(self):
        """lang (example: ru_RU)"""
        locale = clLocale()
        return locale.getLangByField("locale",self.Get('os_locale_locale'))

    def get_os_locale_language(self):
        """language (example: ru)"""
        locale = clLocale()
        return locale.getFieldByLang("language",self.Get('os_locale_lang'))

    def get_os_locale_xkb(self):
        """xkb layouts (example: en,ru)"""
        locale = clLocale()
        # is specified keymap support by locale hash
        if self.Get('os_locale_keymap') in locale.getFields('keymap'):
            return locale.getFieldByKeymap("xkblayout",
                                            self.Get('os_locale_keymap'))
        else:
            return locale.getFieldByLang("xkblayout",
                                            self.Get('os_locale_lang'))

    def get_os_locale_keymap(self):
        """keymap of locale (used for /etc/conf.d/keymaps)"""
        locale = clLocale()
        # get keymap from boot calculate param (keymap specified
        # by lang)
        keymapConfd = '/etc/conf.d/keymaps'
        keymap = self.getValueFromCmdLine("calculate",1)
        if locale.isLangExists(keymap):
            return locale.getFieldByLang('keymap',keymap)
        # get keymap by os_locale_lang
        keymap = self.getValueFromConfig(keymapConfd,'KEYMAP')
        if keymap:
            return keymap
        return locale.getFieldByLang("keymap",self.Get("os_locale_lang"))

    def get_os_locale_dumpkeys(self):
        """dumpkeys charset for keymap"""
        locale = clLocale()
        # is specified keymap support by locale hash
        if self.Get('os_locale_keymap') in locale.getFields('keymap'):
            return locale.getFieldByKeymap("dumpkeys_charset",
                                            self.Get('os_locale_keymap'))
        else:
            return locale.getFieldByLang("dumpkeys_charset",
                                            self.Get('os_locale_lang'))

    def get_os_clock_timezone(self):
        """timezone for clock"""
        zoneinfodir = "/usr/share/zoneinfo/"
        localtimefile = "/etc/localtime"
        # try get timezone from kernel calculate param
        timezone = self.getValueFromCmdLine("calculate",2)
        if timezone and \
            os.path.exists(os.path.join(zoneinfodir,timezone)):
            return timezone
        # get timezone from localtime symlink
        if os.path.lexists(localtimefile):
            return os.readlink(localtimefile).replace(zoneinfodir,"")
        return "UTC"

    def get_os_clock_type(self):
        """type of clock (UTC or local)"""
        clockTypeFile = ['/etc/conf.d/clock','/etc/conf.d/hwclock']
        for f in clockTypeFile:
            clock = self.getValueFromConfig(f,"clock")
            if clock:
                if clock.upper() == 'UTC':
                    return clock.upper()
                elif clock.lower() == 'local':
                    return clock.lower()
        return "local"

    def get_ur_login(self):
        """Имя пользователя"""
        uid = os.getuid()
        try:
            userName = pwd.getpwuid(uid).pw_name
        except:
            return ""
        return userName

    def get_ur_group(self):
        """Название группы пользователя"""
        userName = self.Get('ur_login')
        groupName = ""
        if userName:
            try:
                gid = pwd.getpwnam(userName).pw_gid
                groupName = grp.getgrgid(gid).gr_name
            except:
                return ""
        return groupName

    def get_ur_fullname(self):
        """Полное имя пользователя"""
        userName = self.Get('ur_login')
        fullName = ""
        if userName:
            try:
                fullName = pwd.getpwnam(userName).pw_gecos
            except:
                return ""
        return fullName

    def getLdapUserObject(self):
        """Объект данных из LDAP"""
        if not self._ldapUserObject:
            self._ldapUserObject = ldapUser()
        return self._ldapUserObject

    def getUserInfo(self):
        """Получение информации о пользователе из LDAP"""
        userName = self.Get('ur_login')
        if userName:
            if userName in self._ldapUserData:
                return self._ldapUserData[userName]
            else:
                ldapObj = self.getLdapUserObject()
                userInfo = ldapObj.getUserLdapInfo(userName)
                if userInfo:
                    self._ldapUserData[userName] = userInfo
                    return userInfo
        return {}

    def get_ur_jid(self):
        """Jabber id пользователя"""
        userInfo = self.getUserInfo()
        userJID = ""
        if userInfo:
            userJID = userInfo["jid"] 
        return userJID

    def get_ur_mail(self):
        """Почтовый адрес пользователя"""
        userInfo = self.getUserInfo()
        userMail = ""
        if userInfo:
            userMail = userInfo["mail"] 
        return userMail

    def get_ur_home_path(self):
        """Домашняя директория пользователя"""
        userName = self.Get('ur_login')
        homeDir = ""
        if userName:
            try:
                homeDir = pwd.getpwnam(userName).pw_dir
            except:
                return ""
        return homeDir