/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 formatting, remove catch-all for exceptions when opening local repositories.

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