#-*- 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 re from crypt import crypt import cl_overriding from cl_datavars import glob_attr from os.path import join as pathjoin, exists as pathexists from os import readlink,listdir,access,R_OK from cl_utils import isMount,typeFile,getTupleVersion 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 class fillVars(object, glob_attr): nonTransferedDirs = ["/","/bin", "/dev", "/etc", "/lib", "/lib32", "/lib64", "/opt", "/proc", "/sbin", "/sys", "/usr", "/var"] def get_cl_install_merge_action(self): """Need perform templates for install:merge or install:unmerge""" actionsMap = {'merge':'up', 'system':'up'} cl_action = self.Get('cl_action') 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_action') == 'system': return "up" else: return "" def get_cl_install_scratch_action(self): """Need perform templates for install:system""" if self.Get('cl_action') in ('system','merge') and \ self.Get('os_install_scratch'): return "up" else: 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 pathexists(fdhcpInfo) or pathexists(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' usbdevices = \ map(lambda x: readlink(pathjoin(diskIdPath,x)).rpartition('/')[2], filter(lambda x: x.startswith('usb-'),listdir(diskIdPath))) 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)): 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 execStr = '/sbin/fdisk -l' res = self._runos(execStr,env={"LANG":"C"},ret_list=True) 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 execStr = '/usr/sbin/parted -l' res = self._runos(execStr,env={"LANG":"C"},ret_list=True) 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' res = self._runos(execStr,ret_list=True) 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 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 = \ filter(lambda x: len(x)>=4, map(lambda x: filter(lambda x: x , x.replace('\t',' ').split(' ')), 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 = {} dictOptionList.update(mountOptionsList) for dev in disk_hash.keys(): if dev in dictOptionList: disk_hash[dev]['options'] = ",".join(dictOptionList[dev]) return disk_hash def get_os_disk_dev(self): """List of available partition devices""" return sorted(self.Get('os_disk_hash').keys()) 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())) 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_uuid(self): """List uudi for partition devices""" return self.Get('os_disk_uuid') def get_os_install_disk_options(self): """List mount options for partition devices of installed os""" return self.Get('os_disk_options') def isFstabMount(self,path): """Get mount point or device from fstab""" if path == "swap": absPath = "swap" else: absPath = os.path.abspath(path) # 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")))) # get mount point or device or dir return filter(lambda x: x!=absPath, reduce(lambda x,y: y, filter(lambda x: absPath in x and x[1] != "none", map(lambda x: [x[0], x[1] if x[2] != "swap" else "swap"], listFstab)),[""]))[0] 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 = self.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 = self.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())) def get_os_disk_mount(self): """List mounted points for current operation system""" disk_hash = self.Get('os_disk_hash') return map(lambda x: self.isFstabMount(x) or "", sorted(self.Get('os_disk_hash').keys())) 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_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()) 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_info(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_info(self): """Information about mount points for fstab""" devicesForFstab = sorted(filter(lambda x:x[1] != "" and x[1] != "swap", zip(self.Get('os_disk_dev'), self.Get('os_install_disk_mount'), self.Get('os_install_disk_format'), self.Get('os_install_disk_options'))), lambda x,y: cmp(x[1],y[1])) # 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" % (x[0],x[1],x[2],x[3]), devicesForFstab[:1])) otherLines = "\n".join(map(lambda x: "%s\t%s\t%s\t%s\t0 0" % (x[0],x[1],x[2],x[3]), devicesForFstab[1:])) bindData = zip(self.Get('os_install_bind_dir'), 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"},ret_list=True) #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 get_os_install_fstab_swap_info(self): """Information about swap for fstab""" return "\n".join(map(lambda x: "%s\tnone\tswap\tsw\t0 0"%x[0], filter(lambda x: x[1] == "swap", zip(self.Get('os_disk_dev'), self.Get('os_install_disk_mount'))))) def get_os_install_linux_system(self): """Get linux system (server or desktop)""" mapNameSystem = {'CDS':'server', 'CLD':'desktop', 'CLDG':'desktop', 'CLDX':'desktop', 'CLS':'desktop', 'CSS':'server' } shortName = self.Get('os_install_linux_shortname') if shortName in mapNameSystem: return mapNameSystem[shortName] else: return "" 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_disk_dev'), self.Get('os_install_disk_mount')): if install == "swap": return "resume=%s"%dev return "" def get_os_install_arch_machine(self): """install maching architecture""" return self.Get('os_arch_machine') def get_cl_image(self): """Get image file from distributive repository""" if self.Get('cl_action') != 'system': return "" if self.Get('os_root_type') == "livecd": livedistr = ['/mnt/livecd'] else: livedistr = [] distRep = DistributiveRepository(self.Get('cl_image_path')+livedistr) return distRep.getBestDistributive( march=self.Get('os_install_arch_machine'), shortname=self.Get('os_install_linux_shortname').lower()) or "" 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.Get('cl_image') res = DistributiveRepository.reDistName.search(imagename) if res: return res.groupdict()['ver'] elif os.path.isdir(imagename): calculateini = 'etc/calculate/calculate.ini' d = self.calculateini_to_dict(pathjoin(imagename,calculateini)) if "linuxver" in d: return d['linuxver'] else: if self.Get('os_install_linux_shortname') == \ self.Get('os_linux_shortname'): return self.Get('os_linux_ver') return "" def get_cl_pkgdir_path(self): return "/var/calculate/remote/packages/%s/%s/%s" % ( self.Get('os_linux_shortname'), self.Get('os_linux_ver'), self.Get('os_install_arch_machine')) def get_os_install_linux_subname(self): """Subname of installation os""" linuxShortName = self.Get("os_install_linux_shortname") if linuxShortName: dictLinuxSubName = {"CLD":"KDE", "CLDX":"XFCE", "CLDG":"GNOME"} if linuxShortName in dictLinuxSubName.keys(): return dictLinuxSubName[linuxShortName] else: return "" else: return "" def get_os_install_linux_name(self): """Name of installation os""" linuxShortName = self.Get("os_install_linux_shortname") if linuxShortName: dictLinuxName = {"CLD":"Calculate Linux Desktop", "CLDX":"Calculate Linux Desktop", "CLDG":"Calculate Linux Desktop", "CDS":"Calculate Directory Server", "CLS":"Calculate Linux Scratch", "CSS":"Calculate Scratch Server", "Gentoo":"Gentoo"} if linuxShortName in dictLinuxName.keys(): return dictLinuxName[linuxShortName] else: return "Linux" else: return "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_dir(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_dir(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_dir'), 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_dir'), 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" # try get timezone from kernel calculate param timezone = self.getValueFromCmdLine("calculate",2) if timezone and \ os.path.exists(os.path.join(zoneinfodir,timezone)): return timezone # get timezone from localtime symlink if os.path.islink(localtimefile): return os.readlink(localtimefile).replace(zoneinfodir,"") 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+\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""" domain=self._runos("hostname -d 2>&1") 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 pathexists(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) reFindVer = re.compile( "(?<=version )(\d+\.?\d*\.?\d*\.?\d*)([^\d* ])*(\d*)") def getFilesByType(self,path,descr): """Get files from "path" has "descr" in descriptions""" filelist = map(lambda x:pathjoin(path,x),os.listdir(path)) ftype = typeFile(magic=0x4).getMType filesWithType = map(lambda x:(x,ftype(x)), filelist) return filter(lambda x:descr in x[1],filesWithType) def get_os_install_kernel(self): bootdir = pathjoin(self.Get('cl_chroot_path'),'boot') modulesdir = pathjoin(self.Get('cl_chroot_path'),'lib/modules') validKernel = os.listdir(modulesdir) kernelFiles = self.getFilesByType(bootdir,"Linux kernel") kernelsWithVer = \ map(lambda x:(x[0],(getTupleVersion("".join(x[1].groups()[0:3:2])), os.path.getmtime(x[0]))), filter(lambda x:x[1] and x[1].group() in validKernel, map(lambda x:(x[0],self.reFindVer.search(x[1])), kernelFiles))) if kernelsWithVer: return os.path.split(max(kernelsWithVer,key=itemgetter(1))[0])[-1] else: return "vmlinuz" def getInitrd(self,suffix=""): """Get initrd for kernel""" #def initrd_version_by_content(filename): # p1 = Popen(["/bin/gzip","-dc",filename],stdout=PIPE,stderr=PIPE) # p2 = Popen(["/bin/cpio","-tf"],stdin=p1.stdout,stdout=PIPE, # stderr=PIPE) # result = filter(lambda x: "lib/modules/" in x, # p2.communicate()[0].split('\n')) # if result: # splitresult = result[0].split('/') # if len(splitresult)>2: # return splitresult[2] # return "" reInitrdVer = re.compile("(initrd|initramfs)-(.+?%s-%s)(-install)?$"% (self.Get('os_install_arch_machine'), self.Get('os_install_linux_shortname')),re.S) def initrd_version_by_name(filename): resInitrdVer = reInitrdVer.search(filename) if resInitrdVer: return resInitrdVer.groups()[1] return "" ftype = typeFile(magic=0x4).getMType kernelfile = pathjoin(self.Get('cl_chroot_path'),'boot', self.Get('os_install_kernel')) resKernelVer = self.reFindVer.search(ftype(kernelfile)) if resKernelVer: kernelVersion = "%s-%s-%s"% \ (resKernelVer.group().replace('-calculate',''), self.Get('os_install_arch_machine'), self.Get('os_install_linux_shortname')) bootdir = pathjoin(self.Get('cl_chroot_path'),'boot') initramfsFiles = self.getFilesByType(bootdir,"ASCII cpio archive") initramfsWithVer = \ filter(lambda x: kernelVersion in x[1] and \ x[0].endswith(suffix), map(lambda x:(x[0],initrd_version_by_name(x[0])), initramfsFiles)) if initramfsWithVer: return os.path.split(min(initramfsWithVer, key=itemgetter(0))[0])[-1] if suffix: return "initrd-%s"%suffix else: return "initrd" def get_os_install_initrd(self): return self.getInitrd(suffix="") #return self.Get('os_install_initrd_install').strip('-install') def get_os_install_initrd_install(self): return self.getInitrd(suffix="install") def get_os_install_kernel_config(self): configfile = self.Get('os_install_kernel').replace('vmlinuz', 'config') if configfile.startswith('config') and pathexists( pathjoin(self.Get('cl_chroot_path'),'boot',configfile)): return configfile 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)\s*#[^\n]*?(?=\n|$)", re.S) reGrubEntry = re.compile("title.*?(?=title|$)", re.S | re.I ) 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'))) if roothd: roothd = "root=%s" % roothd[0][0] return ("".join(filter(lambda x: not roothd in 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"), 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 pathexists(convertDictOpt._fileSystemOpt[x]["makefs"]) else "no", self.Get('os_format_type')) def get_os_install_lang(self): """Supported languages""" return clLocale().getLangs() def get_os_install_scratch(self): """Install system in scratch mode""" return self.Get('os_scratch') def get_os_scratch(self): """Current system is scratch""" return "on" if isMount('/mnt/scratch') else "off" def getFieldByField(self,resField,field,value, firstPrefix="os_disk", secondPrefix="os_disk"): 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_device_dev'): return self.Get('os_device_dev')[0] else: return ""