/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 converter.py

Fix tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
converter.py
1
 
# Copyright (C) 2009 Canonical Ltd
 
1
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Map from Git sha's to Bazaar objects."""
18
18
 
19
 
import bzrlib
20
 
 
21
 
from bzrlib import ui
22
 
 
23
 
from bzrlib.errors import NoSuchRevision
 
19
from dulwich.objects import (
 
20
    Blob,
 
21
    Tree,
 
22
    )
 
23
import stat
 
24
 
 
25
from bzrlib import (
 
26
    errors,
 
27
    ui,
 
28
    )
24
29
 
25
30
from bzrlib.plugins.git.mapping import (
26
 
    inventory_to_tree_and_blobs,
 
31
    directory_to_tree,
 
32
    mapping_registry,
27
33
    revision_to_commit,
28
34
    )
29
 
from bzrlib.plugins.git.shamap import GitShaMap
30
 
 
31
 
from dulwich.objects import (
32
 
    Blob,
 
35
from bzrlib.plugins.git.shamap import (
 
36
    SqliteGitShaMap,
33
37
    )
34
38
 
35
39
 
36
 
class GitObjectConverter(object):
 
40
class BazaarObjectStore(object):
 
41
    """A Git-style object store backed onto a Bazaar repository."""
37
42
 
38
43
    def __init__(self, repository, mapping=None):
39
44
        self.repository = repository
41
46
            self.mapping = self.repository.get_mapping()
42
47
        else:
43
48
            self.mapping = mapping
44
 
        self._idmap = GitShaMap(self.repository._transport)
 
49
        self._idmap = SqliteGitShaMap(self.repository._transport)
45
50
 
46
51
    def _update_sha_map(self):
47
52
        all_revids = self.repository.all_revision_ids()
48
53
        graph = self.repository.get_graph()
49
54
        present_revids = set(self._idmap.revids())
 
55
        missing_revids = [revid for revid in graph.iter_topo_order(all_revids) if revid not in present_revids]
50
56
        pb = ui.ui_factory.nested_progress_bar()
51
57
        try:
52
 
            for i, revid in enumerate(graph.iter_topo_order(all_revids)):
53
 
                if revid in present_revids:
54
 
                    continue
55
 
                pb.update("updating git map", i, len(all_revids))
 
58
            for i, revid in enumerate(missing_revids):
 
59
                pb.update("updating git map", i, len(missing_revids))
56
60
                self._update_sha_map_revision(revid)
57
61
        finally:
 
62
            self._idmap.commit()
58
63
            pb.finished()
59
64
 
60
65
    def _update_sha_map_revision(self, revid):
61
66
        inv = self.repository.get_inventory(revid)
62
 
        objects = inventory_to_tree_and_blobs(self.repository, self.mapping, revid)
63
 
        for sha, o, path in objects:
64
 
            if path == "":
65
 
                tree_sha = sha
66
 
            ie = inv[inv.path2id(path)]
67
 
            if ie.kind in ("file", "symlink"):
68
 
                self._idmap.add_entry(sha, "blob", (ie.file_id, ie.revision))
69
 
            else:
70
 
                self._idmap.add_entry(sha, "tree", (ie.file_id, ie.revision))
 
67
        tree_sha = self._get_ie_sha1(inv.root, inv)
71
68
        rev = self.repository.get_revision(revid)
72
 
        commit_obj = revision_to_commit(rev, tree_sha, self._idmap._parent_lookup)
73
 
        self._idmap.add_entry(commit_obj.sha().hexdigest(), "commit", (revid, tree_sha))
74
 
 
75
 
    def _get_blob(self, fileid, revision):
76
 
        text = self.repository.texts.get_record_stream([(fileid, revision)], "unordered", True).next().get_bytes_as("fulltext")
 
69
        commit_obj = revision_to_commit(rev, tree_sha,
 
70
            self._idmap._parent_lookup)
 
71
        try:
 
72
            foreign_revid, mapping = mapping_registry.parse_revision_id(revid)
 
73
        except errors.InvalidRevisionId:
 
74
            pass
 
75
        else:
 
76
            if foreign_revid != commit_obj.id:
 
77
                raise AssertionError("recreated git commit had different sha1: expected %s, got %s" % (foreign_revid, commit_obj.id))
 
78
        self._idmap.add_entry(commit_obj.id, "commit", (revid, tree_sha))
 
79
 
 
80
    def _check_expected_sha(self, expected_sha, object):
 
81
        if expected_sha is None:
 
82
            return
 
83
        if expected_sha != object.id:
 
84
            raise AssertionError("Invalid sha for %r: %s" % (object, expected_sha))
 
85
 
 
86
    def _get_ie_sha1(self, entry, inv):
 
87
        if entry.kind == "directory":
 
88
            try:
 
89
                ret = self._idmap.lookup_tree(entry.file_id, inv.revision_id)
 
90
            except KeyError:
 
91
                ret = self._get_tree(entry.file_id, inv.revision_id, 
 
92
                    inv=inv).id
 
93
                self._idmap.add_entry(ret, "tree", (entry.file_id, inv.revision_id))
 
94
                return ret
 
95
        else:
 
96
            try:
 
97
                return self._idmap.lookup_blob(entry.file_id, entry.revision)
 
98
            except KeyError:
 
99
                ret = self._get_blob(entry.file_id, entry.revision).id
 
100
                self._idmap.add_entry(ret, "blob", (entry.file_id, entry.revision))
 
101
                return ret
 
102
 
 
103
    def _get_blob(self, fileid, revision, expected_sha=None):
 
104
        """Return a Git Blob object from a fileid and revision stored in bzr.
 
105
        
 
106
        :param fileid: File id of the text
 
107
        :param revision: Revision of the text
 
108
        """
 
109
        text = self.repository.texts.get_record_stream([(fileid, revision)],
 
110
            "unordered", True).next().get_bytes_as("fulltext")
77
111
        blob = Blob()
78
112
        blob._text = text
 
113
        self._check_expected_sha(expected_sha, blob)
79
114
        return blob
80
115
 
81
 
    def _get_tree(self, fileid, revid):
82
 
        raise NotImplementedError(self._get_tree)
83
 
 
84
 
    def _get_commit(self, revid, tree_sha):
 
116
    def _get_tree(self, fileid, revid, inv=None, expected_sha=None):
 
117
        """Return a Git Tree object from a file id and a revision stored in bzr.
 
118
 
 
119
        :param fileid: fileid in the tree.
 
120
        :param revision: Revision of the tree.
 
121
        """
 
122
        if inv is None:
 
123
            inv = self.repository.get_inventory(revid)
 
124
        tree = directory_to_tree(inv[fileid], lambda ie: self._get_ie_sha1(ie, inv))
 
125
        self._check_expected_sha(expected_sha, tree)
 
126
        return tree
 
127
 
 
128
    def _get_commit(self, revid, tree_sha, expected_sha=None):
85
129
        rev = self.repository.get_revision(revid)
86
 
        return revision_to_commit(rev, tree_sha, self._idmap._parent_lookup)
 
130
        commit = revision_to_commit(rev, tree_sha, self._idmap._parent_lookup)
 
131
        self._check_expected_sha(expected_sha, commit)
 
132
        return commit
 
133
 
 
134
    def get_raw(self, sha):
 
135
        return self[sha]._text
87
136
 
88
137
    def __getitem__(self, sha):
89
138
        # See if sha is in map
96
145
            (type, type_data) = self._idmap.lookup_git_sha(sha)
97
146
        # convert object to git object
98
147
        if type == "commit":
99
 
            return self._get_commit(*type_data)
 
148
            return self._get_commit(type_data[0], type_data[1], 
 
149
                                    expected_sha=sha)
100
150
        elif type == "blob":
101
 
            return self._get_blob(*type_data)
 
151
            return self._get_blob(type_data[0], type_data[1], expected_sha=sha)
102
152
        elif type == "tree":
103
 
            return self._get_tree(*type_data)
 
153
            return self._get_tree(type_data[0], type_data[1], expected_sha=sha)
104
154
        else:
105
155
            raise AssertionError("Unknown object type '%s'" % type)