from time import sleep
#from fs.osfs import OSFS
#from fs.expose import fuse
from fs.memoryfs import MemoryFS
from multiprocessing.managers import BaseManager
from multiprocessing import Process, get_logger

class data(object):
    def __init__(self, fspath='tmpramfs'):
        self.ofiles = list()
        self.fname = fspath
#       self.homefs = OSFS('/tmp')
#       self.homefs.makedir(
#           self.fname,
#           allow_recreate=True)
        self.memoryfs = MemoryFS()
        self.memoryfs.makedir('testing')
#       self.mount = fuse.mount(
#               self.memoryfs,
#               '/tmp/xmond_tmpramfs')

    def internalLock(self, Argument):
        for _ in range(1000):
            if not Argument in self.ofiles:
                self.ofiles.append(Argument)
                return
            sleep(.005)
        return

    def finish(self):
        self.mount.umount()
        return

    def exists(self, Argument):
        if self.isDir(Argument) or self.isFile(Argument):
            return True
        return False

    def isFile(self, Argument):
        if self.memoryfs.isfile(Argument):
            return True
        return False

    def isDir(self, Argument):
        if self.memoryfs.isdir(Argument):
            return True
        return False

    def tree(self, Argument=False):
        if not Argument:
            tmpResult = []
            _walk = self.memoryfs.walk()
            while True:
                try: tmpResult.append(_walk.next())
                except: return tmpResult

            tmpResult = self.memoryfs.tree()
            return tmpResult
            return self.memoryfs.tree()
        if self.memoryfs.isdir(Argument):
            return self.memoryfs.tree(Argument)
        return False

    def get(self, Argument):
        if self.memoryfs.isfile(Argument):
            self.internalLock(Argument)
            try: tmpDataFile = self.memoryfs.open(Argument, 'r')
            except: self._unlock(Argument)
            else:
                tmpData = tmpDataFile.read()
                tmpDataFile.close()
                self._unlock(Argument)
                return tmpData
        return False

    def close(self, Argument):
        if Argument in self.ofiles:
            try: self.memoryfs.close(Argument)
            except: return False
            self._unlock(Argument)
            return True
        return False

    def open(self, Argument, rw='rb'):
        if self.memoryfs.isfile(Argument):
            self.internalLock(Argument)
            try: tmpfh = self.memoryfs.open(Argument, rw)
            except: return False
            else:
                self.ofiles.append(Argument)
                return tmpfh
        return False

    def create(self, Argument, Value=None):
        return self.set(Argument, Value)

    def _unlock(self, Argument):
        if Argument in self.ofiles:
            self.ofiles.remove(Argument)
        return

    def remove(self, Argument):
        return self.delete(Argument)

    def delete(self, Argument):
        if self.exists(Argument):
            self.internalLock(Argument)
            if self.isDir(Argument):
                self.memoryfs.removedir(Argument,
                    recursive=False, force=True)
                self._unlock(Argument)
                return True
            elif self.isFile(Argument):
                self.memoryfs.remove(Argument)
                self._unlock(Argument)
                return True
        self._unlock(Argument)
        return False

    def set(self, Argument, Value=None):
        if len(Argument) <= 1:
            return False

        if not Value:
            if self.memoryfs.isdir(Argument):
                return True
            elif self.memoryfs.isfile(Argument):
                return False
            self.memoryfs.makedir(Argument,
                    allow_recreate=True,
                    recursive=True)
            return True

        if self.memoryfs.isdir(Argument):
            return False

        self.internalLock(Argument)

        tmppath = "/".join(Argument.split('/')
                )[:-len(Argument.split('/')[-1]
                )-1].replace('//', '/')
        if not self.memoryfs.isdir(tmppath):
            self.memoryfs.makedir(tmppath,
                    allow_recreate=True,
                    recursive=True)

        if not self.memoryfs.isfile(Argument):
            try: self.memoryfs.createfile(Argument, repr(Value))
            except:
                self._unlock(Argument)
                return False

        try: tmpDataFile = self.memoryfs.open(Argument, 'rw')
        except:
            self._unlock(Argument)
            return False
        else:
            tmpDataFile.write(repr(Value))
            tmpDataFile.close()
            self._unlock(Argument)
            return True

        self._unlock(Argument)
        return False


class DataManager(BaseManager): pass


class DataProcess(Process):
    def __init__(self, authkey, public):
        Process.__init__(self)
        self.authkey = authkey
        self.dataS = data()
        self.daemon = True
        self.addr = '127.0.0.1'
        if public:
            self.addr = '0.0.0.0'

    def run(self):
        DataManager.register('get_data',
            callable=lambda:self.dataS)
        datamgr = DataManager(
            address = (self.addr, 7349),
            authkey = self.authkey)

        datasrv = datamgr.get_server()
        datasrv.serve_forever()



def create(authkey, public=False):
    try:
        DP = DataProcess(authkey, public)
        DP.start()
    except: return False

    return True


create('authKey')
while True:
    sleep(600)