|
#!/usr/bin/env python |
|
|
|
from __future__ import with_statement |
|
|
|
import atexit |
|
import os |
|
import sys |
|
import errno |
|
import multiprocessing |
|
|
|
import http.server |
|
import socketserver |
|
import functools |
|
|
|
from fuse import FUSE, FuseOSError, Operations |
|
|
|
def serve(): |
|
try: |
|
PORT = 8000 |
|
DIRECTORY = "workdir" |
|
|
|
Handler = functools.partial(http.server.SimpleHTTPRequestHandler, directory=DIRECTORY) |
|
|
|
with socketserver.TCPServer(("", PORT), Handler) as httpd: |
|
print("serving at port", PORT) |
|
httpd.serve_forever() |
|
finally: |
|
atexit._run_exitfuncs() |
|
|
|
class Passthrough(Operations): |
|
def __init__(self, root): |
|
self.root = root |
|
|
|
def _full_path(self, partial): |
|
if partial.startswith("/"): |
|
partial = partial[1:] |
|
path = os.path.join(self.root, partial) |
|
if not os.path.exists("/".join(path.split("/")[:4])): |
|
os.system("nix copy --from https://cache.nixos.org " + path) |
|
return path |
|
|
|
def access(self, path, mode): |
|
full_path = self._full_path(path) |
|
if not os.access(full_path, mode): |
|
raise FuseOSError(errno.EACCES) |
|
|
|
def chmod(self, path, mode): |
|
full_path = self._full_path(path) |
|
return os.chmod(full_path, mode) |
|
|
|
def chown(self, path, uid, gid): |
|
full_path = self._full_path(path) |
|
return os.chown(full_path, uid, gid) |
|
|
|
def getattr(self, path, fh=None): |
|
full_path = self._full_path(path) |
|
st = os.lstat(full_path) |
|
return dict((key, getattr(st, key)) for key in ('st_atime', 'st_ctime', |
|
'st_gid', 'st_mode', 'st_mtime', 'st_nlink', 'st_size', 'st_uid')) |
|
|
|
def readdir(self, path, fh): |
|
full_path = self._full_path(path) |
|
|
|
dirents = ['.', '..'] |
|
if os.path.isdir(full_path): |
|
dirents.extend(os.listdir(full_path)) |
|
for r in dirents: |
|
yield r |
|
|
|
def readlink(self, path): |
|
pathname = os.readlink(self._full_path(path)) |
|
if pathname.startswith("/"): |
|
# Path name is absolute, sanitize it. |
|
return os.path.relpath(pathname, self.root) |
|
else: |
|
return pathname |
|
|
|
def mknod(self, path, mode, dev): |
|
return os.mknod(self._full_path(path), mode, dev) |
|
|
|
def rmdir(self, path): |
|
full_path = self._full_path(path) |
|
return os.rmdir(full_path) |
|
|
|
def mkdir(self, path, mode): |
|
return os.mkdir(self._full_path(path), mode) |
|
|
|
def statfs(self, path): |
|
full_path = self._full_path(path) |
|
stv = os.statvfs(full_path) |
|
return dict((key, getattr(stv, key)) for key in ('f_bavail', 'f_bfree', |
|
'f_blocks', 'f_bsize', 'f_favail', 'f_ffree', 'f_files', 'f_flag', |
|
'f_frsize', 'f_namemax')) |
|
|
|
def unlink(self, path): |
|
return os.unlink(self._full_path(path)) |
|
|
|
def symlink(self, name, target): |
|
return os.symlink(target, self._full_path(name)) |
|
|
|
def rename(self, old, new): |
|
return os.rename(self._full_path(old), self._full_path(new)) |
|
|
|
def link(self, target, name): |
|
return os.link(self._full_path(name), self._full_path(target)) |
|
|
|
def utimens(self, path, times=None): |
|
return os.utime(self._full_path(path), times) |
|
|
|
def open(self, path, flags): |
|
full_path = self._full_path(path) |
|
return os.open(full_path, flags) |
|
|
|
def create(self, path, mode, fi=None): |
|
full_path = self._full_path(path) |
|
return os.open(full_path, os.O_WRONLY | os.O_CREAT, mode) |
|
|
|
def read(self, path, length, offset, fh): |
|
os.lseek(fh, offset, os.SEEK_SET) |
|
return os.read(fh, length) |
|
|
|
def write(self, path, buf, offset, fh): |
|
os.lseek(fh, offset, os.SEEK_SET) |
|
return os.write(fh, buf) |
|
|
|
def truncate(self, path, length, fh=None): |
|
full_path = self._full_path(path) |
|
with open(full_path, 'r+') as f: |
|
f.truncate(length) |
|
|
|
def flush(self, path, fh): |
|
return os.fsync(fh) |
|
|
|
def release(self, path, fh): |
|
return os.close(fh) |
|
|
|
def fsync(self, path, fdatasync, fh): |
|
return self.flush(path, fh) |
|
|
|
|
|
def main(mountpoint, root): |
|
try: |
|
FUSE(Passthrough(root), os.path.join(mountpoint, "nix", "store"), nothreads=True, foreground=True, **{'allow_other': True}) |
|
finally: |
|
atexit._run_exitfuncs() |
|
|
|
if __name__ == '__main__': |
|
fuse = multiprocessing.Process(target=main, args=(sys.argv[2], sys.argv[1],)) |
|
serve = multiprocessing.Process(target=serve) |
|
fuse.start() |
|
serve.start() |
|
|
