Simplification of the object module : now use only one class (maybe add some function back later)

Requesting the child items now works
Add a zip example of objects for testing

4 files changed, 71 insertions, 186 deletions

diff --git a/server/object.py b/server/object.py
index d9cdc92..73bd96e 100644
--- a/server/object.py
+++ b/server/object.py
@@ -10,198 +10,76 @@ import fileinput
 import logging
 
 from permission import *
+from config import config
 
-class Object:
-
-    def __get_path(self):
-        return self.root + self.owner + '/' + self.name[:2] + '/' + self.name[2:]
-
-    def __create_dir(self):
-        if (not os.path.exists(self.__get_path())):
-            os.mkdirs(self.__get_path())
-
-    ##
-    # Save the object on the disk.
-    def save(self):
-        self.__create_dir()
-
-        header = "author " + self.data['author'] + "\n"
-        header += "parent " + self.data['parent'] + "\n"
-        header += "created " + self.data['created'] + "\n"
-        header += "#\n" #end of header
-        store = header + self.data['content']
-
-        file = open(self.__get_path() + "/object", 'w')
-        file.write(zlib.compress(store))
-        file.close()
-        os.mknod(self.path + "/childs")
-        os.mknod(self.path + "/permissions")
-        self.saved = True
-
-    ##
-    # Class constructor.
-    def __init__(self, root, owner, init):
-        
-        self.root = root
-        if isinstance(init, dict):
-            if 'author' not in init:
-                init['author'] = 'None'
-            if 'parent' not in init:
-                init['parent'] = 'None'
-            if 'content' not in init:
-                init['content'] = 'None'
+class ObjectError(Exception):
+    pass;
 
-            self.data = init
-            self.data['created'] = str(datetime.datetime.now())
-            self.name = hashlib.sha1(str(self.data)).hexdigest()
-            self.saved = False
-
-        elif isinstance(init, str):
-            self.name = init
-            if (os.path.exists(self.__get_path())):
-                file = open(self.__get_path() + '/object', 'r')
-                contentStream = StringIO.StringIO(zlib.decompress(file.read()))
-                data = {}
-
-                for line in contentStream:
-                    if (line == "#\n"):
-                        data['content'] = contentStream.read()
-                        break
-                    else:
-                        key, sep, value = line.rstrip('\n').partition(' ')
-                        data[key] = value
-
-                self.data = data
-                file.close()
-            else:
-                logging.error("Object {} root doesn't exist".format(init))
-
-    def append_to(self, father):
-        father.append_child(self)
+class Object:
 
-    def append_child(self, child):
-        if not self.saved:
-            self.save()
+    def __init__(self, owner, hash):
+        self.owner = owner
+        self.hash = hash
+        owner_path = config.root + self.owner + '/'
 
-        file = open(self.path + "/childs", 'a')
-        file.write(child.name + "\n")
-        file.close()
+        if not os.path.exists(owner_path) :
+            logging.error("User {} is not registered".format(self.owner))
+            raise ObjectError
 
-    @staticmethod
-    def get_permission_by_hash(hash, user):
-        path = hash[:2] + '/' + hash[2:]
-        try:
-            file = open(path + '/permissions', 'r')
-        except IOError:
-            print 'cannot open', path
-        else:
-            for line in file:
-                name, sep, perm = line.rstrip('\n').partition(' ')
-                if name == user:
-                    return perm
+        self.path = owner_path + self.hash[:2] + '/' + self.hash[2:] + '/'
 
-            return 0
+        if not os.path.exists(self.path) :
+            logging.error("Object {} can't be found for user {}".format(self.hash,
+                                                                        self.owner))
+            raise ObjectError
 
     def get_permission(self, user):
-        file = open(self.__get_path() + '/permissions', 'r')
+        file = open(self.path + 'permissions', 'r')
         for line in file:
             name, sep, perm = line.rstrip('\n').partition(' ')
             if name == user:
-                return perm
+                return int(perm)
 
         return 0
 
-    def set_permission(self, user, permission):
-        if not self.saved:
-            self.save()
+    def get_child_list(self, user):
+        perm = self.get_permission(user)
+        if not perm & LIST :
+            logging.error("User {} doesn't have the list permission for object {}"
+                          .format(user, self.hash))
+            raise PermissionError
 
-        sentinel = False
-        for line in fileinput.input(self.__get_path() + "/permissions", inplace = 1):
-            name, sep, perm = line.rstrip('\n').partition(' ')
-            if name == user:
-                sys.stdout.write(name + ' ' + str(permission) + '\n')
-                sentinel = True
-            else:
-                sys.stdout.write(line)
-
-        if not sentinel:
-            file = open(self.__get_path() + '/permissions', 'a')
-            file.write(user + ' ' + str(permission) + '\n')
-            file.close()
-
-class ObjectHandler:
-
-    def __init__(self, root, owner):
-        self.root = root
-        self.owner = owner
-        
-    def get_user_directory(self):
-        if os.path.exists(self.root + '/' + self.owner):
-            return self.root + '/' + self.owner
-        else:
-            logging.error("User {} root doesn't exist".format(self.owner))
-
-    def get_object_directory(self, hash):
-        directory = self.get_user_directory() + hash[:2] + '/' + hash[2:]
-        if (os.path.exists(directory)):
-            return directory
-        else:
-            logging.error("Object {} directory doesn't exist".format(hash))
-
-    def get_object(self, hash):
-        return Object(self.root, self.owner, hash)
-
-    #return a list of hash, permission pairs
-    #for the objects the queryer has permissions on 
-    def get_child_list(self, hash, queryer):
-        directory = self.get_object_directory(hash)
-        if directory:
-            result = []
-            file = open(directory + "/childs", 'r')
-            for line in file :
+        file = open(self.path + "childs", 'r')
+        result = []
+        for line in file :
                 name = line.rstrip('\n')
-                result.append(name)
-            file.close()
-            return result
-        else:
-            return None
-
-    def create_home_node(self):
-        pass
+                try:
+                    child = Object(self.owner, name)
+                except ObjectError:
+                    logging.error("Object {} can't be find for user {}".format(self.hash,
+                                                                               self.owner))
+                else:
+                    permission = child.get_permission(user)
+                    if permission > 0:
+                        result.append((name, permission))
 
-    def get_home_node(self):
-        return hashlib.sha1(self.owner).hexdigest()
-
-if __name__ == '__main__':
-    config.root = os.path.abspath('object_tests')
-    if not(os.path.exists(config.root)):
-        os.mkdir(config.root)
-    os.chdir(config.root)
-    if not(os.path.exists('guillaume')):
-        os.mkdir('guillaume')
+        file.close()
+        return result
 
-    guillaume_stuff = ObjectHandler('guillaume')
-    os.chdir('guillaume')
-    x = Object({'parent' : 'toto', 'author' : 'Zaran'})
-    x.set_permission("test", READ)
-    x.set_permission("toto", READ | MODIFY)
-    x.set_permission("toto", READ | MODIFY | APPEND)
-    x.set_permission("toto2", READ | MODIFY | APPEND)
-    print x.get_permission("toto")
-    print Object.get_permission_by_hash(x.name, "toto")
-    child = Object({'parent' : x.name, 'author' : 'Zaran'})
-    child.save()
+    def get_content(self, user):
+        perm = self.get_permission(user)
+        if not perm & READ :
+            logging.error("User {} doesn't have read access to object {}"
+                          .format(user, self.hash))
+            raise PermissionError
 
-    x.append_child(child)
-    os.chdir(config.root)
+        file = open(self.path + "object", 'r')
+        result = file.read()
+        file.close()
+        return result
 
-    y = guillaume_stuff.get_object(x.name)
-    pomme = guillaume_stuff.get_child_list(x.name, None)
-    print pomme
-    print y.data['author']
-    print y.data['parent']
-    print y.data['content']
-    print y.data['created']
+if __name__ == '__main__':
+    pass
 
 
 
diff --git a/server/permission.py b/server/permission.py
index fe93928..3ce7323 100644
--- a/server/permission.py
+++ b/server/permission.py
@@ -1,6 +1,9 @@
 # -*- coding: utf-8 -*-
 
-READ   = 1 << 0
+READ = 1 << 0
 MODIFY = 1 << 1
 APPEND = 1 << 2
-    
\ No newline at end of file
+LIST = 1 << 3
+
+class PermissionError(Exception):
+    pass
\ No newline at end of file
diff --git a/server/plugin.py b/server/plugin.py
index 62ae958..c3bd81d 100644
--- a/server/plugin.py
+++ b/server/plugin.py
@@ -1,5 +1,6 @@
 import logging
 import base64
+import hashlib
 from xml.etree import cElementTree as ET
 
 from sleekxmpp.xmlstream.stanzabase import ElementBase, register_stanza_plugin
@@ -8,7 +9,8 @@ from sleekxmpp.xmlstream.handler.callback import Callback
 from sleekxmpp.xmlstream.matcher.xpath import MatchXPath
 from sleekxmpp.stanza.iq import Iq
 
-import object
+from object import Object
+from permission import PermissionError
 
 class AliasQuery(ElementBase):
     namespace = 'alias:query'
@@ -21,7 +23,7 @@ class AliasQuery(ElementBase):
         item = AliasItem(None, self)
         item['node'] = node
         if permission is not None:
-            item['permission'] = permission
+            item['permission'] = str(permission)
 
 class AliasItem(ElementBase):
     namespace = 'alias:query'
@@ -38,7 +40,7 @@ class AliasPlugin(base.base_plugin):
                                                                 AliasQuery.namespace))
         self.xmpp.register_handler(Callback('Alias queries', query_parser,
                                             self.handle_alias_query))
-        
+
     def post_init(self):
         base.base_plugin.post_init(self)
         self.xmpp.plugin['xep_0030'].add_feature("alias:query")
@@ -48,17 +50,19 @@ class AliasPlugin(base.base_plugin):
             callee = base64.b64decode(iq['to'].user)
         except TypeError:
             logging.error("callee field not base64 encoded")
-        caller = iq['alias']['from']
-        handler = object.ObjectHandler(self.config['root'],callee)
+        caller = iq['from'].bare
         node = iq['alias']['node']
         if not node:
-            node = handler.get_home_node()
+            node = hashlib.sha1(callee).hexdigest()
+
+        node = Object(callee, node)
+
         if iq['alias']['type'] == 'items':
             logging.debug('childs of {} requested'.format(node))
-            childs = handler.get_child_list(node, caller)
+            childs = Object.get_child_list(node, caller)
             reply = AliasQuery()
-            reply['node'] = node
+            reply['node'] = node.hash
             reply['type'] = 'items'
-            for child in childs:
-                reply.addItem(child, "test")
+            for name, perm in childs:
+                reply.addItem(name, perm)
             iq.reply().set_payload(reply).send()
\ No newline at end of file
diff --git a/server/server.py b/server/server.py
index fcddfe8..d802436 100755
--- a/server/server.py
+++ b/server/server.py
@@ -13,7 +13,7 @@ class ObjectComponent(ComponentXMPP):
     def __init__(self, jid, secret, server, port, root):
         ComponentXMPP.__init__(self, jid, secret, server, port)
         self.register_plugin('xep_0030')
-        self.register_plugin("AliasPlugin", module = "plugin", pconfig={'root': root})
+        self.register_plugin("AliasPlugin", module = "plugin", pconfig = {'root': root})
         self.add_event_handler("session_start", self.start)
         self.add_event_handler("presence_probe", self.presence_probe)
         self.add_event_handler("message", self.message)
@@ -94,6 +94,6 @@ if __name__ == '__main__':
         logging.info('Component {} connected'.format(component.boundjid))
         component.process(False)
     else :
-        print "Couldn't connect"
+        logging.error("Component {} couldn't connect".format(component.boundjid))