329 lines
17 KiB
Python
329 lines
17 KiB
Python
# -*- coding: UTF-8 -*-
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import platform
|
|
import lib
|
|
from log import *
|
|
|
|
DISTDIR_DEFAULT = 'distribution'
|
|
BUILD_PREFIX_DEFAULT = '/var/tmp/portage'
|
|
BUILD_TEMPDIR_DEFAULT = '/var/tmp/prepare'
|
|
PARSE_EBUILD_FILENAME = re.compile("^.*/([^/]+)/([^/]+)/([^/]+)\.ebuild$")
|
|
|
|
# collect source package configuration
|
|
########################
|
|
# config variables used:
|
|
# kernels: version of source kernel ebuild package to use [default='latest']; eg: 5.15.41, 5.15, latest
|
|
# distdir: name of distribution base directory [defalt='distribution']
|
|
# package: name of kernel package configuration [mandatory]
|
|
# packages.<package>.pkg: name of source kernel ebuild package for this package configuration [mandatory]
|
|
# ebuild.cleanup: boolean flag indicating request to clean up temp files [default=True]
|
|
# ebuild.prefix: name of portage build base directory [default='/var/tmp/portage']
|
|
# ebuild.tempdir: name of ktool build base directory [default='/var/tmp/prepare']
|
|
# ebuild.format: name of package format configuration to use [mandatory]
|
|
# formats.<format>.extension: extension to use for this format configuration [mandatory]
|
|
# formats.<format>.archive: archive creation command to use for format configuration [mandatory]; variables: SRCDIR=source directory, DESTDIR=target directory, DESTFILENAME=target filename
|
|
# formats.<format>.extract: archive extraction command to use for format configuration [mandatory]; variables: SRCFILE=source file, DESTDIR=target directory
|
|
# context variables set up:
|
|
# arch: runtime architecture (x86, x64)
|
|
# pkg_name: name of kernel package configuration to use (copied from config variable 'package'); eg: mygentoo
|
|
# package_to_check: name and version of source kernel ebuild package to use (constructed from config variables 'packages.<package>.pkg' and 'kernels'); eg: sys-kernel/mygentoo-sources-5.15
|
|
# build_prefix: name of portage build base directory (copied from config variable 'ebuild.prefix'); eg: /var/tmp/portage
|
|
# build_tempdir: name of ktool build base directory (copied from config variable 'ebuild.tempdir'); eg: /var/tmp/prepare
|
|
# distdir: name of distribution base directory (copied from config variable 'distdir'); eg: distribution
|
|
# build_clean: boolean flag indicating request to clean up temp files (copied from config variable 'ebuild.cleanup'); eg: True
|
|
# build_source_format: name of package format configuration to use (copied from config variable 'ebuild.format'); eg: tarxz
|
|
# build_source_extension: extension to use for package format (copied from config variable 'formats.<format>.extension'); eg: tar.xz
|
|
# build_source_archive: archive creation command to use for package format (copied from config variable 'formats.<format>.archive'); eg: tar cJfC
|
|
# build_source_extract: archive creation command to use for package format (copied from config variable 'formats.<format>.extract'); eg: tar xJfC
|
|
########################
|
|
def get_source_package_config(config, context):
|
|
arch = platform.machine()
|
|
if arch == 'i686':
|
|
arch = 'x86'
|
|
elif arch == 'x86_64':
|
|
arch = 'x64'
|
|
else:
|
|
sys.stdout.write("Unsupported cpu architecture: %s\n" % (arch))
|
|
return 2
|
|
context['arch'] = arch
|
|
|
|
config_pkg_name = config.get_config_param('package', mandatory=True)
|
|
if config_pkg_name == None:
|
|
return 3
|
|
context['pkg_name'] = config_pkg_name
|
|
config_pkg_id = 'packages.%s.pkg' % (config_pkg_name)
|
|
package_name = config.get_config_param(config_pkg_id, mandatory=True)
|
|
if package_name == None:
|
|
return 3
|
|
|
|
build_clean = config.get_config_param('ebuild.cleanup', default=True, type='boolean')
|
|
context['build_clean'] = build_clean
|
|
|
|
version_wanted = config.get_config_param('kernels', default='latest')
|
|
if version_wanted == 'latest':
|
|
version_wanted = ''
|
|
package_to_check = package_name if version_wanted == '' else '%s-%s*' % (package_name, version_wanted)
|
|
build_prefix = config.get_config_param('ebuild.prefix', default=BUILD_PREFIX_DEFAULT)
|
|
build_tempdir = config.get_config_param('ebuild.tempdir', default=BUILD_TEMPDIR_DEFAULT)
|
|
distdir = config.get_config_param('distdir', default=DISTDIR_DEFAULT)
|
|
context['package_to_check'] = package_to_check
|
|
context['build_prefix'] = build_prefix
|
|
context['build_tempdir'] = build_tempdir
|
|
context['distdir'] = distdir
|
|
|
|
build_source_format = config.get_config_param('ebuild.format', mandatory=True)
|
|
if build_source_format == None:
|
|
return 3
|
|
build_source_extension = config.get_config_param('formats.%s.extension' % (build_source_format), mandatory=True)
|
|
if build_source_extension == None:
|
|
return 3
|
|
build_source_archive = config.get_config_param('formats.%s.archive' % (build_source_format), mandatory=True)
|
|
if build_source_archive == None:
|
|
return 3
|
|
build_source_extract = config.get_config_param('formats.%s.extract' % (build_source_format), mandatory=True)
|
|
if build_source_extract == None:
|
|
return 3
|
|
context['build_source_format'] = build_source_format
|
|
context['build_source_extension'] = build_source_extension
|
|
context['build_source_archive'] = build_source_archive
|
|
context['build_source_extract'] = build_source_extract
|
|
|
|
for key in 'arch', 'pkg_name', 'build_prefix', 'build_tempdir', 'distdir', 'build_source_format', 'build_source_extension', 'build_source_archive', 'build_source_extract':
|
|
sys.stdout.write("%s: %s\n" % (key, context[key]))
|
|
return 0
|
|
|
|
# determine source ebuild and version info
|
|
########################
|
|
# context variables used:
|
|
# package_to_check (get_source_package_config)
|
|
# build_prefix (get_source_package_config)
|
|
# context variables set up:
|
|
# found_ebuild_filename: name of ebuild file found using 'equery which' based on context variable 'package_to_check'; eg: /var/db/repos/myoverlay/sys-kernel/mygentoo-sources/mygentoo-sources-5.15.41.ebuild
|
|
# found_package_group: package group parsed from ebuild file directory path .../<pkggroup>/<pkgname>/<pkgname>-<version>.ebuild; eg: sys-kernel
|
|
# found_package_name: package name parsed from ebuild file directory path .../<pkggroup>/<pkgname>/<pkgname>-<version>.ebuild; eg: mygentoo-sources
|
|
# found_version: package version parsed from ebuild file name .../<pkggroup>/<pkgname>/<pkgname>-<version>.ebuild; eg: 5.15.41
|
|
# found_package_fullname: package full atom identifier reconstructed from package group, package name, package version; eg: sys-kernel/mygentoo-sources-5.15.41
|
|
# build_image_dir: name of image directory within portage package build directory (constructed from context variable 'build_prefix' and package full atom identifier); eg: /var/tmp/portage/sys-kernel/mygentoo-sources-5.15.41/image
|
|
# build_env_file: name of env file within portage package build directory (constructed from context variable 'build_prefix' and package full atom identifier); eg: /var/tmp/portage/sys-kernel/mygentoo-sources-5.15.41/temp/environment
|
|
########################
|
|
def get_source_ebuild_info(config, context):
|
|
result = lib.run_command(config, "get ebuild file for package %s" % (context['package_to_check']), ['equery', 'which', context['package_to_check']])
|
|
if result == None:
|
|
return 3
|
|
found_ebuild_filename = result.strip()
|
|
|
|
m = PARSE_EBUILD_FILENAME.match(found_ebuild_filename)
|
|
if not m:
|
|
sys.stdout.write("Could not parse ebuild file name: %s\n" % (found_ebuild_filename))
|
|
return 3
|
|
found_package_group = m.group(1)
|
|
found_package_name = m.group(2)
|
|
found_package_plus_version = m.group(3)
|
|
if not found_package_plus_version.startswith(found_package_name) or found_package_plus_version[len(found_package_name):len(found_package_name)+1] != '-':
|
|
sys.stdout.write("Inconsistent package name in ebuild file name: %s\n" % (found_ebuild_filename))
|
|
return 3
|
|
found_version = found_package_plus_version[len(found_package_name) + 1:]
|
|
found_package_fullname = '%s/%s-%s' % (found_package_group, found_package_name, found_version)
|
|
sys.stdout.write("Package version found: %s\n" % (found_package_fullname))
|
|
|
|
context['found_ebuild_filename'] = found_ebuild_filename
|
|
context['found_package_group'] = found_package_group
|
|
context['found_package_name'] = found_package_name
|
|
context['found_version'] = found_version
|
|
context['found_package_fullname'] = found_package_fullname
|
|
context['build_image_dir'] = "%s/%s/image" % (context['build_prefix'], found_package_fullname)
|
|
context['build_env_file'] = "%s/%s/temp/environment" % (context['build_prefix'], found_package_fullname)
|
|
|
|
for key in 'found_ebuild_filename', 'found_package_fullname':
|
|
sys.stdout.write("%s: %s\n" % (key, context[key]))
|
|
return 0
|
|
|
|
# extract build variables
|
|
########################
|
|
# context variables used:
|
|
# distdir (get_source_package_config)
|
|
# build_source_extension (get_source_package_config)
|
|
# build_image_dir (get_source_ebuild_info)
|
|
# build_env_file (get_source_ebuild_info)
|
|
# context variables set up:
|
|
# kernel_version_string: build variable KV_FULL extracted; eg: 5.15.41-mygentoo
|
|
# kernel_version_major: build variable KV_MAJOR extracted; eg: 5
|
|
# kernel_version_minor: build variable KV_MINOR extracted; eg: 15
|
|
# kernel_version_patch: build variable KV_PATCH extracted; eg: 41
|
|
# kernel_series: kernel series identifier (constructed from KV_MAJOR and KV_MINOR); eg: 5.15
|
|
# kernel_series_distdir: distribution subdirectory for kernel series (constructed from config variable 'distdir' and KV_MAJOR and KV_MINOR); eg: distribution/5.15
|
|
# build_kernel_dir: kernel source directory extracted into portage package build directory (constructed from context variables 'build_image_dir' and 'kernel_version_string'); eg: /var/tmp/portage/sys-kernel/mygentoo-sources-5.15.41/image//usr/src/linux-5.15.41-mygentoo
|
|
# source_archive_filename: kernel source archive filename (constructed from context variables 'kernel_version_string' and 'build_source_extension'); eg: 5.15.41-mygentoo.tar.xz
|
|
# source_archive_dist: kernel source archive subdirectory (constructed from context variables 'kernel_series_distdir' and 'source_archive_filename'); eg: distribution/5.15/5.15.41-mygentoo.tar.xz
|
|
########################
|
|
def extract_source_variables(config, context):
|
|
vars = dict()
|
|
for variable in ('KV_FULL', 'KV_MAJOR', 'KV_MINOR', 'KV_PATCH'):
|
|
result = lib.run_command(config, "extract kernel version string from %s" % (context['build_env_file']), ['env', '-i', 'bash', '-c', "source %s && echo \"${%s}\"" % (context['build_env_file'], variable)])
|
|
if result == None:
|
|
return "Could not extract kernel variable %s" % (variable)
|
|
vars[variable] = result.strip()
|
|
if vars[variable] == '':
|
|
return "Could not extract kernel variable %s" % (variable)
|
|
|
|
kernel_version_string = vars['KV_FULL']
|
|
context['kernel_version_string'] = kernel_version_string
|
|
kernel_version_major = vars['KV_MAJOR']
|
|
context['kernel_version_major'] = kernel_version_major
|
|
kernel_version_minor = vars['KV_MINOR']
|
|
context['kernel_version_minor'] = kernel_version_minor
|
|
kernel_version_patch = vars['KV_PATCH']
|
|
context['kernel_version_patch'] = kernel_version_patch
|
|
kernel_series = "%s.%s" % (kernel_version_major, kernel_version_minor)
|
|
context['kernel_series'] = kernel_series
|
|
kernel_series_distdir = "%s/%s" % (context['distdir'], kernel_series)
|
|
context['kernel_series_distdir'] = kernel_series_distdir
|
|
context['build_kernel_dir'] = "%s/usr/src/linux-%s" % (context['build_image_dir'], kernel_version_string)
|
|
source_archive_filename = "%s.%s" % (kernel_version_string, context['build_source_extension'])
|
|
context['source_archive_filename'] = source_archive_filename
|
|
context['source_archive_dist'] = "%s/%s" % (kernel_series_distdir, source_archive_filename)
|
|
sys.stdout.write("Kernel version: %s.%s.%s full: %s\n" % (kernel_version_major, kernel_version_minor, kernel_version_patch, kernel_version_string))
|
|
|
|
for key in 'kernel_version_string', 'kernel_series', 'kernel_series_distdir', 'source_archive_filename':
|
|
sys.stdout.write("%s: %s\n" % (key, context[key]))
|
|
return ""
|
|
|
|
# determine if source build is needed
|
|
########################
|
|
def check_source_build_needed(config, context):
|
|
sys.stdout.write("Checking build environment file: %s\n" % (context['build_env_file']))
|
|
if not os.path.isfile(context['build_env_file']):
|
|
if config.force:
|
|
sys.stdout.write("No kernel build environment file found but forced to rebuild source image anyway\n")
|
|
return True
|
|
sys.stdout.write("No kernel build environment file found\n")
|
|
result = lib.run_command(config, "create kernel build environment file from ebuild %s" % (context['found_ebuild_filename']), ['ebuild', context['found_ebuild_filename'], 'clean', 'setup'])
|
|
if result == None:
|
|
return True
|
|
if not os.path.isfile(context['build_env_file']):
|
|
sys.stdout.write("No kernel build environment file found after setup\n")
|
|
return True
|
|
else:
|
|
if config.force:
|
|
sys.stdout.write("Existing kernel build environment file found but forced to rebuild source image\n")
|
|
return True
|
|
error = extract_source_variables(config, context)
|
|
if error:
|
|
sys.stdout.write("%s\n" % (error))
|
|
return True
|
|
if os.path.isfile(context['source_archive_dist']):
|
|
return False
|
|
sys.stdout.write("Checking build image location: %s\n" % (context['build_image_dir']))
|
|
if not os.path.isdir(context['build_image_dir']):
|
|
sys.stdout.write("No kernel source image found\n")
|
|
return True
|
|
sys.stdout.write("Checking build kernel directory: %s\n" % (context['build_kernel_dir']))
|
|
if not os.path.isdir(context['build_kernel_dir']):
|
|
sys.stdout.write("No kernel directory found\n")
|
|
return True
|
|
sys.stdout.write("Existing kernel directory found\n")
|
|
return False
|
|
|
|
# determine if making build archive is needed
|
|
########################
|
|
def check_build_archive_needed(config, context):
|
|
if os.path.isfile(context['source_archive_dist']):
|
|
if os.path.isdir(context['build_kernel_dir']):
|
|
try:
|
|
dest_mtime = os.path.getmtime(context['source_archive_dist'])
|
|
except OSError as e:
|
|
return True
|
|
try:
|
|
src_mtime = os.path.getmtime(context['build_kernel_dir'])
|
|
except OSError as e:
|
|
return True
|
|
sys.stdout.write("%s vs %s\n" % (src_mtime, dest_mtime))
|
|
if src_mtime > dest_mtime:
|
|
sys.stdout.write("Existing source archive older than built image\n")
|
|
return True
|
|
sys.stdout.write("Existing source archive found: %s\n" % (context['source_archive_dist']))
|
|
return False
|
|
return True
|
|
|
|
# create archive for built source
|
|
########################
|
|
def make_build_source_archive(config, context):
|
|
sys.stdout.write("Using build kernel directory: %s\n" % (context['build_kernel_dir']))
|
|
env = dict(os.environ)
|
|
env['SRCDIR'] = context['build_kernel_dir']
|
|
env['DESTDIR'] = context['kernel_series_distdir']
|
|
env['DESTFILENAME'] = context['source_archive_filename']
|
|
result = lib.run_command(config, "create archive for kernel source %s" % (context['source_archive_dist']), ['bash', '-c', context['build_source_archive']], env)
|
|
if result == None:
|
|
return 3
|
|
if not os.path.isfile(context['source_archive_dist']):
|
|
sys.stdout.write("Kernel source archive file not found after creation\n")
|
|
return 3
|
|
return 0
|
|
|
|
# build kernel source
|
|
########################
|
|
def build_source(config, context):
|
|
result = lib.run_command(config, "create kernel source from ebuild %s" % (context['found_ebuild_filename']), ['ebuild', context['found_ebuild_filename'], 'clean', 'install'])
|
|
if result == None:
|
|
return 3
|
|
if not os.path.isfile(context['build_env_file']):
|
|
sys.stdout.write("No kernel build environment file found after ebuild command\n")
|
|
return 3
|
|
error = extract_source_variables(config, context)
|
|
if error:
|
|
sys.stdout.write("%s after ebuild command\n" % (error))
|
|
return 3
|
|
if not os.path.isdir(context['build_image_dir']):
|
|
sys.stdout.write("No kernel source image found after ebuild command\n")
|
|
return 3
|
|
if not os.path.isdir(context['build_kernel_dir']):
|
|
sys.stdout.write("No kernel directory found after ebuild command\n")
|
|
return 3
|
|
return 0
|
|
|
|
# clear kernel source built
|
|
########################
|
|
def clear_source(config, context):
|
|
lib.run_command(config, "clear kernel source for ebuild %s" % (context['found_ebuild_filename']), ['ebuild', context['found_ebuild_filename'], 'clean'])
|
|
return 0
|
|
|
|
# make source (mksrc command)
|
|
########################
|
|
def make_source(config):
|
|
context = dict()
|
|
rc = get_source_package_config(config, context)
|
|
if rc:
|
|
return rc
|
|
rc = get_source_ebuild_info(config, context)
|
|
if rc:
|
|
return rc
|
|
build = check_source_build_needed(config, context)
|
|
if build:
|
|
rc = build_source(config, context)
|
|
if rc:
|
|
return rc
|
|
make = check_build_archive_needed(config, context)
|
|
if make:
|
|
rc = make_build_source_archive(config, context)
|
|
if rc:
|
|
return rc
|
|
if context['build_clean']:
|
|
rc = clear_source(config, context)
|
|
if rc:
|
|
return rc
|
|
return None
|
|
|
|
# prepare source (prepare command)
|
|
########################
|
|
def prepare_source(config):
|
|
context = dict()
|
|
rc = get_source_package_config(config, context)
|
|
if rc:
|
|
return rc
|
|
|
|
return None
|