path: root/proof-of-concept/repofs.py

#!/usr/bin/python

import os
import glob
from stat import *
import errno
import subprocess
import time

import fuse
fuse.fuse_python_api = (0, 2)
fuse.feature_assert('stateful_files', 'has_init')
from fuse import Fuse

from sqlite3 import dbapi2 as sqlite

import bz2, gzip

import yum.repoMDObject

def bunzip(infile,outfile):
    (p,f) = os.path.split(outfile)
    if not os.path.isdir(p):
        os.makedirs(p)
    outf = open(outfile,"w")
    inf = bz2.BZ2File(infile)
    data = inf.read(4096)
    while data:
        outf.write(data)
        data = inf.read(4096)
    inf.close()
    outf.close()

def flag2mode(flags):
    md = {os.O_RDONLY: 'r', os.O_WRONLY: 'w', os.O_RDWR: 'w+'}
    m = md[flags & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR)]
    if flags | os.O_APPEND:
        m = m.replace('w', 'a', 1)
    return m

def fuseclonestat(stat):
    s = fuse.Stat()
    (s.st_mode, s.st_ino, s.st_dev, s.st_nlink, s.st_uid, s.st_gid, s.st_size,
            s.st_atime, s.st_mtime, s.st_ctime) = stat
    return s

class SimpleYumRepo(object):
    def __init__(self, path=None, cachedir=None):
        self.path = path
        self.cachedir = cachedir
        self._attrcache = {}
        self._linkcache = {}
        if path:
            self.parse_repomd()

    def parse_repomd(self):
        repomd = os.path.join(self.path, "repodata/repomd.xml")
        repoXML = yum.repoMDObject.RepoMD(self.path, repomd)
        for t in ('primary_db', 'filelists_db'):
            if t in repoXML.fileTypes():
                d = repoXML.getData(t)
                (base,dbpath) = d.location
                dbfile = os.path.join(self.path,dbpath)
                # TODO check for existing db file
                if dbfile.endswith(".bz2"):
                    outfile = os.path.join(self.cachedir,".repodata",
                                           os.path.basename(dbfile)[:-4])
                    bunzip(dbfile,outfile)
                    dbfile = outfile
                # TODO: elif .gz, else...
                con = sqlite.connect(dbfile)
                setattr(self,t,con)

    def packages_for_file(self, path):
        '''Return a (possibly-empty) list of RPMs containing the file with the
        given path.'''
        keys = []
        (dirname,filename) = os.path.split(path)
        c = self.filelists_db.cursor()
        c.execute("SELECT pkgKey,filenames FROM filelist "
                  "WHERE dirname=?",(dirname,))
        keys = [k for (k, f) in c if filename in f.split('/')]
        c.close()
        rpms = []
        for key in keys:
            # FIXME do one query? WHERE pkgKey=? OR ...
            # Nope, too long, but maybe we could do a join..
            c = self.primary_db.cursor()
            c.execute("SELECT location_base,location_href FROM packages "
                      "WHERE pkgKey=?",(key,))
            (base,href) = c.fetchone()
            rpms.append(os.path.join(self.path,href))
            c.close()
        return rpms

    def unpack(self,rpm,targetdir=None):
        if targetdir:
            if not os.path.isdir(targetdir):
                os.makedirs(targetdir)
        else:
            targetdir = self.cachedir

        inf = open(rpm)
        # Find RPM header and read compression algorithm
        # Skip forward to gzipped CPIO archive
        # FIXME: Awful. Just awful.
        header = inf.read(409600)
        offset = header.index("\x1f\x8b")
        del header
        inf.seek(offset)
        gz = gzip.GzipFile(fileobj=inf, mode="rb")
        # Open a pipe to "cpio -iumd --quiet"
        cpio = subprocess.Popen(args=["cpio","-iumd","--quiet"],
                cwd=targetdir, stdin=subprocess.PIPE)
        data = gz.read(4096)
        while data:
            cpio.stdin.write(data)
            data = gz.read(4096)
        gz.close()
        inf.close()
        cpio.stdin.close()
        cpio.wait()

class Repofs(Fuse):
    def __init__(self, *args, **kw):
        Fuse.__init__(self, *args, **kw)

    def fsinit(self):
        if not os.path.isdir(self.cachedir):
            os.makedirs(self.cachedir)
        self.logfile = open(os.path.join(self.cachedir,".log"),"a",0)
        self.log("fsinit(path=%s). Hang on.." % self.repopath)
        # TODO: figure out the repo type (Yum, etc) and use the right class
        self.repos = []
        for rp in self.repopath.split(":"):
            r = SimpleYumRepo(path=rp, cachedir=self.cachedir)
            self.repos.append(r)
            self.log(" cachedir=%s, repopath=%s" % (r.cachedir, r.path))

    def log(self,message):
        self.logfile.write("%s %s\n" % (time.asctime(), message))
        
    def _package_for_file(self, path):
        for repo in self.repos:
            packages = repo.packages_for_file(path)
            if packages:
                return (packages[0], repo)

    def _cachefile(self, path):
        '''Find the given filename in the repo, extract it from whatever
        package it's in, and save it into the cache.
        Returns the actual on-disk path for the (now cached) file.'''
        cachefile = os.path.join(self.cachedir, path.strip('/'))
        if os.path.exists(cachefile):
            return cachefile
        # FIXME try/except
        # FIXME multiple repos
        # FIXME assumes that filenames are unique
        (package, repo) = self._package_for_file(path)
        if not package:
            return None
        repo.unpack(package, self.cachedir) 
        self.log("unpacked %s" % package)
        if os.path.exists(cachefile):
            return cachefile

    def getattr(self, path):
        self.log("getattr(%s)" % path)
        f = self._cachefile(path)
        if not f:
            return -errno.ENOENT
        # Not os.lstat() - we're ignoring symlinks.
        # This means we don't have to implement readlink().
        attr = fuseclonestat(os.stat(f))
        # No writeable files - turn off write bits
        attr.st_mode &= ~(S_IWUSR|S_IWGRP|S_IWOTH)
        return attr

    # FIXME actually use the provided arg
    def utime(self, path, times):
        self.log("utime(%s, %s)" % path, str(times))
        return os.utime(self._cachefile(path))
    def access(self, path, mode):
        self.log("access(%s, %s)" % path, mode)
        if not os.access(self._cachefile(path)):
            return -errno.EACCES

    def readdir(self, path, offset):
        '''Return an empty list. We don't let you list directory contents.'''
        self.log("Huh? readdir(%s)" % path)
        return []

    def statfs(self):
        #self.log("statfs()")
        s = fuse.StatVFS()
        local_s = os.statvfs(self.cachedir)
        # FIXME modify s using info from local_s
        return local_s

    # XXX explicitly declare other functions that return proper error codes?

    def open(self, path, flags):
        self.log("open(%s,%s)" % (path,flags))
        return open(self._cachefile(path),flag2mode(flags))

    def read(self, path, length, offset, fh=None):
        self.log("read(%s,%s,%s)" % (path,length,offset))
        fh.seek(offset)
        return fh.read(length)

    def release(self, path, fh=None):
        self.log("release(%s)" % path)
        fh.close()

    def fgetattr(self, path, fh=None):
        self.log("fgetattr(%s)" % path)
        return os.fstat(fh.fileno())

    def main(self, *a, **kw):
        return Fuse.main(self, *a, **kw)

    # FIXME need some kind of destroy() that removes the per-instance cache

def main():
    usage = 'Repofs: mount a package repo and export all the files in the packages.\n\n' + Fuse.fusage
    server = Repofs(version="%prog " + fuse.__version__, usage=usage,
                    dash_s_do='setsingle')
    server.parser.add_option(mountopt="repo", metavar="PATH", dest="repopath",
            help="Package repo to mount")
    server.parser.add_option(mountopt="cachedir", metavar="PATH",
            help="Cache dir for expanded packages")
    server.parse(values=server, errex=1)
    server.main()

if __name__ == '__main__':
    main()