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