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"))