/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/object_store.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/object_store.py
97
97
            return len(inv) * 250
98
98
        self.repository = repository
99
99
        self._cache = lru_cache.LRUSizeCache(max_size=MAX_TREE_CACHE_SIZE,
100
 
            after_cleanup_size=None, compute_size=approx_tree_size)
 
100
                                             after_cleanup_size=None, compute_size=approx_tree_size)
101
101
 
102
102
    def revision_tree(self, revid):
103
103
        try:
118
118
            else:
119
119
                if tree.get_revision_id() != revid:
120
120
                    raise AssertionError(
121
 
                            "revision id did not match: %s != %s" % (
122
 
                                tree.get_revision_id(), revid))
 
121
                        "revision id did not match: %s != %s" % (
 
122
                            tree.get_revision_id(), revid))
123
123
                trees[revid] = tree
124
124
        for tree in self.repository.revision_trees(todo):
125
125
            trees[tree.get_revision_id()] = tree
164
164
    if len(expected_sha) == 40:
165
165
        if expected_sha != object.sha().hexdigest().encode('ascii'):
166
166
            raise AssertionError("Invalid sha for %r: %s" % (object,
167
 
                expected_sha))
 
167
                                                             expected_sha))
168
168
    elif len(expected_sha) == 20:
169
169
        if expected_sha != object.sha().digest():
170
170
            raise AssertionError("Invalid sha for %r: %s" % (object,
171
 
                sha_to_hex(expected_sha)))
 
171
                                                             sha_to_hex(expected_sha)))
172
172
    else:
173
173
        raise AssertionError("Unknown length %d for %r" % (len(expected_sha),
174
 
            expected_sha))
 
174
                                                           expected_sha))
175
175
 
176
176
 
177
177
def directory_to_tree(path, children, lookup_ie_sha1, unusual_modes, empty_file_name,
227
227
    except IndexError:
228
228
        base_tree = tree._repository.revision_tree(NULL_REVISION)
229
229
        other_parent_trees = []
 
230
 
230
231
    def find_unchanged_parent_ie(file_id, kind, other, parent_trees):
231
232
        for ptree in parent_trees:
232
233
            try:
237
238
                pkind = ptree.kind(ppath, file_id)
238
239
                if kind == "file":
239
240
                    if (pkind == "file" and
240
 
                        ptree.get_file_sha1(ppath, file_id) == other):
 
241
                            ptree.get_file_sha1(ppath, file_id) == other):
241
242
                        return (file_id, ptree.get_file_revision(ppath, file_id))
242
243
                if kind == "symlink":
243
244
                    if (pkind == "symlink" and
244
 
                        ptree.get_symlink_target(ppath, file_id) == other):
 
245
                            ptree.get_symlink_target(ppath, file_id) == other):
245
246
                        return (file_id, ptree.get_file_revision(ppath, file_id))
246
247
        raise KeyError
247
248
 
254
255
            sha1 = tree.get_file_sha1(path[1], file_id)
255
256
            blob_id = None
256
257
            try:
257
 
                (pfile_id, prevision) = find_unchanged_parent_ie(file_id, kind[1], sha1, other_parent_trees)
 
258
                (pfile_id, prevision) = find_unchanged_parent_ie(
 
259
                    file_id, kind[1], sha1, other_parent_trees)
258
260
            except KeyError:
259
261
                pass
260
262
            else:
274
276
            else:
275
277
                shamap[path[1]] = blob_id
276
278
                if add_cache_entry is not None:
277
 
                    add_cache_entry(("blob", blob_id), (file_id, tree.get_file_revision(path[1])), path[1])
 
279
                    add_cache_entry(("blob", blob_id), (file_id,
 
280
                                                        tree.get_file_revision(path[1])), path[1])
278
281
        elif kind[1] == "symlink":
279
282
            target = tree.get_symlink_target(path[1], file_id)
280
283
            blob = symlink_to_blob(target)
281
284
            shamap[path[1]] = blob.id
282
285
            if add_cache_entry is not None:
283
 
                add_cache_entry(blob, (file_id, tree.get_file_revision(path[1])), path[1])
 
286
                add_cache_entry(
 
287
                    blob, (file_id, tree.get_file_revision(path[1])), path[1])
284
288
            try:
285
 
                find_unchanged_parent_ie(file_id, kind[1], target, other_parent_trees)
 
289
                find_unchanged_parent_ie(
 
290
                    file_id, kind[1], target, other_parent_trees)
286
291
            except KeyError:
287
292
                if changed_content:
288
293
                    yield path[1], blob, (file_id, tree.get_file_revision(path[1], file_id))
297
302
 
298
303
    # Fetch contents of the blobs that were changed
299
304
    for (path, file_id), chunks in tree.iter_files_bytes(
300
 
        [(path, (path, file_id)) for (path, file_id) in new_blobs]):
 
305
            [(path, (path, file_id)) for (path, file_id) in new_blobs]):
301
306
        obj = Blob()
302
307
        obj.chunked = chunks
303
308
        if add_cache_entry is not None:
337
342
            # Not all cache backends store the tree information,
338
343
            # calculate again from scratch
339
344
            ret = directory_to_tree(path, ie.children.values(), ie_to_hexsha,
340
 
                unusual_modes, dummy_file_name, ie.parent_id is None)
 
345
                                    unusual_modes, dummy_file_name, ie.parent_id is None)
341
346
            if ret is None:
342
347
                return ret
343
348
            return ret.id
423
428
        if self._map_updated:
424
429
            return
425
430
        if (stop_revision is not None and
426
 
            not self._missing_revisions([stop_revision])):
 
431
                not self._missing_revisions([stop_revision])):
427
432
            return
428
433
        graph = self.repository.get_graph()
429
434
        if stop_revision is None:
483
488
            except errors.NoSuchRevision:
484
489
                return None
485
490
        return self.mapping.export_commit(rev, tree_sha, parent_lookup,
486
 
            lossy, verifiers)
 
491
                                          lossy, verifiers)
487
492
 
488
493
    def _create_fileid_map_blob(self, tree):
489
494
        # FIXME: This can probably be a lot more efficient,
507
512
            [p for p in rev.parent_ids if p in present_parents])
508
513
        root_tree = None
509
514
        for path, obj, bzr_key_data in _tree_to_objects(tree, parent_trees,
510
 
                self._cache.idmap, unusual_modes,
511
 
                self.mapping.BZR_DUMMY_FILE, add_cache_entry):
 
515
                                                        self._cache.idmap, unusual_modes,
 
516
                                                        self.mapping.BZR_DUMMY_FILE, add_cache_entry):
512
517
            if path == "":
513
518
                root_tree = obj
514
519
                root_key_data = bzr_key_data
534
539
        yield "", root_tree
535
540
        if not lossy:
536
541
            testament3 = StrictTestament3(rev, tree)
537
 
            verifiers = { "testament3-sha1": testament3.as_sha1() }
 
542
            verifiers = {"testament3-sha1": testament3.as_sha1()}
538
543
        else:
539
544
            verifiers = {}
540
545
        commit_obj = self._reconstruct_commit(rev, root_tree.id,
541
 
            lossy=lossy, verifiers=verifiers)
 
546
                                              lossy=lossy, verifiers=verifiers)
542
547
        try:
543
548
            foreign_revid, mapping = mapping_registry.parse_revision_id(
544
549
                rev.revision_id)
583
588
                tree = self.tree_cache.revision_tree(revision)
584
589
                path = tree.id2path(file_id)
585
590
                if tree.kind(path, file_id) == 'symlink':
586
 
                    blob = symlink_to_blob(tree.get_symlink_target(path, file_id))
 
591
                    blob = symlink_to_blob(
 
592
                        tree.get_symlink_target(path, file_id))
587
593
            _check_expected_sha(expected_sha, blob)
588
594
            yield blob
589
595
 
590
596
    def _reconstruct_tree(self, fileid, revid, bzr_tree, unusual_modes,
591
 
        expected_sha=None):
 
597
                          expected_sha=None):
592
598
        """Return a Git Tree object from a file id and a revision stored in bzr.
593
599
 
594
600
        :param fileid: fileid in the tree.
598
604
            if entry.kind == "directory":
599
605
                try:
600
606
                    return self._cache.idmap.lookup_tree_id(entry.file_id,
601
 
                        revid)
 
607
                                                            revid)
602
608
                except (NotImplementedError, KeyError):
603
609
                    obj = self._reconstruct_tree(entry.file_id, revid, bzr_tree,
604
 
                        unusual_modes)
 
610
                                                 unusual_modes)
605
611
                    if obj is None:
606
612
                        return None
607
613
                    else:
609
615
            elif entry.kind in ("file", "symlink"):
610
616
                try:
611
617
                    return self._cache.idmap.lookup_blob_id(entry.file_id,
612
 
                        entry.revision)
 
618
                                                            entry.revision)
613
619
                except KeyError:
614
620
                    # no-change merge?
615
621
                    return next(self._reconstruct_blobs(
621
627
                raise AssertionError("unknown entry kind '%s'" % entry.kind)
622
628
        path = bzr_tree.id2path(fileid)
623
629
        tree = directory_to_tree(
624
 
                path,
625
 
                bzr_tree.iter_child_entries(path),
626
 
                get_ie_sha1, unusual_modes, self.mapping.BZR_DUMMY_FILE,
627
 
                bzr_tree.get_root_id() == fileid)
 
630
            path,
 
631
            bzr_tree.iter_child_entries(path),
 
632
            get_ie_sha1, unusual_modes, self.mapping.BZR_DUMMY_FILE,
 
633
            bzr_tree.get_root_id() == fileid)
628
634
        if (bzr_tree.get_root_id() == fileid and
629
 
            self.mapping.BZR_FILE_IDS_FILE is not None):
 
635
                self.mapping.BZR_FILE_IDS_FILE is not None):
630
636
            if tree is None:
631
637
                tree = Tree()
632
638
            b = self._create_fileid_map_blob(bzr_tree)
745
751
                    raise KeyError(sha)
746
752
                # FIXME: the type data should say whether conversion was lossless
747
753
                commit = self._reconstruct_commit(rev, tree_sha,
748
 
                    lossy=(not self.mapping.roundtripping), verifiers=verifiers)
 
754
                                                  lossy=(not self.mapping.roundtripping), verifiers=verifiers)
749
755
                _check_expected_sha(sha, commit)
750
756
                return commit
751
757
            elif kind == "blob":
759
765
                    rev = self.repository.get_revision(revid)
760
766
                except errors.NoSuchRevision:
761
767
                    trace.mutter('entry for %s %s in shamap: %r, but not found in '
762
 
                        'repository', kind, sha, type_data)
 
768
                                 'repository', kind, sha, type_data)
763
769
                    raise KeyError(sha)
764
770
                unusual_modes = extract_unusual_modes(rev)
765
771
                try:
766
772
                    return self._reconstruct_tree(fileid, revid,
767
 
                        tree, unusual_modes, expected_sha=sha)
 
773
                                                  tree, unusual_modes, expected_sha=sha)
768
774
                except errors.NoSuchRevision:
769
775
                    raise KeyError(sha)
770
776
            else:
773
779
            raise KeyError(sha)
774
780
 
775
781
    def generate_lossy_pack_data(self, have, want, progress=None,
776
 
            get_tagged=None, ofs_delta=False):
 
782
                                 get_tagged=None, ofs_delta=False):
777
783
        return pack_objects_to_data(
778
 
                self.generate_pack_contents(have, want, progress, get_tagged,
779
 
            lossy=True))
 
784
            self.generate_pack_contents(have, want, progress, get_tagged,
 
785
                                        lossy=True))
780
786
 
781
787
    def generate_pack_contents(self, have, want, progress=None,
782
 
            ofs_delta=False, get_tagged=None, lossy=False):
 
788
                               ofs_delta=False, get_tagged=None, lossy=False):
783
789
        """Iterate over the contents of a pack file.
784
790
 
785
791
        :param have: List of SHA1s of objects that should not be sent
832
838
        import os
833
839
        fd, path = tempfile.mkstemp(suffix=".pack")
834
840
        f = os.fdopen(fd, 'wb')
 
841
 
835
842
        def commit():
836
843
            from .fetch import import_git_objects
837
844
            os.fsync(fd)
839
846
            if os.path.getsize(path) == 0:
840
847
                return
841
848
            pd = PackData(path)
842
 
            pd.create_index_v2(path[:-5]+".idx", self.object_store.get_raw)
 
849
            pd.create_index_v2(path[:-5] + ".idx", self.object_store.get_raw)
843
850
 
844
851
            p = Pack(path[:-5])
845
852
            with self.repository.lock_write():
846
853
                self.repository.start_write_group()
847
854
                try:
848
855
                    import_git_objects(self.repository, self.mapping,
849
 
                        p.iterobjects(get_raw=self.get_raw),
850
 
                        self.object_store)
 
856
                                       p.iterobjects(get_raw=self.get_raw),
 
857
                                       self.object_store)
851
858
                except:
852
859
                    self.repository.abort_write_group()
853
860
                    raise