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

Fix branch tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fetch.py
22
22
from bzrlib.tsort import topo_sort
23
23
 
24
24
from bzrlib.plugins.git import git
25
 
from bzrlib.plugins.git.repository import (
26
 
        LocalGitRepository, 
27
 
        GitRepository, 
28
 
        GitFormat,
29
 
        )
 
25
from bzrlib.plugins.git.repository import LocalGitRepository, GitRepository, GitFormat
30
26
from bzrlib.plugins.git.remote import RemoteGitRepository
31
27
 
32
 
from dulwich.client import SimpleFetchGraphWalker
33
28
from dulwich.objects import Commit
34
29
 
35
30
from cStringIO import StringIO
50
45
 
51
46
    def remove(self, revid):
52
47
        self.done.add(revid)
53
 
        if revid in self.heads:
 
48
        if ref in self.heads:
54
49
            self.heads.remove(revid)
55
50
        if revid in self.parents:
56
51
            for p in self.parents[revid]:
122
117
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
123
118
 
124
119
 
125
 
def import_git_objects(repo, mapping, num_objects, object_iter, pb=None):
 
120
def import_git_objects(repo, mapping, object_iter, pb=None):
126
121
    """Import a set of git objects into a bzr repository.
127
122
 
128
123
    :param repo: Bazaar repository
129
124
    :param mapping: Mapping to use
130
 
    :param num_objects: Number of objects.
131
125
    :param object_iter: Iterator over Git objects.
132
126
    """
133
127
    # TODO: a more (memory-)efficient implementation of this
134
128
    objects = {}
135
129
    for i, o in enumerate(object_iter):
136
130
        if pb is not None:
137
 
            pb.update("fetching objects", i, num_objects) 
 
131
            pb.update("fetching objects", i) 
138
132
        objects[o.id] = o
139
133
    graph = []
140
134
    root_trees = {}
163
157
                return objects[sha]
164
158
            return reconstruct_git_object(repo, mapping, sha)
165
159
        parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
166
 
        import_git_tree(repo, mapping, "", root_tree, inv, parent_invs, 
167
 
            lookup_object)
 
160
        import_git_tree(repo, mapping, "", root_tree, inv, parent_invs, lookup_object)
168
161
        repo.add_revision(rev.revision_id, rev, inv)
169
162
 
170
163
 
187
180
    raise KeyError("No such object %s" % sha)
188
181
 
189
182
 
190
 
class InterGitNonGitRepository(InterRepository):
 
183
class InterGitRepository(InterRepository):
191
184
 
192
185
    _matching_repo_format = GitFormat()
193
186
 
204
197
        if mapping is None:
205
198
            mapping = self.source.get_mapping()
206
199
        def progress(text):
207
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
 
200
            if pb is not None:
 
201
                pb.note("git: %s" % text)
 
202
            else:
 
203
                info("git: %s" % text)
208
204
        def determine_wants(heads):
209
205
            if revision_id is None:
210
206
                ret = heads.values()
212
208
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
213
209
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
214
210
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
215
 
        create_pb = None
216
 
        if pb is None:
217
 
            create_pb = pb = ui.ui_factory.nested_progress_bar()
 
211
        self.target.lock_write()
218
212
        try:
219
 
            self.target.lock_write()
 
213
            self.target.start_write_group()
220
214
            try:
221
 
                self.target.start_write_group()
222
 
                try:
223
 
                    (num_objects, objects_iter) = \
224
 
                            self.source.fetch_objects(determine_wants, 
225
 
                                graph_walker, progress)
226
 
                    import_git_objects(self.target, mapping, num_objects, 
227
 
                                       objects_iter, pb)
228
 
                finally:
229
 
                    self.target.commit_write_group()
 
215
                import_git_objects(self.target, mapping,
 
216
                    iter(self.source.fetch_objects(determine_wants, graph_walker, 
 
217
                        progress)), pb)
230
218
            finally:
231
 
                self.target.unlock()
 
219
                self.target.commit_write_group()
232
220
        finally:
233
 
            if create_pb:
234
 
                create_pb.finished()
 
221
            self.target.unlock()
235
222
 
236
223
    @staticmethod
237
224
    def is_compatible(source, target):
238
225
        """Be compatible with GitRepository."""
239
226
        # FIXME: Also check target uses VersionedFile
240
 
        return (isinstance(source, GitRepository) and 
241
 
                target.supports_rich_root() and
242
 
                not isinstance(target, GitRepository))
243
 
 
244
 
 
245
 
class InterGitRepository(InterRepository):
246
 
 
247
 
    _matching_repo_format = GitFormat()
248
 
 
249
 
    @staticmethod
250
 
    def _get_repo_format_to_test():
251
 
        return None
252
 
 
253
 
    def copy_content(self, revision_id=None, pb=None):
254
 
        """See InterRepository.copy_content."""
255
 
        self.fetch(revision_id, pb, find_ghosts=False)
256
 
 
257
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
258
 
              mapping=None):
259
 
        if mapping is None:
260
 
            mapping = self.source.get_mapping()
261
 
        def progress(text):
262
 
            info("git: %s", text)
263
 
        r = self.target._git
264
 
        if revision_id is None:
265
 
            determine_wants = lambda x: [y for y in x.values() if not y in r.object_store]
266
 
        else:
267
 
            args = [mapping.revision_id_bzr_to_foreign(revision_id)]
268
 
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
269
 
 
270
 
        graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
271
 
        f, commit = r.object_store.add_pack()
272
 
        try:
273
 
            self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
274
 
            f.close()
275
 
            commit()
276
 
        except:
277
 
            f.close()
278
 
            raise
279
 
 
280
 
    @staticmethod
281
 
    def is_compatible(source, target):
282
 
        """Be compatible with GitRepository."""
283
 
        return (isinstance(source, GitRepository) and 
284
 
                isinstance(target, GitRepository))
 
227
        return (isinstance(source, LocalGitRepository) and 
 
228
                target.supports_rich_root())