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

Cope with files disappearing during commit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
 
1
# Copyright (C) 2006-2009 Canonical Ltd
 
2
 
 
3
# Authors: Robert Collins <robert.collins@canonical.com>
 
4
#          Jelmer Vernooij <jelmer@samba.org>
 
5
#          John Carr <john.carr@unrouted.co.uk>
 
6
#
 
7
# This program is free software; you can redistribute it and/or modify
 
8
# it under the terms of the GNU General Public License as published by
 
9
# the Free Software Foundation; either version 2 of the License, or
 
10
# (at your option) any later version.
 
11
#
 
12
# This program is distributed in the hope that it will be useful,
 
13
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
# GNU General Public License for more details.
 
16
#
 
17
# You should have received a copy of the GNU General Public License
 
18
# along with this program; if not, write to the Free Software
 
19
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
 
 
21
 
 
22
"""A GIT branch and repository format implementation for bzr."""
 
23
 
 
24
import os
 
25
import sys
 
26
 
 
27
import bzrlib
 
28
import bzrlib.api
 
29
 
 
30
from info import (
 
31
    bzr_compatible_versions,
 
32
    bzr_plugin_version as version_info,
 
33
    dulwich_minimum_version,
 
34
    )
 
35
 
 
36
if version_info[3] == 'final':
 
37
    version_string = '%d.%d.%d' % version_info[:3]
 
38
else:
 
39
    version_string = '%d.%d.%d%s%d' % version_info
 
40
__version__ = version_string
 
41
 
 
42
bzrlib.api.require_any_api(bzrlib, bzr_compatible_versions)
 
43
 
 
44
 
 
45
from bzrlib import (
 
46
    errors as bzr_errors,
 
47
    )
 
48
 
 
49
from bzrlib.controldir import (
 
50
    ControlDirFormat,
 
51
    Prober,
 
52
    format_registry,
 
53
    network_format_registry as controldir_network_format_registry,
 
54
    )
 
55
 
 
56
from bzrlib.foreign import (
 
57
    foreign_vcs_registry,
 
58
    )
 
59
from bzrlib.help_topics import (
 
60
    topic_registry,
 
61
    )
 
62
from bzrlib.transport import (
 
63
    register_lazy_transport,
 
64
    register_transport_proto,
 
65
    )
 
66
from bzrlib.commands import (
 
67
    plugin_cmds,
 
68
    )
 
69
from bzrlib.send import (
 
70
    format_registry as send_format_registry,
 
71
    )
 
72
 
 
73
 
 
74
if getattr(sys, "frozen", None):
 
75
    # allow import additional libs from ./_lib for bzr.exe only
 
76
    sys.path.append(os.path.normpath(
 
77
        os.path.join(os.path.dirname(__file__), '_lib')))
 
78
 
 
79
 
 
80
def import_dulwich():
 
81
    try:
 
82
        from dulwich import __version__ as dulwich_version
 
83
    except ImportError:
 
84
        raise bzr_errors.DependencyNotPresent("dulwich",
 
85
            "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
86
    else:
 
87
        if dulwich_version < dulwich_minimum_version:
 
88
            raise bzr_errors.DependencyNotPresent("dulwich",
 
89
                "bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
 
90
                    dulwich_minimum_version)
 
91
 
 
92
 
 
93
_versions_checked = False
 
94
def lazy_check_versions():
 
95
    global _versions_checked
 
96
    if _versions_checked:
 
97
        return
 
98
    import_dulwich()
 
99
    _versions_checked = True
 
100
 
 
101
format_registry.register_lazy('git',
 
102
    "bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
 
103
    help='GIT repository.', native=False, experimental=False,
 
104
    )
 
105
 
 
106
format_registry.register_lazy('git-bare',
 
107
    "bzrlib.plugins.git.dir", "BareLocalGitControlDirFormat",
 
108
    help='Bare GIT repository (no working tree).', native=False,
 
109
    experimental=False,
 
110
    )
 
111
 
 
112
from bzrlib.revisionspec import revspec_registry
 
113
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
114
    "RevisionSpec_git")
 
115
 
 
116
from bzrlib.revisionspec import dwim_revspecs, RevisionSpec_dwim
 
117
if getattr(RevisionSpec_dwim, "append_possible_lazy_revspec", None):
 
118
    RevisionSpec_dwim.append_possible_lazy_revspec(
 
119
        "bzrlib.plugins.git.revspec", "RevisionSpec_git")
 
120
else: # bzr < 2.4
 
121
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
122
    dwim_revspecs.append(RevisionSpec_git)
 
123
 
 
124
 
 
125
class LocalGitProber(Prober):
 
126
 
 
127
    def probe_transport(self, transport):
 
128
        try:
 
129
            if not transport.has_any(['info/refs', '.git/HEAD', 'HEAD', 'objects', '.git/objects']):
 
130
                raise bzr_errors.NotBranchError(path=transport.base)
 
131
        except bzr_errors.NoSuchFile:
 
132
            raise bzr_errors.NotBranchError(path=transport.base)
 
133
        from bzrlib import urlutils
 
134
        if urlutils.split(transport.base)[1] == ".git":
 
135
            raise bzr_errors.NotBranchError(path=transport.base)
 
136
        lazy_check_versions()
 
137
        import dulwich
 
138
        from bzrlib.plugins.git.transportgit import TransportRepo
 
139
        try:
 
140
            gitrepo = TransportRepo(transport)
 
141
        except dulwich.errors.NotGitRepository, e:
 
142
            raise bzr_errors.NotBranchError(path=transport.base)
 
143
        else:
 
144
            from bzrlib.plugins.git.dir import (
 
145
                BareLocalGitControlDirFormat,
 
146
                LocalGitControlDirFormat,
 
147
                )
 
148
            if gitrepo.bare:
 
149
                return BareLocalGitControlDirFormat()
 
150
            else:
 
151
                return LocalGitControlDirFormat()
 
152
 
 
153
    @classmethod
 
154
    def known_formats(cls):
 
155
        from bzrlib.plugins.git.dir import (
 
156
            BareLocalGitControlDirFormat,
 
157
            LocalGitControlDirFormat,
 
158
            )
 
159
        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
 
160
 
 
161
 
 
162
class RemoteGitProber(Prober):
 
163
 
 
164
    def probe_transport(self, transport):
 
165
        url = transport.base
 
166
        if url.startswith('readonly+'):
 
167
            url = url[len('readonly+'):]
 
168
        if (not url.startswith("git://") and not url.startswith("git+")):
 
169
            raise bzr_errors.NotBranchError(transport.base)
 
170
        # little ugly, but works
 
171
        from bzrlib.plugins.git.remote import (
 
172
            GitSmartTransport,
 
173
            RemoteGitControlDirFormat,
 
174
            )
 
175
        if not isinstance(transport, GitSmartTransport):
 
176
            raise bzr_errors.NotBranchError(transport.base)
 
177
        return RemoteGitControlDirFormat()
 
178
 
 
179
    @classmethod
 
180
    def known_formats(cls):
 
181
        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
182
        return set([RemoteGitControlDirFormat()])
 
183
 
 
184
 
 
185
if not getattr(Prober, "known_formats", None): # bzr < 2.4
 
186
    from bzrlib.plugins.git.dir import (
 
187
        LocalGitControlDirFormat, BareLocalGitControlDirFormat,
 
188
        )
 
189
    from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
190
    ControlDirFormat.register_format(LocalGitControlDirFormat())
 
191
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
 
192
    ControlDirFormat.register_format(RemoteGitControlDirFormat())
 
193
    # Provide RevisionTree.get_file_revision, so various parts of bzr-svn
 
194
    # can avoid inventories.
 
195
    from bzrlib.revisiontree import RevisionTree
 
196
    def get_file_revision(tree, file_id, path=None):
 
197
        return tree.inventory[file_id].revision
 
198
    RevisionTree.get_file_revision = get_file_revision
 
199
 
 
200
ControlDirFormat.register_prober(LocalGitProber)
 
201
ControlDirFormat.register_prober(RemoteGitProber)
 
202
 
 
203
register_transport_proto('git://',
 
204
        help="Access using the Git smart server protocol.")
 
205
register_transport_proto('git+ssh://',
 
206
        help="Access using the Git smart server protocol over SSH.")
 
207
 
 
208
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
209
                        'TCPGitSmartTransport')
 
210
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
211
                        'SSHGitSmartTransport')
 
212
 
 
213
foreign_vcs_registry.register_lazy("git",
 
214
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
215
 
 
216
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
217
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
218
    "bzrlib.plugins.git.commands")
 
219
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
220
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
221
 
 
222
def update_stanza(rev, stanza):
 
223
    mapping = getattr(rev, "mapping", None)
 
224
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
225
        stanza.add("git-commit", rev.foreign_revid)
 
226
 
 
227
try:
 
228
    from bzrlib.hooks import install_lazy_named_hook
 
229
except ImportError: # Compatibility with bzr < 2.4
 
230
    from bzrlib.version_info_formats.format_rio import (
 
231
        RioVersionInfoBuilder,
 
232
        )
 
233
    RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza,
 
234
        "git commits")
 
235
else:
 
236
    install_lazy_named_hook("bzrlib.version_info_formats.format_rio",
 
237
        "RioVersionInfoBuilder.hooks", "revision", update_stanza,
 
238
        "git commits")
 
239
 
 
240
 
 
241
from bzrlib.transport import transport_server_registry
 
242
transport_server_registry.register_lazy('git',
 
243
    'bzrlib.plugins.git.server',
 
244
    'serve_git',
 
245
    'Git Smart server protocol over TCP. (default port: 9418)')
 
246
 
 
247
 
 
248
from bzrlib.repository import (
 
249
    format_registry as repository_format_registry,
 
250
    network_format_registry as repository_network_format_registry,
 
251
    )
 
252
repository_network_format_registry.register_lazy('git',
 
253
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
254
 
 
255
try:
 
256
    register_extra_lazy_repository_format = getattr(repository_format_registry,
 
257
        "register_extra_lazy")
 
258
except AttributeError: # bzr < 2.4
 
259
    pass
 
260
else:
 
261
    register_extra_lazy_repository_format('bzrlib.plugins.git.repository',
 
262
        'GitRepositoryFormat')
 
263
 
 
264
from bzrlib.branch import (
 
265
    network_format_registry as branch_network_format_registry,
 
266
    )
 
267
branch_network_format_registry.register_lazy('git',
 
268
    'bzrlib.plugins.git.branch', 'GitBranchFormat')
 
269
 
 
270
try:
 
271
    from bzrlib.branch import (
 
272
        format_registry as branch_format_registry,
 
273
        )
 
274
except ImportError: # bzr < 2.4
 
275
    pass
 
276
else:
 
277
    branch_format_registry.register_extra_lazy(
 
278
        'bzrlib.plugins.git.branch',
 
279
        'GitBranchFormat',
 
280
        )
 
281
 
 
282
try:
 
283
    from bzrlib.workingtree import (
 
284
        format_registry as workingtree_format_registry,
 
285
        )
 
286
except ImportError: # bzr < 2.4
 
287
    pass
 
288
else:
 
289
    workingtree_format_registry.register_extra_lazy(
 
290
        'bzrlib.plugins.git.workingtree',
 
291
        'GitWorkingTreeFormat',
 
292
        )
 
293
 
 
294
controldir_network_format_registry.register_lazy('git',
 
295
    "bzrlib.plugins.git.dir", "GitControlDirFormat")
 
296
 
 
297
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
298
                                   'send_git', 'Git am-style diff format')
 
299
 
 
300
topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
 
301
    'Using Bazaar with Git')
 
302
 
 
303
from bzrlib.diff import format_registry as diff_format_registry
 
304
diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
305
    'GitDiffTree', 'Git am-style diff format')
 
306
 
 
307
def test_suite():
 
308
    from bzrlib.plugins.git import tests
 
309
    return tests.test_suite()