/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

More work on roundtrip push support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
push.py
1
 
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
 
1
# Copyright (C) 2009-2010 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
17
17
"""Push implementation that simply prints message saying push is not supported."""
18
18
 
19
19
from bzrlib import (
 
20
    errors,
20
21
    ui,
21
22
    )
22
23
from bzrlib.repository import (
53
54
        """
54
55
        self.source = source
55
56
        self._object_store = store
56
 
        self._revids = set()
57
 
        self._sent_shas = set()
58
57
        self._pending = []
59
58
        self.pb = pb
60
59
 
61
 
    def import_revisions(self, revids):
62
 
        self._revids.update(revids)
 
60
    def import_revisions(self, revids, roundtrip):
 
61
        """Import a set of revisions into this git repository.
 
62
 
 
63
        :param revids: Revision ids of revisions to import
 
64
        :param roundtrip: Whether to roundtrip bzr metadata
 
65
        """
63
66
        for i, revid in enumerate(revids):
64
67
            if self.pb:
65
68
                self.pb.update("pushing revisions", i, len(revids))
66
 
            git_commit = self.import_revision(revid)
 
69
            git_commit = self.import_revision(revid, roundtrip)
67
70
            yield (revid, git_commit)
68
71
 
69
 
    def need_sha(self, sha):
70
 
        if sha in self._sent_shas:
71
 
            return False
72
 
        (type, (fileid, revid)) = self._object_store._idmap.lookup_git_sha(sha)
73
 
        assert type in ("blob", "tree")
74
 
        if revid in self._revids:
75
 
            # Not sent yet, and part of the set of revisions to send
76
 
            return True
77
 
        # Not changed in the revisions to send, so either not necessary
78
 
        # or already present remotely (as git doesn't do ghosts)
79
 
        return False
80
 
 
81
 
    def queue(self, sha, obj, path, ie=None, inv=None):
82
 
        if obj is None:
83
 
            obj = (ie, inv)
84
 
        self._pending.append((obj, path))
85
 
        self._sent_shas.add(sha)
86
 
 
87
 
    def import_revision(self, revid):
88
 
        """Import the gist of a revision into this Git repository.
89
 
 
 
72
    def import_revision(self, revid, roundtrip):
 
73
        """Import a revision into this Git repository.
 
74
 
 
75
        :param revid: Revision id of the revision
 
76
        :param roundtrip: Whether to roundtrip bzr metadata
90
77
        """
91
 
        inv = self.source.get_inventory(revid)
92
 
        todo = [inv.root]
93
 
        tree_sha = None
94
 
        while todo:
95
 
            ie = todo.pop()
96
 
            (sha, object) = self._object_store._get_ie_object_or_sha1(ie, inv)
97
 
            if ie.parent_id is None:
98
 
                tree_sha = sha
99
 
            if not self.need_sha(sha):
100
 
                continue
101
 
            self.queue(sha, object, inv.id2path(ie.file_id), ie, inv)
102
 
            if ie.kind == "directory":
103
 
                todo.extend(ie.children.values())
104
 
        assert tree_sha is not None
105
 
        commit = self._object_store._get_commit(revid, tree_sha)
106
 
        self.queue(commit.id, commit, None)
 
78
        tree = self._object_store.tree_cache.revision_tree(revid)
 
79
        rev = self.source.get_revision(revid)
 
80
        commit = None
 
81
        for path, obj, ie in self._object_store._revision_to_objects(rev, tree,
 
82
            roundtrip):
 
83
            if obj.type_name == "commit":
 
84
                commit = obj
 
85
            self._pending.append((obj, path))
107
86
        return commit.id
108
87
 
109
88
    def __len__(self):
110
89
        return len(self._pending)
111
90
 
112
91
    def __iter__(self):
113
 
        for i, (object, path) in enumerate(self._pending):
114
 
            if self.pb:
115
 
                self.pb.update("writing pack objects", i, len(self))
116
 
            if isinstance(object, tuple):
117
 
                object = self._object_store._get_ie_object(*object)
118
 
            yield (object, path)   
 
92
        return iter(self._pending)
119
93
 
120
94
 
121
95
class InterToGitRepository(InterRepository):
136
110
        """See InterRepository.copy_content."""
137
111
        self.fetch(revision_id, pb, find_ghosts=False)
138
112
 
139
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
140
 
            fetch_spec=None):
141
 
        raise NoPushSupport()
 
113
    def dfetch_refs(self, update_refs):
 
114
        """Fetch non-roundtripped revisions into the target repository.
 
115
 
 
116
        :param update_refs: Generate refs to fetch. Receives dictionary
 
117
            with old names to old git shas. Should return a dictionary
 
118
            of new names to Bazaar revision ids.
 
119
        :return: revision id map, old refs dictionary and new refs dictionary
 
120
        """
 
121
        raise NotImplementedError(self.dfetch_refs)
 
122
 
 
123
    def fetch_refs(self, update_refs):
 
124
        """Fetch possibly roundtripped revisions into the target repository.
 
125
 
 
126
        :param update_refs: Generate refs to fetch. Receives dictionary
 
127
            with old refs (git shas), returns dictionary of new names to
 
128
            git shas.
 
129
        :return: old refs, new refs
 
130
        """
 
131
        raise NotImplementedError(self.fetch_refs)
142
132
 
143
133
 
144
134
class InterToLocalGitRepository(InterToGitRepository):
145
 
 
146
 
    def missing_revisions(self, stop_revisions, check_revid):
 
135
    """InterBranch implementation between a Bazaar and a Git repository."""
 
136
 
 
137
    def __init__(self, source, target):
 
138
        super(InterToLocalGitRepository, self).__init__(source, target)
 
139
        self.target_store = self.target._git.object_store
 
140
        self.target_refs = self.target._git.refs
 
141
 
 
142
    def _revision_needs_fetching(self, sha_id, revid):
 
143
        if revid == NULL_REVISION:
 
144
            return False
 
145
        if sha_id is None:
 
146
            try:
 
147
                sha_id = self.source_store._lookup_revision_sha1(revid)
 
148
            except KeyError:
 
149
                return False
 
150
        try:
 
151
            return (sha_id not in self.target_store)
 
152
        except errors.NoSuchRevision:
 
153
            # Ghost, can't push
 
154
            return False
 
155
 
 
156
    def missing_revisions(self, stop_revisions):
 
157
        """Find the revisions that are missing from the target repository.
 
158
 
 
159
        :param stop_revisions: Revisions to check for (tuples with
 
160
            Git SHA1, bzr revid)
 
161
        :return: sequence of missing revisions, in topological order
 
162
        :raise: NoSuchRevision if the stop_revisions are not present in
 
163
            the source
 
164
        """
 
165
        revid_sha_map = {}
 
166
        stop_revids = []
 
167
        stop_sha1s = []
 
168
        for (sha1, revid) in stop_revisions:
 
169
            if sha1 is not None and revid is not None:
 
170
                revid_sha_map[revid] = sha1
 
171
            elif sha1 is not None:
 
172
                stop_sha1s.append(sha1)
 
173
            else:
 
174
                assert revid is not None
 
175
                stop_revids.append(revid)
147
176
        missing = []
 
177
        graph = self.source.get_graph()
148
178
        pb = ui.ui_factory.nested_progress_bar()
149
179
        try:
150
 
            graph = self.source.get_graph()
151
 
            for revid, _ in graph.iter_ancestry(stop_revisions):
 
180
            for revid, _ in graph.iter_ancestry(stop_revids):
 
181
                assert type(revid) is str
152
182
                pb.update("determining revisions to fetch", len(missing))
153
 
                if not check_revid(revid):
 
183
                sha1 = revid_sha_map.get(revid)
 
184
                if self._revision_needs_fetching(sha1, revid):
154
185
                    missing.append(revid)
155
 
            return graph.iter_topo_order(missing)
156
186
        finally:
157
187
            pb.finished()
158
 
 
159
 
    def dfetch_refs(self, refs):
160
 
        new_refs = {}
161
 
        revidmap, gitidmap = self.dfetch(refs.values())
162
 
        for name, revid in refs.iteritems():
163
 
            if revid in gitidmap:
164
 
                gitid = gitidmap[revid]
165
 
            else:
166
 
                gitid = self.source_store._lookup_revision_sha1(revid)
167
 
            self.target._git.refs[name] = gitid
168
 
            new_refs[name] = gitid
169
 
        return revidmap, new_refs
 
188
        for sha1 in stop_sha1s:
 
189
            try:
 
190
                (kind, (revid, tree_sha, verifiers)) = self.source_store.lookup_git_sha(sha1)
 
191
            except KeyError:
 
192
                continue
 
193
            else:
 
194
                missing.append(revid)
 
195
                revid_sha_map[revid] = sha1
 
196
        return graph.iter_topo_order(missing)
 
197
 
 
198
    def _get_target_bzr_refs(self):
 
199
        """Return a dictionary with references.
 
200
 
 
201
        :return: Dictionary with reference names as keys and tuples
 
202
            with Git SHA, Bazaar revid as values.
 
203
        """
 
204
        bzr_refs = {}
 
205
        refs = self.target._git.get_refs()
 
206
        for k, v in refs.iteritems():
 
207
            try:
 
208
                (kind, type_data) = self.source_store.lookup_git_sha(v)
 
209
            except KeyError:
 
210
                revid = None
 
211
            else:
 
212
                if kind == "commit":
 
213
                    revid = type_data[0]
 
214
                else:
 
215
                    revid = None
 
216
            bzr_refs[k] = (v, revid)
 
217
        return bzr_refs
 
218
 
 
219
    def fetch_refs(self, update_refs):
 
220
        self.source.lock_read()
 
221
        try:
 
222
            old_refs = self._get_target_bzr_refs()
 
223
            new_refs = update_refs(old_refs)
 
224
            self.fetch(mapped_refs=new_refs.values())
 
225
        finally:
 
226
            self.source.unlock()
 
227
        return old_refs, new_refs
 
228
 
 
229
    def dfetch_refs(self, update_refs):
 
230
        self.source.lock_read()
 
231
        try:
 
232
            old_refs = self._get_target_bzr_refs()
 
233
            new_refs = update_refs(old_refs)
 
234
            revidmap, gitidmap = self.dfetch(new_refs.values())
 
235
            for name, (gitid, revid) in new_refs.iteritems():
 
236
                if gitid is None:
 
237
                    try:
 
238
                        gitid = gitidmap[revid]
 
239
                    except KeyError:
 
240
                        gitid = self.source_store._lookup_revision_sha1(revid)
 
241
                self.target._git.refs[name] = gitid
 
242
                new_refs[name] = (gitid, self.source_store.lookup_git_sha(gitid)[1][0])
 
243
        finally:
 
244
            self.source.unlock()
 
245
        return revidmap, old_refs, new_refs
 
246
 
 
247
    def _get_missing_objects_iterator(self, pb):
 
248
        return MissingObjectsIterator(self.source_store, self.source, pb)
170
249
 
171
250
    def dfetch(self, stop_revisions):
172
251
        """Import the gist of the ancestry of a particular revision."""
174
253
        revidmap = {}
175
254
        self.source.lock_read()
176
255
        try:
177
 
            target_store = self.target._git.object_store
178
 
            def check_revid(revid):
179
 
                if revid == NULL_REVISION:
180
 
                    return True
181
 
                return (self.source_store._lookup_revision_sha1(revid) in target_store)
182
 
            todo = list(self.missing_revisions(stop_revisions, check_revid))
 
256
            todo = list(self.missing_revisions(stop_revisions))
183
257
            pb = ui.ui_factory.nested_progress_bar()
184
258
            try:
185
 
                object_generator = MissingObjectsIterator(self.source_store, self.source, pb)
 
259
                object_generator = self._get_missing_objects_iterator(pb)
186
260
                for old_bzr_revid, git_commit in object_generator.import_revisions(
187
 
                    todo):
 
261
                    todo, roundtrip=False):
188
262
                    new_bzr_revid = self.mapping.revision_id_foreign_to_bzr(git_commit)
189
263
                    revidmap[old_bzr_revid] = new_bzr_revid
190
264
                    gitidmap[old_bzr_revid] = git_commit
191
 
                target_store.add_objects(object_generator) 
 
265
                self.target_store.add_objects(object_generator)
192
266
            finally:
193
267
                pb.finished()
194
268
        finally:
195
269
            self.source.unlock()
196
270
        return revidmap, gitidmap
197
271
 
 
272
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
273
            fetch_spec=None, mapped_refs=None):
 
274
        if mapped_refs is not None:
 
275
            stop_revisions = mapped_refs
 
276
        elif revision_id is not None:
 
277
            stop_revisions = [(None, revision_id)]
 
278
        elif fetch_spec is not None:
 
279
            stop_revisions = [(None, revid) for revid in fetch_spec.heads]
 
280
        else:
 
281
            stop_revisions = [(None, revid) for revid in self.source.all_revision_ids()]
 
282
        self.source.lock_read()
 
283
        try:
 
284
            todo = list(self.missing_revisions(stop_revisions))
 
285
            pb = ui.ui_factory.nested_progress_bar()
 
286
            try:
 
287
                object_generator = self._get_missing_objects_iterator(pb)
 
288
                for (revid, git_sha) in object_generator.import_revisions(
 
289
                    todo, roundtrip=True):
 
290
                    try:
 
291
                        self.mapping.revision_id_bzr_to_foreign(revid)
 
292
                    except errors.InvalidRevisionId:
 
293
                        self.target_refs[self.mapping.revid_as_refname(revid)] = git_sha
 
294
                self.target_store.add_objects(object_generator)
 
295
            finally:
 
296
                pb.finished()
 
297
        finally:
 
298
            self.source.unlock()
 
299
 
198
300
    @staticmethod
199
301
    def is_compatible(source, target):
200
302
        """Be compatible with GitRepository."""
201
 
        return (not isinstance(source, GitRepository) and 
 
303
        return (not isinstance(source, GitRepository) and
202
304
                isinstance(target, LocalGitRepository))
203
305
 
204
306
 
205
307
class InterToRemoteGitRepository(InterToGitRepository):
206
308
 
207
 
    def dfetch_refs(self, new_refs):
 
309
    def dfetch_refs(self, update_refs):
208
310
        """Import the gist of the ancestry of a particular revision."""
209
311
        revidmap = {}
210
 
        def determine_wants(refs):
 
312
        def determine_wants(old_refs):
211
313
            ret = {}
212
 
            for name, revid in new_refs.iteritems():
213
 
                ret[name] = self.source_store._lookup_revision_sha1(revid)
 
314
            self.old_refs = old_refs
 
315
            self.new_refs = update_refs(self.old_refs)
 
316
            for name, (gitid, revid) in self.new_refs.iteritems():
 
317
                if gitid is None:
 
318
                    ret[name] = self.source_store._lookup_revision_sha1(revid)
 
319
                else:
 
320
                    ret[name] = gitid
214
321
            return ret
215
322
        self.source.lock_read()
216
323
        try:
217
324
            new_refs = self.target.send_pack(determine_wants,
218
 
                    self.source_store.generate_pack_contents)
 
325
                    self.source_store.generate_lossy_pack_contents)
219
326
        finally:
220
327
            self.source.unlock()
221
 
        return revidmap, new_refs
 
328
        return revidmap, self.old_refs, self.new_refs
 
329
 
 
330
    def fetch_refs(self, update_refs):
 
331
        raise NoPushSupport()
222
332
 
223
333
    @staticmethod
224
334
    def is_compatible(source, target):
225
335
        """Be compatible with GitRepository."""
226
 
        return (not isinstance(source, GitRepository) and 
 
336
        return (not isinstance(source, GitRepository) and
227
337
                isinstance(target, RemoteGitRepository))