/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
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, urlutils
 
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.converter 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, gitmap, executable):
 
67
def import_git_blob(repo, mapping, path, blob, inv):
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
78
    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
 
    gitmap._idmap.add_entry(blob.sha().hexdigest(), "blob", (ie.file_id, ie.revision))
96
 
 
97
 
 
98
 
def import_git_tree(repo, mapping, path, tree, inv, parent_invs, 
99
 
                    gitmap, lookup_object):
 
79
 
 
80
 
 
81
def import_git_tree(repo, mapping, path, tree, inv, lookup_object):
100
82
    """Import a git tree object into a bzr repository.
101
83
 
102
84
    :param repo: A Bzr repository object
105
87
    :param inv: Inventory object
106
88
    """
107
89
    file_id = mapping.generate_file_id(path)
108
 
    text_revision = inv.revision_id
109
 
    repo.texts.add_lines((file_id, text_revision),
110
 
        [(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 
111
92
        [])
112
 
    ie = inv.add_path(path, "directory", file_id)
113
 
    ie.revision = text_revision
114
 
    gitmap._idmap.add_entry(tree.sha().hexdigest(), "tree", (file_id, text_revision))
 
93
    inv.add_path(path, "directory", file_id)
115
94
    for mode, name, hexsha in tree.entries():
116
95
        entry_kind = (mode & 0700000) / 0100000
117
96
        basename = name.decode("utf-8")
121
100
            child_path = urlutils.join(path, name)
122
101
        if entry_kind == 0:
123
102
            tree = lookup_object(hexsha)
124
 
            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)
125
104
        elif entry_kind == 1:
126
105
            blob = lookup_object(hexsha)
127
 
            fs_mode = mode & 0777
128
 
            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)
129
107
        else:
130
108
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
131
109
 
132
110
 
133
 
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever, 
134
 
        pb=None):
 
111
def import_git_objects(repo, mapping, object_iter):
135
112
    """Import a set of git objects into a bzr repository.
136
113
 
137
114
    :param repo: Bazaar repository
139
116
    :param object_iter: Iterator over Git objects.
140
117
    """
141
118
    # TODO: a more (memory-)efficient implementation of this
142
 
    graph = []
 
119
    objects = {}
 
120
    for o in object_iter:
 
121
        objects[o.id] = o
143
122
    root_trees = {}
144
 
    revisions = {}
145
123
    # Find and convert commit objects
146
 
    for o in object_iter.iterobjects():
 
124
    for o in objects.itervalues():
147
125
        if isinstance(o, Commit):
148
126
            rev = mapping.import_commit(o)
149
 
            root_trees[rev.revision_id] = object_iter[o.tree]
150
 
            revisions[rev.revision_id] = rev
151
 
            graph.append((rev.revision_id, rev.parent_ids))
152
 
            target_git_object_retriever._idmap.add_entry(o.sha().hexdigest(), "commit", (rev.revision_id, o._tree))
153
 
    # Order the revisions
 
127
            root_trees[rev] = objects[o.tree]
154
128
    # Create the inventory objects
155
 
    for i, revid in enumerate(topo_sort(graph)):
156
 
        if pb is not None:
157
 
            pb.update("fetching revisions", i, len(graph))
158
 
        root_tree = root_trees[revid]
159
 
        rev = revisions[revid]
 
129
    for rev, root_tree in root_trees.iteritems():
160
130
        # We have to do this here, since we have to walk the tree and 
161
131
        # we need to make sure to import the blobs / trees with the riht 
162
132
        # path; this may involve adding them more than once.
163
133
        inv = Inventory()
164
134
        inv.revision_id = rev.revision_id
165
135
        def lookup_object(sha):
166
 
            if sha in object_iter:
167
 
                return object_iter[sha]
168
 
            return target_git_object_retriever[sha]
169
 
        parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
170
 
        import_git_tree(repo, mapping, "", root_tree, inv, parent_invs, 
171
 
            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)
172
140
        repo.add_revision(rev.revision_id, rev, inv)
173
141
 
174
142
 
175
 
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):
176
163
 
177
164
    _matching_repo_format = GitFormat()
178
165
 
184
171
        """See InterRepository.copy_content."""
185
172
        self.fetch(revision_id, pb, find_ghosts=False)
186
173
 
187
 
    def fetch_objects(self, determine_wants, mapping, pb=None):
188
 
        def progress(text):
189
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
190
 
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
191
 
        create_pb = None
192
 
        if pb is None:
193
 
            create_pb = pb = ui.ui_factory.nested_progress_bar()
194
 
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
195
 
        
196
 
        try:
197
 
            self.target.lock_write()
198
 
            try:
199
 
                self.target.start_write_group()
200
 
                try:
201
 
                    objects_iter = self.source.fetch_objects(determine_wants, 
202
 
                                graph_walker, 
203
 
                                target_git_object_retriever.__getitem__, 
204
 
                                progress)
205
 
                    import_git_objects(self.target, mapping, objects_iter, 
206
 
                            target_git_object_retriever, pb)
207
 
                finally:
208
 
                    self.target.commit_write_group()
209
 
            finally:
210
 
                self.target.unlock()
211
 
        finally:
212
 
            if create_pb:
213
 
                create_pb.finished()
214
 
 
215
174
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
216
175
              mapping=None):
217
176
        if mapping is None:
218
177
            mapping = self.source.get_mapping()
 
178
        def progress(text):
 
179
            if pb is not None:
 
180
                pb.note("git: %s" % text)
 
181
            else:
 
182
                info("git: %s" % text)
219
183
        def determine_wants(heads):
220
184
            if revision_id is None:
221
185
                ret = heads.values()
222
186
            else:
223
 
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
 
187
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
224
188
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
225
 
        return self.fetch_objects(determine_wants, mapping, pb)
 
189
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
190
        self.target.lock_write()
 
191
        try:
 
192
            self.target.start_write_group()
 
193
            try:
 
194
                import_git_objects(self.target, mapping,
 
195
                    iter(self.source.fetch_objects(determine_wants, graph_walker, 
 
196
                        progress)))
 
197
            finally:
 
198
                self.target.commit_write_group()
 
199
        finally:
 
200
            self.target.unlock()
226
201
 
227
202
    @staticmethod
228
203
    def is_compatible(source, target):
229
204
        """Be compatible with GitRepository."""
230
205
        # FIXME: Also check target uses VersionedFile
231
 
        return (isinstance(source, GitRepository) and 
232
 
                target.supports_rich_root() and
233
 
                not isinstance(target, GitRepository))
234
 
 
235
 
 
236
 
class InterGitRepository(InterRepository):
237
 
 
238
 
    _matching_repo_format = GitFormat()
239
 
 
240
 
    @staticmethod
241
 
    def _get_repo_format_to_test():
242
 
        return None
243
 
 
244
 
    def copy_content(self, revision_id=None, pb=None):
245
 
        """See InterRepository.copy_content."""
246
 
        self.fetch(revision_id, pb, find_ghosts=False)
247
 
 
248
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
249
 
              mapping=None):
250
 
        if mapping is None:
251
 
            mapping = self.source.get_mapping()
252
 
        def progress(text):
253
 
            info("git: %s", text)
254
 
        r = self.target._git
255
 
        if revision_id is None:
256
 
            determine_wants = lambda x: [y for y in x.values() if not y in r.object_store]
257
 
        else:
258
 
            args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
259
 
            determine_wants = lambda x: [y for y in args if not y in r.object_store]
260
 
 
261
 
        graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
262
 
        f, commit = r.object_store.add_pack()
263
 
        try:
264
 
            self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
265
 
            f.close()
266
 
            commit()
267
 
        except:
268
 
            f.close()
269
 
            raise
270
 
 
271
 
    @staticmethod
272
 
    def is_compatible(source, target):
273
 
        """Be compatible with GitRepository."""
274
 
        return (isinstance(source, GitRepository) and 
275
 
                isinstance(target, GitRepository))
 
206
        return (isinstance(source, LocalGitRepository) and 
 
207
                target.supports_rich_root())