You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1067 lines
44 KiB
1067 lines
44 KiB
#-*- 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
|
|
import sys
|
|
import time
|
|
import traceback
|
|
from os import path
|
|
from StringIO import StringIO
|
|
from time import sleep
|
|
from subprocess import PIPE,STDOUT
|
|
from shutil import copy2
|
|
from calculate.lib.utils.files import (runOsCommand,pathJoin,scanDirectory,
|
|
process,listDirectory,STDOUT,checkUtils)
|
|
from calculate.lib.utils.common import (appendProgramToEnvFile,
|
|
removeProgramToEnvFile, getTupleVersion,
|
|
cmpVersion,getUserPassword,
|
|
getSupportArch, getInstalledVideo )
|
|
from calculate.lib.utils.device import (detectDeviceForPartition,
|
|
getUdevDeviceInfo, getLvmPartitions, refreshLVM,
|
|
refreshUdev,countPartitions)
|
|
from calculate.lib.cl_vars_share import varsShare
|
|
from calculate.lib import cl_overriding
|
|
from calculate.lib.utils import ip
|
|
from calculate.lib.datavars import VariableError
|
|
from datavars import DataVarsInstall, __version__,__app__
|
|
from calculate.install.variables.autopartition import (AutopartitionError,
|
|
AutoPartition)
|
|
from calculate.install.fs_manager import FileSystemManager
|
|
|
|
from cl_kernel_utils import KernelConfig,InitRamFs
|
|
|
|
from calculate.lib.variables.locale import Locale
|
|
from calculate.lib.cl_template import Template,TemplatesError,ProgressTemplate
|
|
from calculate.lib.datavars import DataVars
|
|
from calculate.lib.cl_print import color_print
|
|
from cl_distr import (PartitionDistributive,
|
|
DistributiveError, ScratchPartitionDistributive,
|
|
MultiPartitions, FlashDistributive,
|
|
Distributive)
|
|
from calculate.lib.utils.text import tableReport
|
|
from calculate.lib.server.utils import dialogYesNo
|
|
from subprocess import Popen,PIPE,STDOUT
|
|
|
|
class InstallError(Exception):
|
|
"""Installation Error"""
|
|
|
|
from cl_migrate_users import migrate, currentUsers, MigrationError
|
|
from calculate.lib.encrypt import encrypt
|
|
|
|
from calculate.lib.cl_lang import setLocalTranslate
|
|
setLocalTranslate('cl_install3',sys.modules[__name__])
|
|
|
|
class printNoColor:
|
|
def colorPrint(self,attr,fg,bg,string):
|
|
sys.stdout.write(string)
|
|
|
|
class cltCopy(scanDirectory):
|
|
"""Copy clt files
|
|
|
|
Example:
|
|
cltCopier = cltCopy(target="/targetdir")
|
|
# copy all clt files from etc directory to /targetdir/etc
|
|
cltCopier.performCopy('/etc')
|
|
"""
|
|
def __init__(self,target='/tmp'):
|
|
self.target = target
|
|
|
|
performCopy = scanDirectory.scanningDirectory
|
|
|
|
def processingFile(self,pathname,prefix):
|
|
try:
|
|
if pathname.endswith(".clt"):
|
|
targetDir = pathJoin(self.target,path.dirname(pathname))
|
|
if not path.exists(targetDir):
|
|
os.makedirs(targetDir)
|
|
copy2(pathname,pathJoin(self.target,pathname))
|
|
except Exception,e:
|
|
raise InstallError(_("Failed to copy '%(src)s' to '%(dst)s'")%
|
|
{'src':pathname,'dst':pathJoin(self.target,pathname)})
|
|
return True
|
|
|
|
class otherfilesCopy(scanDirectory):
|
|
"""Copy some files
|
|
|
|
Example:
|
|
otherfilesCopier = otherfilesCopy(target="/targetdir")
|
|
# copy need files from etc directory to /targetdir/etc
|
|
otherfilesCopier.performCopy('/etc')
|
|
"""
|
|
def __init__(self,target='/tmp',reTest=".*"):
|
|
self.target = target
|
|
self.reTest = re.compile(reTest,re.S)
|
|
|
|
performCopy = scanDirectory.scanningDirectory
|
|
|
|
def processingFile(self,pathname,prefix):
|
|
try:
|
|
if self.reTest.search(pathname):
|
|
targetDir = pathJoin(self.target,path.dirname(pathname))
|
|
if not path.exists(targetDir):
|
|
os.makedirs(targetDir)
|
|
copy2(pathname,pathJoin(self.target,pathname))
|
|
except Exception,e:
|
|
raise InstallError(_("Failed to copy '%(src)s' to '%(dst)s'")%
|
|
{'src':pathname,'dst':pathJoin(self.target,pathname)})
|
|
return True
|
|
|
|
class Install(color_print):
|
|
"""Primary class for templates appling and system installation"""
|
|
|
|
def __init__(self):
|
|
self.clVars = None
|
|
self.clTempl = None
|
|
self.listDisksOptions = []
|
|
self.listBindsOptions = []
|
|
self.listSwapsOptions = []
|
|
self.startMessage = ""
|
|
self.lenStartMessage = 0
|
|
self.stdoutHide = None
|
|
self.stderrHide = None
|
|
# refresh information about LVM
|
|
refreshLVM()
|
|
# refresh information about device in udevadm info
|
|
refreshUdev()
|
|
|
|
|
|
def setNoColor(self):
|
|
self.color = False
|
|
|
|
def initVars(self,datavars=None):
|
|
"""Primary initialization of variables"""
|
|
if not datavars:
|
|
self.clVars = DataVarsInstall()
|
|
self.clVars.importInstall()
|
|
self.clVars.flIniFile()
|
|
else:
|
|
self.clVars = datavars
|
|
|
|
|
|
def canInstallGrub2(self,target):
|
|
"""Check that system has grub2 in current and installed system"""
|
|
if self.clVars.Get('os_grub2_path'):
|
|
return bool(
|
|
filter(lambda x:x.startswith('grub-1.99'),
|
|
listDirectory('/var/db/pkg/sys-boot')))
|
|
return False
|
|
|
|
def prepareBoot(self,targetDistr):
|
|
"""Prepare system for boot"""
|
|
if self.clVars.Get('os_install_root_type') == "flash":
|
|
self.installSyslinuxBootloader(targetDistr)
|
|
else:
|
|
if self.canInstallGrub2(targetDistr):
|
|
self.installGrub2Bootloader(targetDistr)
|
|
else:
|
|
self.installLegacyGrubBootloader(targetDistr)
|
|
|
|
def closeClTemplate(self):
|
|
if self.clTempl:
|
|
if self.clTempl.cltObj:
|
|
self.clTempl.cltObj.closeFiles()
|
|
self.clTempl.closeFiles()
|
|
self.clTempl = None
|
|
|
|
def applyTemplatesStartup(self):
|
|
"""Apply templates for root of system."""
|
|
#self.clVars.Set("cl_root_path","/", True)
|
|
self.clVars.Set("cl_chroot_path","/", True)
|
|
templates_locate = self.clVars.Get('cl_templates_locate')
|
|
|
|
# cltObj = True if 'clt' in templates_locate else False
|
|
dirs_list, files_list = ([],[])
|
|
listTemplatePaths = ["/var/lib/layman/calculate/profiles/templates",
|
|
"/var/calculate/templates",
|
|
"/var/calculate/remote/templates"]
|
|
for location in templates_locate:
|
|
if location in ("overlay", "local", "remote", "clt"):
|
|
if len(listTemplatePaths) != 3:
|
|
self.printERROR(\
|
|
_("Error in template variable 'cl_template_path=%s'")\
|
|
%str(listTemplatePaths))
|
|
return False
|
|
elif location == "local":
|
|
if not os.path.isdir(listTemplatePaths[1]):
|
|
continue
|
|
self.clVars.Set("cl_template_path",
|
|
[listTemplatePaths[1]], True)
|
|
elif location == "remote":
|
|
if not os.path.isdir(listTemplatePaths[2]):
|
|
continue
|
|
self.clVars.Set("cl_template_path",
|
|
[listTemplatePaths[2]], True)
|
|
elif location == "overlay":
|
|
if not os.path.isdir(listTemplatePaths[0]):
|
|
continue
|
|
self.clVars.Set("cl_template_path",
|
|
[listTemplatePaths[0]], True)
|
|
elif location == "clt":
|
|
# list_paths = ['/etc'] + \
|
|
# os.environ.get('CONFIG_PROTECT').split()
|
|
# for template_path in list_paths:
|
|
# if not os.path.isdir(template_path):
|
|
# continue
|
|
# print template_path
|
|
# self.clVars.Set("cl_template_path",
|
|
# [template_path], True)
|
|
# self.clTempl = ProgressTemplate(self.setProgress,
|
|
# self.clVars,cltObj=True,
|
|
# cltFilter=True)
|
|
#
|
|
# dirsFiles = self.clTempl.applyTemplates()
|
|
# # cltObj = False
|
|
# print dirsFiles
|
|
# dirs_list += (dirsFiles[0])
|
|
# files_list += (dirsFiles[1])
|
|
continue
|
|
|
|
self.clTempl = ProgressTemplate(self.setProgress, self.clVars,
|
|
cltFilter=False)
|
|
|
|
dirsFiles = self.clTempl.applyTemplates()
|
|
if type(dirsFiles) in [list, tuple]:
|
|
if len (dirsFiles) > 1:
|
|
dirs_list += (dirsFiles[0])
|
|
files_list += (dirsFiles[1])
|
|
self.clVars.Set("cl_template_path", listTemplatePaths, True)
|
|
try:
|
|
if self.clTempl.getError():
|
|
self.printERROR(self.clTempl.getError())
|
|
return False
|
|
except AttributeError:
|
|
pass
|
|
return (dirs_list, files_list)
|
|
|
|
def applyTemplatesFlash(self,directory):
|
|
"""Apply templates for root of system."""
|
|
#self.clVars.Set("cl_root_path",directory, True)
|
|
self.clVars.Set("cl_chroot_path","/", True)
|
|
self.clVars.Set("cl_chroot_grub","/", True)
|
|
self.clVars.Set("cl_root_path",directory, True)
|
|
self.clTempl = ProgressTemplate(self.setProgress,self.clVars,
|
|
cltObj=False)
|
|
dirsFiles = self.clTempl.applyTemplates()
|
|
if self.clTempl.getError():
|
|
raise InstallError(self.clTempl.getError())
|
|
else:
|
|
return dirsFiles
|
|
|
|
def applyTemplates(self,directory,grubDirectory):
|
|
"""Apply templates for root of system."""
|
|
self.clVars.Set("cl_chroot_path",directory, True)
|
|
self.clVars.Set("cl_chroot_grub",grubDirectory, True)
|
|
clTemplateCltPath = \
|
|
filter(lambda x:path.exists(x),
|
|
map(lambda x:pathJoin(directory,x),
|
|
self.clVars.Get('cl_template_clt_path')))
|
|
self.clVars.Set('cl_template_clt_path',clTemplateCltPath,True)
|
|
self.clTempl = ProgressTemplate(self.setProgress,self.clVars,
|
|
cltFilter=False)
|
|
dirsFiles = self.clTempl.applyTemplates()
|
|
if self.clTempl.getError():
|
|
raise InstallError(self.clTempl.getError())
|
|
else:
|
|
return dirsFiles
|
|
|
|
def checkDuplicate(self,datalist,name,key=lambda x:x):
|
|
"""Check on duplicate and print error"""
|
|
keydata = map(key,datalist)
|
|
dupKey = set(filter(lambda x:keydata.count(x)>1, keydata))
|
|
if dupKey:
|
|
self.printERROR(_("Duplicated {keyname}: {keylist}").format(
|
|
keyname=name,keylist=",".join(dupKey)))
|
|
return False
|
|
return True
|
|
|
|
def setVarList(self,varsList,matrix):
|
|
"""Set matrix to vars"""
|
|
if not matrix:
|
|
map(lambda x:self.clVars.Set(x,[],True),varsList)
|
|
else:
|
|
map(lambda x:self.clVars.Set(x[0],list(x[1]),True),
|
|
zip(varsList,zip(*matrix)))
|
|
|
|
def setDisks(self):
|
|
"""
|
|
TODO: remove check grub2_path in disk variables
|
|
"""
|
|
try:
|
|
if not self.clVars.Get('os_grub2_path'):
|
|
self.checkForLegacyGrub()
|
|
else:
|
|
self.checkForGrub2()
|
|
except InstallError,e:
|
|
error.append(e)
|
|
return True
|
|
|
|
def setUsers(self,listUsers,autologinUser):
|
|
"""Set users data (migration)"""
|
|
if autologinUser == "none":
|
|
autologinUser = ""
|
|
if autologinUser or autologinUser == "":
|
|
self.clVars.Set('cl_autologin', autologinUser, force=True)
|
|
else:
|
|
autologinUser = self.clVars.Get('cl_autologin')
|
|
autologinUser = [autologinUser] if autologinUser else []
|
|
listUsers = listUsers or []
|
|
if listUsers or autologinUser:
|
|
migrateUsers = list(set(listUsers+autologinUser))
|
|
migrateUsers.sort()
|
|
migrateUsers = ["root"] + filter(lambda x: x!="root", migrateUsers)
|
|
self.clVars.Set('cl_migrate_user', migrateUsers, force=True)
|
|
return True
|
|
|
|
|
|
def setInstallOptions(self, listDisks, listBinds, listSwaps, listUsers,
|
|
autologinUser, brDisk):
|
|
"""Set install options (set users, disks and boot record"""
|
|
try:
|
|
if self.setUsers(listUsers,autologinUser) and \
|
|
self.setDisks(listDisks,listBinds,listSwaps) and \
|
|
self.setBR(brDisk):
|
|
return self.createListOptions()
|
|
else:
|
|
return False
|
|
except InstallError,e:
|
|
self.printERROR(str(e).strip())
|
|
return False
|
|
|
|
def getDeviceByField(self,field,value, secondPrefix="os_disk"):
|
|
"""Get device by fields (install load format uuid grub part name)"""
|
|
return self.getFieldByField('dev',field,value,
|
|
secondPrefix=secondPrefix)
|
|
|
|
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 getFieldByDevice(self,field,device):
|
|
"""Get value of field by device"""
|
|
device_hash = self.clVars.Get('os_disk_hash')
|
|
if device in device_hash and field in device_hash[device]:
|
|
return device_hash[device][field]
|
|
else:
|
|
return ""
|
|
|
|
def setActivePartition(self,partition):
|
|
"""Change partition id, specified by systemid,set active"""
|
|
deviceName = detectDeviceForPartition(partition)
|
|
if deviceName is None:
|
|
raise DistributiveError(
|
|
_("Failed to determine the parent device for %s")%partition)
|
|
# device hasn't any partition
|
|
elif deviceName == "":
|
|
return True
|
|
fdiskProg, gdiskProg, partedProg = checkUtils('/sbin/fdisk',
|
|
'/usr/sbin/gdisk','/usr/sbin/parted')
|
|
|
|
disk = self.clVars.Select('os_install_disk_parent',
|
|
where='os_install_disk_dev',eq=partition,
|
|
limit=1)
|
|
parttable = self.clVars.Select('os_device_table',where='os_device_dev',
|
|
eq=disk,limit=1)
|
|
partitionNumber = \
|
|
getUdevDeviceInfo(name=partition).get('ID_PART_ENTRY_NUMBER','')
|
|
devicePartitionCount = countPartitions(deviceName)
|
|
if deviceName and not partitionNumber:
|
|
raise DistributiveError(
|
|
_("Failed to determine the partition number for %s")%partition)
|
|
bootFlag = "boot" if parttable == "dos" else "legacy_boot"
|
|
parted = process(partedProg, "-m",deviceName,"print")
|
|
DEVICENUM,FLAGS = 0,6
|
|
changeActive = \
|
|
map(lambda x:x[DEVICENUM],
|
|
filter(lambda x:x[DEVICENUM] != partitionNumber and \
|
|
bootFlag in x[FLAGS].strip(';').split(', ') or \
|
|
x[DEVICENUM] == partitionNumber and \
|
|
not bootFlag in x[FLAGS].strip(';').split(', '),
|
|
filter(lambda x:len(x)>=7,
|
|
map(lambda x:x.split(':'),
|
|
parted.readlines()[2:]))))
|
|
if not changeActive:
|
|
return True
|
|
if parttable == "dos":
|
|
pipe = Popen([fdiskProg,deviceName],
|
|
stdin=PIPE, stdout=PIPE,stderr=PIPE)
|
|
for partnum in changeActive:
|
|
pipe.stdin.write("a\n%s\n"%partnum)
|
|
pipe.stdin.write("w\n")
|
|
pipe.stdin.close()
|
|
pipe.wait()
|
|
elif parttable == "gpt":
|
|
pipe = Popen([gdiskProg,deviceName],
|
|
stdin=PIPE, stdout=PIPE,stderr=PIPE)
|
|
if devicePartitionCount > 1:
|
|
pipe.stdin.write("x\n")
|
|
for partnum in changeActive:
|
|
pipe.stdin.write("a\n%s\n2\n\n"%partnum)
|
|
pipe.stdin.write("w\nY\n")
|
|
else:
|
|
pipe.stdin.write("x\na\n2\n\nw\nY\n")
|
|
pipe.stdin.close()
|
|
pipe.wait()
|
|
for waittime in (0.1,0.2,0.5,1,2,4):
|
|
if path.exists(partition):
|
|
return True
|
|
else:
|
|
sleep(waittime)
|
|
raise InstallError(
|
|
_("Failed to find partition %s after changing the activity")%
|
|
partition)
|
|
|
|
def installSyslinuxBootloader(self,target):
|
|
"""Install boot loader by syslinux
|
|
|
|
Perform syslinux installation to flash.
|
|
"""
|
|
if not self.clVars.Get('os_install_mbr'):
|
|
return
|
|
ddProcess = process("/bin/dd","if=/usr/share/syslinux/mbr.bin",
|
|
"of=%s"%self.clVars.Get('os_install_mbr')[0],
|
|
stderr=STDOUT)
|
|
if ddProcess.failed():
|
|
raise DistributiveError(
|
|
_("Failed to write the master boot record\n%s")%
|
|
ddProcess.read())
|
|
target.close()
|
|
installRootDev = self.clVars.Get('os_install_root_dev')
|
|
syslinuxProcess = process("/usr/bin/syslinux",
|
|
installRootDev, stderr=STDOUT)
|
|
if syslinuxProcess.failed():
|
|
raise DistributiveError(_("Failed to install syslinux\n%s")%
|
|
syslinuxProcess.read())
|
|
# is partition active
|
|
return self.setActivePartition(self.clVars.Get('os_install_root_dev'))
|
|
|
|
def varSelect(self,selField,where="os_disk_dev",eq=""):
|
|
"""Select value from os_disk/device matrix"""
|
|
res = filter(lambda x: x[1] == eq,
|
|
zip(self.clVars.Get(selField),
|
|
self.clVars.Get(where))) or\
|
|
[("","")]
|
|
return res[0][0]
|
|
|
|
def installGrub2Bootloader(self,target):
|
|
"""
|
|
Install grub2 boot loader
|
|
"""
|
|
for bootPath in ("/boot","/"):
|
|
bootDisk = self.clVars.Select("os_install_disk_dev",
|
|
where="os_install_disk_mount",eq=bootPath,limit=1)
|
|
if bootDisk:
|
|
self.setActivePartition(bootDisk)
|
|
break
|
|
cmdGrubInstall = self.clVars.Get('os_grub2_path')
|
|
if not cmdGrubInstall:
|
|
raise DistributiveError(_("Failed to install the bootloader"))
|
|
|
|
for mbrDisk in self.clVars.Get('os_install_mbr'):
|
|
process("sync").success()
|
|
if self.clVars.Get('os_install_scratch') == "on" and \
|
|
self.clVars.Get('cl_action') != "system":
|
|
prefixBoot = "/mnt/scratch"
|
|
else:
|
|
prefixBoot = ""
|
|
grubProcess = process(cmdGrubInstall,
|
|
"--boot-directory=%s"%target.getBootDirectory(),
|
|
mbrDisk, "-f", stderr=STDOUT,envdict=os.environ)
|
|
if grubProcess.failed():
|
|
raise DistributiveError(_("Failed to install the bootloader"))
|
|
|
|
def installLegacyGrubBootloader(self,target):
|
|
"""
|
|
Install legecy grub boot loader
|
|
|
|
Perform grub installation to disk, which has root partition
|
|
"""
|
|
cmdGrub = varsShare().getProgPath('/sbin/grub')
|
|
if not cmdGrub:
|
|
raise DistributiveError(_("Failed to install the bootloader"))
|
|
grubProcess = process(cmdGrub,
|
|
"--device-map=%s/boot/grub/device.map"%target.getDirectory(),
|
|
"--batch",stderr=STDOUT)
|
|
bootDisk = self.Select('os_install_disk_grub',
|
|
where='os_install_disk_mount',
|
|
_in=('/','/boot'),
|
|
sort='DESC',limit=1)
|
|
if not bootDisk:
|
|
raise DistributiveError(_("Failed to determine the boot disk"))
|
|
self.setActivePartition(bootDisk)
|
|
for mbrDisk in self.clVars.Get('os_install_mbr'):
|
|
mbrDiskNum = self.Select("os_device_map",
|
|
where="os_device_dev",
|
|
eq=mbrDisk)
|
|
if not mbrDiskNum and mbrDiskNum != 0:
|
|
raise DistributiveError(_("Failed to determine mbr"))
|
|
for line in ("root (hd%s)"%bootDisk,
|
|
"setup (hd%d)"%mbrDiskNum,
|
|
"quit"):
|
|
grubProcess.write("%s\n"%line)
|
|
if grubProcess.failed():
|
|
raise DistributiveError(_("Failed to install the bootloader"))
|
|
|
|
def setupOpenGL(self):
|
|
"""Setup opengl for current video driver"""
|
|
defaultGL = "xorg-x11"
|
|
pathGlModules = path.join(self.clVars.Get('cl_chroot_path'),
|
|
'usr/lib/opengl')
|
|
openGLenv = path.join(self.clVars.Get('cl_chroot_path'),
|
|
'etc/env.d/03opengl')
|
|
|
|
openGlMods = filter(lambda x:x != "global",
|
|
listDirectory(pathGlModules))
|
|
mapGL_drivers = {'fglrx':"ati" if "ati" in openGlMods
|
|
else defaultGL,
|
|
'nvidia':"nvidia" if "nvidia" in openGlMods
|
|
else defaultGL}
|
|
x11_driver = self.clVars.Get('os_install_x11_video_drv')
|
|
if x11_driver in mapGL_drivers:
|
|
newModuleName = mapGL_drivers[x11_driver]
|
|
else:
|
|
newModuleName = defaultGL
|
|
curModuleName = map(lambda x:x.strip().rpartition('=')[-1].strip('"\''),
|
|
filter(lambda x: x.startswith("OPENGL_PROFILE="),
|
|
open(openGLenv,'r')))
|
|
curModuleName = curModuleName[-1] if curModuleName else ""
|
|
if curModuleName == newModuleName:
|
|
return True
|
|
res,errmes = runOsCommand('eselect opengl set %s'%newModuleName)
|
|
if res == 0:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def checkVideoDriver(self):
|
|
"""Check video driver and install nvidia driver"""
|
|
binPackages = '/usr/portage/packages'
|
|
nvidiaBinDrivers = path.join(binPackages,'x11-drivers')
|
|
if self.clVars.Get('hr_video') != 'nvidia' or \
|
|
not path.exists(nvidiaBinDrivers):
|
|
return True
|
|
maskFile = '/etc/portage/package.mask'
|
|
nvidiaMaskFile = path.join(maskFile,'nvidia-drivers')
|
|
# convert file package.mask to directory package mask
|
|
if path.isfile(maskFile):
|
|
os.rename(maskFile,maskFile+"2")
|
|
os.mkdir(maskFile,mode=0755)
|
|
os.rename(maskFile+"2",path.join(maskFile,"default"))
|
|
if path.exists(nvidiaMaskFile):
|
|
curNvidiaMask = open(nvidiaMaskFile,'r').read().strip()
|
|
else:
|
|
curNvidiaMask = ""
|
|
|
|
maskNvidia = self.clVars.Get('os_nvidia_mask')
|
|
if maskNvidia == curNvidiaMask:
|
|
return True
|
|
self.printByResult(True)
|
|
self.startTask(_("Driver installation for %s")%
|
|
self.clVars.Get('hr_video'))
|
|
open(nvidiaMaskFile,'w').write(maskNvidia)
|
|
return True
|
|
|
|
def configureSystem(self,autologin):
|
|
"""configuring the current system"""
|
|
configureMessage = _("Configuring the system")
|
|
error = None
|
|
keyInter = None
|
|
try:
|
|
try:
|
|
if autologin:
|
|
objUsers = currentUsers()
|
|
if not objUsers.hasUsers(autologin):
|
|
self.printERROR(_("User %s does not exist")%autologin)
|
|
else:
|
|
self.setUsers([],autologin)
|
|
# install this package
|
|
self.installPackage()
|
|
self.printMessageForTest(configureMessage)
|
|
self.printByResult(self.applyTemplatesStartup())
|
|
|
|
linuxShortname = self.clVars.Get('os_install_linux_shortname')
|
|
# install desktop package
|
|
if linuxShortname in ("CLD","CLS","CLDG","CLDX"):
|
|
desktopLib = '/usr/lib/calculate-2.2/calculate-desktop/pym'
|
|
if path.exists(desktopLib):
|
|
sys.path.insert(0, path.abspath(desktopLib))
|
|
from cl_desktop import desktop
|
|
self.printMessageForTest(
|
|
_("calculate-desktop enabled "
|
|
"for package configuration"))
|
|
self.hideStdout()
|
|
objDesktop = desktop()
|
|
objDesktop.createClVars()
|
|
res = objDesktop.installProg()
|
|
self.showStdout()
|
|
|
|
# install client package
|
|
if linuxShortname in ("CLD","CLDG","CLDX"):
|
|
clientLib = '/usr/lib/calculate-2.2/calculate-client/pym'
|
|
if path.exists(clientLib):
|
|
sys.path.insert(0, path.abspath(clientLib))
|
|
from cl_client import client
|
|
self.printMessageForTest(
|
|
_("calculate-client enabled "
|
|
"for package configuration"))
|
|
objClient = client()
|
|
objClient.createClVars()
|
|
self.hideStdout()
|
|
if hasattr(objClient,"updateEnvFiles") and \
|
|
objClient.updateEnvFiles():
|
|
objClient.clVars.flIniFile()
|
|
res = objClient.installProg(onlyEnv=True)
|
|
self.showStdout()
|
|
self.printByResult(res)
|
|
|
|
pathGlModules = path.join(self.clVars.Get('cl_chroot_path'),
|
|
'usr/lib/opengl')
|
|
self.printMessageForTest(_("Checking the video driver"))
|
|
self.printByResult(self.checkVideoDriver())
|
|
if path.exists(pathGlModules):
|
|
self.printMessageForTest(_("Configuring OpenGL"))
|
|
self.printByResult(self.setupOpenGL())
|
|
# if change video driver, then restore initramfs
|
|
installDrv = self.clVars.Get('os_install_x11_video_drv')
|
|
if self.clVars.Get('os_x11_video_drv') != installDrv:
|
|
initrdPath = path.join('/boot',
|
|
self.clVars.Get('os_install_initrd'))
|
|
initrdInstallPath = path.join('/boot',
|
|
self.clVars.Get('os_install_initrd_install'))
|
|
needMod = {'radeon':'radeon',
|
|
'intel':'i915',
|
|
'nouveau':'nouveau'}.get(installDrv,'uvesafb')
|
|
if not InitRamFs(initrdPath).isModuleInside(needMod):
|
|
self.printMessageForTest(_("Restoring initramfs"))
|
|
self.printByResult(InitRamFs(initrdInstallPath)\
|
|
.cleanInitRamFs(initrdPath))
|
|
oldXdrv = self.clVars.Get('os_x11_video_drv')
|
|
newXdrv = self.clVars.Get('os_install_x11_video_drv')
|
|
if oldXdrv != newXdrv:
|
|
kmsDrv = ("radeon","i915","intel","nouveau","ati")
|
|
self.defaultPrint("\n")
|
|
if oldXdrv in kmsDrv or newXdrv in kmsDrv:
|
|
self.defaultPrint(
|
|
_("To apply the changes, reboot the system")
|
|
+".\n")
|
|
else:
|
|
self.defaultPrint(
|
|
_("To apply the changes, restart the X server")
|
|
+".\n")
|
|
except (InstallError,VariableError,DistributiveError),e:
|
|
error = e
|
|
except Exception,e:
|
|
error = ""
|
|
for i in apply(traceback.format_exception, sys.exc_info()):
|
|
error += i
|
|
except KeyboardInterrupt:
|
|
keyInter = True
|
|
except KeyboardInterrupt:
|
|
keyInter = True
|
|
self.showStdout()
|
|
if keyInter:
|
|
if self.startMessage:
|
|
self.printByResult(False)
|
|
self.defaultPrint("\n")
|
|
self.printWARNING(_("System configuration interrupted"))
|
|
error = _("Configuration manually interrupted")
|
|
if self.startMessage:
|
|
self.printByResult(False)
|
|
if error:
|
|
for line in filter(lambda x: x,str(error).split('\n')):
|
|
self.printERROR(line)
|
|
self.printERROR(_("System configuration failed"))
|
|
return False
|
|
return True
|
|
|
|
def cleanInitrd(self):
|
|
"""Clean initrd from needless modules"""
|
|
# get path to initrd and initrd-install in new system
|
|
# (/boot/initramfs-...-install,/boot/initramfs-...)
|
|
chrootPath = path.join(self.clVars.Get('cl_chroot_path'),'boot')
|
|
initrdPath = path.join(chrootPath,self.clVars.Get('os_install_initrd'))
|
|
initrdInstallPath = path.join(chrootPath,
|
|
self.clVars.Get('os_install_initrd_install'))
|
|
if path.exists(initrdInstallPath):
|
|
copy2(initrdInstallPath,initrdPath);
|
|
return True
|
|
|
|
def afterCopyHDDinstall(self,targetDistr):
|
|
"""Action performed after distributive copy for hdd install"""
|
|
# copy clt files from current system
|
|
self.startTask(_("Copying clt templates to the new system"))
|
|
cltCpy = cltCopy(target=targetDistr.getDirectory())
|
|
for directory in self.clVars.Get('cl_template_clt_path'):
|
|
cltCpy.performCopy(directory)
|
|
self.endTask()
|
|
|
|
self.startTask(_("Copying configuration files to the new system"))
|
|
fileMask = r"/etc/udev/rules\.d/70-persistent-net\.rules"
|
|
if self.clVars.Get('os_root_type') != "livecd":
|
|
fileMask = \
|
|
"(%s|/etc/ssh/ssh_host_.*|/root/.ssh/(id_.*|known_hosts))"% \
|
|
fileMask
|
|
fileCpy = otherfilesCopy(target=targetDistr.getDirectory(),
|
|
reTest=fileMask)
|
|
fileCpy.performCopy('/etc')
|
|
if path.exists('/root/.ssh'):
|
|
fileCpy.performCopy('/root/.ssh')
|
|
self.endTask()
|
|
|
|
# optimize initrd
|
|
self.clVars.Set("cl_chroot_path",targetDistr.getDirectory(), True)
|
|
self.startTask(_("Creating a new initrd file"))
|
|
self.cleanInitrd()
|
|
self.endTask("")
|
|
|
|
# join templates
|
|
self.startTask(_("Updating the configuration"),progress=True)
|
|
self.applyTemplates(targetDistr.getDirectory(),
|
|
targetDistr.getBootDirectory()[:-4])
|
|
# mount bind mount points
|
|
|
|
self.endTask()
|
|
|
|
self.startTask(_("Post-install configuration"))
|
|
targetDistr.postinstallMountBind()
|
|
self.endTask()
|
|
|
|
# migrate users
|
|
self.startTask(_("Migrating users"))
|
|
objMigrate = migrate(targetDistr.getDirectory())
|
|
if not objMigrate.migrate(self.clVars.Get('cl_migrate_data'),[],[]):
|
|
raise InstallError(_("Failed to migrate users onto the new system"))
|
|
self.endTask()
|
|
|
|
def setupVideo(self):
|
|
"""Setup video"""
|
|
pathGlModules = path.join(self.clVars.Get('cl_chroot_path'),
|
|
'usr/lib/opengl')
|
|
self.startTask(_("Checking the video driver"))
|
|
self.checkVideoDriver()
|
|
self.endTask()
|
|
if path.exists(pathGlModules):
|
|
self.startTask(_("Configuring OpenGL"))
|
|
self.setupOpenGL()
|
|
self.endTask()
|
|
oldXdrv = self.clVars.Get('os_x11_video_drv')
|
|
newXdrv = self.clVars.Get('os_install_x11_video_drv')
|
|
if oldXdrv != newXdrv:
|
|
kmsDrv = ("radeon","i915","intel","nouveau","ati")
|
|
self.defaultPrint("\n")
|
|
if oldXdrv in kmsDrv or newXdrv in kmsDrv:
|
|
self.printWARNING(
|
|
_("To apply the changes, reboot the system")
|
|
+".\n")
|
|
else:
|
|
self.printWARNING(
|
|
_("To apply the changes, restart the X server")
|
|
+".\n")
|
|
|
|
def hideStdout(self):
|
|
if not self.stdoutHide:
|
|
self.stdoutHide = sys.stdout
|
|
self.stderrHide = sys.stderr
|
|
sys.stdout = StringIO()
|
|
sys.stderr = StringIO()
|
|
sys.stdout.fileno = self.stdoutHide.fileno
|
|
sys.stderr.fileno = self.stderrHide.fileno
|
|
|
|
def showStdout(self):
|
|
if self.stdoutHide:
|
|
sys.stdout = self.stdoutHide
|
|
sys.stderr = self.stderrHide
|
|
self.stdoutHide = None
|
|
self.stderrHide = None
|
|
|
|
def installDesktopClient(self):
|
|
"""
|
|
Install desktop and client package
|
|
"""
|
|
linuxShortname = self.clVars.Get('os_install_linux_shortname')
|
|
# install desktop package
|
|
if linuxShortname in ("CLD","CLS","CLDG","CLDX"):
|
|
generalLib = '/usr/lib/calculate-2.2/calculate-lib/pym'
|
|
desktopLib = '/usr/lib/calculate-2.2/calculate-desktop/pym'
|
|
if path.exists(generalLib) and path.exists(desktopLib):
|
|
sys.path.insert(0, path.abspath(generalLib))
|
|
sys.path.insert(0, path.abspath(desktopLib))
|
|
from cl_desktop import desktop
|
|
self.startTask(_("calculate-desktop enabled "
|
|
"for package configuration"))
|
|
self.hideStdout()
|
|
objDesktop = desktop()
|
|
objDesktop.createClVars()
|
|
if objDesktop.installProg():
|
|
self.endTask()
|
|
else:
|
|
self.printERROR()
|
|
self.showStdout()
|
|
sys.path.pop(0)
|
|
sys.path.pop(0)
|
|
|
|
# install client package
|
|
if linuxShortname in ("CLD","CLDG","CLDX"):
|
|
generalLib = '/usr/lib/calculate-2.2/calculate-lib/pym'
|
|
clientLib = '/usr/lib/calculate-2.2/calculate-client/pym'
|
|
if path.exists(generalLib) and path.exists(clientLib):
|
|
sys.path.insert(0, path.abspath(generalLib))
|
|
sys.path.insert(0, path.abspath(clientLib))
|
|
from cl_client import client
|
|
self.startTask(
|
|
_("calculate-client enabled "
|
|
"for package configuration"))
|
|
objClient = client()
|
|
objClient.createClVars()
|
|
self.hideStdout()
|
|
if hasattr(objClient,"updateEnvFiles") and \
|
|
objClient.updateEnvFiles():
|
|
objClient.clVars.flIniFile()
|
|
if objClient.installProg():
|
|
self.endTask()
|
|
else:
|
|
self.printERROR()
|
|
self.showStdout()
|
|
sys.path.pop(0)
|
|
sys.path.pop(0)
|
|
|
|
def setupSystem(self,variables):
|
|
error = None
|
|
if variables:
|
|
self.clVars = variables
|
|
else:
|
|
self.initVars()
|
|
try:
|
|
target = None
|
|
setupType = self.clVars.Get('cl_setup',humanreadable=True)
|
|
if setupType:
|
|
self.startTask((_("%s are being configured")%
|
|
setupType).capitalize(),progress=True)
|
|
else:
|
|
self.startTask(_("System configuration"),progress=True)
|
|
res = self.applyTemplatesStartup()
|
|
self.endTask()
|
|
if setupType and self.clVars.Get('cl_setup') == 'network':
|
|
pass
|
|
if setupType and self.clVars.Get('cl_setup') == 'video':
|
|
self.setupVideo()
|
|
if setupType and self.clVars.Get('cl_setup') == 'users':
|
|
pass
|
|
if self.clVars.Get('cl_setup') == 'boot' and \
|
|
self.clVars.Get('os_root_type') != 'livecd':
|
|
target = self.clVars.Get('cl_image')
|
|
if self.clVars.Get('os_install_mbr'):
|
|
self.startTask(_("Installing the bootloader"))
|
|
self.prepareBoot(target)
|
|
self.endTask()
|
|
root_dev = self.clVars.Select('os_disk_parent',
|
|
where='os_disk_mount',
|
|
eq='/',limit=1)
|
|
if root_dev:
|
|
self.startTask(_("Changing the I/O scheduler"))
|
|
try:
|
|
schedpath = ("/sys%s/queue/scheduler"%
|
|
(getUdevDeviceInfo(name=root_dev).get('DEVPATH','')))
|
|
if path.exists(schedpath):
|
|
open(schedpath,'w').write(
|
|
self.clVars.Get('os_install_kernel_scheduler'))
|
|
self.endTask()
|
|
except:
|
|
self.printERROR(_("Unable to change the I/O scheduler"))
|
|
pass
|
|
if not setupType:
|
|
self.installDesktopClient()
|
|
except KeyboardInterrupt:
|
|
error = _("Configuration manually interrupted")
|
|
self.printERROR(error)
|
|
except (MigrationError,
|
|
TemplatesError,
|
|
InstallError,
|
|
AutopartitionError,
|
|
DistributiveError) as e:
|
|
error = str(e)
|
|
self.printERROR(error)
|
|
except (BaseException),e:
|
|
error = ""
|
|
for i in apply(traceback.format_exception, sys.exc_info()):
|
|
error += i
|
|
self.printERROR(error)
|
|
return False
|
|
finally:
|
|
try:
|
|
self.clVars.close()
|
|
if target:
|
|
target.close()
|
|
except (MigrationError,
|
|
TemplatesError,
|
|
InstallError,
|
|
AutopartitionError,
|
|
DistributiveError) as e:
|
|
error = str(e)
|
|
self.printERROR(error)
|
|
except (BaseException),e:
|
|
error = ""
|
|
for i in apply(traceback.format_exception, sys.exc_info()):
|
|
error += i
|
|
self.printERROR(error)
|
|
return False
|
|
if not error:
|
|
self.printSUCCESS(_("System configured")+"!")
|
|
self.endTask()
|
|
self.endFrame()
|
|
return True
|
|
|
|
def installSystem(self,variables):
|
|
"""install System by current variable enviroment"""
|
|
error = None
|
|
if variables:
|
|
self.clVars = variables
|
|
else:
|
|
self.initVars()
|
|
try:
|
|
results = []
|
|
self.writeFile()
|
|
# Помещение данных в словарь процессов
|
|
self.briefParams('install_view')
|
|
#self.beginFrame()
|
|
targetDistr = None
|
|
sourceDistr = None
|
|
try:
|
|
#self.clVars.printVars()
|
|
if self.clVars.Get('cl_autopartition_set') == 'on':
|
|
self.startTask(_("Creating a new partition table"),
|
|
progress=True)
|
|
ap = AutoPartition()
|
|
devices = self.clVars.Get('cl_autopartition_device')
|
|
ap.clearLvm(devices,self.clVars)
|
|
ap.clearRaid(devices,self.clVars)
|
|
ap.recreateSpace(
|
|
self.clVars.Get('cl_autopartition_table'),
|
|
devices,
|
|
self.clVars.Get('cl_autopartition_disk_data'),
|
|
self.clVars.GetBool('cl_autopartition_lvm_set'),
|
|
self.clVars.Get('cl_autopartition_lvm_vgname'))
|
|
self.endTask()
|
|
targetDistr = self.clVars.Get('cl_target')
|
|
sourceDistr = self.clVars.Get('cl_image')
|
|
self.setTaskNumber(25)
|
|
# cmd options
|
|
if targetDistr.needFormat:
|
|
self.startTask(_("Formatting the partitions"),progress=True)
|
|
targetDistr.performFormat()
|
|
self.endTask()
|
|
# install distributive
|
|
#raise InstallError("Manual stop")
|
|
self.startTask(_("Unpacking the system image to the target"),
|
|
progress=True,num=18)
|
|
self.clVars.Get('os_grub_conf')
|
|
# set spinner flag
|
|
filesnum = self.clVars.Get('os_install_linux_files')
|
|
if filesnum.isdigit():
|
|
filesnum = int(filesnum)
|
|
else:
|
|
filesnum = 0
|
|
targetDistr.installFrom(sourceDistr,
|
|
callbackProgress=self.setProgress,
|
|
filesnum=filesnum)
|
|
if self.clVars.Get('os_install_pxe') == 'off':
|
|
targetDistr.convertToDirectory()
|
|
self.endTask()
|
|
|
|
self.clVars.processRefresh()
|
|
if self.clVars.Get('os_install_root_type') != "flash" and \
|
|
self.clVars.Get('os_install_pxe') == 'off':
|
|
self.afterCopyHDDinstall(targetDistr)
|
|
else:
|
|
# join templates
|
|
if self.clVars.Get('os_install_pxe') == 'on':
|
|
self.startTask(
|
|
_("Configuring the PXE install"),progress=True)
|
|
self.applyTemplatesFlash('/')
|
|
else:
|
|
self.startTask(
|
|
_("Configuring the Flash install"),progress=True)
|
|
self.applyTemplatesFlash(targetDistr.getDirectory())
|
|
self.endTask()
|
|
self.closeClTemplate()
|
|
# change boot config
|
|
if self.clVars.Get('os_install_mbr') and \
|
|
self.clVars.Get('os_install_pxe') == "off":
|
|
self.startTask(_("Preparing the system for reboot"))
|
|
self.prepareBoot(targetDistr)
|
|
self.endTask()
|
|
except EOFError as e:
|
|
error = str(e)
|
|
except (MigrationError,
|
|
TemplatesError,
|
|
InstallError,
|
|
AutopartitionError,
|
|
DistributiveError) as e:
|
|
error = str(e)
|
|
except Exception as e:
|
|
error = ""
|
|
for i in apply(traceback.format_exception, sys.exc_info()):
|
|
error += i
|
|
except KeyboardInterrupt,e:
|
|
self.printWARNING(_("Installation interrupted"))
|
|
error = _("Installation manually interrupted")
|
|
if error:
|
|
self.printERROR(error)
|
|
try:
|
|
self.closeClTemplate()
|
|
if sourceDistr and sourceDistr.childs:
|
|
self.startTask(_("Letting go the source distribution"))
|
|
sourceDistr.close()
|
|
self.endTask()
|
|
if targetDistr and targetDistr.childs:
|
|
self.startTask(_("Unmounting the target system volume"))
|
|
targetDistr.close()
|
|
self.endTask()
|
|
except (VariableError,TemplatesError,
|
|
InstallError,DistributiveError),e:
|
|
error = "%s\n%s" % (str(error),_("Unmounting error"))
|
|
self.printERROR(error)
|
|
except KeyboardInterrupt,e:
|
|
pass
|
|
if error:
|
|
self.printERROR(_("Failed to install the system")+"!")
|
|
return False
|
|
self.printSUCCESS(_("System successfully installed")+"!")
|
|
self.endTask()
|
|
self.endFrame()
|
|
# necessary for correct complete the process
|
|
return True
|
|
except (BaseException),e:
|
|
error = ""
|
|
for i in apply(traceback.format_exception, sys.exc_info()):
|
|
error += i
|
|
self.printERROR(error)
|
|
return False
|
|
finally:
|
|
try:
|
|
self.clVars.close()
|
|
except (BaseException),e:
|
|
error = ""
|
|
for i in apply(traceback.format_exception, sys.exc_info()):
|
|
error += i
|
|
self.printERROR(error)
|
|
return False
|
|
return True
|