|
|
#-*- 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 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')
|
|
|
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('cl_action') == 'system':
|
|
|
return "up"
|
|
|
else:
|
|
|
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)):
|
|
|
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
|
|
|
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"})
|
|
|
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
|
|
|
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))
|
|
|
# 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 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 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()))
|
|
|
|
|
|
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()))
|
|
|
|
|
|
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_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_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]))
|
|
|
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" %
|
|
|
(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_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 get_os_install_fstab_swap_conf(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)"""
|
|
|
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_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_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'),
|
|
|
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'))
|
|
|
res = DistributiveRepository.reDistName.search(imagename)
|
|
|
if res:
|
|
|
return res.groupdict()['ver']
|
|
|
elif path.isdir(imagename):
|
|
|
d = DistributiveRepository()._getdistrinfo(imagename)
|
|
|
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" % (
|
|
|
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"
|
|
|
# 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 localtime symlink
|
|
|
if 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+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)\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") 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 ""
|
|
|
elif self.Get('os_device_dev'):
|
|
|
return self.Get('os_device_dev')[0]
|
|
|
else:
|
|
|
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 ""
|
