Revision 15a96c3e

b/pithos/api/functions.py
537 537 
        objects = request.backend.list_object_meta(request.user_uniq, v_account,
538 538 
                                    v_container, prefix, delimiter, marker,
539 539 
                                    limit, virtual, 'pithos', keys, shared, until)
540 
        object_permissions = {}
541 
        object_public = {}
542 
        if until is None:
543 
            name_idx = len('/'.join((v_account, v_container, '')))
544 
            for x in request.backend.list_object_permissions(request.user_uniq,
545 
                                    v_account, v_container, prefix):
546 
                object = x[name_idx:]
547 
                object_permissions[object] = request.backend.get_object_permissions(
548 
                                    request.user_uniq, v_account, v_container, object)
549 
            for k, v in request.backend.list_object_public(request.user_uniq,
550 
                                    v_account, v_container, prefix).iteritems():
551 
                object_public[k[name_idx:]] = v
540 552 
    except NotAllowedError:
541 553 
        raise Forbidden('Not allowed')
542 554 
    except NameError:
543 555 
        raise ItemNotFound('Container does not exist')
544 556
545 
#     object_meta = []
546 
#     for x in objects:
547 
#         if x[1] is None:
548 
#             # Virtual objects/directories.
549 
#             object_meta.append({'subdir': x[0]})
550 
#         else:
551 
#             try:
552 
#                 meta = request.backend.get_object_meta(request.user_uniq, v_account,
553 
#                                                         v_container, x[0], 'pithos', x[1])
554 
#                 if until is None:
555 
#                     permissions = request.backend.get_object_permissions(
556 
#                                     request.user_uniq, v_account, v_container, x[0])
557 
#                     public = request.backend.get_object_public(request.user_uniq,
558 
#                                                 v_account, v_container, x[0])
559 
#                 else:
560 
#                     permissions = None
561 
#                     public = None
562 
#             except NotAllowedError:
563 
#                 raise Forbidden('Not allowed')
564 
#             except NameError:
565 
#                 pass
566 
#             else:
567 
#                 rename_meta_key(meta, 'hash', 'x_object_hash') # Will be replaced by checksum.
568 
#                 rename_meta_key(meta, 'checksum', 'hash')
569 
#                 rename_meta_key(meta, 'type', 'content_type')
570 
#                 rename_meta_key(meta, 'uuid', 'x_object_uuid')
571 
#                 rename_meta_key(meta, 'modified', 'last_modified')
572 
#                 rename_meta_key(meta, 'modified_by', 'x_object_modified_by')
573 
#                 rename_meta_key(meta, 'version', 'x_object_version')
574 
#                 rename_meta_key(meta, 'version_timestamp', 'x_object_version_timestamp')
575 
#                 m = dict([(k[14:], v) for k, v in meta.iteritems() if k.startswith('X-Object-Meta-')])
576 
#                 for k in m:
577 
#                     del(meta['X-Object-Meta-' + k])
578 
#                 if m:
579 
#                     meta['X-Object-Meta'] = printable_header_dict(m)
580 
#                 update_sharing_meta(request, permissions, v_account, v_container, x[0], meta)
581 
#                 update_public_meta(public, meta)
582 
#                 object_meta.append(printable_header_dict(meta))
583 
#     if request.serialization == 'xml':
584 
#         data = render_to_string('objects.xml', {'container': v_container, 'objects': object_meta})
585 
#     elif request.serialization  == 'json':
586 
#         data = json.dumps(object_meta, default=json_encode_decimal)
587 
#     response.status_code = 200
588 
#     response.content = data
589 
#     return response
590
591 557 
    object_meta = []
592 558 
    for meta in objects:
593 559 
        if len(meta) == 1:
......
605 571 
            rename_meta_key(meta, 'modified_by', 'x_object_modified_by')
606 572 
            rename_meta_key(meta, 'version', 'x_object_version')
607 573 
            rename_meta_key(meta, 'version_timestamp', 'x_object_version_timestamp')
574 
            permissions = object_permissions.get(meta['name'], None)
575 
            if permissions:
576 
                update_sharing_meta(request, permissions, v_account, v_container, meta['name'], meta)
577 
            public = object_public.get(meta['name'], None)
578 
            if public:
579 
                update_public_meta(public, meta)
608 580 
            object_meta.append(printable_header_dict(meta))
609 581 
    if request.serialization == 'xml':
610 582 
        data = render_to_string('objects.xml', {'container': v_container, 'objects': object_meta})
b/pithos/backends/base.py
325 325
326 326 
        Same parameters with list_objects. Returned dicts have no user-defined
327 327 
        metadata and, if until is not None, a None 'modified' timestamp.
328
329 
        Raises:
330 
            NotAllowedError: Operation not permitted
331
332 
            NameError: Container does not exist
328 333 
        """
329 334 
        return []
330 335
336 
    def list_object_permissions(self, user, account, container, prefix=''):
337 
        """Return a list of paths that enforce permissions under a container.
338
339 
        Raises:
340 
            NotAllowedError: Operation not permitted
341 
        """
342 
        return []
343
344 
    def list_object_public(self, user, account, container, prefix=''):
345 
        """Return a dict mapping paths to public ids for objects that are public under a container."""
346 
        return {}
347
331 348 
    def get_object_meta(self, user, account, container, name, domain, version=None):
332 349 
        """Return a dictionary with the object metadata for the domain.
333 350
b/pithos/backends/lib/sqlalchemy/public.py
85 85 
            return row[0]
86 86 
        return None
87 87
88 
    def public_list(self, prefix):
89 
        s = select([self.public.c.path, self.public.c.public_id])
90 
        s = s.where(self.xfeatures.c.path.like(self.escape_like(prefix) + '%', escape='\\'))
91 
        s = s.where(self.public.c.active == True)
92 
        r = self.conn.execute(s)
93 
        rows = r.fetchall()
94 
        r.close()
95 
        return rows
96
88 97 
    def public_path(self, public):
89 98 
        s = select([self.public.c.path])
90 99 
        s = s.where(and_(self.public.c.public_id == public,
b/pithos/backends/lib/sqlite/public.py
66 66 
            return row[0]
67 67 
        return None
68 68
69 
    def public_list(self, prefix):
70 
        q = "select path, public_id from public where path like ? escape '\\' and active = 1"
71 
        self.execute(q, (self.escape_like(prefix) + '%',))
72 
        return self.fetchall()
73
69 74 
    def public_path(self, public):
70 75 
        q = "select path from public where public_id = ? and active = 1"
71 76 
        self.execute(q, (public,))
b/pithos/backends/modular.py
423 423 
        self._report_size_change(user, account, -size, {'action': 'container delete'})
424 424
425 425 
    def _list_objects(self, user, account, container, prefix, delimiter, marker, limit, virtual, domain, keys, shared, until, size_range, all_props):
426 
        if user != account and until:
427 
            raise NotAllowedError
428 
        allowed = self._list_object_permissions(user, account, container, prefix, shared)
429 
        path, node = self._lookup_container(account, container)
430 
        allowed = self._get_formatted_paths(allowed)
431 
        return self._list_object_properties(node, path, prefix, delimiter, marker, limit, virtual, domain, keys, until, size_range, allowed, all_props)
432
433 
    def _list_object_permissions(self, user, account, container, prefix, shared):
426 434 
        allowed = []
427 435 
        if user != account:
428 
            if until:
429 
                raise NotAllowedError
430 
            allowed = self.permissions.access_list_paths(user, '/'.join((account, container)))
436 
            allowed = self.permissions.access_list_paths(user, '/'.join((account, container, prefix)))
431 437 
            if not allowed:
432 438 
                raise NotAllowedError
433 439 
        else:
434 440 
            if shared:
435 
                allowed = self.permissions.access_list_shared('/'.join((account, container)))
441 
                allowed = self.permissions.access_list_shared('/'.join((account, container, prefix)))
436 442 
                if not allowed:
437 443 
                    return []
438 
        path, node = self._lookup_container(account, container)
439 
        allowed = self._get_formatted_paths(allowed)
440 
        return self._list_object_properties(node, path, prefix, delimiter, marker, limit, virtual, domain, keys, until, size_range, allowed, all_props)
444 
        return allowed
441 445
442 446 
    @backend_method
443 447 
    def list_objects(self, user, account, container, prefix='', delimiter=None, marker=None, limit=10000, virtual=True, domain=None, keys=[], shared=False, until=None, size_range=None):
......
470 474 
        return objects
471 475
472 476 
    @backend_method
477 
    def list_object_permissions(self, user, account, container, prefix=''):
478 
        """Return a list of paths that enforce permissions under a container."""
479
480 
        logger.debug("list_object_permissions: %s %s %s", account, container, prefix)
481 
        return self._list_object_permissions(user, account, container, prefix, True)
482
483 
    @backend_method
484 
    def list_object_public(self, user, account, container, prefix=''):
485 
        """Return a dict mapping paths to public ids for objects that are public under a container."""
486
487 
        logger.debug("list_object_public: %s %s %s", account, container, prefix)
488 
        public = {}
489 
        for path, p in self.permissions.public_list('/'.join((account, container, prefix))):
490 
            public[path] = p + ULTIMATE_ANSWER
491 
        return public
492
493 
    @backend_method
473 494 
    def get_object_meta(self, user, account, container, name, domain, version=None):
474 495 
        """Return a dictionary with the object metadata for the domain."""
475 496

Also available in: Unified diff