/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
 
18
from bzrlib.errors import InvalidRevisionId
 
19
from bzrlib.inventory import Inventory
17
20
from bzrlib.repository import InterRepository
18
 
 
19
 
from bzrlib.plugins.git.repository import GitRepository, GitFormat
20
 
 
21
 
class InterFromGitRepository(InterRepository):
 
21
from bzrlib.trace import info
 
22
 
 
23
from bzrlib.plugins.git import git
 
24
from bzrlib.plugins.git.repository import LocalGitRepository, GitRepository, GitFormat
 
25
from bzrlib.plugins.git.remote import RemoteGitRepository
 
26
 
 
27
from dulwich.objects import Commit
 
28
 
 
29
from cStringIO import StringIO
 
30
 
 
31
 
 
32
class BzrFetchGraphWalker(object):
 
33
 
 
34
    def __init__(self, repository, mapping):
 
35
        self.repository = repository
 
36
        self.mapping = mapping
 
37
        self.done = set()
 
38
        self.heads = set(repository.all_revision_ids())
 
39
        self.parents = {}
 
40
 
 
41
    def ack(self, sha):
 
42
        revid = self.mapping.revision_id_foreign_to_bzr(sha)
 
43
        self.remove(revid)
 
44
 
 
45
    def remove(self, revid):
 
46
        self.done.add(revid)
 
47
        if ref in self.heads:
 
48
            self.heads.remove(revid)
 
49
        if revid in self.parents:
 
50
            for p in self.parents[revid]:
 
51
                self.remove(p)
 
52
 
 
53
    def next(self):
 
54
        while self.heads:
 
55
            ret = self.heads.pop()
 
56
            ps = self.repository.get_parent_map([ret])[ret]
 
57
            self.parents[ret] = ps
 
58
            self.heads.update([p for p in ps if not p in self.done])
 
59
            try:
 
60
                self.done.add(ret)
 
61
                return self.mapping.revision_id_bzr_to_foreign(ret)
 
62
            except InvalidRevisionId:
 
63
                pass
 
64
        return None
 
65
 
 
66
 
 
67
def import_git_blob(repo, mapping, path, blob):
 
68
    """Import a git blob object into a bzr repository.
 
69
 
 
70
    :param repo: bzr repository
 
71
    :param path: Path in the tree
 
72
    :param blob: A git blob
 
73
    """
 
74
    file_id = mapping.generate_file_id(path)
 
75
    repo.texts.add_lines((file_id, blob.id),
 
76
        [], #FIXME 
 
77
        osutils.split_lines(blob.data))
 
78
    inv.add_path(path, "file", file_id)
 
79
 
 
80
 
 
81
def import_git_tree(repo, mapping, path, tree, inv, lookup_object):
 
82
    """Import a git tree object into a bzr repository.
 
83
 
 
84
    :param repo: A Bzr repository object
 
85
    :param path: Path in the tree
 
86
    :param tree: A git tree object
 
87
    :param inv: Inventory object
 
88
    """
 
89
    file_id = mapping.generate_file_id(path)
 
90
    repo.texts.add_lines((file_id, tree.id),
 
91
        [], #FIXME 
 
92
        [])
 
93
    inv.add_path(path, "directory", file_id)
 
94
    for mode, name, hexsha in tree.entries():
 
95
        entry_kind = (mode & 0700000) / 0100000
 
96
        basename = name.decode("utf-8")
 
97
        if path == "":
 
98
            child_path = name
 
99
        else:
 
100
            child_path = urlutils.join(path, name)
 
101
        if entry_kind == 0:
 
102
            import_git_tree(repo, mapping, child_path, lookup_object, inv)
 
103
        elif entry_kind == 1:
 
104
            import_git_blob(repo, mapping, child_path, lookup_object, inv)
 
105
        else:
 
106
            raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
 
107
 
 
108
 
 
109
def import_git_objects(repo, mapping, object_iter):
 
110
    """Import a set of git objects into a bzr repository.
 
111
 
 
112
    :param repo: Bazaar repository
 
113
    :param mapping: Mapping to use
 
114
    :param object_iter: Iterator over Git objects.
 
115
    """
 
116
    # TODO: a more (memory-)efficient implementation of this
 
117
    objects = {}
 
118
    for o in object_iter:
 
119
        objects[o.id] = o
 
120
    root_trees = {}
 
121
    # Find and convert commit objects
 
122
    for o in objects.iterkeys():
 
123
        if isinstance(o, Commit):
 
124
            rev = mapping.import_commit(o)
 
125
            root_trees[rev] = objects[o.tree_sha]
 
126
    # Create the inventory objects
 
127
    for rev, root_tree in root_trees.iteritems():
 
128
        # We have to do this here, since we have to walk the tree and 
 
129
        # we need to make sure to import the blobs / trees with the riht 
 
130
        # path; this may involve adding them more than once.
 
131
        inv = Inventory()
 
132
        def lookup_object(sha):
 
133
            if sha in objects:
 
134
                return objects[sha]
 
135
            return reconstruct_git_object(repo, mapping, sha)
 
136
        import_git_tree(repo, mapping, "", tree, inv, lookup_object)
 
137
        repo.add_revision(rev.revision_id, rev, inv)
 
138
 
 
139
 
 
140
def reconstruct_git_commit(repo, rev):
 
141
    raise NotImplementedError(self.reconstruct_git_commit)
 
142
 
 
143
 
 
144
def reconstruct_git_object(repo, mapping, sha):
 
145
    # Commit
 
146
    revid = mapping.revision_id_foreign_to_bzr(sha)
 
147
    try:
 
148
        rev = repo.get_revision(revid)
 
149
    except NoSuchRevision:
 
150
        pass
 
151
    else:
 
152
        return reconstruct_git_commit(rev)
 
153
 
 
154
    # TODO: Tree
 
155
    # TODO: Blob
 
156
    raise KeyError("No such object %s" % sha)
 
157
 
 
158
 
 
159
class InterGitRepository(InterRepository):
22
160
 
23
161
    _matching_repo_format = GitFormat()
24
162
 
32
170
 
33
171
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
34
172
              mapping=None):
35
 
        raise NotImplementedError(self.fetch)
 
173
        if mapping is None:
 
174
            mapping = self.source.get_mapping()
 
175
        def progress(text):
 
176
            if pb is not None:
 
177
                pb.note("git: %s" % text)
 
178
            else:
 
179
                info("git: %s" % text)
 
180
        def determine_wants(heads):
 
181
            if revision_id is None:
 
182
                ret = heads.values()
 
183
            else:
 
184
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
 
185
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
 
186
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
187
        self.target.lock_write()
 
188
        try:
 
189
            import_git_objects(self.target, mapping,
 
190
                self.source.fetch_objects(determine_wants, graph_walker, 
 
191
                    progress))
 
192
        finally:
 
193
            self.target.unlock()
36
194
 
37
195
    @staticmethod
38
196
    def is_compatible(source, target):
39
197
        """Be compatible with GitRepository."""
40
198
        # FIXME: Also check target uses VersionedFile
41
 
        return isinstance(source, GitRepository) and target.supports_rich_root()
42
 
 
43
 
 
44
 
 
 
199
        return (isinstance(source, LocalGitRepository) and 
 
200
                target.supports_rich_root())