/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

Reoncile InterGitRepository objects.

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