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