Ejemplo n.º 1
0
class VirtApt(object):
    def __init__(self, xml):

        # pylint: disable=too-many-statements
        self.xml = xml

        arch = xml.text("project/buildimage/arch", key="arch")
        suite = xml.text("project/suite")

        self.basefs = TmpdirFilesystem()
        self.initialize_dirs()

        create_apt_prefs(self.xml, self.basefs)

        mirror = self.xml.create_apt_sources_list(build_sources=True,
                                                  initvm=False)
        self.basefs.write_file("etc/apt/sources.list", 0o644, mirror)

        self.setup_gpg()
        self.import_keys()

        apt_pkg.config.set("APT::Architecture", arch)
        apt_pkg.config.set("APT::Architectures", arch)
        apt_pkg.config.set("Acquire::http::Proxy::127.0.0.1", "DIRECT")
        apt_pkg.config.set("APT::Install-Recommends", "0")
        apt_pkg.config.set("Dir::Etc", self.basefs.fname('/'))
        apt_pkg.config.set("Dir::Etc::Trusted",
                           self.basefs.fname('/etc/apt/trusted.gpg'))
        apt_pkg.config.set("Dir::Etc::TrustedParts",
                           self.basefs.fname('/etc/apt/trusted.gpg.d'))
        apt_pkg.config.set("APT::Cache-Limit", "0")
        apt_pkg.config.set("APT::Cache-Start", "32505856")
        apt_pkg.config.set("APT::Cache-Grow", "2097152")
        apt_pkg.config.set("Dir::State", self.basefs.fname("state"))
        apt_pkg.config.set("Dir::State::status",
                           self.basefs.fname("state/status"))
        apt_pkg.config.set("Dir::Cache", self.basefs.fname("cache"))
        apt_pkg.config.set("Dir::Cache::archives",
                           self.basefs.fname("cache/archives"))
        apt_pkg.config.set("Dir::Etc", self.basefs.fname("etc/apt"))
        apt_pkg.config.set("Dir::Log", self.basefs.fname("log"))
        if self.xml.has('project/noauth'):
            apt_pkg.config.set("APT::Get::AllowUnauthenticated", "1")
            apt_pkg.config.set("Acquire::AllowInsecureRepositories", "1")
        else:
            apt_pkg.config.set("APT::Get::AllowUnauthenticated", "0")
            apt_pkg.config.set("Acquire::AllowInsecureRepositories", "0")

        apt_pkg.init_system()

        self.source = apt_pkg.SourceList()
        self.source.read_main_list()
        self.cache = apt_pkg.Cache()
        try:
            self.cache.update(self, self.source)
        except BaseException as e:
            print(e)

        apt_pkg.config.set("APT::Default-Release", suite)

        self.cache = apt_pkg.Cache()
        try:
            self.cache.update(self, self.source)
        except BaseException as e:
            print(e)

        try:
            self.depcache = apt_pkg.DepCache(self.cache)
            prefs_name = self.basefs.fname("/etc/apt/preferences")
            self.depcache.read_pinfile(prefs_name)
        except BaseException as e:
            print(e)

        self.downloads = {}
        self.acquire = apt_pkg.Acquire(self)

    def add_key(self, key):
        cmd = 'echo "%s" > %s' % (key, self.basefs.fname("tmp/key.pub"))
        clean = 'rm -f %s' % self.basefs.fname("tmp/key.pub")
        system(cmd)
        system('fakeroot apt-key --keyring "%s" add "%s"' %
               (self.basefs.fname('/etc/apt/trusted.gpg'),
                self.basefs.fname("tmp/key.pub")))
        system(clean)

    def import_keys(self):
        if self.xml.has('project/mirror/url-list'):
            # Should we use self.xml.prj.has("noauth")???
            #
            # If so, this is related to issue #220 -
            # https://github.com/Linutronix/elbe/issues/220
            #
            # I could make a none global 'noauth' flag for mirrors
            for url in self.xml.node('project/mirror/url-list'):
                if url.has('raw-key'):
                    key = "\n".join(
                        line.strip(" \t")
                        for line in url.text('raw-key').splitlines()[1:-1])
                    self.add_key(key)

    def start(self):
        pass

    def stop(self):
        pass

    @staticmethod
    def pulse(_obj):
        return True

    def initialize_dirs(self):
        self.basefs.mkdir_p("cache/archives/partial")
        self.basefs.mkdir_p("etc/apt/preferences.d")
        self.basefs.mkdir_p("etc/apt/trusted.gpg.d")
        self.basefs.mkdir_p("db")
        self.basefs.mkdir_p("log")
        self.basefs.mkdir_p("state/lists/partial")
        self.basefs.mkdir_p("tmp")
        self.basefs.touch_file("state/status")

    def setup_gpg(self):
        ring_path = self.basefs.fname("etc/apt/trusted.gpg")
        if not os.path.isdir("/etc/apt/trusted.gpg.d"):
            print("/etc/apt/trusted.gpg.d doesn't exist")
            print("apt-get install debian-archive-keyring may "
                  "fix this problem")
            sys.exit(20)

        if os.path.exists("/etc/apt/trusted.gpg"):
            system('cp /etc/apt/trusted.gpg "%s"' % ring_path)

        trustkeys = os.listdir("/etc/apt/trusted.gpg.d")
        for key in trustkeys:
            system('cp "/etc/apt/trusted.gpg.d/%s" "%s"' %
                   (key, ring_path + '.d'))

    def mark_install(self, pkgname):
        self.depcache.mark_install(self.cache[pkgname])

    def marked_install(self, pkgname):
        return self.depcache.marked_install(self.cache[pkgname])

    def get_candidate_ver(self, pkgname):
        return self.depcache.get_candidate_ver(self.cache[pkgname]).ver_str

    def has_pkg(self, pkgname):
        return pkgname in self.cache

    def mark_pkg_download(self, pkgname):
        pkg = self.cache[pkgname]
        c = self.depcache.get_candidate_ver(pkg)

        r = apt_pkg.PackageRecords(self.cache)
        r.lookup(c.file_list[0])

        x = self.source.find_index(c.file_list[0][0])
        uri = x.archive_uri(r.filename)
        hashval = str(r.hashes.find('SHA256'))

        acq = apt_pkg.AcquireFile(self.acquire,
                                  uri,
                                  hash=hashval,
                                  size=c.size,
                                  descr=r.long_desc,
                                  short_descr=r.short_desc,
                                  destdir=self.basefs.fname('/cache/archives'))
        self.downloads[pkgname] = acq

    def do_downloads(self):
        res = self.acquire.run()
        print(res)

    def get_downloaded_files(self):
        ret = []
        for _, d in self.downloads.items():
            if d.complete:
                ret.append(d.destfile)
            else:
                print('incomplete download "%s"' % d.desc_uri)

        return ret

    def get_downloaded_pkg(self, pkgname):
        d = self.downloads[pkgname]

        if not d.complete:
            print('incomplete download "%s"' % d.desc_uri)
            raise KeyError

        return d.destfile

    def get_uri(self, target_pkg, incl_deps=False):

        d = apt_pkg.DepCache(self.cache)

        if not incl_deps:
            return [lookup_uri(self, d, target_pkg)]

        deps = [lookup_uri(self, d, target_pkg)]
        togo = [target_pkg]
        while togo:
            pp = togo.pop()
            try:
                pkg = self.cache[pp]
                c = d.get_candidate_ver(pkg)
            except KeyError:
                pkg = None
                c = None
            if not c:
                # pylint: disable=E1133
                for p in self.cache.packages:
                    for x in p.provides_list:
                        if pp == x[0]:
                            pkg = self.cache[x[2].parent_pkg.name]
                            c = d.get_candidate_ver(pkg)
            if not c:
                print("couldnt get candidate: %s" % pkg)
            else:
                for p in getdeps(c):
                    if [y for y in deps if y[0] == p]:
                        continue
                    if p != target_pkg and p == pp:
                        continue
                    deps.append(lookup_uri(self, d, p))
                    togo.append(p)

        return list(set(deps))
class TestCopyFilelist(unittest.TestCase):
    def setUp(self):
        self.src = TmpdirFilesystem()
        self.dst = TmpdirFilesystem()

    def tearDown(self):
        del self.src
        del self.dst

    def test_usrmerge_abs(self):

        self.src.mkdir_p('/usr/bin')

        # this will link to /usr/bin in the host RFS,
        # when no special logic is applied.
        self.src.symlink('/usr/bin', '/bin')

        self.src.write_file('/bin/bla', 0o644, 'bla')

        copy_filelist(self.src, ['/bin/bla'], self.dst)

        # We should now have the same content from /SRC/usr/bin/bla in
        # /DST/usr/bin/bla
        self.assertEqual(self.src.read_file('/usr/bin/bla'),
                         self.dst.read_file('/usr/bin/bla'))

    def test_usrmerge_rel(self):

        self.src.mkdir_p('/usr/bin')

        # create a proper relative path, that should
        # work fine from inside.
        self.src.symlink('usr/bin', '/bin')

        self.src.write_file('/bin/bla', 0o644, 'bla')

        copy_filelist(self.src, ['/bin/bla'], self.dst)

        # We should now have the same content from /SRC/usr/bin/bla in
        # /DST/usr/bin/bla
        self.assertEqual(self.src.read_file('/usr/bin/bla'),
                         self.dst.read_file('/usr/bin/bla'))

    def test_deeplinks(self):

        self.src.mkdir_p('/a/b/c')

        # c <- /a/b/d
        self.src.symlink('c', '/a/b/d')

        # This write into /a/b/c/bla (c instead of d)
        self.src.write_file('/a/b/d/bla', 0o644, 'bla')

        copy_filelist(self.src, ['/a/b/d/bla'], self.dst)

        # We should now have the same content from /SRC/a/b/c/bla in
        # /DST/a/b/c/bla
        self.assertEqual(self.src.read_file('/a/b/c//bla'),
                         self.dst.read_file('/a/b/c/bla'))

    def test_multilinks(self):

        self.src.mkdir_p('/a')

        # a <- b
        # ../b <- /a/c
        self.src.symlink('a', '/b')
        self.src.symlink('../b', '/a/c')

        # This write into /a/bla
        self.src.write_file('a/c/bla', 0o644, 'bla')

        copy_filelist(self.src, ['/a/c/bla'], self.dst)

        # We should now have the content from /SRC/a/bla in /DST/a/bla
        self.assertEqual(self.src.read_file('/a/bla'),
                         self.dst.read_file('/a/bla'))

    @unittest.expectedFailure
    def test_badfile(self):
        # This should throw a CommandError
        copy_filelist(self.src, ['/doesnt/exist'], self.dst)