/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 syntax errors.

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
            # TODO: need to lookup bzr objects as sha..
 
134
            return objects[sha]
 
135
        import_git_tree(repo, mapping, "", tree, inv, lookup_object)
 
136
        repo.add_revision(rev.revision_id, rev, inv)
 
137
 
 
138
 
 
139
class InterGitRepository(InterRepository):
 
140
 
 
141
    _matching_repo_format = GitFormat()
 
142
 
 
143
    @staticmethod
 
144
    def _get_repo_format_to_test():
 
145
        return None
 
146
 
 
147
    def copy_content(self, revision_id=None, pb=None):
 
148
        """See InterRepository.copy_content."""
 
149
        self.fetch(revision_id, pb, find_ghosts=False)
 
150
 
 
151
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, 
 
152
              mapping=None):
 
153
        if mapping is None:
 
154
            mapping = self.source.get_mapping()
 
155
        def progress(text):
 
156
            if pb is not None:
 
157
                pb.note("git: %s" % text)
 
158
            else:
 
159
                info("git: %s" % text)
 
160
        def determine_wants(heads):
 
161
            if revision_id is None:
 
162
                ret = heads.values()
 
163
            else:
 
164
                ret = [mapping.revision_id_bzr_to_foreign(revision_id)]
 
165
            return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
 
166
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
167
        self.target.lock_write()
 
168
        try:
 
169
            import_git_objects(self.target, mapping,
 
170
                self.source.fetch_objects(determine_wants, graph_walker, 
 
171
                    progress))
 
172
        finally:
 
173
            self.target.unlock()
 
174
 
 
175
    @staticmethod
 
176
    def is_compatible(source, target):
 
177
        """Be compatible with GitRepository."""
 
178
        # FIXME: Also check target uses VersionedFile
 
179
        return (isinstance(source, LocalGitRepository) and 
 
180
                target.supports_rich_root())