calculate-utils-2.2-install/pym/cl_fill_install.py

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

# Copyright 2010 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 os
import sys
import re
from crypt import crypt
import cl_overriding
from cl_datavars import glob_attr
from os import path
from os import readlink,access,R_OK
from cl_utils import isMount,typeFile,getTupleVersion,pathJoin,isFstabMount,\
                     listDirectory, getAvailableVideo, getUUIDDict, \
                     getUdevDeviceInfo, getPartitionDevice, getPartitionSize, \
                     isPkgInstalled, process, checkUtils, readLinesFile, \
                     FStab, lspci, getInstalledVideo,getDeviceType, \
                     getPartitionType, getOsProberHash, getProgPath, \
                     getRaidPartitions, getLvmPartitions, getLvmGroups, \
                     getPasswdUsers, readFile, readLinesFile
from cl_distr import DistributiveRepository,PartitionDistributive
from cl_fill import clLocale
from operator import itemgetter
from cl_template import _terms
from subprocess import PIPE, Popen
from cl_install import convertDictOpt
from utils import ip

from cl_lang import lang
tr = lang()
tr.setLocalDomain('cl_install')
tr.setLanguage(sys.modules[__name__])

class fillVars(object, glob_attr):
    nonTransferedDirs = ["/","/bin", "/dev", "/etc",
                           "/lib", "/lib32", "/lib64",
                           "/opt", "/proc", "/sbin",
                           "/sys", "/usr", "/var"]

    reWrongDevice = re.compile("|".join(['^fd','^ram','^loop']))

    def removeFloppy(self):
        """Remove floopy device and return floppyData"""
        floppyPath = '/dev/fd1'
        if path.exists(floppyPath):
            info = os.lstat(floppyPath)
            os.unlink(floppyPath)
            return (floppyPath,info)
        return None

    def restoreFloppy(self,floppyData):
        """Restore floppy device by floppyData"""
        try:
            if floppyData:
                os.mknod(floppyData[0],floppyData[1].st_mode,
                         floppyData[1].st_rdev)
                os.chown(floppyData[0],floppyData[1].st_uid,
                                       floppyData[1].st_gid)
        except:
            pass

    def get_ac_install_merge(self):
        """Need perform templates for install:merge or install:unmerge"""
        actionsMap = {'merge':'up',
                      'system':'up'}
        cl_action = self.Get('cl_action')
        if cl_action == 'system' and (
            self.Get('os_install_root_type') == 'flash' or
            self.Get('os_install_pxe') == 'on'):
            return ""
        return actionsMap[cl_action] if cl_action in actionsMap else ""

    def get_ac_install_system(self):
        """Need perform templates for install:system"""
        if self.Get('cl_action') == 'system' and \
            self.Get('os_install_root_type') != "flash" and \
            self.Get('os_install_pxe') != "on":
            return "up"
        else:
            return ""

    def get_ac_install_flash(self):
        """Need perform templates for install:flash"""
        clAction = self.Get('cl_action')
        if clAction == 'system' and self.Get('os_install_root_type') == 'flash':
            return "up"
        return ""

    def get_ac_install_pxe(self):
        """Need perform templates for install:flash"""
        clAction = self.Get('cl_action')
        if clAction == 'system' and self.Get('os_install_pxe') == 'on':
            return "up"
        return ""

    def get_ac_install_live(self):
        """Need perform templates for install:live"""
        if self.Get('ac_install_merge') == "up" and \
            self.Get('cl_chroot_status') == "off"  or \
            self.Get('cl_action') == 'live':
            return "up"
        else:
            return ""

    def get_os_install_net_hash(self):
        """Get net hash"""
        rePci = re.compile(r"(\d\d:\d\d\.\d)(?:/[^/]+){2}$")
        def getPci(interface):
            pathname = path.realpath(path.join('/sys/class/net',
                                                       interface))
            pci = rePci.search(pathname)
            if pci:
                return pci.group(1)
            else:
                return ""
        interfaces = ip.getInterfaces()
        net_hash = {}
        pciEthernet = lspci(shortInfo=True)
        nfsRoot = self.Get('os_install_root_dev') == '/dev/nfs'
        for interface in interfaces:
            ipaddr,mask = ip.receiveIpAndMask(interface)
            dhcp = ip.isDhcpIp(interface)
            mac = ip.receiveMac(interface)
            pciInfo = pciEthernet.get(getPci(interface),
                                      {'vendor':_("Unknown"),
                                       'name':_("vendor")})
            mapInterface = {}
            mapInterface["ip"] = ipaddr
            mapInterface["cidr"] = str(ip.maskToCidr(mask)) if mask else ""
            if ipaddr and mask:
                mapInterface["network"] = ip.getIpNet(ipaddr,mask=mask)
            else:
                mapInterface["network"] = ""
            mapInterface["dhcp"] = "on" if dhcp or nfsRoot else "off"
            mapInterface["mac"] = mac
            mapInterface["name"] = "{vendor} {name}".format(**pciInfo)
            net_hash[interface]=mapInterface
        return net_hash

    def get_os_install_net_dhcp_set(self):
        """DHCP or not"""
        return self.getAttributeFromHash('os_install_net_hash','dhcp')

    def get_os_install_net_route_hash(self):
        """Routing hash"""
        interfaces = self.Get('os_install_net_interfaces')
        interfaces_dhcp = self.Get('os_install_net_dhcp_set')
        staticInterface = \
            map(lambda x:x[0],
            filter(lambda x:x[1] == "off",
            zip(interfaces,interfaces_dhcp)))
        route_hash = {}
        if staticInterface:
            for network,routeParam in ip.getRouteTable(staticInterface):
                param = {}
                param['gw'] = routeParam.get('via','')
                param['src'] = routeParam.get('src','')
                param['dev'] = routeParam.get('dev','')
                route_hash[network] = param
        return route_hash

    def performRouteData(self,performFunc):
        routeMatrix = zip(self.Get('os_install_net_route_network'),
                          self.Get('os_install_net_route_gw'),
                          self.Get('os_install_net_route_dev'),
                          self.Get('os_install_net_route_src'))
        DEV,IP,CIDR,NET = 0,1,2,1
        return map(lambda x:performFunc(x[DEV],x[NET],routeMatrix),
               # union ip and mask to ip/net
               map(lambda x:(x[DEV],ip.getIpNet(x[IP],cidr=x[CIDR])),
               filter(lambda x:x[IP] and x[CIDR],
               zip(self.Get('os_install_net_interfaces'),
                   self.Get('os_install_net_ip'),
                   self.Get('os_install_net_cidr')))))

    def get_os_install_net_nmroute(self):
        """Route info for system-connections of NetworkManager"""
        def getRouteForInterfaceNM(interface,net,routeMatrix):
            NET,GW,DEV,SRC = 0,1,2,3
            defaultGw = map(lambda x:"%s;"%x[GW],
                        filter(lambda x:interface==x[DEV] and \
                                         x[NET]=="default",
                        routeMatrix))
            return "{0}\n".format(defaultGw[0] if defaultGw else "") + \
               "\n".join(
               # build string for route from net,gateway,dev and src
               map(lambda x:"routes{num}={ip};{cidr};{gateway};0;".format(
                   num=x[0]+1,
                   ip=x[1][NET].partition('/')[0],
                   cidr=x[1][NET].partition('/')[2],
                   gateway=x[1][GW] if x[1][GW] else "0.0.0.0"),
               # filter by interface and discard direct routes
               # example: for 192.168.1.5/24 discard 192.168.1.0/24 net
               enumerate(
               filter(lambda x:interface==x[DEV] and net!=x[NET] and \
                               x[NET]!="default",routeMatrix))))
        return self.performRouteData(getRouteForInterfaceNM)

    def get_os_install_net_route(self):
        """Route info for conf.d/net"""
        def getRouteForInterfaceConf(interface,net,routeMatrix):
            NET,GW,DEV,SRC = 0,1,2,3
            return "\n".join(
               # build string for route from net,gateway,dev and src
               map(lambda x:"{net}{gateway}{src}".format(
                   net=x[NET],
                   gateway=" via %s"%x[GW] if x[GW] else "",
                   src=" src %s"%x[SRC] if x[SRC] else ""),
               # filter by interface and discard direct routes
               # example: for 192.168.1.5/24 discard 192.168.1.0/24 net
               filter(lambda x:interface==x[DEV] and net!=x[NET],routeMatrix)))
        return self.performRouteData(getRouteForInterfaceConf)
        

    def get_os_install_net_route_network(self):
        return sorted(self.Get('os_install_net_route_hash').keys())

    def get_os_install_net_route_gw(self):
        return self.getAttributeFromHash('os_install_net_route_hash','gw')

    def get_os_install_net_route_dev(self):
        return self.getAttributeFromHash('os_install_net_route_hash','dev')

    def get_os_install_net_route_src(self):
        return self.getAttributeFromHash('os_install_net_route_hash','src')

    def get_os_net_interfaces_info(self):
        """Информация о существующих сетевых интерфейсах"""
        netInterfaces=self.Get("os_net_interfaces")
        listInterfacesInfo = []
        # Получена ли сеть по DHCP если нет to ip или off
        for interface,ipaddr,dhcp in zip(self.Get('os_install_net_interfaces'),
                                     self.Get('os_install_net_ip'),
                                     self.Get('os_install_net_dhcp_set')):
            if dhcp == "on":
                listInterfacesInfo.append((interface, "DHCP"))
            else:
                listInterfacesInfo.append((interface,
                                           ipaddr if ipaddr else "Off"))
        return ", ".join(map(lambda x:"%s (%s)"%(x[0],x[1]),
                             listInterfacesInfo))

    
    def getTableByChild(self,device):
        """Get table by child partitions"""
        syspath = getUdevDeviceInfo(name=device).get('DEVPATH','')
        if not syspath.startswith('/sys'):
            syspath = pathJoin('/sys',syspath)
        shortnameDevice = path.basename(device)
        childs = filter(lambda x:x.startswith(shortnameDevice),
                 listDirectory(syspath))
        if childs:
            child = pathJoin(syspath,childs[0])
            return getUdevDeviceInfo(path=child).get('ID_PART_ENTRY_SCHEME','')
        return ""
                 
    def get_os_device_hash(self):
        """Generate hash information about device"""
        def onlyDisk(devpath):
            """Check by udevadm that devpath is device (disk)"""
            prop = getUdevDeviceInfo(devpath)
            return prop.get("ID_TYPE","")=="disk" and \
                   prop.get("DEVTYPE","")=="disk"

        # get usb device by '/dev/disk/by-id'(usb devices contain 'usb' in name)
        diskIdPath = '/dev/disk/by-id'
        if path.exists(diskIdPath):
            usbdevices = \
             map(lambda x: readlink(path.join(diskIdPath,x)).rpartition('/')[2],
             filter(lambda x: x.startswith('usb-'),listDirectory(diskIdPath)))
        else:
            usbdevices = []
        # get devices from /sys/block directories(discard mem,sr,loop and other)
        sysBlockPath = '/sys/block'
        devices = map(lambda x:path.join(sysBlockPath,x),
                  filter(lambda x: onlyDisk(path.join(sysBlockPath,x)),
                  filter(lambda x: not self.reWrongDevice.search(x),
                  listDirectory(sysBlockPath))))
        device_hash = {}
        # filling hash
        for mapnum,device in enumerate(sorted(devices,key=self.separateDevice)):
            # get information by udev
            props = getUdevDeviceInfo(device)
            if not "DEVNAME" in props:
                continue
            # DEVNAME - /dev/(device_name)
            device = props['DEVNAME']
            device_hash[device] = {}
            # get partition table
            # (if PART_TABLE_TYPE absent then get by child partition)
            device_hash[device]['table'] = props.get('ID_PART_TABLE_TYPE',
                                           self.getTableByChild(device))
            # enumerate disk for legecy grub
            device_hash[device]['map'] = mapnum
            # if device is usb device
            if path.basename(device) in usbdevices:
                # check for usb flash (removeable fiel in sysfs contains "1")
                removablePath = '/sys/block/%s/removable'%path.basename(device)
                if os.access(removablePath,R_OK) and \
                    open(removablePath,'r').read().strip() == "1":
                    devtype = "flash" 
                else:
                    devtype = "usb-hdd" 
            else:
                devtype = "hdd" 
            # set detect device type (hdd,flash or usb-hdd)
            device_hash[device]['type'] = devtype
        return device_hash

    def get_os_disk_hash(self):
        """Get information about disk, which use for installation"""
        def selfOrPartition(devpath):
            """Return self device or partitions if it has them"""
            # search partition in device
            # get devices in sysfs which startswith devname
            partitions = \
                filter(lambda x:x.startswith(path.basename(devpath)),
                listDirectory(devpath))
            # if partition found then return them or partition on them
            if partitions:
                return filter(lambda x:x,
                       map(lambda x:selfOrPartition(path.join(devpath,x)),
                       partitions))
            else:
                return devpath

        devicesHash = self.Get('os_device_hash')
        sysBlockPath = '/sys/block'
        # get disks from sys block which not contains partitions
        new_disks = reduce(lambda x,y:x+ ([y] if type(y) == str else y),
                    map(lambda x:selfOrPartition(path.join(sysBlockPath,x)),
                    filter(lambda x: not self.reWrongDevice.search(x),
                    listDirectory(sysBlockPath))),[])
        disk_hash = {}

        fstab = FStab('/etc/fstab')
        raidUsedDisks = []
        lvmUsedDisks = []
        mapTypeUUID = {'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7':'0700',
                       '0657fd6d-a4ab-43c4-84e5-0933c84b4f4f':'8200',
                       'a19d880f-05fc-4d3b-a006-743f0f84911e':'FD00',
                       '21686148-6449-6e6f-744e-656564454649':'EF02'}
        # filling information about disks
        for disk in new_disks:
            props = getUdevDeviceInfo(disk)
            if not "DEVNAME" in props:
                continue
            devName = props['DEVNAME']
            dev_hash = {}
            dev_hash['uuid'] = props.get('ID_FS_UUID','')
            dev_hash['format'] = props.get('FSTAB_TYPE') or \
                                 fstab.getBy(what=fstab.TYPE,eq=devName) or \
                                 props.get('ID_FS_TYPE','')
            dev_hash['name'] = props.get('ID_FS_LABEL','')
            dev_hash['table'] = props.get('ID_PART_ENTRY_SCHEME','')
            # schema device (disk-partition or disk-partition-raid and etc)
            dev_hash['type'] = getDeviceType(disk)
            dev_hash['id'] = \
                props.get('ID_PART_ENTRY_TYPE','').rpartition("x")[2]
            dev_hash['id'] = mapTypeUUID.get(dev_hash['id'],dev_hash['id'])
            devParent = getPartitionDevice(disk)
            dev_hash['parent'] = devParent
            # primary, extended or logical
            dev_hash['part'] = getPartitionType(props)
            # get options from fstab
            dev_hash['options'] = fstab.getBy(what=fstab.OPTS,eq=devName) or ""
            # get disk size
            dev_hash['size'] = getPartitionSize(disk)
            if devParent in devicesHash and 'ID_PART_ENTRY_NUMBER' in props:
                dev_hash['grub'] = "%s,%d"%(devicesHash[devParent]['map'],
                                    int(props['ID_PART_ENTRY_NUMBER'])-1)
            else:
                dev_hash['grub'] = ""
            disk_hash[devName] = dev_hash
            # if device raid then get its partition and
            # add to raid partitions list
            if "raid" in dev_hash['type']:
                raidUsedDisks.extend(map(lambda x:(devName,x),
                                         getRaidPartitions(disk)))
            # if device lvm then get its partition and 
            # add to lvm partitions list
            if dev_hash['type'].endswith("lvm"):
                prop = getUdevDeviceInfo(path=disk)
                lvmUsedDisks.extend(map(lambda x:(devName,x),
                                getLvmPartitions(prop.get('DM_VG_NAME',''),
                                                 prop.get('DM_LV_NAME',''))))
        # fix type information for raid disks
        for disk,part in raidUsedDisks:
            if part in disk_hash:
                disk_hash[part]['type'] = "%s-raidmember(%s)"%(
                                          disk_hash[part]['type'],disk)
        # fix type information for lvm disks
        for disk,part in lvmUsedDisks:
            if part in disk_hash:
                disk_hash[part]['type'] = "%s-lvmmember(%s)"%(
                                          disk_hash[part]['type'],disk)
        return disk_hash

    def separateDevice(self,device):
        return map(lambda x: int(x) if x.isdigit() else x,
                   re.findall('\d+|\D+',device))

    def get_os_disk_dev(self):
        """List of available partition devices"""
        return sorted(self.Get('os_disk_hash').keys(),
                      key=self.separateDevice)

    def getAttributeFromHash(self,var,attr):
        hash = self.Get(var)
        return map(lambda x: hash[x][attr] if attr in hash[x] else "",
                sorted(hash.keys(),
                       key=self.separateDevice))

    def get_os_install_disk_id(self):
        """List id for partition after installation"""
        diskHash = self.Get('os_disk_hash')
        def getIdByFS(fs,parttable,oldid):
            if parttable == "dos":
                return PartitionDistributive.formatId.get(fs,oldid)
            elif parttable == "gpt":
                return PartitionDistributive.formatIdGpt.get(fs,oldid)
            return oldid
        return map(lambda x:getIdByFS(x[0],
                        diskHash.get(x[2],{}).get('table',None),x[1]),
                   zip(self.Get('os_install_disk_format'),
                       self.Get('os_disk_id'),
                       self.Get('os_disk_dev')))

    def get_os_disk_id(self):
        """List id for partition devices"""
        return self.getAttributeFromHash('os_disk_hash','id')

    def get_os_disk_uuid(self):
        """List uuid for partition devices"""
        return self.getAttributeFromHash('os_disk_hash','uuid')

    def get_os_disk_options(self):
        """List mount options for partition devices"""
        return self.getAttributeFromHash('os_disk_hash','options')

    def get_os_install_disk_use(self):
        """Get real id (by cl_uuid_set) device"""
        if self.Get('cl_uuid_set') == "on":
            return map(lambda x:"UUID=%s"%x[0] if x[0] else x[1],
                   zip(self.Get('os_install_disk_uuid'),
                       self.Get('os_disk_dev')))
        else:
            return self.Get('os_disk_dev')

    def get_os_install_disk_uuid(self):
        """List uuid for partition devices"""
        diskDev = self.Get('os_disk_dev')
        hashUUID = getUUIDDict(revers=True)
        return map(lambda x:hashUUID.get(x,"")[5:],diskDev)

    def get_os_install_disk_options(self):
        """List mount options for partition devices of installed os"""
        return self.Get('os_disk_options')

    def get_os_install_disk_mount(self):
        """List mounted points for installed system"""
        rootdev = self.Get('os_install_root_dev')
        disk_hash = self.Get('os_disk_hash')
        fstab = FStab('/etc/fstab')
        fstabHasSwap = bool(fstab.isExists(what=FStab.TYPE,eq="swap"))
        def getMountPoint(disk):
            """Get mount point for disk. If fstab not contains swap then
            for swap use all swap formated partition"""
            if disk == rootdev:
                return "/"
            elif not fstabHasSwap and "format" in disk_hash[disk] and \
                "swap" in disk_hash[disk]['format']:
                return "swap"
            else:
                mount_point = fstab.getBy(eq=disk)
                if mount_point in self.nonTransferedDirs:
                    return ""
                else:
                    return mount_point
        return map(lambda x: getMountPoint(x),
               sorted(
               self.Get('os_disk_hash').keys(),key=self.separateDevice))

    def get_os_disk_mount(self):
        """List mounted points for current operation system"""
        disk_hash = self.Get('os_disk_hash')
        fstab = FStab('/etc/fstab')
        rootdev = self.Get('os_root_dev')
        return map(lambda x: '/' if x == rootdev else fstab.getBy(eq=x) or "",
                    sorted(self.Get('os_disk_hash').keys(),
                           key=self.separateDevice))

    def get_os_disk_format(self):
        """List filesystem for partition devices"""
        return self.getAttributeFromHash('os_disk_hash','format')

    def get_os_install_disk_format(self):
        """Install list filesystem for partition devices"""
        return self.Get('os_disk_format')

    def get_os_install_disk_grub(self):
        """List grub id for partition devices"""
        def swapfirstnum(x,first,second):
            disk,delimeter,part = x.partition(',')
            if disk == str(first):
                return "%d,%s"%(second,part)
            elif disk == str(second):
                return "%d,%s"%(first,part)
            return x

        curDiskGrub = self.getAttributeFromHash('os_disk_hash','grub')
        bootDev=sorted(
                filter(lambda x:x[0] in ('/','/boot'),
                zip(self.Get('os_install_disk_mount'),
                    self.Get('os_disk_grub'))),
                key=lambda x:x[0],reverse=True)
        if bootDev:
            bootDev=bootDev[0][1].partition(',')[0]
            bootDevName = filter(lambda x:str(x[1])==bootDev,
                          zip(self.Get('os_device_dev'),
                              self.Get('os_device_map')))
            if bootDevName:
                if bootDevName[0][0] == self.Get('os_install_mbr'):
                    return map(lambda x:swapfirstnum(x,bootDevName[0][1],0),
                           curDiskGrub)
        return curDiskGrub

    def get_os_disk_grub(self):
        """List grub id for partition devices"""
        return self.getAttributeFromHash('os_disk_hash','grub')

    def get_os_disk_part(self):
        """Type of partition devices (primary, extended or logical)"""
        return self.getAttributeFromHash('os_disk_hash','part')

    def get_os_disk_table(self):
        """Partition table for this partition"""
        return self.getAttributeFromHash('os_disk_hash','table')

    def get_os_install_disk_perform_format(self):
        """Needformat partitions"""
        return self.getAttributeFromHash('os_disk_hash','needformat')

    def get_os_disk_size(self):
        """Partition size"""
        return self.getAttributeFromHash('os_disk_hash','size')

    def get_os_disk_type(self):
        """Partition type"""
        return self.getAttributeFromHash('os_disk_hash','type')

    def get_os_disk_content(self):
        """Partition content"""
        distrRep = DistributiveRepository()
        osProberHash = getOsProberHash(getContentFunc=distrRep._getfromcontent)
        devicesHash = self.Get('os_device_hash')
        def detectContent(devName,devType,devParent,mountPoint):
            if mountPoint == '/':
               return "{short}-{march}{build}".format(
                       short=self.Get('os_linux_shortname'),
                       march=self.Get('os_arch_machine'),
                       build="-%s"%(self.Get('os_linux_build') if
                             self.Get('os_linux_build') else
                             self.Get('os_linux_ver')))
            content = osProberHash.get(devName,'')
            if not content and ((devParent in devicesHash and \
                devicesHash[devParent]['type'] == "flash") or 
                "cdrom" in devType or devType.endswith('raid') or
                devType.endswith('lvm')):
                dataInfo = distrRep._getfromcontent(devName)
                if "build" in dataInfo and dataInfo['build']:
                    if "cdrom" in devType:
                        dataInfo['livetype'] = " livecd"
                    elif devType.endswith('raid') or devType.endswith('lvm'):
                        dataInfo['livetype'] = ""
                    else:
                        dataInfo['livetype'] = " liveusb"
                    content = \
                        "{name}-{march}-{build}{livetype}".format(
                            **dataInfo)
            return content
        return map(lambda x:detectContent(x[0],x[1],x[2],x[3]),
               zip(self.Get('os_disk_dev'),
                   self.Get('os_disk_type'),
                   self.getAttributeFromHash('os_disk_hash','parent'),
                   self.Get('os_disk_mount')))

    def get_os_disk_name(self):
        """Label of partitions"""
        return self.getAttributeFromHash('os_disk_hash','name')

    def get_os_device_dev(self):
        """Devices"""
        return sorted(self.Get('os_device_hash').keys(),
                      key=self.separateDevice)

    def get_os_device_type(self):
        """Device type (hdd,cdrom,usb-flash)"""
        return self.getAttributeFromHash('os_device_hash','type')

    def get_os_device_map(self):
        """Map number for grub"""
        return self.getAttributeFromHash('os_device_hash','map')

    def get_os_device_table(self):
        """Table on device"""
        return self.getAttributeFromHash('os_device_hash','table')

    def get_os_install_grub_devicemap_conf(self):
        """Content of device.map file for grub"""
        rootType = self.Get('os_install_root_type')
        return "\n".join(map(lambda x: "(hd%s)   %s" % (x[0],x[1]),
                                filter(lambda x:x[2] == rootType,
                                zip(self.Get('os_device_map'),
                                    self.Get('os_device_dev'),
                                    self.Get('os_device_type')))))

    def get_os_install_fstab_mount_conf(self):
        """Information about mount points for fstab"""
        devicesForFstab = sorted(filter(lambda x:x[1] != "" and x[1] != "swap",
                                        zip(self.Get('os_install_disk_use'),
                                        self.Get('os_install_disk_mount'),
                                        self.Get('os_install_disk_format'),
                                        self.Get('os_install_disk_options'),
                                        self.Get('os_disk_dev'))),
                                 lambda x,y: cmp(self.separateDevice(x[1]),
                                                 self.separateDevice(y[1])))
        if self.Get('os_install_scratch') == "on":
            devicesForFstab = filter(lambda x:x[1] != "/", devicesForFstab)

        # rootLine one string, but it correct work if devicesForFstab is empty
        rootLine =  "\n".join(map(lambda x: "%s\t%s\t%s\t%s\t0 2" %
                                (self._comment(x[0],x[1],x[4]),x[1],x[2],x[3]),
                                        devicesForFstab[:1]))
        otherLines = "\n".join(map(lambda x: "%s\t%s\t%s\t%s\t0 0" %
                                (self._comment(x[0],x[1],x[4]),x[1],x[2],x[3]),
                                        devicesForFstab[1:]))

        bindData = zip(self.Get('os_install_bind_path'),
                       self.Get('os_install_bind_mountpoint'))

        bindLines = "\n".join(map(lambda x: "%s\t%s\tnone\tbind\t0 0"\
                                  %(x[0],x[1]), bindData))
        return "\n".join(filter(lambda x: x, [rootLine,otherLines,bindLines]))



    #def get_os_net_config_info(self):
        #"""Content of /etc/conf.d/net file"""

        #def getNetGateways():
            #"""Get the network gateways"""
            #execStr = 'route -n'
            #res = self._runos(execStr,env={"LANG":"C"})
            #if res is False:
                #cl_overriding.printERROR("Failed to execute '%s'"%execStr)
                #cl_overriding.exit(1)
            #flagData = False
            ## retData = {'eth0':'10.0.0.1' ...}
            #retData = {}
            #for line in res:
                #if flagData:
                    #routeData = map(lambda y: y.strip(),
                                    #filter(lambda x: x, line.split(" ")))
                    #if len(routeData) == 8:
                        #if routeData[3] == "UG" and routeData[7]!="lo":
                            #retData[routeData[7]] = routeData[1]
                #if line.startswith('Destination'):
                    #flagData = True
            #return retData

        #strIpAllow = self.Get('os_net_ip')
        #strNetAllow = self.Get('os_net_allow')
        #strInterfInfo = self.Get('os_net_interfaces_info')
        #systemName = self.Get('os_linux_shortname')
        #ret = ""
        #retList = []
        #gatewaysData = getNetGateways()
        #if strIpAllow and strNetAllow:
            #listDevInfo = map(lambda x: x.split(" "),strInterfInfo.split(","))
            #listDevInfo = map(lambda x: (x[0], x[1][1:-1]),listDevInfo)
            #listDevInfo = filter(lambda x: x[1]!="Off" ,listDevInfo)
            #listIpNet = map(lambda x: (x[0],"%s/%s"%(x[1],x[2])),
                            #zip(listDevInfo,strIpAllow.split(","),
                                #map(lambda x: x.partition("/")[2],
                                    #strNetAllow.split(","))))
            #flagNotPlug = not systemName in ("CLS")
            #for info, ipNet in listIpNet:
                #dev, data = info 
                #if data=="DHCP":
                    #retList.append('config_%s=( "dhcp" )'%dev)
                    #if flagNotPlug:
                        #retList.append('modules_%s=( "!plug" )'%dev)
                #else:
                    #retList.append('config_%s=( %s )'%(dev,ipNet))
                    #if gatewaysData and dev in gatewaysData:
                        #retList.append('routes_%s=( "default gw %s" )'\
                                        #%(dev,gatewaysData[dev]))
                    #if flagNotPlug:
                        #retList.append('modules_%s=( "!plug" )'%dev)
        #return "\n".join(retList)

    def _comment(self,s,mp,dev):
            if s.startswith("UUID"):
                return "# %s was on %s during installation\n%s" % (mp,dev,s)
            else:
                return s

    def get_os_install_fstab_swap_conf(self):
        """Information about swap for fstab"""
        return "\n".join(map(lambda x: "%s\tnone\tswap\tsw\t0 0"%\
                                    self._comment(x[0],"swap",x[2]),
                                filter(lambda x: x[1] == "swap",
                                    zip(self.Get('os_install_disk_use'),
                                        self.Get('os_install_disk_mount'),
                                        self.Get('os_disk_dev')))))

    def get_os_install_linux_system(self):
        """Get linux system (server or desktop)"""
        shortName = self.Get('os_install_linux_shortname')
        return self.dictNameSystem.get(shortName,"")

    def get_os_install_kernel_scheduler(self):
        """Get scheduler for install root device"""
        root_dev = filter(lambda x: x[1] == '/',
                            zip(self.Get('os_disk_dev'),
                                self.Get('os_install_disk_mount')))
        if root_dev:
            root_dev = root_dev[0][0]
            root_dev = filter(lambda x: x in root_dev,
                              self.Get('os_device_dev'))
            if root_dev:
                root_dev = root_dev[0].rpartition('/')[2]
                pathScheduler = '/sys/block/%s/queue/scheduler'%root_dev
                if access(pathScheduler,R_OK):
                    res = re.search("\[([^\]]+)\]",
                                    open(pathScheduler).read(),re.S)
                    if res:
                        return res.groups()[0]
        return "cfq"

    def get_os_kernel_schedulers(self):
        
        """Get scheduler for install root device"""
        root_dev = self.Get('os_device_dev')
        if root_dev:
            root_dev = root_dev[0].rpartition('/')[2]
            pathScheduler = '/sys/block/%s/queue/scheduler'%root_dev
            return map(lambda x:x.strip("[]"),
                   readFile(pathScheduler).strip().split())
        return []

    def get_os_install_lvm_set(self):
        """Using lvm"""
        lvm = filter(lambda x:x[1] != '' and "lvm" in x[0],
                    zip(self.Get('os_disk_type'),
                        self.Get('os_install_disk_mount')))
        return "on" if lvm else "off"

    def get_os_install_mdadm_set(self):
        """Using mdadm"""
        mdadm = filter(lambda x:x[1] != '' and "raid" in x[0],
                    zip(self.Get('os_disk_type'),
                        self.Get('os_install_disk_mount')))
        return "on" if mdadm else "off"

    def get_os_install_kernel_attr(self):
        """Kernel attributes"""
        # on usb-hdd install must be "delay=5"
        attr = ""
        if self.Get('os_install_root_type') == 'usb-hdd':
            attr = " scandelay=5"
        if self.Get('os_install_mdadm_set') == 'on':
            attr += " domdadm"
        if self.Get('os_install_lvm_set') == 'on':
            attr += " dolvm"
        return attr

    def get_os_install_kernel_resume(self):
        """install kernel resume parameter"""
        for dev, install in zip(self.Get('os_install_disk_use'),
                                self.Get('os_install_disk_mount')):
            if install == "swap":
                return "real_resume=%s"%dev
        return ""

    def get_os_install_arch_machine(self):
        """install maching architecture"""
        return self.Get('os_arch_machine')

    def get_cl_image_path(self):
        if self.Get('os_root_type') == "livecd":
            if self.Get('os_scratch') == "on" and path.exists('/mnt/flash'):
                livedistr = ['/mnt/flash']
            elif path.exists('/mnt/squash'):
                livedistr = ['/mnt/livecd']
            else:
                livedistr = ['/mnt/cdrom']
        else:
            livedistr = []
        rootDev = self.Get('os_install_root_dev')
        livedistr += \
            map(lambda x:x[0],
            filter(lambda x:" live" in x[1] and x[0] != rootDev,
            zip(self.Get('os_disk_dev'),
                self.Get('os_disk_content'))))
        return ['/var/calculate/remote/linux',
                '/var/calculate/linux'] + livedistr

    def getImage(self,scratch,rootType,imagePath,archMachine,
                 shortName,linuxVer=None):
        """Get image by parameters"""
        if scratch == "on" or rootType == "flash":
            discardType = ["dir"]
        else:
            discardType = []
        if type(imagePath) == str:
            imagePath = [imagePath]
        distRep = DistributiveRepository(imagePath)
        return distRep.getBestDistributive(march=archMachine,
                                           shortname=shortName.lower(),
                                           discardType=discardType,
                                           version=linuxVer) or ""

    def get_cl_image(self):
        """Get image file from distributive repository"""
        if self.Get('cl_action') != 'system':
            return ""
        return self.getImage(self.Get('os_install_scratch'),
                             self.Get('os_install_root_type'),
                             self.Get('cl_image_path'),
                             self.Get('os_install_arch_machine'),
                             self.Get('os_install_linux_shortname'),
                             None)
                             #self.Get('os_install_linux_ver'))

    def get_os_install_linux_shortname(self):
        """Shortname of installation os"""
        return self.Get('os_linux_shortname')

    def calculateini_to_dict(self,filename):
        if os.access(filename,os.R_OK):
            return dict(map(lambda x: x.strip().rpartition('=')[0::2],
                            open(filename,'r')))
        else:
            return {}

    def get_os_install_linux_ver(self):
        """Linux version of installation os"""
        if self.Get('cl_action') != "system":
            return self.Get('os_linux_ver')
        imagename = self.getImage(self.Get('os_install_scratch'),
                                  self.Get('os_install_root_type'),
                                  self.Get('cl_image_path'),
                                  self.Get('os_install_arch_machine'),
                                  self.Get('os_install_linux_shortname'))
        if not imagename and self.Get('cl_action') != 'merge':
            return ""
        d = DistributiveRepository()._getfromcontent(imagename)
        if "linuxver" in d and d['linuxver'] != "0":
            return d['linuxver']
        elif "ver" in d and d['ver'] != "0":
            return d['ver']
        res = DistributiveRepository.reDistName.search(imagename)
        if res:
            return res.groupdict()['ver']
        if self.Get('os_install_linux_shortname') == \
            self.Get('os_linux_shortname'):
            return self.Get('os_linux_ver')
        return "0"

    def get_cl_pkgdir_path(self):
        return "/var/calculate/remote/packages/%s/%s" % (
                self.Get('os_linux_shortname'),
                self.Get('os_install_arch_machine'))

    def get_os_install_linux_subname(self):
        """Subname of installation os"""
        linuxShortName = self.Get("os_install_linux_shortname")
        return self.dictLinuxSubName.get(linuxShortName,"")

    def get_os_install_linux_name(self):
        """Name of installation os"""
        linuxShortName = self.Get("os_install_linux_shortname")
        return self.dictLinuxName.get(linuxShortName,"Linux")

    def get_os_bind_hash(self):
        """List mounted points for current operation system"""
        # convert fstab to
        # [['/dev/sda3', '/', '', 'reiserfs', 'noatime', '', '', '0', '2\n'],
        # ['/dev/sda5', '/var/calculate', 'reiserfs', 'noatime', '0', '0\n']]
        listFstab = filter(lambda x: len(x)>=4,
                    map(lambda x: filter(lambda x: x,
                                         x.replace('\t',' ').split(' ')),
                        filter(lambda x: not x.startswith('#') and x.strip(),
                               open("/etc/fstab"))))
        return dict(map(lambda x:[x[0],x[1]],
                        filter(lambda x: "bind" in x[3],
                               listFstab)))

    def get_os_bind_path(self):
        """Directories for bind"""
        return sorted(self.Get('os_bind_hash').keys())

    def get_os_bind_mountpoint(self):
        """Mountpoint for directories bind"""
        bindhash = self.Get('os_bind_hash')
        return [ bindhash[i] for i in sorted(bindhash.keys()) ]

    def get_os_install_bind_path(self):
        """Install directories for bind"""
        return map(lambda x:x[0],
                   # skip nonTransferedDirs
                   filter(lambda x: not x[0] in self.nonTransferedDirs and
                                    not x[1] in self.nonTransferedDirs,
                          zip(self.Get('os_bind_path'),
                              self.Get('os_bind_mountpoint'))))

    def get_os_install_bind_mountpoint(self):
        """Mountpoint for install directories bind"""
        return map(lambda x:x[1],
                   # skip nonTransferedDirs
                   filter(lambda x: not x[0] in self.nonTransferedDirs and
                                    not x[1] in self.nonTransferedDirs,
                          zip(self.Get('os_bind_path'),
                              self.Get('os_bind_mountpoint'))))

    def get_os_install_root_dev(self):
        return self.Get('os_root_dev')

    def get_os_install_clock_timezone(self):
        """timezone for clock"""
        return self.Get('os_clock_timezone')

    def get_os_install_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_os_install_x11_resolution(self):
        """Xorg resolution"""
        # get resolution from xorg.log
        res = self.Get('os_x11_resolution')
        if res or self.Get('os_install_root_type') in ('livecd','usb-hdd'):
            return res
        else:
            return "1024x768"
    
    def get_os_install_x11_video_drv(self):
        """Video driver used by xorg"""
        if self.Get('os_install_root_type') == 'usb-hdd':
            prefix = self.Get('cl_chroot_path')
            videoVal = self.getValueFromCmdLine("calculate","video")
            videoVal = {'i915':'intel'}.get(videoVal,videoVal)
            if not isPkgInstalled('xorg-server',
                                  prefix=self.Get('cl_chroot_path')) or \
                videoVal in getAvailableVideo(prefix=prefix):
                return videoVal
            return self.getVideoByDefault(getInstalledVideo(prefix=prefix))
        else:
            return self.Get('os_x11_video_drv')
    
    def get_os_install_x11_composite(self):
        """On/off composite"""
        defaultCompositeOn = ("nvidia","intel","fglrx","nouveau","radeon")
        composite = self.getValueFromCmdLine("calculate",5)
        videodrv = self.getValueFromCmdLine("calculate",4)
        if videodrv != "auto":
            composite = {'nocomposite':'off',
                         'off':'off',
                         'on':'on',
                         'composite':'on'}.get(composite)
        else:
            composite = None

        if self.Get('os_x11_video_drv') in defaultCompositeOn:
            defaultComposite = "on"
        else:
            defaultComposite = "off"
        state = self.get_composite_from_xorgconf()
        return composite or state or defaultComposite

    def get_os_install_linguas(self):
        """Current linguas"""
        def get_linguas(lines):
            linguas = map(lambda x:x.strip().rpartition('=')[-1].strip('"\''),
                       filter(lambda x: x.startswith("LINGUAS="),
                              lines))
            return linguas[-1] if linguas else ""
        makeconf = '/etc/make.conf'
        infocommand = 'emerge --info'
        # get linguas from make.conf, emerge --info or default
        curlanguage = self.Get('os_install_locale_language')
        return get_linguas(open(makeconf,'r')) or \
               " ".join(filter(lambda x:x=="en" or x==curlanguage,
                      get_linguas(self._runos(infocommand) or []).split())) or \
               "bg en de es fr it pl pt_BR ru uk"

    def get_os_install_locale_consolefont(self):
        """consolefont"""
        locale = clLocale()
        return locale.getFieldByKeymap("consolefont",
                            self.Get('os_install_locale_keymap'))

    def get_os_install_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_install_locale_lang
        keymap = self.getValueFromConfig(keymapConfd,'KEYMAP')
        if keymap:
            return keymap
        return locale.getFieldByLang("keymap",
                        self.Get("os_install_locale_lang"))

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

    def get_os_install_locale_locale(self):
        """locale (example: ru_RU.UTF-8)"""
        return self.Get('os_locale_locale')

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

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

    def get_os_install_locale_xkb(self):
        """xkb layouts (example: en,ru)"""
        locale = clLocale()
        return locale.getFieldByLang("xkblayout",
                    self.Get('os_install_locale_lang'))

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

    def get_os_install_net_hostname(self):
        """Computer hostname"""
        return self.Get("os_net_hostname") or "calculate"

    def get_os_install_net_allow(self):
        """Allowed network"""
        return self.Get("os_net_allow")

    def get_os_install_net_ip(self):
        """Current ip"""
        return self.getAttributeFromHash('os_install_net_hash','ip')

    def get_os_install_net_cidr(self):
        """Current mask"""
        return self.getAttributeFromHash('os_install_net_hash','cidr')

    def get_os_install_net_network(self):
        """Current network"""
        return self.getAttributeFromHash('os_install_net_hash','network')

    def get_os_install_net_mac(self):
        """Current mac"""
        return self.getAttributeFromHash('os_install_net_hash','mac')

    def get_os_install_net_name(self):
        """Current mac"""
        return self.getAttributeFromHash('os_install_net_hash','name')

    def get_os_install_net_gateway(self):
        """Get default gateway"""
        ipCmd = checkUtils("/sbin/ip")
        reDefault = re.compile("^default via ({0})".format(ip.IP_ADDR))
        gw = map(lambda x:x.group(1),
            filter(lambda x:x,
            map(reDefault.search,
            process(ipCmd,"route"))))
        if gw:
            return gw[0]
        else:
            return ""

    def isDNSByDHCP(self):
        """If first interface get ip by DHCP dns must be DHCP"""
        dhcps = self.Get('os_install_net_dhcp_set')
        if dhcps:
            if dhcps[0] == "on":
                return True
        return False

    def get_os_install_net_dns(self):
        """Get current name servers"""
        dnsIps = filter(ip.checkIp,
                 map(lambda x:x.strip().partition("nameserver")[2].strip(),
                 filter(lambda x:x.lstrip().startswith("nameserver"),
                 readLinesFile('/etc/resolv.conf'))))
        return "" if self.isDNSByDHCP() else " ".join(dnsIps)

    def get_os_install_net_dns_search(self):
        """Get current name servers"""
        dnsSearch = " ".join(
                    map(lambda x:x.strip().partition("search")[2].strip(),
                    filter(lambda x:x.lstrip().startswith("search"),
                    readLinesFile('/etc/resolv.conf'))))
        return "" if self.isDNSByDHCP() else dnsSearch

    def get_os_install_net_conf(self):
        """Net setup (networkmanager or openrc)"""
        if filter(lambda x:x.lower() == ("networkmanager"),
           listDirectory('/etc/runlevels/boot')+
           listDirectory('/etc/runlevels/default')) \
            or self.Get('os_install_root_type') == "livecd" and \
               self.Get('os_install_root_dev') != "/dev/nfs":
            if isPkgInstalled("net-misc/networkmanager",
                              prefix=self.Get('cl_chroot_path')):
                return "networkmanager"
        return "openrc"

    def get_os_install_net_interfaces(self):
        """Net interfaces"""
        return sorted(self.Get('os_install_net_hash').keys())

    def get_os_install_net_domain(self):
        """Domain"""
        if path.exists('/proc/self/fd/1') and \
            readlink('/proc/self/fd/1') == '/dev/console' and \
            self.Get('os_root_dev') == '/dev/nfs':
            return "local"
        textLines = self._runos("hostname -d 2>&1")
        domain = ""
        if textLines:
            domain = textLines[0]
        return domain or "local"

    def get_os_install_root_type(self):
        """Type of device for install"""
        rootdev = self.Get('os_install_root_dev')
        devicetype = getPartitionDevice(
                        getUdevDeviceInfo(name=rootdev).get('DEVPATH',''))
        devicetype = map(lambda x: x[1],
                     filter(lambda x:x[0] == devicetype,
                     zip(self.Get('os_device_dev'),
                         self.Get('os_device_type'))))
        if devicetype:
            return devicetype[0]
        else:
            return self.Get('os_root_type')

    def get_os_install_dev_from(self):
        """Detect previous system"""
        calculate1ini = "/etc/calculate/calculate.ini"
        calculate1param = "install.devfrom"
        if path.exists(calculate1ini):
            res = reduce(lambda x,y: [y.rpartition('=')[2].strip()],
                      filter(lambda x: x.partition("=")[0] == calculate1param,
                             open(calculate1ini,"r")),
                      "")
            if res:
                return res[-1]
        return ""

    def get_os_install_makeopts(self):
        """Get makeopts for make.conf file"""
        cpunum = self.Get('hr_cpu_num')
        if cpunum == 1:
            return "-j1"
        else:
            return "-j%d"%(cpunum+1)

    def get_os_install_kernel(self):
        bootdir = path.join(self.Get('cl_chroot_path'),'boot')
        modulesdir = path.join(self.Get('cl_chroot_path'),'lib/modules')
        validKernel = listDirectory(modulesdir)
        kernelFiles = self.getFilesByType(bootdir,"Linux kernel")
        installMarch = self.Get('os_install_arch_machine')
        kernelsWithVer = \
            map(lambda x:(x[0],(getTupleVersion("".join(x[1].groups()[0:3:2])),
                                path.getmtime(x[0]))),
                filter(lambda x:x[1] and x[1].group() in validKernel and
                       installMarch in x[0].rpartition('/')[2],
                       map(lambda x:(x[0],self.reFindVer.search(x[1])),
                       kernelFiles)))
        if kernelsWithVer:
            return path.split(max(kernelsWithVer,key=itemgetter(1))[0])[-1]
        else:
            return "vmlinuz"

    def get_os_install_initrd(self):
        return self.getInitrd(self.Get('os_install_arch_machine'),
                              self.Get('os_install_linux_shortname'),
                              self.Get('cl_chroot_path'),
                              self.Get('os_install_kernel'),
                              suffix="",notsuffix="-install") or \
               self.getInitrd(self.Get('os_install_arch_machine'),
                              self.Get('os_install_linux_shortname'),
                              self.Get('cl_chroot_path'),
                              self.Get('os_install_kernel'),
                              suffix="-install")[:-8] \
                              or "initrd"

    def get_os_install_initrd_install(self):
        return self.getInitrd(self.Get('os_install_arch_machine'),
                              self.Get('os_install_linux_shortname'),
                              self.Get('cl_chroot_path'),
                              self.Get('os_install_kernel'),
                              suffix="-install") or "initrd-install"

    def get_os_install_kernel_config(self):
        configfile = self.Get('os_install_kernel').replace('vmlinuz', 'config')
        if configfile.startswith('config') and path.exists(
                path.join(self.Get('cl_chroot_path'),'boot',configfile)):
            return configfile
        else:
            return ""

    def get_os_install_system_map(self):
        systemmapfile = self.Get('os_install_kernel').replace('vmlinuz',
                        'System.map')
        if systemmapfile.startswith('System.map') and path.exists(
                path.join(self.Get('cl_chroot_path'),'boot',systemmapfile)):
            return systemmapfile
        else:
            return ""

    def get_os_grub_conf(self):
        """Use for generate grub.conf for new system"""
        pathGrubConf = "/boot/grub/grub.conf"
        replace = ""
        if os.access(pathGrubConf,os.R_OK):
            reRemoveComments = re.compile("(^|\n)[\t ]*#[^\n]*?(?=\n|$)", re.S)
            reGrubEntry = re.compile("(title.*?)(?=title|$)", re.S | re.I )
            reRootEntry = re.compile("root=(\S+)")
            grubconf = reRemoveComments.sub("",open(pathGrubConf,'r').read())
            roothd = filter(lambda x: x[1] == '/',
                            zip(self.Get('os_disk_dev'),
                                self.Get('os_install_disk_mount'),
                                self.Get('os_disk_uuid')))
            if roothd:
                transRoot = \
                    filter(lambda x:x != roothd[0][0] and \
                                    x != "UUID=%s"%roothd[0][2],
                    self.Get('os_disk_dev')+
                        map(lambda x:"UUID=%s"%x,
                        filter(lambda x:x,self.Get('os_disk_uuid'))))
                return ("".join(
                    map(lambda x:x[0],
                    filter(lambda x:not x[1] or x[1].groups()[0] in transRoot,
                    map(lambda x:(x,reRootEntry.search(x)),
                    reGrubEntry.findall(grubconf)))))).strip()
        return ""

    def get_cl_migrate_user(self):
        """migrate users"""
        return getPasswdUsers()

    def get_cl_migrate_user_pwd(self):
        retList = []
        fileName = "/etc/shadow"
        if access(fileName, R_OK):
            migrateusers = self.Get("cl_migrate_user")
            if migrateusers:
                lenData=9
                shadowData = filter(lambda x: len(x)==lenData,
                                    map(lambda x: x.rstrip().split(":"),
                                    open(fileName)))
                shadowData = filter(lambda x: x[0] in migrateusers, shadowData)
                shadowData = map(lambda x: (x[0], x[1]), shadowData)
                shadowUsers = map(lambda x: x[0], shadowData)
                for userName in migrateusers:
                    if userName in ("root"):
                        if userName in shadowUsers:
                            userData = filter(lambda x: x[0]==userName,
                                              shadowData)
                            hashPwd = userData[0][1]
                            salt = "".join(hashPwd.rpartition("$")[:1])
                            if salt and crypt(userName, salt) == hashPwd:
                                retList.append("yes")
                            else:
                                retList.append("no")
                        else:
                            retList.append("yes")
                    else:
                        if userName in shadowUsers:
                            retList.append("no")
                        else:
                            retList.append("yes")
        return retList

    def get_os_format_type(self):
        """Filesystem format support by calcualte-install"""
        return filter(lambda x:not x in ("default","noformat") and
                               x in convertDictOpt._fileSystemOpt,
               filter(lambda x:not x.startswith("_"),
                      convertDictOpt._fileSystemOpt.keys())+\
                      convertDictOpt._propertiesFileSystem.keys())

    def get_os_format_use(self):
        """Avialable format by mkfs utility"""
        return map(lambda x:"yes" 
            if path.exists(convertDictOpt._fileSystemOpt[x]["makefs"])
            else "no", self.Get('os_format_type'))

    def get_os_install_scratch(self):
        """Install system in scratch mode"""
        return self.Get('os_scratch')

    def getFieldByField(self,resField,field,value, firstPrefix="os_disk",
                        secondPrefix="os_disk"):
        """Get value of field specified by 'firstPrefix_resField',
        by field specified by 'secondPrefix_resField==value'"""
        res = filter(lambda x: x[1] == value,
                zip(self.clVars.Get('%s_%s'%(firstPrefix,resField)),
                    self.clVars.Get('%s_%s'%(secondPrefix,field)))) or\
                    [("","")]
        return res[0][0]

    def get_os_install_mbr(self):
        if self.Get('os_install_pxe') == 'on':
            return ''
        if self.Get('os_install_root_type') in ("flash","usb-hdd"):
            rootdev = self.Get('os_install_root_dev')
            device = filter(lambda x:x in rootdev,
                                self.Get('os_device_dev'))
            if device:
                return device[0]
            else:
                return ""
        # if loaded system livecd
        if self.Get('os_root_type') == "livecd":
            # search /boot device or / device, by priority /boot,/
            bootDev=sorted(
                    filter(lambda x:x[0] in ('/','/boot'),
                    zip(self.Get('os_install_disk_mount'),
                        self.Get('os_disk_dev'))),
                    key=lambda x:x[0],reverse=True)
            if bootDev:
                bootdev = bootDev[0][1]
                # search device for partition
                device = filter(lambda x:x in bootdev,
                                    self.Get('os_device_dev'))
                # set it by default
                if device:
                    return device[0]
        if self.Get('os_device_dev'):
            return self.Get('os_device_dev')[0]
        return ""

    def get_cl_install_autoupdate_set(self):
        if self.Get('ac_install_system') == "up":
            if self.Get('os_install_linux_system') == 'desktop':
                return "on"
            else:
                return "off"
        else:
            return self.Get('cl_autoupdate_set')

    def get_cl_install_kernel_uid(self):
        return self.getKernelUid(self.Get('os_install_root_dev'))

    def get_os_nvidia_mask(self):
        nvidiaeclass = pathJoin(self.Get('cl_chroot_path'),
                                'usr/portage/eclass/nvidia-driver.eclass')
        if not os.access(nvidiaeclass,os.R_OK):
            return ""
        category = "0300"
        vendor = "10de"
        lsPciProg = self.getProgPath("/usr/sbin/lspci")
        nvidiacards =  filter(lambda x:" %s: "%category in x,
                      self._runos('%s -d %s: -n'%(lsPciProg,vendor)))
        if not nvidiaeclass:
            return ""
        cardsid = map(lambda x:x.groups()[0],
             filter(lambda x:x,
                map(lambda x:re.search("[0-9a-fA-F]{4}:([0-9a-fA-F]{4})",x),
                     nvidiacards)))
        if not cardsid:
            return ""
        eclassdata = open(nvidiaeclass,'r').read()
        drv_categories = re.findall('^drv_([^=]+)="', eclassdata, re.M)
        drvs = map(lambda x:(x[0],x[1].replace('\\\n','').split()),
                    re.findall('\ndrv_(%s)="(.*?)"'%"|".join(drv_categories),
                               eclassdata,re.S))
        mask_categories = re.findall('^mask_([^=]+)="', eclassdata, re.M)
        masks = dict(map(lambda x:(x[0],x[1].replace('\\\n','')),
                    re.findall('\nmask_(%s)="(.*?)"'%"|".join(drv_categories),
                               eclassdata,re.S)))
        drvsForCardsid = filter(lambda x:set(x[1])&set(cardsid),drvs)
        if drvsForCardsid and drvsForCardsid[0][0] in masks:
            return masks[drvsForCardsid[0][0]]
        return ""

    def get_os_install_linux_build(self):
        """Linux build"""
        imagename = self.getImage(self.Get('os_install_scratch'),
                                  self.Get('os_install_root_type'),
                                  self.Get('cl_image_path'),
                                  self.Get('os_install_arch_machine'),
                                  self.Get('os_install_linux_shortname'))
        if imagename in ('/mnt/flash', '/mnt/squash',
                         '/mnt/livecd', '/mnt/cdrom'):
            return self.Get('os_linux_build')
        if imagename:
            d = DistributiveRepository()._getfromcontent(imagename)
            if d and "build" in d:
                build = d['build']
                return build
            res = DistributiveRepository.reDistName.search(imagename)
            if res:
                build = res.groupdict()['ver']
                if re.match('^\d{8}$',build):
                    return build
        return ""

    def get_os_install_fb_resolution(self):
        """Get current framebuffer resolution"""
        textLines = self._runos("/sbin/fbres 2>&1")
        resolution = ""
        if textLines:
            cxx11,cyx11 = \
                self.Get('os_install_x11_resolution').partition('x')[0::2]
            cxfb, cyfb = textLines[0].partition('x')[0::2]
            if not filter(lambda x:not x.isdigit(),[cxfb,cyfb,cxx11,cyx11])and \
                int(cxx11) >= int(cxfb) and int(cyx11) >= int(cyfb):
                resolution = "%s-32"%textLines[0]
        return resolution or "1024x768-32@60"

    def get_os_grub2_path(self):
        """Get Grub2 Install cmd"""
        # find grub2-install
        grubInstall = self.getProgPath('/sbin/grub2-install')
        if grubInstall:
            return grubInstall
        # find grub-install and check, that this is grub2-install (ver 1.99)
        grubInstall = self.getProgPath('/sbin/grub-install')
        if grubInstall and filter(lambda x:"1.99" in x,
                           process(grubInstall,'-v')):
            return grubInstall
        return ""

    def get_cl_chroot_grub(self):
        """Chroot for grub-mkconfig"""
        if self.Get('os_install_scratch') == "on":
            return path.join(self.Get('cl_chroot_path'),"mnt/scratch")
        else:
            return self.Get('cl_chroot_path')

    def get_cl_autologin(self):
        """Autologin"""
        if self.Get('os_install_root_type') == "livecd" or \
            self.Get('os_install_linux_shortname') == "CMC":
            nonRootUsers = filter(lambda x: x != "root",
                           self.Get('cl_migrate_user'))
            if nonRootUsers:
                return nonRootUsers[0]
        else:
            return ""

    def get_os_install_kernel_cpufreq(self):
        """Get cpufreq (and other from modules_3= param) from conf.d/modules"""
        cpufreqmods = map(lambda x:x.partition('=')[2].strip("\n '\""),
                      filter(lambda x:x.startswith('modules_3'),
                      readLinesFile('/etc/conf.d/modules')))
        if cpufreqmods:
            return cpufreqmods[0]
        else:
            return ""