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