/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:59:44 UTC
  • mfrom: (7143.15.15 more-cleanups)
  • Revision ID: breezy.the.bot@gmail.com-20181116185944-biefv1sub37qfybm
Sprinkle some PEP8iness.

Merged from https://code.launchpad.net/~jelmer/brz/more-cleanups/+merge/358611

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/object_store.py
47
47
    NULL_REVISION,
48
48
    )
49
49
from ..sixish import viewitems
50
 
from ..testament import(
 
50
from ..testament import (
51
51
    StrictTestament3,
52
52
    )
53
53
 
96
96
                inv = tree.inventory
97
97
            return len(inv) * 250
98
98
        self.repository = repository
99
 
        self._cache = lru_cache.LRUSizeCache(max_size=MAX_TREE_CACHE_SIZE,
100
 
            after_cleanup_size=None, compute_size=approx_tree_size)
 
99
        self._cache = lru_cache.LRUSizeCache(
 
100
            max_size=MAX_TREE_CACHE_SIZE, after_cleanup_size=None,
 
101
            compute_size=approx_tree_size)
101
102
 
102
103
    def revision_tree(self, revid):
103
104
        try:
118
119
            else:
119
120
                if tree.get_revision_id() != revid:
120
121
                    raise AssertionError(
121
 
                            "revision id did not match: %s != %s" % (
122
 
                                tree.get_revision_id(), revid))
 
122
                        "revision id did not match: %s != %s" % (
 
123
                            tree.get_revision_id(), revid))
123
124
                trees[revid] = tree
124
125
        for tree in self.repository.revision_trees(todo):
125
126
            trees[tree.get_revision_id()] = tree
164
165
    if len(expected_sha) == 40:
165
166
        if expected_sha != object.sha().hexdigest().encode('ascii'):
166
167
            raise AssertionError("Invalid sha for %r: %s" % (object,
167
 
                expected_sha))
 
168
                                                             expected_sha))
168
169
    elif len(expected_sha) == 20:
169
170
        if expected_sha != object.sha().digest():
170
 
            raise AssertionError("Invalid sha for %r: %s" % (object,
171
 
                sha_to_hex(expected_sha)))
 
171
            raise AssertionError("Invalid sha for %r: %s" % (
 
172
                object, sha_to_hex(expected_sha)))
172
173
    else:
173
174
        raise AssertionError("Unknown length %d for %r" % (len(expected_sha),
174
 
            expected_sha))
175
 
 
176
 
 
177
 
def directory_to_tree(path, children, lookup_ie_sha1, unusual_modes, empty_file_name,
178
 
                      allow_empty=False):
 
175
                                                           expected_sha))
 
176
 
 
177
 
 
178
def directory_to_tree(path, children, lookup_ie_sha1, unusual_modes,
 
179
                      empty_file_name, allow_empty=False):
179
180
    """Create a Git Tree object from a Bazaar directory.
180
181
 
181
182
    :param path: directory path
219
220
    """
220
221
    dirty_dirs = set()
221
222
    new_blobs = []
222
 
    new_contents = {}
223
223
    shamap = {}
224
224
    try:
225
225
        base_tree = parent_trees[0]
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
 
                        return (file_id, ptree.get_file_revision(ppath, file_id))
 
241
                            ptree.get_file_sha1(ppath, file_id) == other):
 
242
                        return (
 
243
                            file_id, ptree.get_file_revision(ppath, file_id))
242
244
                if kind == "symlink":
243
245
                    if (pkind == "symlink" and
244
 
                        ptree.get_symlink_target(ppath, file_id) == other):
245
 
                        return (file_id, ptree.get_file_revision(ppath, file_id))
 
246
                            ptree.get_symlink_target(ppath, file_id) == other):
 
247
                        return (
 
248
                            file_id, ptree.get_file_revision(ppath, file_id))
246
249
        raise KeyError
247
250
 
248
251
    # Find all the changed blobs
254
257
            sha1 = tree.get_file_sha1(path[1], file_id)
255
258
            blob_id = None
256
259
            try:
257
 
                (pfile_id, prevision) = find_unchanged_parent_ie(file_id, kind[1], sha1, other_parent_trees)
 
260
                (pfile_id, prevision) = find_unchanged_parent_ie(
 
261
                    file_id, kind[1], sha1, other_parent_trees)
258
262
            except KeyError:
259
263
                pass
260
264
            else:
274
278
            else:
275
279
                shamap[path[1]] = blob_id
276
280
                if add_cache_entry is not None:
277
 
                    add_cache_entry(("blob", blob_id), (file_id, tree.get_file_revision(path[1])), path[1])
 
281
                    add_cache_entry(
 
282
                        ("blob", blob_id),
 
283
                        (file_id, tree.get_file_revision(path[1])), path[1])
278
284
        elif kind[1] == "symlink":
279
285
            target = tree.get_symlink_target(path[1], file_id)
280
286
            blob = symlink_to_blob(target)
281
287
            shamap[path[1]] = blob.id
282
288
            if add_cache_entry is not None:
283
 
                add_cache_entry(blob, (file_id, tree.get_file_revision(path[1])), path[1])
 
289
                add_cache_entry(
 
290
                    blob, (file_id, tree.get_file_revision(path[1])), path[1])
284
291
            try:
285
 
                find_unchanged_parent_ie(file_id, kind[1], target, other_parent_trees)
 
292
                find_unchanged_parent_ie(
 
293
                    file_id, kind[1], target, other_parent_trees)
286
294
            except KeyError:
287
295
                if changed_content:
288
 
                    yield path[1], blob, (file_id, tree.get_file_revision(path[1], file_id))
 
296
                    yield (path[1], blob,
 
297
                           (file_id, tree.get_file_revision(path[1], file_id)))
289
298
        elif kind[1] is None:
290
299
            shamap[path[1]] = None
291
300
        elif kind[1] != 'directory':
297
306
 
298
307
    # Fetch contents of the blobs that were changed
299
308
    for (path, file_id), chunks in tree.iter_files_bytes(
300
 
        [(path, (path, file_id)) for (path, file_id) in new_blobs]):
 
309
            [(path, (path, file_id)) for (path, file_id) in new_blobs]):
301
310
        obj = Blob()
302
311
        obj.chunked = chunks
303
312
        if add_cache_entry is not None:
336
345
        elif ie.kind == "directory":
337
346
            # Not all cache backends store the tree information,
338
347
            # calculate again from scratch
339
 
            ret = directory_to_tree(path, ie.children.values(), ie_to_hexsha,
340
 
                unusual_modes, dummy_file_name, ie.parent_id is None)
 
348
            ret = directory_to_tree(
 
349
                path, ie.children.values(), ie_to_hexsha, unusual_modes,
 
350
                dummy_file_name, ie.parent_id is None)
341
351
            if ret is None:
342
352
                return ret
343
353
            return ret.id
423
433
        if self._map_updated:
424
434
            return
425
435
        if (stop_revision is not None and
426
 
            not self._missing_revisions([stop_revision])):
 
436
                not self._missing_revisions([stop_revision])):
427
437
            return
428
438
        graph = self.repository.get_graph()
429
439
        if stop_revision is None:
450
460
        try:
451
461
            pb = ui.ui_factory.nested_progress_bar()
452
462
            try:
453
 
                for i, revid in enumerate(graph.iter_topo_order(missing_revids)):
 
463
                for i, revid in enumerate(graph.iter_topo_order(
 
464
                        missing_revids)):
454
465
                    trace.mutter('processing %r', revid)
455
466
                    pb.update("updating git map", i, len(missing_revids))
456
467
                    self._update_sha_map_revision(revid)
458
469
                pb.finished()
459
470
            if stop_revision is None:
460
471
                self._map_updated = True
461
 
        except:
 
472
        except BaseException:
462
473
            self.abort_write_group()
463
474
            raise
464
475
        else:
483
494
            except errors.NoSuchRevision:
484
495
                return None
485
496
        return self.mapping.export_commit(rev, tree_sha, parent_lookup,
486
 
            lossy, verifiers)
 
497
                                          lossy, verifiers)
487
498
 
488
499
    def _create_fileid_map_blob(self, tree):
489
500
        # FIXME: This can probably be a lot more efficient,
506
517
        parent_trees = self.tree_cache.revision_trees(
507
518
            [p for p in rev.parent_ids if p in present_parents])
508
519
        root_tree = None
509
 
        for path, obj, bzr_key_data in _tree_to_objects(tree, parent_trees,
510
 
                self._cache.idmap, unusual_modes,
 
520
        for path, obj, bzr_key_data in _tree_to_objects(
 
521
                tree, parent_trees, self._cache.idmap, unusual_modes,
511
522
                self.mapping.BZR_DUMMY_FILE, add_cache_entry):
512
523
            if path == "":
513
524
                root_tree = obj
534
545
        yield "", root_tree
535
546
        if not lossy:
536
547
            testament3 = StrictTestament3(rev, tree)
537
 
            verifiers = { "testament3-sha1": testament3.as_sha1() }
 
548
            verifiers = {"testament3-sha1": testament3.as_sha1()}
538
549
        else:
539
550
            verifiers = {}
540
551
        commit_obj = self._reconstruct_commit(rev, root_tree.id,
541
 
            lossy=lossy, verifiers=verifiers)
 
552
                                              lossy=lossy, verifiers=verifiers)
542
553
        try:
543
554
            foreign_revid, mapping = mapping_registry.parse_revision_id(
544
555
                rev.revision_id)
583
594
                tree = self.tree_cache.revision_tree(revision)
584
595
                path = tree.id2path(file_id)
585
596
                if tree.kind(path, file_id) == 'symlink':
586
 
                    blob = symlink_to_blob(tree.get_symlink_target(path, file_id))
 
597
                    blob = symlink_to_blob(
 
598
                        tree.get_symlink_target(path, file_id))
587
599
            _check_expected_sha(expected_sha, blob)
588
600
            yield blob
589
601
 
590
602
    def _reconstruct_tree(self, fileid, revid, bzr_tree, unusual_modes,
591
 
        expected_sha=None):
 
603
                          expected_sha=None):
592
604
        """Return a Git Tree object from a file id and a revision stored in bzr.
593
605
 
594
606
        :param fileid: fileid in the tree.
598
610
            if entry.kind == "directory":
599
611
                try:
600
612
                    return self._cache.idmap.lookup_tree_id(entry.file_id,
601
 
                        revid)
 
613
                                                            revid)
602
614
                except (NotImplementedError, KeyError):
603
 
                    obj = self._reconstruct_tree(entry.file_id, revid, bzr_tree,
604
 
                        unusual_modes)
 
615
                    obj = self._reconstruct_tree(
 
616
                        entry.file_id, revid, bzr_tree, unusual_modes)
605
617
                    if obj is None:
606
618
                        return None
607
619
                    else:
609
621
            elif entry.kind in ("file", "symlink"):
610
622
                try:
611
623
                    return self._cache.idmap.lookup_blob_id(entry.file_id,
612
 
                        entry.revision)
 
624
                                                            entry.revision)
613
625
                except KeyError:
614
626
                    # no-change merge?
615
627
                    return next(self._reconstruct_blobs(
621
633
                raise AssertionError("unknown entry kind '%s'" % entry.kind)
622
634
        path = bzr_tree.id2path(fileid)
623
635
        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)
 
636
            path,
 
637
            bzr_tree.iter_child_entries(path),
 
638
            get_ie_sha1, unusual_modes, self.mapping.BZR_DUMMY_FILE,
 
639
            bzr_tree.get_root_id() == fileid)
628
640
        if (bzr_tree.get_root_id() == fileid and
629
 
            self.mapping.BZR_FILE_IDS_FILE is not None):
 
641
                self.mapping.BZR_FILE_IDS_FILE is not None):
630
642
            if tree is None:
631
643
                tree = Tree()
632
644
            b = self._create_fileid_map_blob(bzr_tree)
743
755
                    trace.mutter('entry for %s %s in shamap: %r, but not '
744
756
                                 'found in repository', kind, sha, type_data)
745
757
                    raise KeyError(sha)
746
 
                # FIXME: the type data should say whether conversion was lossless
747
 
                commit = self._reconstruct_commit(rev, tree_sha,
748
 
                    lossy=(not self.mapping.roundtripping), verifiers=verifiers)
 
758
                # FIXME: the type data should say whether conversion was
 
759
                # lossless
 
760
                commit = self._reconstruct_commit(
 
761
                    rev, tree_sha, lossy=(not self.mapping.roundtripping),
 
762
                    verifiers=verifiers)
749
763
                _check_expected_sha(sha, commit)
750
764
                return commit
751
765
            elif kind == "blob":
758
772
                    tree = self.tree_cache.revision_tree(revid)
759
773
                    rev = self.repository.get_revision(revid)
760
774
                except errors.NoSuchRevision:
761
 
                    trace.mutter('entry for %s %s in shamap: %r, but not found in '
 
775
                    trace.mutter(
 
776
                        'entry for %s %s in shamap: %r, but not found in '
762
777
                        'repository', kind, sha, type_data)
763
778
                    raise KeyError(sha)
764
779
                unusual_modes = extract_unusual_modes(rev)
765
780
                try:
766
 
                    return self._reconstruct_tree(fileid, revid,
767
 
                        tree, unusual_modes, expected_sha=sha)
 
781
                    return self._reconstruct_tree(
 
782
                        fileid, revid, tree, unusual_modes, expected_sha=sha)
768
783
                except errors.NoSuchRevision:
769
784
                    raise KeyError(sha)
770
785
            else:
773
788
            raise KeyError(sha)
774
789
 
775
790
    def generate_lossy_pack_data(self, have, want, progress=None,
776
 
            get_tagged=None, ofs_delta=False):
 
791
                                 get_tagged=None, ofs_delta=False):
777
792
        return pack_objects_to_data(
778
 
                self.generate_pack_contents(have, want, progress, get_tagged,
779
 
            lossy=True))
 
793
            self.generate_pack_contents(have, want, progress, get_tagged,
 
794
                                        lossy=True))
780
795
 
781
796
    def generate_pack_contents(self, have, want, progress=None,
782
 
            ofs_delta=False, get_tagged=None, lossy=False):
 
797
                               ofs_delta=False, get_tagged=None, lossy=False):
783
798
        """Iterate over the contents of a pack file.
784
799
 
785
800
        :param have: List of SHA1s of objects that should not be sent
832
847
        import os
833
848
        fd, path = tempfile.mkstemp(suffix=".pack")
834
849
        f = os.fdopen(fd, 'wb')
 
850
 
835
851
        def commit():
836
852
            from .fetch import import_git_objects
837
853
            os.fsync(fd)
839
855
            if os.path.getsize(path) == 0:
840
856
                return
841
857
            pd = PackData(path)
842
 
            pd.create_index_v2(path[:-5]+".idx", self.object_store.get_raw)
 
858
            pd.create_index_v2(path[:-5] + ".idx", self.object_store.get_raw)
843
859
 
844
860
            p = Pack(path[:-5])
845
861
            with self.repository.lock_write():
846
862
                self.repository.start_write_group()
847
863
                try:
848
864
                    import_git_objects(self.repository, self.mapping,
849
 
                        p.iterobjects(get_raw=self.get_raw),
850
 
                        self.object_store)
851
 
                except:
 
865
                                       p.iterobjects(get_raw=self.get_raw),
 
866
                                       self.object_store)
 
867
                except BaseException:
852
868
                    self.repository.abort_write_group()
853
869
                    raise
854
870
                else: