#!/bin/env python

 # -*- coding: utf-8 -*-

 # ------------------------------------------------------------

 # mirrorfuse

 # 

 # create a mirror filesystem folder as a new filesystem to mount

 #

 # This is directly based on xmp.py of the 

 # dev-python/fuse-python example

 #

 # Autor: Oliver Maurhart, <oliver.maurhart@ait.ac.at>

 #

 # Copyright (C) 2013 AIT Austrian Institute of Technology

 # AIT Austrian Institute of Technology GmbH

 # Donau-City-Strasse 1 | 1220 Vienna | Austria

 # http://www.ait.ac.at

 #

 # This program is free software; you can redistribute it and/or

 # modify it under the terms of the GNU General Public License

 # as published by the Free Software Foundation version 2.

 # 

 # This program is distributed in the hope that it will be useful,

 # but WITHOUT ANY WARRANTY; without even the implied warranty of

 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 # GNU General Public License for more details.

 # 

 # You should have received a copy of the GNU General Public License

 # along with this program; if not, write to the Free Software

 # Foundation, Inc., 51 Franklin Street, Fifth Floor, 

 # Boston, MA  02110-1301, USA.

 # ------------------------------------------------------------

 # ------------------------------------------------------------

 # imports

 import errno

 import fcntl

 import fuse

 import os

 import sys

 from fuse import Fuse

 # ------------------------------------------------------------

 # const

 __version__ = "0.1"

 # ------------------------------------------------------------

 # code

 class MirrorFuse(Fuse):

     """This is the Mirror FUSE in python.

     This is to represnt a file hierarchy elsewhere (and intercept each file system call)

     """

     def __init__(self, *args, **kw):

         fuse.fuse_python_api = (0, 2)

         super(MirrorFuse, self).__init__(*args, **kw)

         self.root = '/'

         self.os_server_url = ''

     def getattr(self, path):

         return os.lstat("." + path)

     #

     # links are not allowed for a mirrored FS

     #

     def readlink(self, path):

         eturn -errno.EACCES

     def readdir(self, path, offset):

         for e in os.listdir("." + path):

             yield fuse.Direntry(e)

     def unlink(self, path):

         sys.stdout.write("===\nInsert Hook here! Deleting file %s\n===\n" % path)

         os.unlink("." + path)

     def rmdir(self, path):

         sys.stdout.write("===\nInsert Hook here! Deleting folder %s\n===\n" % path)

         os.rmdir("." + path)

     #

     # links are not allowed for a mirrored FS

     #

     def symlink(self, path, path1):

         eturn -errno.EACCES

     def rename(self, path, path1):

         sys.stdout.write("===\nInsert Hook here! Moving file %s --> %s\n===\n" % path % path1)

         os.rename("." + path, "." + path1)

     #

     # links are not allowed for a mirrored FS

     #

     def link(self, path, path1):

         return -errno.EACCES

     #

     # changing access mode is not allowed in mirrored FS

     #

     def chmod(self, path, mode):

         return -errno.EACCES

     #

     # changing ownership is not allowed in mirrored FS

     #

     def chown(self, path, user, group):

         return -errno.EACCES

     def truncate(self, path, len):

         f = open("." + path, "a")

         f.truncate(len)

         f.close()

     def mknod(self, path, mode, dev):

         sys.stdout.write("===\nInsert Hook here! Creating file %s\n===\n" % path)

         os.mknod("." + path, mode, dev)

     def mkdir(self, path, mode):

         sys.stdout.write("===\nInsert Hook here! Creating folder %s\n===\n" % path)

         os.mkdir("." + path, mode)

     def utime(self, path, times):

         os.utime("." + path, times)

     def access(self, path, mode):

         if not os.access("." + path, mode):

             return -errno.EACCES

     def statfs(self):

         return os.statvfs(".")

     def fsinit(self):

         os.chdir(self.root)

     def main(self, *a, **kw):

         self.file_class = MirrorFuseFile

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

 class MirrorFuseFile(object):

     """This is a single "File" in the Mirror FUSE"""

     def __init__(self, path, flags, *mode):

         sys.stdout.write("===\nInsert Hook here! Opening file %s\n===\n" % path)

         self.file = os.fdopen(os.open("." + path, flags, *mode), flag2mode(flags))

         self.fd = self.file.fileno()

     def read(self, length, offset):

         self.file.seek(offset)

         return self.file.read(length)

     def write(self, buf, offset):

         self.file.seek(offset)

         self.file.write(buf)

         return len(buf)

     def release(self, flags):

         self.file.close()

     def _fflush(self):

         if 'w' in self.file.mode or 'a' in self.file.mode:

             self.file.flush()

     def fsync(self, isfsyncfile):

         self._fflush()

         if isfsyncfile and hasattr(os, 'fdatasync'):

             os.fdatasync(self.fd)

         else:

             os.fsync(self.fd)

     def flush(self):

         self._fflush()

         os.close(os.dup(self.fd))

     def fgetattr(self):

         return os.fstat(self.fd)

     def ftruncate(self, len):

         self.file.truncate(len)

     def lock(self, cmd, owner, **kw):

         op = {fcntl.F_UNLCK : fcntl.LOCK_UN, fcntl.F_RDLCK : fcntl.LOCK_SH, fcntl.F_WRLCK : fcntl.LOCK_EX}[kw['l_type']]

         if cmd == fcntl.F_GETLK:

             return -EOPNOTSUPP

         elif cmd == fcntl.F_SETLK:

             if op != fcntl.LOCK_UN:

                 op |= fcntl.LOCK_NB

         elif cmd == fcntl.F_SETLKW:

             pass

         else:

             return -errno.EINVAL

         fcntl.lockf(self.fd, op, kw['l_start'], kw['l_len'])

 def flag2mode(flags):

     """Turn os flags into mode chars"""

     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 main():             

     usage = """

 mirror the a file tree from some point on.

 """ + Fuse.fusage

     # launch the Fuse server

     server = MirrorFuse(version = "%prog " + __version__, usage = usage, dash_s_do = 'setsingle')

     server.parser.add_option(mountopt = "root", metavar = "PATH", default='/',  help="mirror filesystem from under PATH [default: %default]")

     server.parser.add_option(mountopt = "os_server_url", metavar = "URL", default='http://localhost:8080',  help="URL to OpenSecurity Server [default: %default]")

     server.parse(values=server, errex=1)

     try:

         if server.fuse_args.mount_expected():

             os.chdir(server.root)

     except OSError:

         print >> sys.stderr, "can't enter root of underlying filesystem"

         sys.exit(1)

     server.main()

 # start

 if __name__ == "__main__":

     main()