def get_rpcaptcache(self):
if self._rpcaptcache is None:
self._rpcaptcache = get_rpcaptcache(
self.buildenv.rfs, "aptcache.log",
self.xml.text("project/arch", key="arch"),
self.rpcaptcache_notifier)
return self._rpcaptcache
def get_rpcaptcache (self):
if self._rpcaptcache is None:
self._rpcaptcache = get_rpcaptcache( self.buildenv.rfs,
"aptcache.log",
self.xml.text( "project/arch", key="arch" ),
self.rpcaptcache_notifier )
return self._rpcaptcache
def get_rpcaptcache(self):
if self._rpcaptcache is None:
self._rpcaptcache = get_rpcaptcache(
self.buildenv.rfs, self.log.fp.name, self.arch,
self.rpcaptcache_notifier, self.xml.prj.has('norecommend'),
self.xml.prj.has('noauth'))
return self._rpcaptcache
def execute(self, log, buildenv, target):
if self.node.et.text:
fp = self.node.et.text
log.printo("transfer gpg key to target: " + fp)
os.environ['GNUPGHOME'] = "/var/cache/elbe/gnupg"
key = BytesIO()
ctx = gpgme.Context()
ctx.armor = True
ctx.export(fp, key)
log.printo(str(key.getvalue()))
with open((target.path + '/pub.key'), 'wb') as tkey:
tkey.write(key.getvalue())
target.mkdir_p("/var/cache/elbe/gnupg", mode=0700)
with target:
os.environ['GNUPGHOME'] = target.path + "/var/cache/elbe/gnupg"
log.do("gpg --import " + target.path + "/pub.key")
log.printo("generate base repo")
arch = target.xml.text("project/arch", key="arch")
buildenv.rfs.mkdir_p('/tmp/pkgs')
with buildenv:
cache = get_rpcaptcache(buildenv.rfs, "updated-repo.log", arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
cache.download_binary(pkg.name, '/tmp/pkgs',
pkg.installed_version)
except ValueError as ve:
log.printo("No Package " + pkg.name + "-" +
pkg.installed_version)
except FetchError as fe:
log.printo("Package " + pkg.name + "-" +
pkg.installed_version +
" could not be downloaded")
except TypeError as te:
log.printo("Package " + pkg.name + "-" +
pkg.installed_version +
" missing name or version")
r = UpdateRepo(target.xml, target.path + '/var/cache/elbe/repos/base',
log)
for d in buildenv.rfs.glob('tmp/pkgs/*.deb'):
r.includedeb(d, 'main')
slist = target.path + '/etc/apt/sources.list.d/base.list'
slist_txt = 'deb file:///var/cache/elbe/repos/base '
slist_txt += target.xml.text("/project/suite")
slist_txt += " main"
with open(slist, 'w') as apt_source:
apt_source.write(slist_txt)
rmtree(buildenv.rfs.path + '/tmp/pkgs')
def execute(self, log, buildenv, target):
if self.node.et.text:
fp = self.node.et.text
log.printo ("transfer gpg key to target: " + fp)
os.environ ['GNUPGHOME'] = "/var/cache/elbe/gnupg"
key = BytesIO ()
ctx = gpgme.Context ()
ctx.armor = True
ctx.export (fp, key)
log.printo (str (key.getvalue ()))
with open ((target.path + '/pub.key'), 'wb') as tkey:
tkey.write (key.getvalue ())
target.mkdir_p ("/var/cache/elbe/gnupg", mode=0700)
with target:
os.environ ['GNUPGHOME'] = target.path + "/var/cache/elbe/gnupg"
log.do ("gpg --import " + target.path + "/pub.key")
log.printo( "generate base repo")
arch = target.xml.text ("project/arch", key="arch")
buildenv.rfs.mkdir_p ('/tmp/pkgs')
with buildenv:
cache = get_rpcaptcache (buildenv.rfs, "updated-repo.log", arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
cache.download_binary (pkg.name, '/tmp/pkgs', pkg.installed_version)
except ValueError as ve:
log.printo( "No Package " + pkg.name + "-" + pkg.installed_version )
except FetchError as fe:
log.printo( "Package " + pkg.name + "-" + pkg.installed_version + " could not be downloaded" )
except TypeError as te:
log.printo( "Package " + pkg.name + "-" + pkg.installed_version + " missing name or version" )
r = UpdateRepo (target.xml,
target.path + '/var/cache/elbe/repos/base',
log)
for d in buildenv.rfs.glob ('tmp/pkgs/*.deb'):
r.includedeb (d, 'main')
slist = target.path + '/etc/apt/sources.list.d/base.list'
slist_txt = 'deb file:///var/cache/elbe/repos/base '
slist_txt += target.xml.text ("/project/suite")
slist_txt += " main"
with open (slist, 'w') as apt_source:
apt_source.write (slist_txt)
rmtree (buildenv.rfs.path + '/tmp/pkgs')
def mk_source_cdrom(rfs,
arch,
codename,
init_codename,
target,
log,
cdrom_size=CDROM_SIZE):
hostfs.mkdir_p('/var/cache/elbe/sources')
rfs.mkdir_p('/var/cache/elbe/sources')
repo = CdromSrcRepo(codename, init_codename,
os.path.join(target, "srcrepo"), log, cdrom_size)
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
dsc = cache.download_source(pkg.name, '/var/cache/elbe/sources')
repo.includedsc(dsc)
except ValueError as ve:
log.printo("No sources for Package " + pkg.name + "-" +
pkg.installed_version)
except FetchError as fe:
log.printo("Source for Package " + pkg.name + "-" +
pkg.installed_version + " could not be downloaded")
pkglist = get_initvm_pkglist()
cache = Cache()
cache.open()
for pkg in pkglist:
try:
p = cache[pkg.name]
if pkg.name == 'elbe-bootstrap':
pkgver = p.versions[0]
else:
pkgver = p.installed
dsc = pkgver.fetch_source('/var/cache/elbe/sources',
ElbeAcquireProgress(cb=None),
unpack=False)
repo.includedsc(dsc)
except ValueError as ve:
log.printo("No sources for Package " + pkg.name + "-" +
str(pkg.installed_version))
except FetchError as fe:
log.printo("Source for Package " + pkg.name + "-" +
pkgver.version + " could not be downloaded")
return repo.buildiso(os.path.join(target, "src-cdrom.iso"))
def get_rpcaptcache(self, env=None, norecommend=None):
if not env:
env = self.buildenv
if norecommend is None:
norecommend = not self.xml.prj.has('install-recommends')
if env.arch == "default":
arch = self.arch
else:
arch = env.arch
if env.rpcaptcache is None:
env.rpcaptcache = get_rpcaptcache(env.rfs, arch,
self.rpcaptcache_notifier,
norecommend,
self.xml.prj.has('noauth'))
return env.rpcaptcache
def mk_source_cdrom(rfs, arch, codename, init_codename, target, log, cdrom_size=CDROM_SIZE):
hostfs.mkdir_p( '/var/cache/elbe/sources' )
rfs.mkdir_p( '/var/cache/elbe/sources' )
repo = CdromSrcRepo( codename, init_codename,
os.path.join( target, "srcrepo" ),
log,
cdrom_size )
cache = get_rpcaptcache( rfs, "aptcache.log", arch )
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
dsc = cache.download_source( pkg.name, '/var/cache/elbe/sources' )
repo.includedsc( dsc )
except ValueError as ve:
log.printo( "No sources for Package " + pkg.name + "-" + pkg.installed_version )
except FetchError as fe:
log.printo( "Source for Package " + pkg.name + "-" + pkg.installed_version + " could not be downloaded" )
pkglist = get_initvm_pkglist()
cache = Cache ()
cache.open ()
for pkg in pkglist:
try:
p = cache[pkg.name]
if pkg.name == 'elbe-bootstrap':
pkgver = p.versions [0]
else:
pkgver = p.installed
dsc = pkgver.fetch_source ('/var/cache/elbe/sources',
ElbeAcquireProgress (cb=None), unpack=False)
repo.includedsc( dsc )
except ValueError as ve:
log.printo( "No sources for Package " + pkg.name + "-" + str(pkg.installed_version) )
except FetchError as fe:
log.printo( "Source for Package " + pkg.name + "-" + pkgver.version + " could not be downloaded" )
return repo.buildiso( os.path.join( target, "src-cdrom.iso" ) )
def get_rpcaptcache(self, env=None, norecommend=None):
if not env:
env = self.buildenv
if norecommend is None:
norecommend = not self.xml.prj.has('install-recommends'),
if env.arch == "default":
arch = self.arch
else:
arch = env.arch
if env.rpcaptcache is None:
env.rpcaptcache = get_rpcaptcache(
env.rfs,
self.log.fp.name,
arch,
self.rpcaptcache_notifier,
norecommend,
self.xml.prj.has('noauth'))
return env.rpcaptcache
def run_command(argv):
# pylint disable=too-many-statements
oparser = OptionParser(usage="usage: %prog mkcdrom [options] <builddir>")
oparser.add_option("--skip-validation",
action="store_true",
dest="skip_validation",
default=False,
help="Skip xml schema validation")
oparser.add_option("--buildtype",
dest="buildtype",
help="Override the buildtype")
oparser.add_option("--arch", dest="arch", help="Override the architecture")
oparser.add_option("--codename",
dest="codename",
help="Override the codename")
oparser.add_option("--init_codename",
dest="init_codename",
help="Override the initvm codename")
oparser.add_option("--rfs-only",
action="store_true",
dest="rfs_only",
default=False,
help="builddir points to RFS")
oparser.add_option("--log", dest="log", help="Log to filename")
oparser.add_option("--binary",
action="store_true",
dest="binary",
default=False,
help="build binary cdrom")
oparser.add_option("--source",
action="store_true",
dest="source",
default=False,
help="build source cdrom")
oparser.add_option("--cdrom-size",
action="store",
dest="cdrom_size",
default=CDROM_SIZE,
help="Source ISO CD size in bytes")
(opt, args) = oparser.parse_args(argv)
if len(args) != 1:
print("wrong number of arguments", file=sys.stderr)
oparser.print_help()
sys.exit(20)
with elbe_logging({"files": opt.log}):
if not opt.rfs_only:
try:
project = ElbeProject(args[0],
override_buildtype=opt.buildtype,
skip_validate=opt.skip_validation)
except ValidationError:
logging.exception("XML validation failed. Bailing out")
sys.exit(20)
builddir = project.builddir
rfs = project.buildenv.rfs
xml = project.xml
arch = xml.text("project/arch", key="arch")
codename = xml.text("project/suite")
init_codename = xml.get_initvm_codename()
else:
builddir = os.path.abspath(os.path.curdir)
rfs = ChRootFilesystem(args[0])
arch = opt.arch
codename = opt.codename
init_codename = opt.init_codename
xml = None
generated_files = []
if opt.source:
with rfs:
cache = get_rpcaptcache(rfs, arch)
components = {
"main":
(rfs, cache, cache.get_corresponding_source_packages())
}
generated_files += mk_source_cdrom(components, codename,
init_codename, builddir,
opt.cdrom_size)
if opt.binary:
with rfs:
generated_files += mk_binary_cdrom(rfs, arch, codename,
init_codename, xml,
builddir)
logging.info("Image Build finished.")
logging.info("Files generated:\n%s",
"\n".join([str(f) for f in generated_files]))
import os
import time
class AsyncStatus:
def __init__ (self):
pass
def status (self, msg):
print "current status: " + msg
xml = elbexml.ElbeXML('source.xml')
log = asciidoclog.ASCIIDocLog( "update.log" )
br = rfs.BuildEnv(xml, log, 'chroot')
status = AsyncStatus ()
from elbepack.rpcaptcache import get_rpcaptcache
# Use "with br" to mount the necessary bind mounts
with br:
cc = get_rpcaptcache(br.rfs, "aptcache.log", "armel", notifier=status)
print "SECTIONS: ", cc.get_sections()
time.sleep (2)
print "SHELLS: ", cc.get_pkglist('shells')
time.sleep (2)
print "QUICKPLOT: ", cc.get_dependencies('quickplot')
time.sleep (2)
cc.mark_install('quickplot','2')
cc.commit()
#cc.mark_delete('quickplot','2')
#cc.commit()
class AsyncStatus:
def __init__(self):
pass
def status(self, msg):
print "current status: " + msg
xml = elbexml.ElbeXML('source.xml')
log = asciidoclog.ASCIIDocLog("update.log")
br = rfs.BuildEnv(xml, log, 'chroot')
status = AsyncStatus()
from elbepack.rpcaptcache import get_rpcaptcache
# Use "with br" to mount the necessary bind mounts
with br:
cc = get_rpcaptcache(br.rfs, "aptcache.log", "armel", notifier=status)
print "SECTIONS: ", cc.get_sections()
time.sleep(2)
print "SHELLS: ", cc.get_pkglist('shells')
time.sleep(2)
print "QUICKPLOT: ", cc.get_dependencies('quickplot')
time.sleep(2)
cc.mark_install('quickplot', '2')
cc.commit()
#cc.mark_delete('quickplot','2')
#cc.commit()
def mk_binary_cdrom(rfs, arch, codename, init_codename, xml, target):
# pylint: disable=too-many-arguments
# pylint: disable=too-many-locals
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
rfs.mkdir_p('/var/cache/elbe/binaries/added')
rfs.mkdir_p('/var/cache/elbe/binaries/main')
if xml is not None:
mirror = xml.get_primary_mirror(rfs.fname("cdrom"))
else:
mirror = 'http://ftp.de.debian.org/debian'
repo_path = os.path.join(target, "binrepo")
target_repo_path = os.path.join(repo_path, 'targetrepo')
# initvm repo has been built upon initvm creation
# just copy it. the repo __init__() afterwards will
# not touch the repo config, nor generate a new key.
try:
do('cp -av /var/cache/elbe/initvm-bin-repo "%s"' % repo_path)
except CommandError:
# When /var/cache/elbe/initvm-bin-repo has not been created
# (because the initvm install was an old version or somthing,
# log an error, and continue with an empty directory.
logging.exception("/var/cache/elbe/initvm-bin-repo does not exist\n"
"The generated CDROM will not contain initvm pkgs\n"
"This happened because the initvm was probably\n"
"generated with --skip-build-bin")
do('mkdir -p "%s"' % repo_path)
repo = CdromInitRepo(init_codename, repo_path, mirror)
target_repo = CdromBinRepo(arch, codename, None,
target_repo_path, mirror)
if xml is not None:
cache = get_rpcaptcache(rfs, arch)
for p in xml.node("debootstrappkgs"):
pkg = XMLPackage(p, arch)
pkg_id = "%s-%s" % (pkg.name, pkg.installed_version)
try:
deb = cache.download_binary(pkg.name,
'/var/cache/elbe/binaries/main',
pkg.installed_version)
target_repo.includedeb(deb, 'main')
except ValueError:
logging.error("No package '%s'", pkg_id)
except FetchError:
logging.error("Package '%s' could not be downloaded", pkg_id)
except TypeError:
logging.error("Package '%s' missing name or version", pkg_id)
cache = get_rpcaptcache(rfs, arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
pkg_id = "%s-%s" % (pkg.name, pkg.installed_version)
try:
deb = cache.download_binary(pkg.name,
'/var/cache/elbe/binaries/added',
pkg.installed_version)
target_repo.includedeb(deb, 'added', pkg.name, True)
except KeyError as ke:
logging.error(str(ke))
except ValueError:
logging.error("No package '%s'", pkg_id)
except FetchError:
logging.error("Package '%s' could not be downloaded", pkg_id)
except TypeError:
logging.error("Package '%s' missing name or version", pkg_id)
target_repo.finalize()
# Mark the binary repo with the necessary Files
# to make the installer accept this as a CDRom
repo_fs = Filesystem(repo_path)
repo_fs.mkdir_p(".disk")
repo_fs.write_file(".disk/base_installable", 0o644, "main\n")
repo_fs.write_file(".disk/base_components", 0o644, "main\n")
repo_fs.write_file(".disk/cd_type", 0o644, "not_complete\n")
repo_fs.write_file(".disk/info", 0o644, "elbe inst cdrom - full cd\n")
repo_fs.symlink(".", "debian", allow_exists=True)
repo_fs.write_file("md5sum.txt", 0o644, "")
# write source xml onto cdrom
xml.xml.write(repo_fs.fname('source.xml'))
# copy initvm-cdrom.gz and vmlinuz
copyfile('/var/cache/elbe/installer/initrd-cdrom.gz',
repo_fs.fname('initrd-cdrom.gz'))
copyfile('/var/cache/elbe/installer/vmlinuz',
repo_fs.fname('vmlinuz'))
target_repo_fs = Filesystem(target_repo_path)
target_repo_fs.write_file(".aptignr", 0o644, "")
return repo.buildiso(os.path.join(target, "bin-cdrom.iso"))
def mk_source_cdrom(rfs, arch, codename, init_codename, target,
cdrom_size=CDROM_SIZE, xml=None):
# pylint: disable=too-many-arguments
# pylint: disable=too-many-locals
# pylint: disable=too-many-branches
hostfs.mkdir_p('/var/cache/elbe/sources')
rfs.mkdir_p('/var/cache/elbe/sources')
if xml is not None:
mirror = xml.get_primary_mirror(rfs.fname("cdrom"))
else:
mirror = 'http://ftp.de.debian.org/debian'
repo = CdromSrcRepo(codename, init_codename,
os.path.join(target, "srcrepo"),
cdrom_size,
mirror)
cache = get_rpcaptcache(rfs, arch)
cache.update()
pkglist = cache.get_installed_pkgs()
forbiddenPackages = []
if xml is not None and xml.has('target/pkg-list'):
for i in xml.node('target/pkg-list'):
try:
if i.tag == 'pkg' and i.et.attrib['on_src_cd'] == 'False':
forbiddenPackages.append(i.text('.').strip())
except KeyError:
pass
for pkg in pkglist:
# Do not include forbidden packages in src cdrom
if pkg.name in forbiddenPackages:
continue
pkg_id = "%s-%s" % (pkg.name, pkg.installed_version)
try:
dsc = cache.download_source(pkg.name, '/var/cache/elbe/sources')
repo.includedsc(dsc, force=True)
except ValueError:
logging.error("No sources for package '%s'", pkg_id)
except FetchError:
logging.error("Source for package '%s' could not be downloaded", pkg_id)
# elbe fetch_initvm_pkgs has downloaded all sources to
# /var/cache/elbe/sources
# use walk_files to scan it, and add all dsc files.
#
# we can not just copy the source repo, like we do
# with the bin repo, because the src cdrom can be split
# into multiple cdroms
initvm_repo = Filesystem('/var/cache/elbe/sources')
for _ , dsc_real in initvm_repo.walk_files():
if not dsc_real.endswith('.dsc'):
continue
repo.include_init_dsc(dsc_real, 'initvm')
repo.finalize()
if xml is not None:
options = get_iso_options(xml)
for arch_vol in xml.all('src-cdrom/archive'):
volume_attr = arch_vol.et.get('volume')
if volume_attr == 'all':
volume_list = repo.volume_indexes
else:
volume_list = [int(v) for v in volume_attr.split(",")]
for volume_number in volume_list:
with archive_tmpfile(arch_vol.text(".")) as fp:
if volume_number in repo.volume_indexes:
do('tar xvfj "%s" -h -C "%s"' % (fp.name,
repo.get_volume_fs(volume_number).path))
else:
logging.warning("The src-cdrom archive's volume value "
"is not contained in the actual volumes")
else:
options = ""
return repo.buildiso(os.path.join(target, "src-cdrom.iso"), options=options)
def mk_binary_cdrom(rfs,
arch,
codename,
init_codename,
xml,
target,
log,
cdrom_size=CDROM_SIZE):
rfs.mkdir_p('/var/cache/elbe/binaries/added')
rfs.mkdir_p('/var/cache/elbe/binaries/main')
hostfs.mkdir_p('/var/cache/elbe/binaries/main')
if not xml is None:
mirror = xml.get_primary_mirror(rfs.fname("cdrom"))
else:
mirror = 'http://ftp.debian.org/debian'
repo_path = os.path.join(target, "binrepo")
repo = CdromBinRepo(arch, codename, init_codename, repo_path, log,
cdrom_size, mirror)
if not xml is None:
pkglist = get_initvm_pkglist()
cache = Cache()
cache.open()
for pkg in pkglist:
try:
p = cache[pkg.name]
if pkg.name == 'elbe-bootstrap':
pkgver = p.versions[0]
else:
pkgver = p.installed
deb = pkgver.fetch_binary('/var/cache/elbe/binaries/main',
ElbeAcquireProgress(cb=None))
repo.include_init_deb(deb, 'main')
except ValueError as ve:
log.printo("No Package " + pkg.name + "-" +
str(pkg.installed_version))
except FetchError as fe:
log.printo("Package " + pkg.name + "-" + pkgver.version +
" could not be downloaded")
except TypeError as te:
log.printo("Package " + pkg.name + "-" +
str(pkg.installed_version) +
" missing name or version")
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
for p in xml.node("debootstrappkgs"):
pkg = XMLPackage(p, arch)
try:
deb = cache.download_binary(pkg.name,
'/var/cache/elbe/binaries/main',
pkg.installed_version)
repo.includedeb(deb, 'main')
except ValueError as ve:
log.printo("No Package " + pkg.name + "-" +
pkg.installed_version)
except FetchError as fe:
log.printo("Package " + pkg.name + "-" +
pkg.installed_version + " could not be downloaded")
except TypeError as te:
log.printo("Package " + pkg.name + "-" +
pkg.installed_version + " missing name or version")
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
deb = cache.download_binary(pkg.name,
'/var/cache/elbe/binaries/added',
pkg.installed_version)
repo.includedeb(deb, 'added')
except KeyError as ke:
log.printo(str(ke))
except ValueError as ve:
log.printo("No Package " + pkg.name + "-" + pkg.installed_version)
except FetchError as fe:
log.printo("Package " + pkg.name + "-" +
str(pkg.installed_version) + " could not be downloaded")
except TypeError as te:
log.printo("Package " + pkg.name + "-" + pkg.installed_version +
" missing name or version")
# Mark the binary repo with the necessary Files
# to make the installer accept this as a CDRom
repo_fs = Filesystem(repo_path)
repo_fs.mkdir_p(".disk")
repo_fs.write_file(".disk/base_installable", 0644, "main\n")
repo_fs.write_file(".disk/base_components", 0644, "main\n")
repo_fs.write_file(".disk/cd_type", 0644, "not_complete\n")
repo_fs.write_file(".disk/info", 0644, "elbe inst cdrom - full cd\n")
repo_fs.symlink(".", "debian", allow_exists=True)
repo_fs.write_file("md5sum.txt", 0644, "")
# write source xml onto cdrom
xml.xml.write(repo_fs.fname('source.xml'))
return repo.buildiso(os.path.join(target, "bin-cdrom.iso"))
def execute(self, buildenv, target):
# pylint: disable=too-many-locals
if self.node.et.text:
fp = self.node.et.text
logging.info("transfert gpg key to target: %s", fp)
gpgdata = core.Data()
ctx = core.Context()
ctx.set_engine_info(PROTOCOL_OpenPGP, None,
'/var/cache/elbe/gnupg')
ctx.set_armor(True)
unlock_key(fp)
ctx.op_export(fp, 0, gpgdata)
gpgdata.seek(0, os.SEEK_SET)
key = gpgdata.read()
logging.info(str(key))
with open((target.path + '/pub.key'), 'wb') as tkey:
tkey.write(key)
target.mkdir_p("/var/cache/elbe/gnupg", mode=0o700)
with target:
env_add = {'GNUPGHOME': target.path + "/var/cache/elbe/gnupg"}
cmd = "gpg --import %s%s" % (target.path, "/pub.key")
do(cmd, env_add=env_add)
logging.info("generate base repo")
arch = target.xml.text("project/arch", key="arch")
buildenv.rfs.mkdir_p('/tmp/pkgs')
with buildenv:
cache = get_rpcaptcache(buildenv.rfs, arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
cache.download_binary(pkg.name, '/tmp/pkgs',
pkg.installed_version)
except ValueError:
logging.exception("No package %s-%s", pkg.name,
pkg.installed_version)
except FetchError:
logging.exception("Package %s-%s could not be downloaded",
pkg.name, pkg.installed_version)
except TypeError:
logging.exception("Package %s-%s missing name or version",
pkg.name, pkg.installed_version)
r = UpdateRepo(target.xml, target.path + '/var/cache/elbe/repos/base')
for d in buildenv.rfs.glob('tmp/pkgs/*.deb'):
r.includedeb(d, 'main')
r.finalize()
slist = target.path + '/etc/apt/sources.list.d/base.list'
slist_txt = 'deb [trusted=yes] file:///var/cache/elbe/repos/base '
slist_txt += target.xml.text("/project/suite")
slist_txt += " main"
with open(slist, 'w') as apt_source:
apt_source.write(slist_txt)
rmtree(buildenv.rfs.path + '/tmp/pkgs')
# allow downgrades by default
target.touch_file('/var/cache/elbe/.downgrade_allowed')
def execute(self, log, buildenv, target):
# pylint: disable=too-many-locals
if self.node.et.text:
fp = self.node.et.text
log.printo("transfer gpg key to target: " + fp)
gpgdata = core.Data()
ctx = core.Context()
ctx.set_engine_info(PROTOCOL_OpenPGP,
None,
'/var/cache/elbe/gnupg')
ctx.set_armor(True)
unlock_key(fp)
ctx.op_export(fp, 0, gpgdata)
gpgdata.seek(0, os.SEEK_SET)
key = gpgdata.read()
log.printo(str(key))
with open((target.path + '/pub.key'), 'wb') as tkey:
tkey.write(key)
target.mkdir_p("/var/cache/elbe/gnupg", mode=0o700)
with target:
env_add = {'GNUPGHOME': target.path + "/var/cache/elbe/gnupg"}
log.do("gpg --import " + target.path + "/pub.key",
env_add=env_add)
log.printo("generate base repo")
arch = target.xml.text("project/arch", key="arch")
buildenv.rfs.mkdir_p('/tmp/pkgs')
with buildenv:
cache = get_rpcaptcache(buildenv.rfs, "updated-repo.log", arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
cache.download_binary(
pkg.name, '/tmp/pkgs', pkg.installed_version)
except ValueError:
log.printo(
"No Package " +
pkg.name +
"-" +
pkg.installed_version)
except FetchError:
log.printo(
"Package " +
pkg.name +
"-" +
pkg.installed_version +
" could not be downloaded")
except TypeError:
log.printo(
"Package " +
pkg.name +
"-" +
pkg.installed_version +
" missing name or version")
r = UpdateRepo(target.xml,
target.path + '/var/cache/elbe/repos/base',
log)
for d in buildenv.rfs.glob('tmp/pkgs/*.deb'):
r.includedeb(d, 'main')
r.finalize()
slist = target.path + '/etc/apt/sources.list.d/base.list'
slist_txt = 'deb [trusted=yes] file:///var/cache/elbe/repos/base '
slist_txt += target.xml.text("/project/suite")
slist_txt += " main"
with open(slist, 'w') as apt_source:
apt_source.write(slist_txt)
rmtree(buildenv.rfs.path + '/tmp/pkgs')
# allow downgrades by default
target.touch_file('/var/cache/elbe/.downgrade_allowed')
def mk_binary_cdrom(rfs, arch, codename, init_codename, xml, target, log, cdrom_size=CDROM_SIZE):
rfs.mkdir_p( '/var/cache/elbe/binaries/added' )
rfs.mkdir_p( '/var/cache/elbe/binaries/main' )
hostfs.mkdir_p( '/var/cache/elbe/binaries/main' )
if not xml is None:
mirror = xml.get_primary_mirror (rfs.fname("cdrom"))
else:
mirror='http://ftp.debian.org/debian'
repo_path = os.path.join (target, "binrepo")
repo = CdromBinRepo (arch, codename, init_codename,
repo_path, log, cdrom_size, mirror)
if not xml is None:
pkglist = get_initvm_pkglist()
cache = Cache ()
cache.open ()
for pkg in pkglist:
try:
p = cache [pkg.name]
if pkg.name == 'elbe-bootstrap':
pkgver = p.versions [0]
else:
pkgver = p.installed
deb = pkgver.fetch_binary ('/var/cache/elbe/binaries/main',
ElbeAcquireProgress (cb=None) )
repo.include_init_deb(deb, 'main')
except ValueError as ve:
log.printo( "No Package " + pkg.name + "-" + str(pkg.installed_version) )
except FetchError as fe:
log.printo( "Package " + pkg.name + "-" + pkgver.version + " could not be downloaded" )
except TypeError as te:
log.printo( "Package " + pkg.name + "-" + str(pkg.installed_version) + " missing name or version" )
cache = get_rpcaptcache( rfs, "aptcache.log", arch )
for p in xml.node("debootstrappkgs"):
pkg = XMLPackage(p, arch)
try:
deb = cache.download_binary( pkg.name,
'/var/cache/elbe/binaries/main',
pkg.installed_version )
repo.includedeb(deb, 'main')
except ValueError as ve:
log.printo( "No Package " + pkg.name + "-" + pkg.installed_version )
except FetchError as fe:
log.printo( "Package " + pkg.name + "-" + pkg.installed_version + " could not be downloaded" )
except TypeError as te:
log.printo( "Package " + pkg.name + "-" + pkg.installed_version + " missing name or version" )
cache = get_rpcaptcache( rfs, "aptcache.log", arch )
pkglist = cache.get_installed_pkgs ()
for pkg in pkglist:
try:
deb = cache.download_binary( pkg.name,
'/var/cache/elbe/binaries/added',
pkg.installed_version )
repo.includedeb(deb, 'added')
except KeyError as ke:
log.printo( str (ke) )
except ValueError as ve:
log.printo( "No Package " + pkg.name + "-" + pkg.installed_version )
except FetchError as fe:
log.printo( "Package " + pkg.name + "-" + str (pkg.installed_version) + " could not be downloaded" )
except TypeError as te:
log.printo( "Package " + pkg.name + "-" + pkg.installed_version + " missing name or version" )
# Mark the binary repo with the necessary Files
# to make the installer accept this as a CDRom
repo_fs = Filesystem( repo_path )
repo_fs.mkdir_p (".disk")
repo_fs.write_file (".disk/base_installable", 0644, "main\n")
repo_fs.write_file (".disk/base_components", 0644, "main\n")
repo_fs.write_file (".disk/cd_type", 0644, "not_complete\n")
repo_fs.write_file (".disk/info", 0644, "elbe inst cdrom - full cd\n")
repo_fs.symlink (".", "debian", allow_exists=True)
repo_fs.write_file ("md5sum.txt", 0644, "")
# write source xml onto cdrom
xml.xml.write (repo_fs.fname ('source.xml'))
return repo.buildiso( os.path.join( target, "bin-cdrom.iso" ) )
def mk_source_cdrom(
rfs,
arch,
codename,
init_codename,
target,
log,
cdrom_size=CDROM_SIZE,
xml=None):
# pylint: disable=too-many-arguments
# pylint: disable=too-many-locals
# pylint: disable=too-many-branches
hostfs.mkdir_p('/var/cache/elbe/sources')
rfs.mkdir_p('/var/cache/elbe/sources')
if xml is not None:
mirror = xml.get_primary_mirror(rfs.fname("cdrom"))
else:
mirror = 'http://ftp.de.debian.org/debian'
repo = CdromSrcRepo(codename, init_codename,
os.path.join(target, "srcrepo"),
log,
cdrom_size,
mirror)
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
cache.update()
pkglist = cache.get_installed_pkgs()
forbiddenPackages = []
if xml is not None and xml.has('target/pkg-list'):
for i in xml.node('target/pkg-list'):
try:
if i.tag == 'pkg' and i.et.attrib['on_src_cd'] == 'False':
forbiddenPackages.append(i.text('.').strip())
except KeyError:
pass
for pkg in pkglist:
# Do not include forbidden packages in src cdrom
if pkg.name in forbiddenPackages:
continue
try:
dsc = cache.download_source(pkg.name, '/var/cache/elbe/sources')
repo.includedsc(dsc, force=True)
except ValueError:
log.printo(
"No sources for Package " +
pkg.name +
"-" +
pkg.installed_version)
except FetchError:
log.printo(
"Source for Package " +
pkg.name +
"-" +
pkg.installed_version +
" could not be downloaded")
# elbe fetch_initvm_pkgs has downloaded all sources to
# /var/cache/elbe/sources
# use walk_files to scan it, and add all dsc files.
#
# we can not just copy the source repo, like we do
# with the bin repo, because the src cdrom can be split
# into multiple cdroms
initvm_repo = Filesystem('/var/cache/elbe/sources')
for _ , dsc_real in initvm_repo.walk_files():
if not dsc_real.endswith('.dsc'):
continue
repo.include_init_dsc(dsc_real, 'initvm')
repo.finalize()
return repo.buildiso(os.path.join(target, "src-cdrom.iso"))
def mk_binary_cdrom(
rfs,
arch,
codename,
init_codename,
xml,
target,
log,
cdrom_size=CDROM_SIZE):
# pylint: disable=too-many-arguments
# pylint: disable=too-many-locals
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
rfs.mkdir_p('/var/cache/elbe/binaries/added')
rfs.mkdir_p('/var/cache/elbe/binaries/main')
if xml is not None:
mirror = xml.get_primary_mirror(rfs.fname("cdrom"))
else:
mirror = 'http://ftp.de.debian.org/debian'
repo_path = os.path.join(target, "binrepo")
target_repo_path = os.path.join(repo_path, 'targetrepo')
# initvm repo has been built upon initvm creation
# just copy it. the repo __init__() afterwards will
# not touch the repo config, nor generate a new key.
try:
log.do('cp -av /var/cache/elbe/initvm-bin-repo "%s"' % repo_path)
except CommandError:
# When /var/cache/elbe/initvm-bin-repo has not been created
# (because the initvm install was an old version or somthing,
# log an error, and continue with an empty directory.
log.printo('ERROR: /var/cache/elbe/initvm-bin-repo does not exist')
log.printo(' The generated CDROM will not contain initvm pkgs')
log.printo(' This happened because the initvm was probably')
log.printo(' generated with --skip-build-bin')
log.do('mkdir -p "%s"' % repo_path)
repo = CdromInitRepo(init_codename, repo_path, log, cdrom_size, mirror)
target_repo = CdromBinRepo(arch, codename, None,
target_repo_path, log, cdrom_size, mirror)
if xml is not None:
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
for p in xml.node("debootstrappkgs"):
pkg = XMLPackage(p, arch)
try:
deb = cache.download_binary(pkg.name,
'/var/cache/elbe/binaries/main',
pkg.installed_version)
target_repo.includedeb(deb, 'main')
except ValueError:
log.printo(
"No Package " +
pkg.name +
"-" +
pkg.installed_version)
except FetchError:
log.printo(
"Package " +
pkg.name +
"-" +
pkg.installed_version +
" could not be downloaded")
except TypeError:
log.printo(
"Package " +
pkg.name +
"-" +
pkg.installed_version +
" missing name or version")
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
pkglist = cache.get_installed_pkgs()
for pkg in pkglist:
try:
deb = cache.download_binary(pkg.name,
'/var/cache/elbe/binaries/added',
pkg.installed_version)
target_repo.includedeb(deb, 'added', pkg.name, True)
except KeyError as ke:
log.printo(str(ke))
except ValueError:
log.printo("No Package " + pkg.name + "-" + pkg.installed_version)
except FetchError:
log.printo("Package " +
pkg.name +
"-" +
str(pkg.installed_version) +
" could not be downloaded")
except TypeError:
log.printo(
"Package " +
pkg.name +
"-" +
pkg.installed_version +
" missing name or version")
target_repo.finalize()
# Mark the binary repo with the necessary Files
# to make the installer accept this as a CDRom
repo_fs = Filesystem(repo_path)
repo_fs.mkdir_p(".disk")
repo_fs.write_file(".disk/base_installable", 0o644, "main\n")
repo_fs.write_file(".disk/base_components", 0o644, "main\n")
repo_fs.write_file(".disk/cd_type", 0o644, "not_complete\n")
repo_fs.write_file(".disk/info", 0o644, "elbe inst cdrom - full cd\n")
repo_fs.symlink(".", "debian", allow_exists=True)
repo_fs.write_file("md5sum.txt", 0o644, "")
# write source xml onto cdrom
xml.xml.write(repo_fs.fname('source.xml'))
# copy initvm-cdrom.gz and vmlinuz
copyfile('/var/cache/elbe/installer/initrd-cdrom.gz',
repo_fs.fname('initrd-cdrom.gz'))
copyfile('/var/cache/elbe/installer/vmlinuz',
repo_fs.fname('vmlinuz'))
target_repo_fs = Filesystem(target_repo_path)
target_repo_fs.write_file(".aptignr", 0o644, "")
return repo.buildiso(os.path.join(target, "bin-cdrom.iso"))
def mk_source_cdrom(rfs,
arch,
codename,
init_codename,
target,
log,
cdrom_size=CDROM_SIZE,
xml=None):
hostfs.mkdir_p('/var/cache/elbe/sources')
rfs.mkdir_p('/var/cache/elbe/sources')
repo = CdromSrcRepo(codename, init_codename,
os.path.join(target, "srcrepo"), log, cdrom_size)
cache = get_rpcaptcache(rfs, "aptcache.log", arch)
pkglist = cache.get_installed_pkgs()
forbiddenPackages = []
if xml != None and xml.has('target/pkg-list'):
for i in xml.node('target/pkg-list'):
try:
if i.tag == 'pkg' and i.et.attrib['on_src_cd'] == 'False':
forbiddenPackages.append(i.text('.').strip())
except KeyError:
pass
for pkg in pkglist:
# Do not include forbidden packages in src cdrom
if pkg.name in forbiddenPackages:
continue
try:
dsc = cache.download_source(pkg.name, '/var/cache/elbe/sources')
repo.includedsc(dsc, force=True)
except ValueError as ve:
log.printo("No sources for Package " + pkg.name + "-" +
pkg.installed_version)
except FetchError as fe:
log.printo("Source for Package " + pkg.name + "-" +
pkg.installed_version + " could not be downloaded")
repo.finalize()
pkglist = get_initvm_pkglist()
cache = Cache()
cache.open()
for pkg in pkglist:
# Do not include forbidden packages in src cdrom
if pkg.name in forbiddenPackages:
continue
try:
p = cache[pkg.name]
if pkg.name == 'elbe-bootstrap':
pkgver = p.versions[0]
else:
pkgver = p.installed
dsc = pkgver.fetch_source('/var/cache/elbe/sources',
ElbeAcquireProgress(cb=None),
unpack=False)
repo.includedsc(dsc)
except ValueError as ve:
log.printo("No sources for Package " + pkg.name + "-" +
str(pkg.installed_version))
except FetchError as fe:
log.printo("Source for Package " + pkg.name + "-" +
pkgver.version + " could not be downloaded")
repo.finalize()
return repo.buildiso(os.path.join(target, "src-cdrom.iso"))
