/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 some bit of fetching.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fetch.py
1
 
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
 
1
# Copyright (C) 2008 Canonical Ltd
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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from cStringIO import StringIO
18
 
import dulwich as git
19
 
from dulwich.client import SimpleFetchGraphWalker
20
 
from dulwich.objects import Commit
21
 
 
22
 
from bzrlib import (
23
 
    osutils,
24
 
    ui,
25
 
    urlutils,
26
 
    )
27
 
from bzrlib.errors import (
28
 
    InvalidRevisionId,
29
 
    NoSuchRevision,
30
 
    )
 
17
from bzrlib import osutils, urlutils
 
18
from bzrlib.errors import InvalidRevisionId
31
19
from bzrlib.inventory import Inventory
32
20
from bzrlib.repository import InterRepository
33
21
from bzrlib.trace import info
34
 
from bzrlib.tsort import topo_sort
35
22
 
36
 
from bzrlib.plugins.git.repository import (
37
 
        LocalGitRepository, 
38
 
        GitRepository, 
39
 
        GitFormat,
40
 
        )
41
 
from bzrlib.plugins.git.converter import GitObjectConverter
 
23
from bzrlib.plugins.git import git
 
24
from bzrlib.plugins.git.repository import LocalGitRepository, GitRepository, GitFormat
42
25
from bzrlib.plugins.git.remote import RemoteGitRepository
43
26
 
 
27
from dulwich.objects import Commit
 
28
 
 
29
from cStringIO import StringIO
44
30
 
45
31
 
46
32
class BzrFetchGraphWalker(object):
47
 
    """GraphWalker implementation that uses a Bazaar repository."""
48
33
 
49
34
    def __init__(self, repository, mapping):
50
35
        self.repository = repository
53
38
        self.heads = set(repository.all_revision_ids())
54
39
        self.parents = {}
55
40
 
56
 
    def __iter__(self):
57
 
        return iter(self.next, None)
58
 
 
59
41
    def ack(self, sha):
60
42
        revid = self.mapping.revision_id_foreign_to_bzr(sha)
61
43
        self.remove(revid)
62
44
 
63
45
    def remove(self, revid):
64
46
        self.done.add(revid)
65
 
        if revid in self.heads:
 
47
        if ref in self.heads:
66
48
            self.heads.remove(revid)
67
49
        if revid in self.parents:
68
50
            for p in self.parents[revid]:
76
58
            self.heads.update([p for p in ps if not p in self.done])
77
59
            try:
78
60
                self.done.add(ret)
79
 
                return self.mapping.revision_id_bzr_to_foreign(ret)[0]
 
61
                return self.mapping.revision_id_bzr_to_foreign(ret)
80
62
            except InvalidRevisionId:
81
63
                pass
82
64
        return None
83
65
 
84
66
 
85
 
def import_git_blob(repo, mapping, path, blob, inv, parent_invs, gitmap, executable):
 
67
def import_git_blob(repo, mapping, path, blob, inv):
86
68
    """Import a git blob object into a bzr repository.
87
69
 
88
70
    :param repo: bzr repository
90
72
    :param blob: A git blob
91
73
    """
92
74
    file_id = mapping.generate_file_id(path)
93
 
    text_revision = inv.revision_id
94
 
    repo.texts.add_lines((file_id, text_revision),
95
 
        [(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
 
75
    repo.texts.add_lines((file_id, blob.id),
 
76
        [], #FIXME 
96
77
        osutils.split_lines(blob.data))
97
78
    ie = inv.add_path(path, "file", file_id)
98
 
    ie.revision = text_revision
99
 
    ie.text_size = len(blob.data)
100
 
    ie.text_sha1 = osutils.sha_string(blob.data)
101
 
    ie.executable = executable
102
 
    gitmap._idmap.add_entry(blob.sha().hexdigest(), "blob", (ie.file_id, ie.revision))
103
 
 
104
 
 
105
 
def import_git_tree(repo, mapping, path, tree, inv, parent_invs, 
106
 
                    gitmap, lookup_object):
 
79
 
 
80
 
 
81
def import_git_tree(repo, mapping, path, tree, inv, lookup_object):
107
82
    """Import a git tree object into a bzr repository.
108
83
 
109
84
    :param repo: A Bzr repository object
112
87
    :param inv: Inventory object
113
88
    """
114
89
    file_id = mapping.generate_file_id(path)
115
 
    text_revision = inv.revision_id
116
 
    repo.texts.add_lines((file_id, text_revision),
117
 
        [(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
 
90
    repo.texts.add_lines((file_id, tree.id),
 
91
        [], #FIXME 
118
92
        [])
119
 
    ie = inv.add_path(path, "directory", file_id)
120
 
    ie.revision = text_revision
121
 
    gitmap._idmap.add_entry(tree.sha().hexdigest(), "tree", (file_id, text_revision))
 
93
    inv.add_path(path, "directory", file_id)
122
94
    for mode, name, hexsha in tree.entries():
123
95
        entry_kind = (mode & 0700000) / 0100000
124
96
        basename = name.decode("utf-8")
128
100
            child_path = urlutils.join(path, name)
129
101
        if entry_kind == 0:
130
102
            tree = lookup_object(hexsha)
131
 
            import_git_tree(repo, mapping, child_path, tree, inv, parent_invs, gitmap, lookup_object)
 
103
            import_git_tree(repo, mapping, child_path, tree, inv, lookup_object)
132
104
        elif entry_kind == 1:
133
105
            blob = lookup_object(hexsha)
134
 
            fs_mode = mode & 0777
135
 
            import_git_blob(repo, mapping, child_path, blob, inv, parent_invs, gitmap, bool(fs_mode & 0111))
 
106
            import_git_blob(repo, mapping, child_path, blob, inv)
136
107
        else:
137
108
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
138
109
 
139
110
 
140
 
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever, 
141
 
        pb=None):
 
111
def import_git_objects(repo, mapping, object_iter):
142
112
    """Import a set of git objects into a bzr repository.
143
113
 
144
114
    :param repo: Bazaar repository
146
116
    :param object_iter: Iterator over Git objects.
147
117
    """
148
118
    # TODO: a more (memory-)efficient implementation of this
149
 
    graph = []
 
119
    objects = {}
 
120
    for o in object_iter:
 
121
        objects[o.id] = o
150
122
    root_trees = {}
151
 
    revisions = {}
152
123
    # Find and convert commit objects
153
 
    for o in object_iter.iterobjects():
 
124
    for o in objects.itervalues():
154
125
        if isinstance(o, Commit):
155
126
            rev = mapping.import_commit(o)
156
 
            root_trees[rev.revision_id] = object_iter[o.tree]
157
 
            revisions[rev.revision_id] = rev
158
 
            graph.append((rev.revision_id, rev.parent_ids))
159
 
            target_git_object_retriever._idmap.add_entry(o.sha().hexdigest(), "commit", (rev.revision_id, o._tree))
160
 
    # Order the revisions
 
127
            root_trees[rev] = objects[o.tree]
161
128
    # Create the inventory objects
162
 
    for i, revid in enumerate(topo_sort(graph)):
163
 
        if pb is not None:
164
 
            pb.update("fetching revisions", i, len(graph))
165
 
        root_tree = root_trees[revid]
166
 
        rev = revisions[revid]
 
129
    for rev, root_tree in root_trees.iteritems():
167
130
        # We have to do this here, since we have to walk the tree and 
168
131
        # we need to make sure to import the blobs / trees with the riht 
169
132
        # path; this may involve adding them more than once.
170
133
        inv = Inventory()
171
134
        inv.revision_id = rev.revision_id
172
135
        def lookup_object(sha):
173
 
            if sha in object_iter:
174
 
                return object_iter[sha]
175
 
            return target_git_object_retriever[sha]
176
 
        parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
177
 
        import_git_tree(repo, mapping, "", root_tree, inv, parent_invs, 
178
 
            target_git_object_retriever, lookup_object)
 
136
            if sha in objects:
 
137
                return objects[sha]
 
138
            return reconstruct_git_object(repo, mapping, sha)
 
139
        import_git_tree(repo, mapping, "", root_tree, inv, lookup_object)
179
140
        repo.add_revision(rev.revision_id, rev, inv)
180
141
 
181
142
 
182
 
class InterGitNonGitRepository(InterRepository):
 
143
def reconstruct_git_commit(repo, rev):
 
144
    raise NotImplementedError(self.reconstruct_git_commit)
 
145
 
 
146
 
 
147
def reconstruct_git_object(repo, mapping, sha):
 
148
    # Commit
 
149
    revid = mapping.revision_id_foreign_to_bzr(sha)
 
150
    try:
 
151
        rev = repo.get_revision(revid)
 
152
    except NoSuchRevision:
 
153
        pass
 
154
    else:
 
155
        return reconstruct_git_commit(rev)
 
156
 
 
157
    # TODO: Tree
 
158
    # TODO: Blob
 
159
    raise KeyError("No such object %s" % sha)
 
160
 
 
161
 
 
162
class InterGitRepository(InterRepository):
183
163
 
184
164
    _matching_repo_format = GitFormat()
185
165
 
191
171
        """See InterRepository.copy_content."""
192
172
        self.fetch(revision_id, pb, find_ghosts=False)
193
173
 
194
 
    def fetch_objects(self, determine_wants, mapping, pb=None):
 
174
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
 
175
              mapping=None):
 
176
        if mapping is None:
 
177
            mapping = self.source.get_mapping()
195
178
        def progress(text):
196
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
 
179
            if pb is not None:
 
180
                pb.note("git: %s" % text)
 
181
            else:
 
182
                info("git: %s" % text)
 
183
        def determine_wants(heads):
 
184
            if revision_id is None:
 
185
                ret = heads.values()
 
186
            else:
 
187
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
 
188
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
197
189
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
198
 
        create_pb = None
199
 
        if pb is None:
200
 
            create_pb = pb = ui.ui_factory.nested_progress_bar()
201
 
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
202
 
        
 
190
        self.target.lock_write()
203
191
        try:
204
 
            self.target.lock_write()
 
192
            self.target.start_write_group()
205
193
            try:
206
 
                self.target.start_write_group()
207
 
                try:
208
 
                    objects_iter = self.source.fetch_objects(determine_wants, 
209
 
                                graph_walker, 
210
 
                                target_git_object_retriever.__getitem__, 
211
 
                                progress)
212
 
                    import_git_objects(self.target, mapping, objects_iter, 
213
 
                            target_git_object_retriever, pb)
214
 
                finally:
215
 
                    self.target.commit_write_group()
 
194
                import_git_objects(self.target, mapping,
 
195
                    iter(self.source.fetch_objects(determine_wants, graph_walker, 
 
196
                        progress)))
216
197
            finally:
217
 
                self.target.unlock()
 
198
                self.target.commit_write_group()
218
199
        finally:
219
 
            if create_pb:
220
 
                create_pb.finished()
221
 
 
222
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
223
 
              mapping=None, fetch_spec=None):
224
 
        self.fetch_refs(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts,
225
 
                mapping=mapping, fetch_spec=fetch_spec)
226
 
 
227
 
    def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False, 
228
 
              mapping=None, fetch_spec=None):
229
 
        if mapping is None:
230
 
            mapping = self.source.get_mapping()
231
 
        if revision_id is not None:
232
 
            interesting_heads = [revision_id]
233
 
        elif fetch_spec is not None:
234
 
            interesting_heads = fetch_spec.heads
235
 
        else:
236
 
            interesting_heads = None
237
 
        self._refs = {}
238
 
        def determine_wants(refs):
239
 
            self._refs = refs
240
 
            if interesting_heads is None:
241
 
                ret = [sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")]
242
 
            else:
243
 
                ret = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in interesting_heads]
244
 
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
245
 
        self.fetch_objects(determine_wants, mapping, pb)
246
 
        return self._refs
 
200
            self.target.unlock()
247
201
 
248
202
    @staticmethod
249
203
    def is_compatible(source, target):
250
204
        """Be compatible with GitRepository."""
251
205
        # FIXME: Also check target uses VersionedFile
252
 
        return (isinstance(source, GitRepository) and 
253
 
                target.supports_rich_root() and
254
 
                not isinstance(target, GitRepository))
255
 
 
256
 
 
257
 
class InterGitRepository(InterRepository):
258
 
 
259
 
    _matching_repo_format = GitFormat()
260
 
 
261
 
    @staticmethod
262
 
    def _get_repo_format_to_test():
263
 
        return None
264
 
 
265
 
    def copy_content(self, revision_id=None, pb=None):
266
 
        """See InterRepository.copy_content."""
267
 
        self.fetch(revision_id, pb, find_ghosts=False)
268
 
 
269
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
270
 
              mapping=None, fetch_spec=None):
271
 
        if mapping is None:
272
 
            mapping = self.source.get_mapping()
273
 
        def progress(text):
274
 
            info("git: %s", text)
275
 
        r = self.target._git
276
 
        if revision_id is not None:
277
 
            args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
278
 
        elif fetch_spec is not None:
279
 
            args = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in fetch_spec.heads]
280
 
        if fetch_spec is None and revision_id is None:
281
 
            determine_wants = r.object_store.determine_wants_all
282
 
        else:
283
 
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
284
 
 
285
 
        graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
286
 
        f, commit = r.object_store.add_pack()
287
 
        try:
288
 
            self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
289
 
            f.close()
290
 
            commit()
291
 
        except:
292
 
            f.close()
293
 
            raise
294
 
 
295
 
    @staticmethod
296
 
    def is_compatible(source, target):
297
 
        """Be compatible with GitRepository."""
298
 
        return (isinstance(source, GitRepository) and 
299
 
                isinstance(target, GitRepository))
 
206
        return (isinstance(source, LocalGitRepository) and 
 
207
                target.supports_rich_root())