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