#-*- 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,listdir,access,R_OK from cl_utils import isMount,typeFile,getTupleVersion,pathJoin,isFstabMount from cl_distr import DistributiveRepository 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 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"] 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_cl_install_merge_action(self): """Need perform templates for install:merge or install:unmerge""" if self.Get('cl_assemble_prepare_action') != "": return "" actionsMap = {'merge':'up', 'system':'up'} cl_action = self.Get('cl_action') clRootType = self.Get('os_install_root_type') if cl_action == "system" and clRootType == "flash": return "" return actionsMap[cl_action] if cl_action in actionsMap else "" def get_cl_install_system_action(self): """Need perform templates for install:system""" if self.Get('cl_assemble_prepare_action') != "": return "" if self.Get('os_install_root_type') == "flash": return "" if self.Get('cl_action') == 'system': return "up" else: return "" def get_cl_install_flash_action(self): """Need perform templates for install:flash""" actionsMap = {'system':'up'} clAction = self.Get('cl_action') clRootType = self.Get('os_install_root_type') if clAction == 'system' and clRootType == 'flash': return "up" return "" def get_cl_install_scratch_action(self): """Need perform templates for install:system""" if self.Get('cl_assemble_prepare_action') != "": return "" if self.Get('cl_action') in ('system','merge') and \ self.Get('os_install_scratch') == "on": return "up" else: return "" def get_cl_assemble_prepare_action(self): """Need perform templates for assemble:prepare""" return "" def get_os_net_interfaces_info(self): """Информация о существующих сетевых интерфейсах""" netInterfaces=self.Get("os_net_interfaces") listInterfacesInfo = [] # Получена ли сеть по DHCP если нет to ip или off for interfaces in netInterfaces: fdhcpLeases = "/var/lib/dhcp/dhclient.leases" if access(fdhcpLeases, R_OK) and\ interfaces in open(fdhcpLeases).read(): listInterfacesInfo.append((interfaces, "DHCP")) continue fdhcpInfo = "/var/lib/dhcpcd/dhcpcd-%s.info"%interfaces fdhcpLease = "/var/lib/dhcpcd/dhcpcd-%s.lease"%interfaces if path.exists(fdhcpInfo) or path.exists(fdhcpLease): listInterfacesInfo.append((interfaces, "DHCP")) # Если интерфейс без DHCP if not (interfaces, "DHCP") in listInterfacesInfo: # Находим ip res = self._runos("/sbin/ifconfig %s"%interfaces) ip = "" for j in res: sIP=re.search('addr:([0-9\.]+).+',j) if sIP: ip = sIP.group(1) listInterfacesInfo.append((interfaces, ip)) break if not ip: listInterfacesInfo.append((interfaces, "Off")) return ", ".join(map(lambda x:"%s (%s)"%(x[0],x[1]), listInterfacesInfo)) def get_os_device_hash(self): 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-'),listdir(diskIdPath))) else: usbdevices = [] reWrongDevice = re.compile("|".join(['sr','fd','ram','loop'])) devices = filter( lambda x: not reWrongDevice.search(x), listdir('/sys/block')) device_hash = {} for mapnum,device in enumerate(sorted(devices,key=self.separateDevice)): device_hash[device] = {} device_hash[device]['map'] = mapnum if device in usbdevices: removablePath = '/sys/block/%s/removable'%device if os.access(removablePath,R_OK) and \ open(removablePath,'r').read().strip() == "1": devtype = "flash" else: devtype = "usb-hdd" else: devtype = "hdd" device_hash[device]['type'] = devtype return device_hash def get_os_disk_hash(self): reSdaPart = re.compile("^/dev/sd([a-z])(\d+)$") devices = self.Get('os_device_hash').keys() disks = reduce( lambda x,y: x + map( lambda x: "/dev/%s"%x, filter(lambda x: y in x,listdir('/sys/block/%s'%y))), devices, [] ) disk_hash = {} # fill grub info for dev in disks: disk_hash[dev] = {} match = reSdaPart.match(dev) if match: disk_hash[dev]['grub'] = "%d,%d" % \ (ord(match.groups()[0])-ord('a'), int(match.groups()[1])-1) curDevice = None # getting id execProg = '/sbin/fdisk' execStr = '%s -l'%execProg if not path.exists(execProg): cl_overriding.printERROR(_("Command not found '%s'")%execProg) cl_overriding.exit(1) execStr = '%s -l'%execProg res = self._runos(execStr,env={"LANG":"C"}) if res is False: cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) cl_overriding.exit(1) partedLines = filter(lambda x: x.startswith('/dev/'), res or [] ) partedMatrix = map(lambda x: filter(lambda y: y and y!="*", x.split())[:6], partedLines) for part,nm,nm,nm,sysid,nm in filter(lambda x:len(x)>5,partedMatrix): if not part in disk_hash: disk_hash[part] = {} disk_hash[part]['id'] = sysid # parse all parted lines started with Disk and started with number floppyData = self.removeFloppy() execProg = '/usr/sbin/parted' execStr = '%s -l'%execProg if not path.exists(execProg): cl_overriding.printERROR(_("Command not found '%s'")%execProg) cl_overriding.exit(1) res = self._runos(execStr,env={"LANG":"C"}) self.restoreFloppy(floppyData) if res is False: cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) cl_overriding.exit(1) partedLines = filter(lambda x: x.startswith("Disk") or x.strip()[:1].isdigit(), res ) for line in partedLines: # split data parts = filter(lambda x: x, line.strip().split(' ')) # if start device description if parts[0] == "Disk": curDevice = parts[1][:-1] continue # if first part is number then it is partition description if parts[0].isdigit(): # part name it is devicename + partition number partition = curDevice + parts[0] # create entry if hash hasn't it if not partition in disk_hash: disk_hash[partition] = {} disk_hash[partition]['part'] = parts[4] disk_hash[partition]['size'] = parts[3] # fill format, name and uuid execStr = '/sbin/blkid' if not path.exists(execStr): cl_overriding.printERROR(_("Command not found '%s'")%execStr) cl_overriding.exit(1) res = self._runos(execStr) if res is False: cl_overriding.printERROR(_("Cann't execute '%s'")%execStr) cl_overriding.exit(1) # map attribute name of blkid to disk_hash blkid_hash = {'LABEL':'name', 'UUID':'uuid', 'TYPE':'format'} for line in res: # split line and discard empty elements parts = filter(lambda x: x, line.strip().split(' ')) if len(parts)>1 and parts[0][:-1] in disks: dev = parts[0][:-1] for i in parts[1:]: key,op,value = i.partition('=') if key in blkid_hash: key = blkid_hash[key] disk_hash[dev][key] = value[1:-1] # discard comment and empty string devuuid = '/dev/disk/by-uuid' if path.exists(devuuid): mapUuidDev = dict( map(lambda x:("UUID=%s"%os.path.basename(x), os.path.normpath(os.path.join(devuuid,os.readlink(x)))), filter(os.path.islink, map(lambda x:os.path.join(devuuid,x), os.listdir(devuuid))))) else: mapUuidDev = {} mapDevUuid = dict(map(lambda x:(x[1],x[0]),mapUuidDev.items())) mountOptionsList = \ filter(lambda x: x.strip() and not x.strip().startswith('#'), open("/etc/fstab").readlines()) # split all string by columns and discard string which has less that 4 # columns mountOptionsList = \ map(lambda x:[mapUuidDev.get(x[0],x[0])]+x[1:4], filter(lambda x: len(x)>=4, map(lambda x: filter(lambda x: x , x.replace('\t',' ').split(' ')), mountOptionsList))) # get dev which has ntfs filesystem mountFormatList = \ filter(lambda x: x[0] in disk_hash.keys() \ and x[1] in ("ntfs","ntfs-3g"), map(lambda y: (y[0],y[2]), mountOptionsList)) # split options and discard rw opt mountOptionsList = \ filter(lambda x: x[0] in disk_hash.keys(), map(lambda y: (y[0],filter(lambda z: z!="rw", y[3].split(','))), mountOptionsList)) dictOptionList = dict(mountOptionsList) dictFormatList = dict(mountFormatList) for dev in disk_hash.keys(): if dev in dictOptionList: disk_hash[dev]['options'] = ",".join(dictOptionList[dev]) if dev in dictFormatList and "format" in disk_hash[dev] and \ disk_hash[dev]['format'] in ("ntfs","ntfs-3g"): disk_hash[dev]['format'] = dictFormatList[dev] 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""" formatId = { 'ext2' : '83', 'ext3' : '83', 'ext4' : '83', 'reiserfs' : '83', 'jfs' : '83', 'xfs' : '83', 'vfat' : 'b', 'swap' : '82' } return map(lambda x:formatId[x[0]] if x[0] in formatId else x[1], zip(self.Get('os_install_disk_format'), self.Get('os_disk_id'))) 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 uudi for partition devices""" devuuid = '/dev/disk/by-uuid' diskDev = self.Get('os_disk_dev') if path.exists(devuuid): hashUUID = dict( map(lambda x:(path.normpath(path.join(devuuid,os.readlink(x))), path.basename(x)), filter(path.islink, map(lambda x:path.join(devuuid,x), os.listdir(devuuid))))) return map(lambda x:hashUUID.get(x,""),diskDev) return [""]*len(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') fstabHasSwap = isFstabMount('swap') def getMountPoint(disk): 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 = isFstabMount(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') return map(lambda x: isFstabMount(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_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_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_install_grub_devicemap_conf(self): """Content of device.map file for grub""" return "\n".join(map(lambda x: "(hd%s) /dev/%s" % (x[0],x[1]), filter(lambda x:x[2] != "flash", 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("Cann't 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] 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_install_kernel_attr(self): """Kernel attributes""" # on usb-hdd install must be "delay=5" if self.Get('os_install_root_type') == 'usb-hdd': return "delay=5" else: return "" 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 = [] return ['/var/calculate/remote/linux', '/var/calculate/linux', '/usr/calculate/share/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 = [] distRep = DistributiveRepository(self.Get('cl_image_path')) 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""" 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""" zoneinfodir = "/usr/share/zoneinfo/" localtimefile = "/etc/localtime" timezonefile = "/etc/timezone" # try get timezone from kernel calculate param timezone = self.getValueFromCmdLine("calculate",2) if timezone and \ path.exists(path.join(zoneinfodir,timezone)): return timezone # get timezone from /etc/timezone if path.exists(timezonefile): return open(timezonefile,"r").read().strip() return "UTC" 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 xlog = "/var/log/Xorg.0.log" if os.access(xlog,os.R_OK): reXorgLogParser = re.compile(""" Virtual\ screen\ size\ determined\ to\ be \ ([0-9]+)\s*x\s*([0-9]+)| Setting\ mode\ "(\d+)x(\d+)[0-9\@]"| Output\ [\S]+\ using\ initial\ mode\ (\d+)x(\d+)| Virtual\ size\ is\ (\d+)x(\d+)""", re.X | re.S) resXorgLogParser = reXorgLogParser.search(open(xlog,'r').read()) if resXorgLogParser: return "%sx%s"%filter(lambda x:x,resXorgLogParser.groups())[:2] # get resolution from xorg.conf xorgconf = "/etc/X11/xorg.conf" reScreenSections = re.compile('Section "Screen"(.*?)EndSection', re.S) reModes = re.compile('Modes\s+"(\d+x\d+)') if os.access(xorgconf,os.R_OK): sectionsScreen = filter(lambda x:"Modes" in x, reScreenSections.findall(open('/etc/X11/xorg.conf','r').read())) modes = map(lambda x:x.groups()[0], filter(lambda x:x, map(reModes.search, sectionsScreen))) if modes: return max(modes,key=lambda x:int(x.partition('x')[0])) # get resolution from command line reRightResolution = re.compile("^(\d+x\d+|auto)$",re.S) kernelResolution = self.getValueFromCmdLine("calculate",3) if kernelResolution and reRightResolution.match(kernelResolution): return kernelResolution # default resolution return "" if self.Get('os_install_root_type') == 'livecd' \ else "1024x768" def get_os_install_x11_video_drv(self): """Video driver used by xorg""" return self.Get('os_x11_video_drv') def get_os_install_x11_composite(self): """On/off composite""" defaultCompositeOn = ["nvidia","intel"] if self.Get('os_x11_video_drv') in defaultCompositeOn: defaultComposite = "on" else: defaultComposite = "off" state = self.get_composite_from_xorgconf() return 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)).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): """Ip for all network interfaces""" return self.Get("os_net_ip") def get_os_install_net_interfaces(self): """Net interfaces""" return self.Get("os_net_interfaces") def get_os_install_net_domain(self): """Domain""" 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 = map(lambda x: x[1], filter(lambda x:x[0] in rootdev, 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 = os.listdir(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""" retList = [] fileName = "/etc/passwd" if access(fileName, R_OK): maxId = 65000 minId = 500 reNumb = re.compile("^\d+$") lenData=7 userData = filter(lambda x: len(x)==lenData, map(lambda x: x.rstrip().split(":"), open(fileName))) userData = filter(lambda x:\ reNumb.match(x[2]) and minId<=int(x[2])<=maxId, userData) sortUsers = map(lambda x: x[0], userData) sortUsers.sort() retList = ["root"] + sortUsers return retList 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_lang(self): """Supported languages""" return list(set(clLocale().getLangs()) & set(["en_US","de_DE","es_ES","fr_FR","it_IT","pl_PL","pt_BR", "uk_UA","bg_BG","ru_RU"])) 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_root_type') == "flash": 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('cl_install_system_action') == "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): uuidpath = '/dev/disk/by-uuid' if not os.access(uuidpath,os.R_OK): return "" uuidDevs = filter(os.path.islink,map(lambda x: os.path.join(uuidpath,x), os.listdir(uuidpath))) mapDevUuid = dict(map(lambda x:(os.path.normpath(os.path.join(uuidpath, os.readlink(x))), os.path.basename(x)), uuidDevs)) if self.Get('os_install_root_dev') in mapDevUuid: return mapDevUuid[self.Get('os_install_root_dev')][:8] else: return "" 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" nvidiacards = filter(lambda x:" %s: "%category in x, self._runos('/usr/sbin/lspci -d %s: -n'%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: res = DistributiveRepository.reDistName.search(imagename) if res: build = res.groupdict()['ver'] if re.match('^\d{8}$',build): return build if imagename in ('/mnt/flash', '/mnt/squash', '/mnt/livecd', '/mnt/cdrom'): return self.Get('os_linux_build') return ""