/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
 
1
# Copyright (C) 2008 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from bzrlib import osutils
 
18
from bzrlib.errors import InvalidRevisionId
 
19
from bzrlib.inventory import Inventory
 
20
from bzrlib.repository import 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):
 
160
 
 
161
    _matching_repo_format = GitFormat()
 
162
 
 
163
    @staticmethod
 
164
    def _get_repo_format_to_test():
 
165
        return None
 
166
 
 
167
    def copy_content(self, revision_id=None, pb=None):
 
168
        """See InterRepository.copy_content."""
 
169
        self.fetch(revision_id, pb, find_ghosts=False)
 
170
 
 
171
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
 
172
              mapping=None):
 
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()
 
194
 
 
195
    @staticmethod
 
196
    def is_compatible(source, target):
 
197
        """Be compatible with GitRepository."""
 
198
        # FIXME: Also check target uses VersionedFile
 
199
        return (isinstance(source, LocalGitRepository) and 
 
200
                target.supports_rich_root())