Revision 3a5e75cc

b/snf-pithos-backend/pithos/backends/modular.py
680 680
                )
681 681
        else:
682 682
            # remove only contents
683
            src_names = self._list_objects_no_limit(
683
            src_objects = self._list_objects_no_limit(
684 684
                user, account, container, prefix='', delimiter=None,
685 685
                virtual=False, domain=None, keys=[], shared=False, until=None,
686
                size_range=None, all_props=True, public=False)
687
            paths = []
688
            for t in src_names:
689
                path = '/'.join((account, container, t[0]))
690
                node = t[2]
691
                if not self._exists(node):
692
                    continue
693
                src_version_id, dest_version_id = self._put_version_duplicate(
694
                    user, node, size=0, type='', hash=None, checksum='',
695
                    cluster=CLUSTER_DELETED,
696
                    update_statistics_ancestors_depth=1)
697
                del_size = self._apply_versioning(
698
                    account, container, src_version_id,
699
                    update_statistics_ancestors_depth=1)
700
                self._report_size_change(
701
                    user, account, -del_size, {
702
                        'action': 'object delete',
703
                        'path': path,
704
                        'versions': ','.join([str(dest_version_id)])})
705
                self._report_object_change(
706
                    user, account, path, details={'action': 'object delete'})
707
                paths.append(path)
708
            self.permissions.access_clear_bulk(paths)
686
                size_range=None, all_props=False, public=False)
687
            for name, _ in src_objects:
688
                self._delete_object(user, account, container, name, until=None,
689
                                    delimiter=None, report_size_change=True)
709 690

  
710 691
    def _list_objects(self, user, account, container, prefix, delimiter,
711 692
                      marker, limit, virtual, domain, keys, shared, until,
......
1190 1171
        if delimiter:
1191 1172
            prefix = (src_name + delimiter if not
1192 1173
                      src_name.endswith(delimiter) else src_name)
1193
            src_names = self._list_objects_no_limit(
1174
            src_objects = self._list_objects_no_limit(
1194 1175
                user, src_account, src_container, prefix, delimiter=None,
1195 1176
                virtual=False, domain=None, keys=[], shared=False, until=None,
1196 1177
                size_range=None, all_props=True, public=False)
1197
            src_names.sort(key=lambda x: x[2])  # order by nodes
1198
            paths = [elem[0] for elem in src_names]
1199
            nodes = [elem[2] for elem in src_names]
1200
            # TODO: Will do another fetch of the properties
1201
            # in duplicate version...
1202
            props = self._get_versions(nodes)  # Check to see if source exists.
1203

  
1204
            for prop, path, node in zip(props, paths, nodes):
1205
                src_version_id = prop[self.SERIAL]
1206
                hash = prop[self.HASH]
1207
                vtype = prop[self.TYPE]
1208
                size = prop[self.SIZE]
1178

  
1179
            for props in src_objects:
1180
                path = props[0]
1181
                type = props[self.TYPE]
1209 1182
                dest_prefix = dest_name + delimiter if not dest_name.endswith(
1210 1183
                    delimiter) else dest_name
1211 1184
                vdest_name = path.replace(prefix, dest_prefix, 1)
1212
                # _update_object_hash() locks destination path
1213
                dest_version_ids.append(self._update_object_hash(
1214
                    user, dest_account, dest_container, vdest_name, size,
1215
                    vtype, hash, None, dest_domain, meta={},
1216
                    replace_meta=False, permissions=None, src_node=node,
1217
                    src_version_id=src_version_id, is_copy=is_copy,
1218
                    report_size_change=report_size_change))
1219
                if is_move and ((src_account, src_container, src_name) !=
1220
                                (dest_account, dest_container, dest_name)):
1221
                    self._delete_object(user, src_account, src_container, path,
1222
                                        report_size_change=report_size_change)
1185
                self._copy_object(user, src_account, src_container,
1186
                                  src_name=path, dest_account=dest_account,
1187
                                  dest_container=dest_container,
1188
                                  dest_name=vdest_name, type=type,
1189
                                  dest_domain=dest_domain, dest_meta=dest_meta,
1190
                                  replace_meta=replace_meta, permissions=None,
1191
                                  src_version=None, is_move=is_move,
1192
                                  delimiter=None)
1223 1193
        return (dest_version_ids[0] if len(dest_version_ids) == 1 else
1224 1194
                dest_version_ids)
1225 1195

  
......
1318 1288

  
1319 1289
        if delimiter:
1320 1290
            prefix = name + delimiter if not name.endswith(delimiter) else name
1321
            src_names = self._list_objects_no_limit(
1291
            src_objects = self._list_objects_no_limit(
1322 1292
                user, account, container, prefix, delimiter=None,
1323 1293
                virtual=False, domain=None, keys=[], shared=False, until=None,
1324
                size_range=None, all_props=True, public=False)
1325
            paths = []
1326
            for t in src_names:
1327
                path = '/'.join((account, container, t[0]))
1328
                node = t[2]
1329
                if not self._exists(node):
1330
                    continue
1331
                src_version_id, dest_version_id = self._put_version_duplicate(
1332
                    user, node, size=0, type='', hash=None, checksum='',
1333
                    cluster=CLUSTER_DELETED,
1334
                    update_statistics_ancestors_depth=1)
1335
                del_size = self._apply_versioning(
1336
                    account, container, src_version_id,
1337
                    update_statistics_ancestors_depth=1)
1338
                if report_size_change:
1339
                    self._report_size_change(
1340
                        user, account, -del_size,
1341
                        {'action': 'object delete',
1342
                         'path': path,
1343
                         'versions': ','.join([str(dest_version_id)])})
1344
                self._report_object_change(
1345
                    user, account, path, details={'action': 'object delete'})
1346
                paths.append(path)
1347
            self.permissions.access_clear_bulk(paths)
1294
                size_range=None, all_props=False, public=False)
1295
            for name, _ in src_objects:
1296
                self._delete_object(user, account, container, name, until=None,
1297
                                    delimiter=None,
1298
                                    report_size_change=report_size_change)
1348 1299

  
1349 1300
    @debug_method
1350 1301
    @backend_method

Also available in: Unified diff