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

Rely less on command-line git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
push.py
16
16
 
17
17
"""Push implementation that simply prints message saying push is not supported."""
18
18
 
 
19
from dulwich.client import (
 
20
    SimpleFetchGraphWalker,
 
21
    )
 
22
from dulwich.repo import (
 
23
    MissingObjectFinder,
 
24
    )
 
25
 
19
26
from bzrlib import (
20
27
    ui,
21
28
    )
26
33
    NULL_REVISION,
27
34
    )
28
35
 
 
36
from bzrlib.plugins.git.converter import (
 
37
    BazaarObjectStore,
 
38
    )
29
39
from bzrlib.plugins.git.errors import (
30
40
    NoPushSupport,
31
41
    )
32
 
from bzrlib.plugins.git.mapping import (
33
 
    extract_unusual_modes,
34
 
    )
35
 
from bzrlib.plugins.git.object_store import (
36
 
    BazaarObjectStore,
37
 
    )
38
42
from bzrlib.plugins.git.repository import (
39
43
    GitRepository,
40
44
    LocalGitRepository,
50
54
 
51
55
    """
52
56
 
53
 
    def __init__(self, store, source, pb=None):
 
57
    def __init__(self, source, mapping, pb=None):
54
58
        """Create a new missing objects iterator.
55
59
 
56
60
        """
57
61
        self.source = source
58
 
        self._object_store = store
 
62
        self._object_store = BazaarObjectStore(self.source, mapping)
59
63
        self._revids = set()
60
64
        self._sent_shas = set()
61
65
        self._pending = []
92
96
 
93
97
        """
94
98
        inv = self.source.get_inventory(revid)
95
 
        rev = self.source.get_revision(revid)
96
 
        unusual_modes = extract_unusual_modes(rev)
97
99
        todo = [inv.root]
98
100
        tree_sha = None
99
101
        while todo:
100
102
            ie = todo.pop()
101
 
            (sha, object) = self._object_store._get_ie_object_or_sha1(ie, inv, unusual_modes)
 
103
            (sha, object) = self._object_store._get_ie_object_or_sha1(ie, inv)
102
104
            if ie.parent_id is None:
103
105
                tree_sha = sha
104
106
            if not self.need_sha(sha):
107
109
            if ie.kind == "directory":
108
110
                todo.extend(ie.children.values())
109
111
        assert tree_sha is not None
110
 
        commit = self._object_store._get_commit(rev, tree_sha)
 
112
        commit = self._object_store._get_commit(revid, tree_sha)
111
113
        self.queue(commit.id, commit, None)
112
114
        return commit.id
113
115
 
131
133
    def __init__(self, source, target):
132
134
        super(InterToGitRepository, self).__init__(source, target)
133
135
        self.mapping = self.target.get_mapping()
134
 
        self.source_store = BazaarObjectStore(self.source, self.mapping)
135
136
 
136
137
    @staticmethod
137
138
    def _get_repo_format_to_test():
148
149
 
149
150
class InterToLocalGitRepository(InterToGitRepository):
150
151
 
151
 
    def missing_revisions(self, stop_revisions, check_revid):
 
152
    def missing_revisions(self, stop_revision):
 
153
        if stop_revision is None:
 
154
            raise NotImplementedError
152
155
        missing = []
153
156
        pb = ui.ui_factory.nested_progress_bar()
154
157
        try:
155
158
            graph = self.source.get_graph()
156
 
            for revid, _ in graph.iter_ancestry(stop_revisions):
 
159
            for revid, _ in graph.iter_ancestry([stop_revision]):
157
160
                pb.update("determining revisions to fetch", len(missing))
158
 
                if not check_revid(revid):
 
161
                if not self.target.has_revision(revid):
159
162
                    missing.append(revid)
160
163
            return graph.iter_topo_order(missing)
161
164
        finally:
162
165
            pb.finished()
163
166
 
164
167
    def dfetch_refs(self, refs):
 
168
        revidmap = {}
165
169
        new_refs = {}
166
 
        revidmap, gitidmap = self.dfetch(refs.values())
167
170
        for name, revid in refs.iteritems():
168
 
            if revid in gitidmap:
169
 
                gitid = gitidmap[revid]
 
171
            newrevidmap, newgitidmap = self.dfetch(revid)
 
172
            revidmap.update(newrevidmap)
 
173
            if revid in newgitidmap:
 
174
                gitid = newgitidmap[revid]
170
175
            else:
171
 
                gitid = self.source_store._lookup_revision_sha1(revid)
172
 
            self.target._git.refs[name] = gitid
 
176
                gitid, _ = self.mapping.revision_id_bzr_to_foreign(revid)
 
177
            self.target._git.set_ref(name, gitid)
173
178
            new_refs[name] = gitid
174
179
        return revidmap, new_refs
175
180
 
176
 
    def dfetch(self, stop_revisions):
 
181
    def dfetch(self, stop_revision=None):
177
182
        """Import the gist of the ancestry of a particular revision."""
178
183
        gitidmap = {}
179
184
        revidmap = {}
180
185
        self.source.lock_read()
181
186
        try:
182
 
            target_store = self.target._git.object_store
183
 
            def check_revid(revid):
184
 
                if revid == NULL_REVISION:
185
 
                    return True
186
 
                return (self.source_store._lookup_revision_sha1(revid) in target_store)
187
 
            todo = list(self.missing_revisions(stop_revisions, check_revid))
 
187
            todo = [revid for revid in self.missing_revisions(stop_revision) if revid != NULL_REVISION]
188
188
            pb = ui.ui_factory.nested_progress_bar()
189
189
            try:
190
 
                object_generator = MissingObjectsIterator(self.source_store, self.source, pb)
 
190
                object_generator = MissingObjectsIterator(self.source, self.mapping, pb)
191
191
                for old_bzr_revid, git_commit in object_generator.import_revisions(
192
192
                    todo):
193
193
                    new_bzr_revid = self.mapping.revision_id_foreign_to_bzr(git_commit)
194
194
                    revidmap[old_bzr_revid] = new_bzr_revid
195
195
                    gitidmap[old_bzr_revid] = git_commit
196
 
                target_store.add_objects(object_generator) 
 
196
                self.target._git.object_store.add_objects(object_generator) 
197
197
            finally:
198
198
                pb.finished()
199
199
        finally:
212
212
    def dfetch_refs(self, new_refs):
213
213
        """Import the gist of the ancestry of a particular revision."""
214
214
        revidmap = {}
215
 
        def determine_wants(refs):
 
215
        def get_changed_refs(refs):
216
216
            ret = {}
217
217
            for name, revid in new_refs.iteritems():
218
 
                ret[name] = self.source_store._lookup_revision_sha1(revid)
 
218
                ret[name] = store._lookup_revision_sha1(revid)
219
219
            return ret
220
220
        self.source.lock_read()
221
221
        try:
222
 
            new_refs = self.target.send_pack(determine_wants,
223
 
                    self.source_store.generate_pack_contents)
 
222
            store = BazaarObjectStore(self.source, self.mapping)
 
223
            def generate_blob_contents(have, want):
 
224
                graphwalker = SimpleFetchGraphWalker(have, store.get_parents)
 
225
                objfinder = MissingObjectFinder(store, want, graphwalker)
 
226
                return store.iter_shas(iter(objfinder.next, None))
 
227
            new_refs = self.target.send_pack(get_changed_refs, generate_blob_contents)
224
228
        finally:
225
229
            self.source.unlock()
226
230
        return revidmap, new_refs