/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
27
from dulwich.objects import Commit
69
64
        return None
70
65
 
71
66
 
72
 
def import_git_blob(repo, mapping, path, blob, inv, parent_invs, executable):
 
67
def import_git_blob(repo, mapping, path, blob):
73
68
    """Import a git blob object into a bzr repository.
74
69
 
75
70
    :param repo: bzr repository
77
72
    :param blob: A git blob
78
73
    """
79
74
    file_id = mapping.generate_file_id(path)
80
 
    text_revision = inv.revision_id
81
 
    repo.texts.add_lines((file_id, text_revision),
82
 
        [(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 
83
77
        osutils.split_lines(blob.data))
84
 
    ie = inv.add_path(path, "file", file_id)
85
 
    ie.revision = text_revision
86
 
    ie.text_size = len(blob.data)
87
 
    ie.text_sha1 = osutils.sha_string(blob.data)
88
 
    ie.executable = executable
89
 
 
90
 
 
91
 
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):
92
82
    """Import a git tree object into a bzr repository.
93
83
 
94
84
    :param repo: A Bzr repository object
97
87
    :param inv: Inventory object
98
88
    """
99
89
    file_id = mapping.generate_file_id(path)
100
 
    text_revision = inv.revision_id
101
 
    repo.texts.add_lines((file_id, text_revision),
102
 
        [(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 
103
92
        [])
104
 
    ie = inv.add_path(path, "directory", file_id)
105
 
    ie.revision = text_revision
 
93
    inv.add_path(path, "directory", file_id)
106
94
    for mode, name, hexsha in tree.entries():
107
95
        entry_kind = (mode & 0700000) / 0100000
108
96
        basename = name.decode("utf-8")
111
99
        else:
112
100
            child_path = urlutils.join(path, name)
113
101
        if entry_kind == 0:
114
 
            tree = lookup_object(hexsha)
115
 
            import_git_tree(repo, mapping, child_path, tree, inv, parent_invs, lookup_object)
 
102
            import_git_tree(repo, mapping, child_path, lookup_object, inv)
116
103
        elif entry_kind == 1:
117
 
            blob = lookup_object(hexsha)
118
 
            fs_mode = mode & 0777
119
 
            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)
120
105
        else:
121
106
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
122
107
 
123
108
 
124
 
def import_git_objects(repo, mapping, object_iter, pb=None):
 
109
def import_git_objects(repo, mapping, object_iter):
125
110
    """Import a set of git objects into a bzr repository.
126
111
 
127
112
    :param repo: Bazaar repository
130
115
    """
131
116
    # TODO: a more (memory-)efficient implementation of this
132
117
    objects = {}
133
 
    for i, o in enumerate(object_iter):
134
 
        if pb is not None:
135
 
            pb.update("fetching objects", i) 
 
118
    for o in object_iter:
136
119
        objects[o.id] = o
137
 
    graph = []
138
120
    root_trees = {}
139
 
    revisions = {}
140
121
    # Find and convert commit objects
141
 
    for o in objects.itervalues():
 
122
    for o in objects.iterkeys():
142
123
        if isinstance(o, Commit):
143
124
            rev = mapping.import_commit(o)
144
 
            root_trees[rev.revision_id] = objects[o.tree]
145
 
            revisions[rev.revision_id] = rev
146
 
            graph.append((rev.revision_id, rev.parent_ids))
147
 
    # Order the revisions
 
125
            root_trees[rev] = objects[o.tree_sha]
148
126
    # Create the inventory objects
149
 
    for i, revid in enumerate(topo_sort(graph)):
150
 
        if pb is not None:
151
 
            pb.update("fetching revisions", i, len(graph))
152
 
        root_tree = root_trees[revid]
153
 
        rev = revisions[revid]
 
127
    for rev, root_tree in root_trees.iteritems():
154
128
        # We have to do this here, since we have to walk the tree and 
155
129
        # we need to make sure to import the blobs / trees with the riht 
156
130
        # path; this may involve adding them more than once.
157
131
        inv = Inventory()
158
 
        inv.revision_id = rev.revision_id
159
132
        def lookup_object(sha):
160
133
            if sha in objects:
161
134
                return objects[sha]
162
135
            return reconstruct_git_object(repo, mapping, sha)
163
 
        parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
164
 
        import_git_tree(repo, mapping, "", root_tree, inv, parent_invs, lookup_object)
 
136
        import_git_tree(repo, mapping, "", tree, inv, lookup_object)
165
137
        repo.add_revision(rev.revision_id, rev, inv)
166
138
 
167
139
 
201
173
        if mapping is None:
202
174
            mapping = self.source.get_mapping()
203
175
        def progress(text):
204
 
            pb.note("git: %s", text)
 
176
            if pb is not None:
 
177
                pb.note("git: %s" % text)
 
178
            else:
 
179
                info("git: %s" % text)
205
180
        def determine_wants(heads):
206
181
            if revision_id is None:
207
182
                ret = heads.values()
209
184
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
210
185
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
211
186
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
212
 
        create_pb = None
213
 
        if pb is None:
214
 
            create_pb = pb = ui.ui_factory.nested_progress_bar()
 
187
        self.target.lock_write()
215
188
        try:
216
 
            self.target.lock_write()
217
 
            try:
218
 
                self.target.start_write_group()
219
 
                try:
220
 
                    import_git_objects(self.target, mapping,
221
 
                        iter(self.source.fetch_objects(determine_wants, graph_walker, 
222
 
                            progress)), pb)
223
 
                finally:
224
 
                    self.target.commit_write_group()
225
 
            finally:
226
 
                self.target.unlock()
 
189
            import_git_objects(self.target, mapping,
 
190
                self.source.fetch_objects(determine_wants, graph_walker, 
 
191
                    progress))
227
192
        finally:
228
 
            if create_pb:
229
 
                create_pb.finished()
 
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 
 
199
        return (isinstance(source, LocalGitRepository) and 
236
200
                target.supports_rich_root())