/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision cf4a7a7b

             """
             placeholders = ','.join('?' for path in paths)
             q = "select path, node from nodes where path in (%s)" % placeholders
             q = "select node from nodes where path in (%s)" % placeholders
             self.execute(q, paths)
             return self.fetchall()
             r = self.fetchall()
             if r is not None:
             	return [row[0] for row in r]
             return None
         def node_get_properties(self, node):
             """Return the node's (parent, path).
-...
             self.statistics_update_ancestors(node, 1, size, mtime, cluster)
             return serial, mtime
         def version_lookup(self, node, before=inf, cluster=0):
         def version_lookup(self, node, before=inf, cluster=0, all_props=True):
             """Lookup the current version of the given node.
                Return a list with its properties:
                (serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster)
                or None if the current version is not found in the given cluster.
             """
             q = ("select serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster "
             q = ("select %s "
                  "from versions "
                  "where serial = (select max(serial) "
                                  "from versions "
                                  "where node = ? and mtime < ?) "
                  "and cluster = ?")
             if not all_props:
                 q = q % "serial"
             else:
                 q = q % "serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster"
             self.execute(q, (node, before, cluster))
             props = self.fetchone()
             if props is not None:
                 return props
             return None
         def version_lookup_bulk(self, nodes, before=inf, cluster=0):
         def version_lookup_bulk(self, nodes, before=inf, cluster=0, all_props=True):
             """Lookup the current versions of the given nodes.
                Return a list with their properties:
                (serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster).
             """
             placeholders = ','.join('?' for node in nodes)
             q = ("select serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster "
             q = ("select %s "
                  "from versions "
                  "where serial in (select max(serial) "
                                  "from versions "
                                  "where node in (%s) and mtime < ? group by node) "
                  "and cluster = ?" % placeholders)
                  "and cluster = ?")
             placeholders = ','.join('?' for node in nodes)
             if not all_props:
                 q = q % ("serial",  placeholders)
             else:
                 q = q % ("serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster",  placeholders)
             args = nodes
             args.extend((before, cluster))
             self.execute(q, args)

                 start, limit = self._list_limits(allowed, marker, limit)
                 return allowed[start:start + limit]
             node = self.node.node_lookup(account)
             return [x[0] for x in self._list_object_properties(node, account, '', '/', marker, limit, False, None, [], until)]
             containers = [x[0] for x in self._list_object_properties(node, account, '', '/', marker, limit, False, None, [], until)]
             start, limit = self._list_limits([x[0] for x in containers], marker, limit)
             return containers[start:start + limit]
         @backend_method
         def list_container_meta(self, user, account, container, domain, until=None):
-...
         def _list_objects(self, user, account, container, prefix, delimiter, marker, limit, virtual, domain, keys, shared, until, size_range, all_props, public):
             if user != account and until:
                 raise NotAllowedError
             if shared and public:
                 # get shared first
                 shared = self._list_object_permissions(user, account, container, prefix, shared=True, public=False)
                 objects = []
                 if shared:
                     path, node = self._lookup_container(account, container)
                     shared = self._get_formatted_paths(shared)
                     objects = self._list_object_properties(node, path, prefix, delimiter, marker, limit, virtual, domain, keys, until, size_range, shared, all_props)
                 # get public
                 objects.extend(self._list_public_object_properties(user, account, container, prefix, all_props))
                 objects.sort(key=lambda x: x[0])
                 start, limit = self._list_limits([x[0] for x in objects], marker, limit)
                 return objects[start:start + limit]
             elif public:
                 objects = self._list_public_object_properties(user, account, container, prefix, all_props)
                 start, limit = self._list_limits([x[0] for x in objects], marker, limit)
                 return objects[start:start + limit]
             allowed = self._list_object_permissions(user, account, container, prefix, shared, public)
             if (shared or public) and not allowed:
             if shared and not allowed:
                 return []
             path, node = self._lookup_container(account, container)
             allowed = self._get_formatted_paths(allowed)
             return self._list_object_properties(node, path, prefix, delimiter, marker, limit, virtual, domain, keys, until, size_range, allowed, all_props)
             objects = self._list_object_properties(node, path, prefix, delimiter, marker, limit, virtual, domain, keys, until, size_range, allowed, all_props)
             start, limit = self._list_limits([x[0] for x in objects], marker, limit)
             return objects[start:start + limit]
         def _list_public_object_properties(self, user, account, container, prefix, all_props):
             public = self._list_object_permissions(user, account, container, prefix, shared=False, public=True)
             paths, nodes = self._lookup_objects(public)
             path = '/'.join((account, container))
             cont_prefix = path + '/'
             paths = [x[len(cont_prefix):] for x in paths]
             props = self.node.version_lookup_bulk(nodes, all_props=all_props)
             objects = [(path,) + props for path, props in zip(paths, props)]
             return objects
         def _list_objects_no_limit(self, user, account, container, prefix, delimiter, virtual, domain, keys, shared, until, size_range, all_props, public):
             objects = []
             while True:
-...
                 raise NameError('Object does not exist')
             return path, node
         def _lookup_objects(self, paths):
         	nodes = self.node.node_lookup_bulk(paths)
             if nodes is None:
                 raise NameError('Object does not exist')
             return paths, nodes
         def _get_properties(self, node, until=None):
             """Return properties until the timestamp given."""
-...
             objects.extend([(p, None) for p in prefixes] if virtual else [])
             objects.sort(key=lambda x: x[0])
             objects = [(x[0][len(cont_prefix):],) + x[1:] for x in objects]
             return objects
             start, limit = self._list_limits([x[0] for x in objects], marker, limit)
             return objects[start:start + limit]
         # Reporting functions.
         def _report_size_change(self, user, account, size, details={}):

Also available in: Unified diff