def get(self):
# find grub2-install
grubInstall = getProgPath('/usr/sbin/grub2-install')
if grubInstall:
return grubInstall
# find grub-install and check, that this is grub2-install (ver 1.99)
grubInstall = getProgPath('/usr/sbin/grub-install')
if grubInstall and filter(lambda x:"1.99" in x or "2.00" in x,
process(grubInstall,'-v')):
return grubInstall
return ""
def recreatePartitionTableDos(self,device,data):
"""
Create DOS partition table by /sbin/fdisk
"""
NEW_PARTITION_TABLE = "o\n"
NEW_PRIMARY_PARTITION = "n\np\n\n\n"
NEW_EXTENDED_PARTITION = "n\ne\n\n"
NEW_LOGICAL_PARTITION = "n\n\n"
MAX_SIZE = "\n"
WRITE_AND_QUIT = "w\nq\n"
fdiskProg = getProgPath('/sbin/fdisk')
fdisk = process(fdiskProg,device[0])
fdisk.write(NEW_PARTITION_TABLE)
num = 1
for size in map(lambda x:str(Sizes().to_K(int(x))) \
if x.isdigit() else x,
map(operator.itemgetter(3),data)):
if num == 4:
fdisk.write(NEW_EXTENDED_PARTITION+MAX_SIZE)
num += 1
size = MAX_SIZE if size == "allfree" else "+%sK\n"%size
if num < 4:
fdisk.write(NEW_PRIMARY_PARTITION+size)
else:
fdisk.write(NEW_LOGICAL_PARTITION+size)
num +=1
fdisk.write(WRITE_AND_QUIT)
fdisk.success()
self._waitDevice(device[0]+str(num-1))
def recreateLvm(self,table,devices,data,vgname):
"""
Create GPT partition table by /sbin/gdisk
"""
for device in devices:
self.recreatePartitionTable(table,[device],[['','','','allfree']])
disks = map(lambda x:"%s1"%x,devices)
if not self._createPhisicalVolumes(disks):
raise AutopartitionError(
_("Failed to create physical volumes from %s")
%",".join(devices))
if not self._createVolumesGroup(vgname,disks):
raise AutopartitionError(
_("Failed to create volume group {groupname} from {disks}")
.format(groupname=vgname,
disks=",".join(devices)))
lvCreateProg = getProgPath('/sbin/lvcreate')
for disk,size in map(operator.itemgetter(0,3),data):
lvname = disk.rpartition('/')[2]
if not self._createLogicalVolume(vgname,lvname,size):
raise AutopartitionError(
_("Failed to create logical volume {name}")
.format(name=lvname))
self._waitDevice('/dev/%s/root'%vgname)
def _createLogicalVolume(self,vgname,lvname,size):
if size.isdigit():
size = str(Sizes().to_K(int(size)))
if size == "allfree":
sizeparam = "-l100%FREE"
else:
sizeparam = "-L%sK"%size
lvCreateProg = getProgPath('/sbin/lvcreate')
return process(lvCreateProg,sizeparam,vgname,"-n",lvname).success()
def clearLvm(self,devices,dv):
"""
Remove lvm physical volumes from devices
"""
vgRemoveProg = getProgPath('/sbin/vgremove')
pvRemoveProg = getProgPath('/sbin/pvremove')
lvRemoveProg = getProgPath('/sbin/lvremove')
disks = dv.Select('os_disk_dev',where='os_disk_parent',_in=devices)
failed = False
for group, pair in groupby(dv.Select(['os_lvm_vgname','os_lvm_lvname'],
where='os_lvm_pvname',_in=disks,
sort="ASC/1"),
operator.itemgetter(0)):
for vgname,lvname in pair:
failed |= self.doubleExec(lvRemoveProg,
"%s/%s"%(vgname,lvname),"-f")
failed |= self.doubleExec(vgRemoveProg,group,"-f")
for pvname in list(set(disks)&set(dv.Get('os_lvm_pvname'))):
failed |= self.doubleExec(pvRemoveProg,pvname,"-ffy")
return not failed
def get(self):
"""Get current framebuffer resolution"""
resolution = ""
fbres = getProgPath('/sbin/fbres')
if fbres:
processFbres = process(fbres,stderr=STDOUT)
textLines = processFbres.readlines()
if textLines:
cxx11,cyx11 = \
self.Get('os_install_x11_resolution').partition('x')[0::2]
cxfb, cyfb = textLines[0].partition('x')[0::2]
if not filter(lambda x:not x.isdigit(),
[cxfb,cyfb,cxx11,cyx11])and \
int(cxx11) >= int(cxfb) and int(cyx11) >= int(cyfb):
resolution = "%s-32"%textLines[0]
return resolution or "1024x768-32"
def get(self):
image = self.Get('cl_image')
try:
if image:
image = image.convertToDirectory()
chrootPath = image.getDirectory()
chrootPath = image.getDirectory()
else:
chrootPath = self.Get("cl_chroot_path")
nvidiaeclass = path.join(chrootPath,
'usr/portage/eclass/nvidia-driver.eclass')
if not os.access(nvidiaeclass,os.R_OK):
return ""
category = "0300"
vendor = "10de:"
lsPciProg = getProgPath("/usr/sbin/lspci")
nvidiacards = filter(lambda x:" %s: "%category in x,
process(lsPciProg,"-d",vendor,"-n"))
if not nvidiacards:
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 = readFile(nvidiaeclass)
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]]
finally:
if image:
image.close()
return ""
def clearRaid(self,devices,dv):
"""
Remove raid from devices
"""
mdAdmProg = getProgPath('/sbin/mdadm')
failed = False
for disktype,grouped in groupby(
dv.Select(['os_disk_type','os_disk_dev'],
where='os_disk_parent',
_in=['/dev/sda','/dev/sdb'],
sort="ASC/1"),
operator.itemgetter(0)):
if disktype.endswith('-raid'):
for disk_type, disk_dev in grouped:
failed |= self.doubleExec(mdAdmProg,'-S',disk_dev)
if "raidmember" in disktype:
for disk_type, disk_dev in grouped:
failed |= self.doubleExec(mdAdmProg,
'--zero-superblock',disk_dev)
return not failed
def recreatePartitionTableGpt(self,device,data):
"""
Create GPT partition table by /sbin/gdisk
"""
NEW_PARTITION_TABLE = "3\no\ny\n"
NEW_PARTITION = "n\n\n\n"
NEW_BIOSBOOT_PARTITION = "n\n\n\n%s\nef02\n"
MAX_SIZE = "\n\n"
WRITE_AND_QUIT = "w\ny\n"
fdiskProg = getProgPath('/usr/sbin/gdisk')
fdisk = process(fdiskProg,device[0])
fdisk.write(NEW_PARTITION_TABLE)
num = 1
biosBootCreated = False
for size in map(lambda x:str(Sizes().to_K(int(x))) \
if x.isdigit() else x,
map(operator.itemgetter(3),data)):
if num == 4:
fdisk.write(NEW_BIOSBOOT_PARTITION%"+2M")
biosBootCreated = True
num += 1
if size == "allfree":
if biosBootCreated:
size = MAX_SIZE
else:
size = "-2M\n\n"
else:
size = "+%sK\n\n"%size
fdisk.write(NEW_PARTITION+size)
num +=1
if not biosBootCreated:
fdisk.write(NEW_BIOSBOOT_PARTITION%"")
fdisk.write(WRITE_AND_QUIT)
fdisk.success()
self._waitDevice(device[0]+str(num-1))
def _removeVolumeGroup(self,vgname):
vgRemoveProg = getProgPath('/sbin/vgremove')
# double remove volume group
return process(vgRemoveProg,vgname,"-f").success() or \
process(vgRemoveProg,vgname,"-f").success()
def _createVolumesGroup(self,vgname,disks):
vgCreateProg = getProgPath('/sbin/vgcreate')
return process(vgCreateProg,vgname,*disks).success()
def _createPhisicalVolumes(self,devices):
pvCreateProg = getProgPath('/sbin/pvcreate')
return process(pvCreateProg,"-ff",*devices).success()
