/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

Implement GitSmartTransport.external_url().

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2009 Canonical Ltd
 
2
 
2
3
# Authors: Robert Collins <robert.collins@canonical.com>
 
4
#          Jelmer Vernooij <jelmer@samba.org>
 
5
#          John Carr <john.carr@unrouted.co.uk>
3
6
#
4
7
# This program is free software; you can redistribute it and/or modify
5
8
# it under the terms of the GNU General Public License as published by
18
21
 
19
22
"""A GIT branch and repository format implementation for bzr."""
20
23
 
21
 
from bzrlib import bzrdir
22
 
from bzrlib.plugins.git.git_dir import GitBzrDirFormat
23
 
 
24
 
bzrdir.format_registry.register(
25
 
    'git', GitBzrDirFormat,
26
 
    help='GIT - the stupid content tracker.',
27
 
    native=False, hidden=True, experimental=True,
28
 
    )
29
 
 
30
 
bzrdir.BzrDirFormat.register_control_format(GitBzrDirFormat)
 
24
import os
 
25
import sys
 
26
 
 
27
import bzrlib
 
28
import bzrlib.api
 
29
 
 
30
# versions ending in 'exp' mean experimental mappings
 
31
# versions ending in 'dev' mean development version
 
32
# versions ending in 'final' mean release (well tested, etc)
 
33
version_info = (0, 3, 3, 'dev', 0)
 
34
 
 
35
if version_info[3] == 'final':
 
36
    version_string = '%d.%d.%d' % version_info[:3]
 
37
else:
 
38
    version_string = '%d.%d.%d%s%d' % version_info
 
39
__version__ = version_string
 
40
 
 
41
MINIMUM_DULWICH_VERSION = (0, 3, 1)
 
42
COMPATIBLE_BZR_VERSIONS = [(1, 14, 0), (1, 15, 0)]
 
43
 
 
44
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
45
 
 
46
 
 
47
from bzrlib import (
 
48
    bzrdir,
 
49
    errors as bzr_errors,
 
50
    osutils,
 
51
    )
 
52
from bzrlib.foreign import (
 
53
    foreign_vcs_registry,
 
54
    )
 
55
from bzrlib.lockable_files import (
 
56
    TransportLock,
 
57
    )
 
58
from bzrlib.transport import (
 
59
    register_lazy_transport,
 
60
    register_transport_proto,
 
61
    )
 
62
from bzrlib.commands import (
 
63
    plugin_cmds,
 
64
    )
 
65
from bzrlib.trace import (
 
66
    warning,
 
67
    )
 
68
from bzrlib.version_info_formats.format_rio import (
 
69
    RioVersionInfoBuilder,
 
70
    )
 
71
 
 
72
 
 
73
if getattr(sys, "frozen", None):
 
74
    # allow import additional libs from ./_lib for bzr.exe only
 
75
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
 
76
 
 
77
_versions_checked = False
 
78
def lazy_check_versions():
 
79
    global _versions_checked
 
80
    if _versions_checked:
 
81
        return
 
82
    _versions_checked = True
 
83
    try:
 
84
        from dulwich import __version__ as dulwich_version
 
85
    except ImportError:
 
86
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
87
    else:
 
88
        if dulwich_version < MINIMUM_DULWICH_VERSION:
 
89
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
 
90
 
 
91
bzrdir.format_registry.register_lazy('git', 
 
92
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
93
    help='GIT repository.', native=False, experimental=True,
 
94
    )
 
95
 
 
96
from bzrlib.revisionspec import revspec_registry
 
97
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
98
    "RevisionSpec_git")
 
99
 
 
100
 
 
101
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
102
    _lock_class = TransportLock
 
103
 
 
104
    def is_supported(self):
 
105
        return True
 
106
 
 
107
    def network_name(self):
 
108
        return "git"
 
109
 
 
110
 
 
111
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
112
    """The .git directory control format."""
 
113
 
 
114
    @classmethod
 
115
    def _known_formats(self):
 
116
        return set([LocalGitBzrDirFormat()])
 
117
 
 
118
    def open(self, transport, _found=None):
 
119
        """Open this directory.
 
120
 
 
121
        """
 
122
        import dulwich as git
 
123
        # we dont grok readonly - git isn't integrated with transport.
 
124
        url = transport.base
 
125
        if url.startswith('readonly+'):
 
126
            url = url[len('readonly+'):]
 
127
 
 
128
        try:
 
129
            gitrepo = git.repo.Repo(transport.local_abspath(".").encode(osutils._fs_enc))
 
130
        except bzr_errors.NotLocalUrl:
 
131
            raise bzr_errors.NotBranchError(path=transport.base)
 
132
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
133
        lockfiles = GitLockableFiles(transport, GitLock())
 
134
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
135
 
 
136
    @classmethod
 
137
    def probe_transport(klass, transport):
 
138
        """Our format is present if the transport ends in '.not/'."""
 
139
        from bzrlib.transport.local import LocalTransport
 
140
 
 
141
        if not isinstance(transport, LocalTransport):
 
142
            raise bzr_errors.NotBranchError(path=transport.base)
 
143
 
 
144
        # This should quickly filter out most things that are not 
 
145
        # git repositories, saving us the trouble from loading dulwich.
 
146
        if not transport.has(".git") and not transport.has("objects"):
 
147
            raise bzr_errors.NotBranchError(path=transport.base)
 
148
 
 
149
        import dulwich as git
 
150
        format = klass()
 
151
        try:
 
152
            format.open(transport)
 
153
            return format
 
154
        except git.errors.NotGitRepository, e:
 
155
            raise bzr_errors.NotBranchError(path=transport.base)
 
156
        raise bzr_errors.NotBranchError(path=transport.base)
 
157
 
 
158
    def get_format_description(self):
 
159
        return "Local Git Repository"
 
160
 
 
161
    def get_format_string(self):
 
162
        return "Local Git Repository"
 
163
 
 
164
    def initialize_on_transport(self, transport):
 
165
        from bzrlib.transport.local import LocalTransport
 
166
 
 
167
        if not isinstance(transport, LocalTransport):
 
168
            raise NotImplementedError(self.initialize, 
 
169
                "Can't create Git Repositories/branches on "
 
170
                "non-local transports")
 
171
 
 
172
        from dulwich.repo import Repo
 
173
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
 
174
        return self.open(transport)
 
175
 
 
176
    def is_supported(self):
 
177
        return True
 
178
 
 
179
 
 
180
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
181
    """The .git directory control format."""
 
182
 
 
183
    @classmethod
 
184
    def _known_formats(self):
 
185
        return set([RemoteGitBzrDirFormat()])
 
186
 
 
187
    def open(self, transport, _found=None):
 
188
        """Open this directory.
 
189
 
 
190
        """
 
191
        # we dont grok readonly - git isn't integrated with transport.
 
192
        url = transport.base
 
193
        if url.startswith('readonly+'):
 
194
            url = url[len('readonly+'):]
 
195
        if (not url.startswith("git://") and 
 
196
            not url.startswith("git+")):
 
197
            raise bzr_errors.NotBranchError(transport.base)
 
198
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
199
        if not isinstance(transport, GitSmartTransport):
 
200
            raise bzr_errors.NotBranchError(transport.base)
 
201
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
202
        lockfiles = GitLockableFiles(transport, GitLock())
 
203
        return RemoteGitDir(transport, lockfiles, self)
 
204
 
 
205
    @classmethod
 
206
    def probe_transport(klass, transport):
 
207
        """Our format is present if the transport ends in '.not/'."""
 
208
        url = transport.base
 
209
        if url.startswith('readonly+'):
 
210
            url = url[len('readonly+'):]
 
211
        if (not url.startswith("git://") and 
 
212
            not url.startswith("git+")):
 
213
            raise bzr_errors.NotBranchError(transport.base)
 
214
        # little ugly, but works
 
215
        format = klass()
 
216
        from bzrlib.plugins.git.remote import GitSmartTransport
 
217
        if not isinstance(transport, GitSmartTransport):
 
218
            raise bzr_errors.NotBranchError(transport.base)
 
219
        return format
 
220
 
 
221
    def get_format_description(self):
 
222
        return "Remote Git Repository"
 
223
 
 
224
    def get_format_string(self):
 
225
        return "Remote Git Repository"
 
226
 
 
227
    def initialize_on_transport(self, transport):
 
228
        raise bzr_errors.UninitializableFormat(self)
 
229
 
 
230
 
 
231
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
232
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
233
 
 
234
register_transport_proto('git://', 
 
235
        help="Access using the Git smart server protocol.")
 
236
register_transport_proto('git+ssh://', 
 
237
        help="Access using the Git smart server protocol over SSH.")
 
238
 
 
239
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
240
                        'TCPGitSmartTransport')
 
241
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
242
                        'SSHGitSmartTransport')
 
243
 
 
244
foreign_vcs_registry.register_lazy("git", 
 
245
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
246
 
 
247
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
248
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
 
249
    "bzrlib.plugins.git.commands")
 
250
 
 
251
def update_stanza(rev, stanza):
 
252
    mapping = getattr(rev, "mapping", None)
 
253
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
254
        stanza.add("git-commit", rev.foreign_revid)
 
255
 
 
256
 
 
257
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
258
if rio_hooks is not None:
 
259
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
260
 
 
261
 
 
262
try:
 
263
    from bzrlib.transport import transport_server_registry
 
264
except ImportError:
 
265
    pass
 
266
else:
 
267
    transport_server_registry.register_lazy('git',
 
268
        'bzrlib.plugins.git.server', 
 
269
        'serve_git',
 
270
        'Git Smart server protocol over TCP. (default port: 9418)')
 
271
 
 
272
 
 
273
from bzrlib.repository import network_format_registry as repository_network_format_registry
 
274
repository_network_format_registry.register_lazy('git', 
 
275
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
276
 
 
277
from bzrlib.bzrdir import network_format_registry as bzrdir_network_format_registry
 
278
bzrdir_network_format_registry.register('git', GitBzrDirFormat)
 
279
 
 
280
 
 
281
def get_rich_root_format(stacked=False):
 
282
    if stacked:
 
283
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
284
    else:
 
285
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
31
286
 
32
287
def test_suite():
33
288
    from bzrlib.plugins.git import tests