/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

Support 'bzr serve --git'.

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
3
# Authors: Robert Collins <robert.collins@canonical.com>
4
4
#          Jelmer Vernooij <jelmer@samba.org>
21
21
 
22
22
"""A GIT branch and repository format implementation for bzr."""
23
23
 
 
24
import os
 
25
import sys
 
26
 
24
27
import bzrlib
25
28
import bzrlib.api
26
 
from bzrlib import bzrdir, errors as bzr_errors
27
 
from bzrlib.foreign import foreign_vcs_registry
28
 
from bzrlib.lockable_files import TransportLock
29
 
from bzrlib.transport import register_lazy_transport
30
 
from bzrlib.commands import plugin_cmds
31
 
from bzrlib.trace import warning
32
 
 
33
 
MINIMUM_DULWICH_VERSION = (0, 1, 0)
34
 
COMPATIBLE_BZR_VERSIONS = [(1, 11, 0), (1, 12, 0)]
 
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')))
35
76
 
36
77
_versions_checked = False
37
78
def lazy_check_versions():
42
83
    try:
43
84
        from dulwich import __version__ as dulwich_version
44
85
    except ImportError:
45
 
        warning("Please install dulwich, https://launchpad.net/dulwich")
46
 
        raise
 
86
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
47
87
    else:
48
88
        if dulwich_version < MINIMUM_DULWICH_VERSION:
49
 
            warning("Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
50
 
            raise ImportError
51
 
 
52
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
89
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
53
90
 
54
91
bzrdir.format_registry.register_lazy('git', 
55
92
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
56
93
    help='GIT repository.', native=False, experimental=True,
57
94
    )
58
95
 
59
 
try:
60
 
    from bzrlib.revisionspec import revspec_registry
61
 
    revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
62
 
        "RevisionSpec_git")
63
 
except ImportError:
64
 
    lazy_check_versions()
65
 
    from bzrlib.revisionspec import SPEC_TYPES
66
 
    from bzrlib.plugins.git.revspec import RevisionSpec_git
67
 
    SPEC_TYPES.append(RevisionSpec_git)
 
96
from bzrlib.revisionspec import revspec_registry
 
97
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
98
    "RevisionSpec_git")
 
99
 
68
100
 
69
101
class GitBzrDirFormat(bzrdir.BzrDirFormat):
70
102
    _lock_class = TransportLock
91
123
            url = url[len('readonly+'):]
92
124
 
93
125
        try:
94
 
            gitrepo = git.repo.Repo(transport.local_abspath("."))
 
126
            gitrepo = git.repo.Repo(transport.local_abspath(".").encode(osutils._fs_enc))
95
127
        except bzr_errors.NotLocalUrl:
96
128
            raise bzr_errors.NotBranchError(path=transport.base)
97
129
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
135
167
                "non-local transports")
136
168
 
137
169
        from dulwich.repo import Repo
138
 
        Repo.create(transport.local_abspath(".")) 
 
170
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
139
171
        return self.open(transport)
140
172
 
141
173
    def is_supported(self):
153
185
        """Open this directory.
154
186
 
155
187
        """
 
188
        # we dont grok readonly - git isn't integrated with transport.
 
189
        url = transport.base
 
190
        if url.startswith('readonly+'):
 
191
            url = url[len('readonly+'):]
 
192
        if (not url.startswith("git://") and 
 
193
            not url.startswith("git+")):
 
194
            raise bzr_errors.NotBranchError(transport.base)
156
195
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
157
196
        if not isinstance(transport, GitSmartTransport):
158
197
            raise bzr_errors.NotBranchError(transport.base)
159
 
        # we dont grok readonly - git isn't integrated with transport.
160
 
        url = transport.base
161
 
        if url.startswith('readonly+'):
162
 
            url = url[len('readonly+'):]
163
 
 
164
198
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
165
199
        lockfiles = GitLockableFiles(transport, GitLock())
166
200
        return RemoteGitDir(transport, lockfiles, self)
168
202
    @classmethod
169
203
    def probe_transport(klass, transport):
170
204
        """Our format is present if the transport ends in '.not/'."""
 
205
        url = transport.base
 
206
        if url.startswith('readonly+'):
 
207
            url = url[len('readonly+'):]
 
208
        if (not url.startswith("git://") and 
 
209
            not url.startswith("git+")):
 
210
            raise bzr_errors.NotBranchError(transport.base)
171
211
        # little ugly, but works
172
212
        format = klass()
173
213
        from bzrlib.plugins.git.remote import GitSmartTransport
174
214
        if not isinstance(transport, GitSmartTransport):
175
215
            raise bzr_errors.NotBranchError(transport.base)
176
 
        # The only way to know a path exists and contains a valid repository 
177
 
        # is to do a request against it:
178
 
        try:
179
 
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
180
 
                                 lambda x: mutter("git: %s" % x))
181
 
        except errors.git_errors.GitProtocolError:
182
 
            raise bzr_errors.NotBranchError(path=transport.base)
183
 
        else:
184
 
            return format
185
 
        raise bzr_errors.NotBranchError(path=transport.base)
 
216
        return format
186
217
 
187
218
    def get_format_description(self):
188
219
        return "Remote Git Repository"
197
228
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
198
229
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
199
230
 
 
231
register_transport_proto('git://', 
 
232
        help="Access using the Git smart server protocol.")
 
233
register_transport_proto('git+ssh://', 
 
234
        help="Access using the Git smart server protocol over SSH.")
 
235
 
200
236
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
201
 
                        'GitSmartTransport')
 
237
                        'TCPGitSmartTransport')
 
238
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
239
                        'SSHGitSmartTransport')
202
240
 
203
241
foreign_vcs_registry.register_lazy("git", 
204
 
                        "bzrlib.plugins.git.mapping", 
205
 
                        "foreign_git",
206
 
                        "Stupid content tracker")
 
242
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
207
243
 
208
 
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
209
244
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
245
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
 
246
    "bzrlib.plugins.git.commands")
 
247
 
 
248
def update_stanza(rev, stanza):
 
249
    mapping = getattr(rev, "mapping", None)
 
250
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
251
        stanza.add("git-commit", rev.foreign_revid)
 
252
 
 
253
 
 
254
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
255
if rio_hooks is not None:
 
256
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
257
 
 
258
 
 
259
try:
 
260
    from bzrlib.transport import transport_server_registry
 
261
except ImportError:
 
262
    pass
 
263
else:
 
264
    transport_server_registry.register_lazy('git',
 
265
        'bzrlib.plugins.git.server', 
 
266
        'serve_git',
 
267
        'Git Smart server protocol over TCP. (default port: 9418)')
 
268
 
 
269
 
 
270
def get_rich_root_format(stacked=False):
 
271
    if stacked:
 
272
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
273
    else:
 
274
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
210
275
 
211
276
def test_suite():
212
277
    from bzrlib.plugins.git import tests