/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 repository.py

  • Committer: John Arbash Meinel
  • Date: 2010-01-12 22:51:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4955.
  • Revision ID: john@arbash-meinel.com-20100112225131-he8h411p6aeeb947
Delay grabbing an output stream until we actually go to show a diff.

This makes the test suite happy, but it also seems to be reasonable.
If we aren't going to write anything, we don't need to hold an
output stream open.

Show diffs side-by-side

added added

removed removed

Lines of Context:
repository.py
1
 
# Copyright (C) 2007 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
 
"""An adapter between a Git Repository and a Bazaar Branch"""
18
 
 
19
 
import os
20
 
import time
21
 
 
22
 
import bzrlib
23
 
from bzrlib import (
24
 
    deprecated_graph,
25
 
    errors,
26
 
    graph,
27
 
    inventory,
28
 
    osutils,
29
 
    repository,
30
 
    revision,
31
 
    revisiontree,
32
 
    urlutils,
33
 
    versionedfile,
34
 
    )
35
 
from bzrlib.foreign import (
36
 
        ForeignRepository,
37
 
        )
38
 
from bzrlib.trace import mutter
39
 
from bzrlib.transport import get_transport
40
 
 
41
 
from bzrlib.plugins.git.foreign import (
42
 
    versionedfiles,
43
 
    )
44
 
from bzrlib.plugins.git.mapping import default_mapping
45
 
 
46
 
from bzrlib.plugins.git import git
47
 
 
48
 
 
49
 
class GitTags(object):
50
 
 
51
 
    def __init__(self, tags):
52
 
        self._tags = tags
53
 
 
54
 
    def __iter__(self):
55
 
        return iter(self._tags)
56
 
 
57
 
 
58
 
class GitRepository(ForeignRepository):
59
 
    """An adapter to git repositories for bzr."""
60
 
 
61
 
    _serializer = None
62
 
 
63
 
    def __init__(self, gitdir, lockfiles):
64
 
        ForeignRepository.__init__(self, GitFormat(), gitdir, lockfiles)
65
 
        from bzrlib.plugins.git import fetch
66
 
        repository.InterRepository.register_optimiser(fetch.InterGitRepository)
67
 
 
68
 
    def is_shared(self):
69
 
        return True
70
 
 
71
 
    def supports_rich_root(self):
72
 
        return True
73
 
 
74
 
    def _warn_if_deprecated(self):
75
 
        # This class isn't deprecated
76
 
        pass
77
 
 
78
 
    def get_mapping(self):
79
 
        return default_mapping
80
 
 
81
 
    def make_working_trees(self):
82
 
        return True
83
 
 
84
 
 
85
 
class LocalGitRepository(GitRepository):
86
 
 
87
 
    def __init__(self, gitdir, lockfiles):
88
 
        # FIXME: This also caches negatives. Need to be more careful 
89
 
        # about this once we start writing to git
90
 
        self._parents_provider = graph.CachingParentsProvider(self)
91
 
        GitRepository.__init__(self, gitdir, lockfiles)
92
 
        self.base = gitdir.root_transport.base
93
 
        self._git = gitdir._git
94
 
        self.texts = None
95
 
        self.signatures = versionedfiles.VirtualSignatureTexts(self)
96
 
        self.revisions = versionedfiles.VirtualRevisionTexts(self)
97
 
        self.tags = GitTags(self._git.get_tags())
98
 
 
99
 
    def all_revision_ids(self):
100
 
        ret = set([revision.NULL_REVISION])
101
 
        if self._git.heads() == []:
102
 
            return ret
103
 
        bzr_heads = [self.get_mapping().revision_id_foreign_to_bzr(h) for h in self._git.heads()]
104
 
        ret = set(bzr_heads)
105
 
        graph = self.get_graph()
106
 
        for rev, parents in graph.iter_ancestry(bzr_heads):
107
 
            ret.add(rev)
108
 
        return ret
109
 
 
110
 
    #def get_revision_delta(self, revision_id):
111
 
    #    parent_revid = self.get_revision(revision_id).parent_ids[0]
112
 
    #    diff = self._git.diff(ids.convert_revision_id_bzr_to_git(parent_revid),
113
 
    #                   ids.convert_revision_id_bzr_to_git(revision_id))
114
 
 
115
 
    def _make_parents_provider(self):
116
 
        """See Repository._make_parents_provider()."""
117
 
        return self._parents_provider
118
 
 
119
 
    def get_parent_map(self, revids):
120
 
        parent_map = {}
121
 
        mutter("get_parent_map(%r)", revids)
122
 
        for revision_id in revids:
123
 
            assert isinstance(revision_id, str)
124
 
            if revision_id == revision.NULL_REVISION:
125
 
                parent_map[revision_id] = ()
126
 
                continue
127
 
            hexsha = self.lookup_git_revid(revision_id, self.get_mapping())
128
 
            commit  = self._git.commit(hexsha)
129
 
            if commit is None:
130
 
                continue
131
 
            else:
132
 
                parent_map[revision_id] = [self.get_mapping().revision_id_foreign_to_bzr(p) for p in commit.parents]
133
 
        return parent_map
134
 
 
135
 
    def get_ancestry(self, revision_id, topo_sorted=True):
136
 
        """See Repository.get_ancestry().
137
 
        """
138
 
        if revision_id is None:
139
 
            return self._all_revision_ids()
140
 
        assert isinstance(revision_id, str)
141
 
        ancestry = []
142
 
        graph = self.get_graph()
143
 
        for rev, parents in graph.iter_ancestry([revision_id]):
144
 
            if rev == revision.NULL_REVISION:
145
 
                rev = None
146
 
            ancestry.append(rev)
147
 
        ancestry.reverse()
148
 
        return ancestry
149
 
 
150
 
    def get_signature_text(self, revision_id):
151
 
        raise errors.NoSuchRevision(self, revision_id)
152
 
 
153
 
    def lookup_revision_id(self, revid):
154
 
        """Lookup a revision id.
155
 
        
156
 
        :param revid: Bazaar revision id.
157
 
        :return: Tuple with git revisionid and mapping.
158
 
        """
159
 
        # Yes, this doesn't really work, but good enough as a stub
160
 
        return osutils.sha(rev_id).hexdigest(), self.get_mapping()
161
 
 
162
 
    def has_signature_for_revision_id(self, revision_id):
163
 
        return False
164
 
 
165
 
    def lookup_git_revid(self, bzr_revid, mapping):
166
 
        try:
167
 
            return mapping.revision_id_bzr_to_foreign(bzr_revid)
168
 
        except errors.InvalidRevisionId:
169
 
            raise errors.NoSuchRevision(self, bzr_revid)
170
 
 
171
 
    def get_revision(self, revision_id):
172
 
        git_commit_id = self.lookup_git_revid(revision_id, self.get_mapping())
173
 
        try:
174
 
            commit = self._git.commit(git_commit_id)
175
 
        except KeyError:
176
 
            raise errors.NoSuchRevision(self, revision_id)
177
 
        # print "fetched revision:", git_commit_id
178
 
        revision = self.get_mapping().import_commit(commit)
179
 
        assert revision is not None
180
 
        return revision
181
 
 
182
 
    def has_revision(self, revision_id):
183
 
        try:
184
 
            self.get_revision(revision_id)
185
 
        except errors.NoSuchRevision:
186
 
            return False
187
 
        else:
188
 
            return True
189
 
 
190
 
    def get_revisions(self, revids):
191
 
        return [self.get_revision(r) for r in revids]
192
 
 
193
 
    def revision_trees(self, revids):
194
 
        for revid in revids:
195
 
            yield self.revision_tree(revid)
196
 
 
197
 
    def revision_tree(self, revision_id):
198
 
        revision_id = revision.ensure_null(revision_id)
199
 
 
200
 
        if revision_id == revision.NULL_REVISION:
201
 
            inv = inventory.Inventory(root_id=None)
202
 
            inv.revision_id = revision_id
203
 
            return revisiontree.RevisionTree(self, inv, revision_id)
204
 
 
205
 
        return GitRevisionTree(self, self.get_mapping(), revision_id)
206
 
 
207
 
    def get_inventory(self, revision_id):
208
 
        assert revision_id != None
209
 
        return self.revision_tree(revision_id).inventory
210
 
 
211
 
    def set_make_working_trees(self, trees):
212
 
        pass
213
 
 
214
 
    def fetch_objects(self, determine_wants, graph_walker, progress=None):
215
 
        return self._git.fetch_objects(determine_wants, graph_walker, progress)
216
 
 
217
 
 
218
 
class GitRevisionTree(revisiontree.RevisionTree):
219
 
 
220
 
    def __init__(self, repository, mapping, revision_id):
221
 
        self._repository = repository
222
 
        self.revision_id = revision_id
223
 
        assert isinstance(revision_id, str)
224
 
        self.mapping = mapping
225
 
        git_id = repository.lookup_git_revid(revision_id, self.mapping)
226
 
        try:
227
 
            commit = repository._git.commit(git_id)
228
 
        except KeyError, r:
229
 
            raise errors.NoSuchRevision(repository, revision_id)
230
 
        self.tree = commit.tree
231
 
        self._inventory = inventory.Inventory(revision_id=revision_id)
232
 
        self._inventory.root.revision = revision_id
233
 
        self._build_inventory(self.tree, self._inventory.root, "")
234
 
 
235
 
    def get_revision_id(self):
236
 
        return self.revision_id
237
 
 
238
 
    def get_file_text(self, file_id):
239
 
        entry = self._inventory[file_id]
240
 
        if entry.kind == 'directory': return ""
241
 
        return self._repository._git.get_blob(entry.text_id).data
242
 
 
243
 
    def _build_inventory(self, tree_id, ie, path):
244
 
        assert isinstance(path, str)
245
 
        tree = self._repository._git.tree(tree_id)
246
 
        for mode, name, hexsha in tree.entries():
247
 
            basename = name.decode("utf-8")
248
 
            if path == "":
249
 
                child_path = name
250
 
            else:
251
 
                child_path = urlutils.join(path, name)
252
 
            file_id = self.mapping.generate_file_id(child_path)
253
 
            entry_kind = (mode & 0700000) / 0100000
254
 
            if entry_kind == 0:
255
 
                child_ie = inventory.InventoryDirectory(file_id, basename, ie.file_id)
256
 
            elif entry_kind == 1:
257
 
                file_kind = (mode & 070000) / 010000
258
 
                b = self._repository._git.get_blob(hexsha)
259
 
                if file_kind == 0:
260
 
                    child_ie = inventory.InventoryFile(file_id, basename, ie.file_id)
261
 
                    child_ie.text_sha1 = osutils.sha_string(b.data)
262
 
                elif file_kind == 2:
263
 
                    child_ie = inventory.InventoryLink(file_id, basename, ie.file_id)
264
 
                    child_ie.text_sha1 = osutils.sha_string("")
265
 
                else:
266
 
                    raise AssertionError(
267
 
                        "Unknown file kind, perms=%o." % (mode,))
268
 
                child_ie.text_id = b.id
269
 
                child_ie.text_size = len(b.data)
270
 
            else:
271
 
                raise AssertionError(
272
 
                    "Unknown blob kind, perms=%r." % (mode,))
273
 
            fs_mode = mode & 0777
274
 
            child_ie.executable = bool(fs_mode & 0111)
275
 
            child_ie.revision = self.revision_id
276
 
            self._inventory.add(child_ie)
277
 
            if entry_kind == 0:
278
 
                self._build_inventory(hexsha, child_ie, child_path)
279
 
 
280
 
 
281
 
class GitFormat(object):
282
 
 
283
 
    supports_tree_reference = False
284
 
    rich_root_data = True
285
 
 
286
 
    def get_format_description(self):
287
 
        return "Git Repository"
288
 
 
289
 
    def initialize(self, url, shared=False, _internal=False):
290
 
        raise bzr_errors.UninitializableFormat(self)
291
 
 
292
 
    def check_conversion_target(self, target_repo_format):
293
 
        return target_repo_format.rich_root_data