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.
469 lines
19 KiB
469 lines
19 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 cl_overriding
|
|
from cl_vars_share import varsShare
|
|
from cl_kernel import cl_kernel
|
|
from os import access, R_OK,W_OK
|
|
from os import path
|
|
from cl_distr import Distributive
|
|
from cl_utils import getTupleVersion,genpassword,pathJoin,_toUNICODE, \
|
|
getFilesCount,getCmdLineParam,countFiles,listDirectory
|
|
from operator import itemgetter
|
|
from types import ListType
|
|
from cl_datavars import iniParser
|
|
from cl_vars import Data as libData
|
|
from datetime import datetime
|
|
|
|
class fillVars(object, varsShare):
|
|
|
|
def get_cl_kernel_src_path(self):
|
|
defaultKernelPath = '/usr/src'
|
|
priorityDir = path.join(defaultKernelPath,"linux")
|
|
if not access(defaultKernelPath,R_OK):
|
|
return ""
|
|
kernel = cl_kernel()
|
|
kernelDirs = filter(kernel._testKernelDirectory,
|
|
map(lambda x:path.join(defaultKernelPath,x),
|
|
os.listdir(defaultKernelPath)))
|
|
if kernelDirs:
|
|
if priorityDir in kernelDirs:
|
|
return priorityDir
|
|
else:
|
|
return path.join(defaultKernelPath,kernelDirs[0])
|
|
return ""
|
|
|
|
def get_cl_kernel_full_ver(self):
|
|
if self.Get('cl_kernel_config') \
|
|
and os.access(self.Get('cl_kernel_config'),os.R_OK):
|
|
localVer = self.getValueFromConfig(
|
|
self.Get('cl_kernel_config'),
|
|
'CONFIG_LOCALVERSION')
|
|
if not localVer:
|
|
localVer=""
|
|
else:
|
|
localVer = ""
|
|
kernelMakefile = path.join(self.Get('cl_kernel_src_path'),'Makefile')
|
|
if os.access(kernelMakefile,os.R_OK):
|
|
extraVer = ""
|
|
for line in open(kernelMakefile,'r'):
|
|
if "EXTRAVERSION" in line:
|
|
extraVer = line.partition('=')[2].strip()
|
|
break
|
|
else:
|
|
localVer = ""
|
|
return "%s%s%s"%(self.Get('cl_kernel_ver'), extraVer, localVer)
|
|
|
|
def get_cl_builder_kernel_suffix(self):
|
|
kernelname = self.Get('cl_builder_kernel')
|
|
reShortname = re.compile(
|
|
r"^vmlinuz-((?:\d+\.)*\d+)-(x86_64|i686)-(.*)$",re.S)
|
|
res = reShortname.search(kernelname)
|
|
bootPath = path.join(self.Get('cl_builder_path'),'boot')
|
|
if res:
|
|
return "%s-%s-%s"%(res.groups()[0],
|
|
self.Get('os_builder_arch_machine'),
|
|
self.Get('os_builder_linux_shortname'))
|
|
return ""
|
|
|
|
|
|
def get_cl_kernel_suffix(self):
|
|
kernelFullVer = self.Get('cl_kernel_full_ver')
|
|
fullVerWithoutCalculate = kernelFullVer.replace("-calculate","")
|
|
return "%s-%s-%s"%(fullVerWithoutCalculate,
|
|
self.Get('os_arch_machine'),
|
|
self.Get('os_linux_shortname'))
|
|
|
|
def get_cl_kernel_ver(self):
|
|
kernelMakefile = path.join(self.Get('cl_kernel_src_path'),'Makefile')
|
|
reVerPart = re.compile(
|
|
"^(?:VERSION|^PATCHLEVEL|^SUBLEVEL)\s*=",re.I)
|
|
if access(kernelMakefile,R_OK):
|
|
try:
|
|
makeVer = \
|
|
"%(VERSION)s.%(PATCHLEVEL)s.%(SUBLEVEL)s"% \
|
|
dict(map(lambda x:(x[0].strip(),x[2].strip()),
|
|
map(lambda x:x.partition('='),
|
|
filter(reVerPart.search,
|
|
open(kernelMakefile,'r')))))
|
|
return makeVer
|
|
except:
|
|
pass
|
|
return ""
|
|
|
|
def get_cl_kernel_config(self):
|
|
kernelDirs = self.Get('cl_kernel_config_path')
|
|
if not access(kernelDirs,R_OK):
|
|
return ""
|
|
# check first number (3 or other kernel)
|
|
tupleKernelVer = self.Get('cl_kernel_ver').split('.')
|
|
if tupleKernelVer and tupleKernelVer[0] == '3':
|
|
shortVerSearch = re.search("^\d+\.\d+",
|
|
self.Get('cl_kernel_ver'),re.I)
|
|
else:
|
|
shortVerSearch = re.search("^\d+\.\d+.\d+",
|
|
self.Get('cl_kernel_ver'),re.I)
|
|
if shortVerSearch:
|
|
shortVer = shortVerSearch.group()
|
|
else:
|
|
return ""
|
|
# find best config
|
|
makeProfile = '/etc/make.profile'
|
|
profileSpec = ''
|
|
if path.islink(makeProfile):
|
|
linkTarget = os.readlink('/etc/make.profile')
|
|
parentDir, profileSpecification = path.split(linkTarget)
|
|
if parentDir.endswith('x86') or parentDir.endswith('amd64'):
|
|
profileSpec = profileSpecification
|
|
configName = "config-%(system)s-%(march)s-%(ver)s" % \
|
|
{'system':self.Get('os_linux_system'),
|
|
'march':self.Get('os_arch_machine'),
|
|
'ver':shortVer}
|
|
configNameSpec = "config-%(system)s-%(march)s-%(ver)s-%(spec)s" % \
|
|
{'system':self.Get('os_linux_system'),
|
|
'march':self.Get('os_arch_machine'),
|
|
'ver':shortVer,
|
|
'spec':profileSpec}
|
|
if profileSpec and path.exists(path.join(kernelDirs,configNameSpec)):
|
|
return path.join(kernelDirs,configNameSpec)
|
|
elif path.exists(path.join(kernelDirs,configName)):
|
|
return path.join(kernelDirs,configName)
|
|
return ""
|
|
|
|
def get_os_builder_makeopts(self):
|
|
makeconf = '/etc/make.conf'
|
|
if access(makeconf,R_OK):
|
|
makeopts = self.getValueFromConfig('/etc/make.conf',"MAKEOPTS")
|
|
if makeopts:
|
|
return makeopts
|
|
return ""
|
|
|
|
def get_cl_kernel_boot_path(self):
|
|
return path.join(self.Get('cl_kernel_install_path'),"boot")
|
|
|
|
def get_cl_kernel_cache_path(self):
|
|
cacheDir = self.getValueFromConfig('/etc/genkernel.conf','CACHE_DIR')
|
|
if cacheDir == False:
|
|
return "/var/cache/genkernel"
|
|
else:
|
|
return cacheDir
|
|
|
|
def get_ac_builder_iso(self):
|
|
"""Need perform templates for builder:iso"""
|
|
if self.Get('cl_action')=='iso':
|
|
return "up"
|
|
return ""
|
|
|
|
def get_ac_builder_squash(self):
|
|
"""Need perform templates for builder:squahs"""
|
|
if self.Get('cl_action')=='squash':
|
|
return "up"
|
|
return ""
|
|
|
|
def get_cl_builder_path(self):
|
|
"""Get path for image"""
|
|
paths = map(lambda x:x[1],reversed(libData.cl_env_data['value']))
|
|
if self.Get('cl_action') != 'kernel':
|
|
for inifile in paths:
|
|
if os.access(inifile,os.R_OK):
|
|
inidata = iniParser(inifile)
|
|
res = inidata.getVar("assemble","cl_assemble_path",
|
|
checkExistVar=True)
|
|
if res and res[0]:
|
|
return _toUNICODE(res[1]).encode('utf-8')
|
|
return "/mnt/builder"
|
|
return "/"
|
|
|
|
def get_cl_builder_kernel(self):
|
|
"""Kernel image"""
|
|
bootdir = path.join(self.Get('cl_builder_path'),'boot')
|
|
modulesdir = path.join(self.Get('cl_builder_path'),'lib/modules')
|
|
if not os.access(modulesdir,os.R_OK):
|
|
return ""
|
|
validKernel = os.listdir(modulesdir)
|
|
kernelFiles = self.getFilesByType(bootdir,"Linux kernel")
|
|
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,
|
|
map(lambda x:(x[0],self.reFindVer.search(x[1])),
|
|
kernelFiles)))
|
|
if kernelsWithVer:
|
|
return path.split(max(kernelsWithVer,key=itemgetter(1))[0])[-1]
|
|
return ""
|
|
|
|
def get_cl_builder_initrd_install(self):
|
|
kernelname = self.Get('cl_builder_kernel')
|
|
reShortname = re.compile(
|
|
r"^vmlinuz-(\d+\.)*\d+-(x86_64|i686)-(.*)$",re.S)
|
|
res = reShortname.search(kernelname)
|
|
if res:
|
|
shortname = res.groups()[2]
|
|
archmachine = res.groups()[1]
|
|
else:
|
|
shortname = self.Get('os_builder_linux_shortname')
|
|
archmachine = self.Get('os_builder_arch_machine')
|
|
return self.getInitrd(archmachine,
|
|
shortname,
|
|
self.Get('cl_builder_path'),
|
|
kernelname,
|
|
suffix="install") or ""
|
|
|
|
def get_cl_builder_kernel_config(self):
|
|
kernelname = self.Get('cl_builder_kernel')
|
|
reShortname = re.compile(
|
|
r"^vmlinuz-((?:\d+\.)*\d+)-(x86_64|i686)-(.*)$",re.S)
|
|
res = reShortname.search(kernelname)
|
|
bootPath = path.join(self.Get('cl_builder_path'),'boot')
|
|
if res:
|
|
kernelconfig = "config-%s-%s-%s"%(res.groups()[:3])
|
|
if path.exists(path.join(bootPath,kernelconfig)):
|
|
return kernelconfig
|
|
elif path.exists(bootPath):
|
|
configs = filter(lambda x:x.startswith('config'),
|
|
os.listdir(bootPath))
|
|
if configs:
|
|
return configs[0]
|
|
return ""
|
|
|
|
def get_cl_builder_kernel_systemmap(self):
|
|
kernelname = self.Get('cl_builder_kernel')
|
|
reShortname = re.compile(
|
|
r"^vmlinuz-((?:\d+\.)*\d+)-(x86_64|i686)-(.*)$",re.S)
|
|
res = reShortname.search(kernelname)
|
|
bootPath = path.join(self.Get('cl_builder_path'),'boot')
|
|
if res:
|
|
systemmap = "System.map-%s-%s-%s"%(res.groups()[:3])
|
|
if path.exists(path.join(bootPath,systemmap)):
|
|
return systemmap
|
|
elif path.exists(bootPath):
|
|
systemmaps = filter(lambda x:x.startswith('System.map'),
|
|
os.listdir(bootPath))
|
|
if systemmaps:
|
|
return systemmaps[0]
|
|
return ""
|
|
|
|
def get_os_builder_linux_name(self):
|
|
"""Build system name"""
|
|
linuxShortName = self.Get("os_builder_linux_shortname")
|
|
return self.dictLinuxName.get(linuxShortName,"Linux")
|
|
|
|
def get_os_builder_linux_subname(self):
|
|
"""Build system subname"""
|
|
linuxShortName = self.Get("os_builder_linux_shortname")
|
|
return self.dictLinuxSubName.get(linuxShortName,"")
|
|
|
|
def get_os_builder_linux_shortname(self):
|
|
"""Build system shortname"""
|
|
systemRoot = self.Get('cl_builder_path')
|
|
return self.getShortnameByMakeprofile(systemRoot) or \
|
|
self.getShortnameByIni(systemRoot) or \
|
|
self.detectOtherShortname(systemRoot) or \
|
|
"Linux"
|
|
|
|
def get_os_builder_linux_filesnum(self):
|
|
"""Files number in image system"""
|
|
if self.Get('cl_builder_tree') == 'off':
|
|
sourceDirectory = self.Get('cl_builder_path')
|
|
portagePath = pathJoin(sourceDirectory,"usr/portage")
|
|
overlayPath = pathJoin(sourceDirectory,"var/lib/layman/calculate")
|
|
excludeCount = \
|
|
reduce(lambda x,y:x + y,
|
|
map(countFiles,
|
|
map(lambda x: path.join(sourceDirectory,"var/lib/layman/calculate",x),
|
|
filter(lambda x: not x in ("distfiles", "eclass", ".git","profiles"),
|
|
listDirectory(overlayPath))) + \
|
|
map(lambda x: path.join(sourceDirectory,"usr/portage",x),
|
|
filter(lambda x: not x in ("distfiles", "eclass", ".git","profiles"),
|
|
listDirectory(portagePath)))),0)
|
|
else:
|
|
excludeCount = 0
|
|
systemRoot = self.Get('cl_builder_path')
|
|
return str(countFiles(systemRoot)-excludeCount)
|
|
|
|
def getVersionFromCalculateEnv(self,systemroot):
|
|
"""Get version from calculate ini"""
|
|
pathname = path.join(systemroot,
|
|
'var/lib/layman/calculate/profiles/calculate.env')
|
|
if path.exists(pathname):
|
|
FD = open(pathname)
|
|
data = FD.readlines()
|
|
FD.close()
|
|
verList = filter(lambda y:y,
|
|
map(lambda x:\
|
|
len(x.split("="))==2 and\
|
|
x.split("=")[0].strip() == "os_linux_ver" and\
|
|
x.split("=")[1].strip(), data))
|
|
if verList:
|
|
reVer=re.compile("^((\d+\.)*\d+|\d+)$",re.S)
|
|
reRes = filter(reVer.search,verList)
|
|
if reRes:
|
|
return reRes[0]
|
|
|
|
def get_os_builder_linux_ver(self):
|
|
"""Build system ver"""
|
|
linuxShortName = self.Get("os_builder_linux_shortname")
|
|
rootSystem = self.Get('cl_builder_path')
|
|
return self.getVersionFromMetapackage(rootSystem,linuxShortName) or \
|
|
self.getVersionFromCalculateEnv(rootSystem) or \
|
|
self.getVersionFromCalculateIni(rootSystem) or \
|
|
self.getVersionFromGentooFiles(rootSystem) or "0"
|
|
|
|
def get_os_builder_arch_machine(self):
|
|
"""Build system arch"""
|
|
rootSystem = self.Get('cl_builder_path')
|
|
lib64path = path.join(rootSystem,"lib64")
|
|
return 'x86_64' if path.lexists(lib64path) else "i686"
|
|
|
|
def get_os_builder_linux_system(self):
|
|
"""Build linux system type"""
|
|
shortName = self.Get('os_builder_linux_shortname')
|
|
return self.dictNameSystem.get(shortName,"")
|
|
|
|
def get_cl_builder_cdname(self):
|
|
"""Cd size specified by name (DVD/CD)"""
|
|
squashfile = pathJoin(self.Get('cl_builder_iso_path'),
|
|
self.Get('cl_builder_current_squash'))
|
|
kernelfile = pathJoin(self.Get('cl_builder_iso_path'),
|
|
self.Get('cl_builder_squash_path'),
|
|
'boot',
|
|
self.Get('cl_builder_kernel'))
|
|
initrdfile = pathJoin(self.Get('cl_builder_iso_path'),
|
|
self.Get('cl_builder_squash_path'),
|
|
'boot',
|
|
self.Get('cl_builder_initrd_install'))
|
|
if os.access(squashfile,R_OK) and os.access(kernelfile,R_OK) and \
|
|
os.access(initrdfile,R_OK):
|
|
isosize = path.getsize(squashfile)+path.getsize(kernelfile)+ \
|
|
path.getsize(initrdfile)+2*1024*1024
|
|
if isosize > 700*1024*1024:
|
|
return "DVD"
|
|
else:
|
|
return "CD"
|
|
return ""
|
|
|
|
def getSquashNum(self,reMatch):
|
|
if reMatch.groups()[1] and reMatch.groups()[1].isdigit():
|
|
return int(reMatch.groups()[1])
|
|
else:
|
|
return 0
|
|
|
|
def get_cl_builder_remove_squash(self):
|
|
"""Livecd.squashfs name for del(may be livecd.squashfs.2 and etc)"""
|
|
directory = self.Get('cl_builder_iso_path')
|
|
if not os.access(directory,R_OK):
|
|
return ""
|
|
squashfiles = filter(lambda x:x,
|
|
map(Distributive.reLive.search,
|
|
os.listdir(directory)))
|
|
curName = self.Get('cl_builder_old_squash')
|
|
if squashfiles:
|
|
return filter(lambda x:x != curName,
|
|
map(lambda x:x.group(),
|
|
sorted(squashfiles, key=self.getSquashNum)))
|
|
return ""
|
|
|
|
def get_cl_builder_current_squash(self):
|
|
"""
|
|
Variable keep value of squash image which will created by squash command
|
|
"""
|
|
oldSquash = self.Get('cl_builder_old_squash')
|
|
reOldSquash = Distributive.reLive.search(oldSquash)
|
|
if "/mnt/flash" in self.Get('cl_builder_iso_path') and reOldSquash:
|
|
newNum = self.getSquashNum(reOldSquash)+1
|
|
return "livecd.squashfs.%d"%newNum
|
|
else:
|
|
return "livecd.squashfs"
|
|
|
|
def get_cl_builder_old_squash(self):
|
|
"""
|
|
Variable keep value of boot squash image
|
|
"""
|
|
loopValue = getCmdLineParam('loop')
|
|
if loopValue:
|
|
return path.basename(loopValue)
|
|
return ""
|
|
|
|
def get_cl_builder_iso_path(self):
|
|
directory = \
|
|
"/var/calculate/tmp/iso-%s-%s"%(self.Get('os_builder_linux_shortname'),
|
|
self.Get('os_builder_arch_machine'))
|
|
newDirectoryName = directory
|
|
while path.exists(newDirectoryName):
|
|
newDirectoryName = "%s.%s"%(directory,genpassword(8))
|
|
return newDirectoryName
|
|
|
|
def get_cl_builder_image(self):
|
|
"""Iso image full path"""
|
|
imagepath = self.Get('cl_builder_image_path')
|
|
if type(imagepath) != ListType:
|
|
imagepath = [imagepath]
|
|
paths = filter(lambda x:os.access(x,W_OK), imagepath)
|
|
if paths:
|
|
return path.join(paths[0],"%(shortname)s-%(ver)s-%(march)s.iso"%
|
|
{'shortname':self.Get('os_builder_linux_shortname').lower(),
|
|
'ver':self.Get('os_builder_linux_build') or
|
|
self.Get('os_builder_linux_ver'),
|
|
'march':self.Get('os_builder_arch_machine')})
|
|
return ""
|
|
|
|
def get_os_builder_linux_build(self):
|
|
"""Generate build"""
|
|
curdate = datetime.now()
|
|
return "%04d%02d%02d"%(curdate.year,curdate.month,curdate.day)
|
|
|
|
def get_cl_builder_distro(self):
|
|
"""Current assembling systems"""
|
|
envFile = '/etc/calculate/assemble.env'
|
|
envData = iniParser(envFile)
|
|
return filter(lambda x:envData.getVar(x,
|
|
'os_assemble_root_dev'),
|
|
map(lambda x:_toUNICODE(x).encode('utf-8'),
|
|
envData.getAllSectionNames()))
|
|
|
|
def get_cl_builder_filesnum(self):
|
|
"""Get files num in assembled distro"""
|
|
#getFilesCount(self.Get('cl_builder_path'))
|
|
return "0"
|
|
|
|
def get_cl_builder_image_path(self):
|
|
"""Path which contains images"""
|
|
imagePath = ['/var/calculate/linux',
|
|
'/var/calculate/remote/linux',
|
|
'/usr/calculate/share/linux']
|
|
if self.Get('os_builder_profile'):
|
|
imagePath.insert(0,path.join("/var/calculate/remote/assemble",
|
|
self.Get('os_builder_profile').replace('/','-'),
|
|
"linux"))
|
|
return imagePath
|
|
|
|
def get_cl_builder_kernel_cmd(self):
|
|
"""Suffix for kernel cmdline"""
|
|
suffix = ""
|
|
timezone = self.Get('os_builder_clock_timezone')
|
|
lang = self.Get('os_builder_locale_lang')
|
|
if timezone and lang:
|
|
suffix = "calculate=lang:%s,keymap:%s,timezone:%s" % \
|
|
(lang,lang,timezone)
|
|
elif timezone:
|
|
suffix = "calculate=,,timezone:%s"%(timezone)
|
|
elif lang:
|
|
suffix = "calculate=lang:%s,keymap:%s" % (lang,lang)
|
|
print suffix
|
|
return suffix
|