/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

Handle lightweight checkouts.

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
from bzrlib import (
 
30
    bzrdir,
 
31
    errors as bzr_errors,
 
32
    )
 
33
from bzrlib.foreign import (
 
34
    foreign_vcs_registry,
 
35
    )
 
36
from bzrlib.lockable_files import (
 
37
    TransportLock,
 
38
    )
 
39
from bzrlib.transport import (
 
40
    register_lazy_transport,
 
41
    register_transport_proto,
 
42
    )
 
43
from bzrlib.commands import (
 
44
    plugin_cmds,
 
45
    )
 
46
from bzrlib.trace import (
 
47
    warning,
 
48
    )
 
49
 
 
50
# versions ending in 'exp' mean experimental mappings
 
51
# versions ending in 'dev' mean development version
 
52
# versions ending in 'final' mean release (well tested, etc)
 
53
version_info = (0, 2, 0, 'dev', 0)
 
54
 
 
55
if version_info[3] == 'final':
 
56
    version_string = '%d.%d.%d' % version_info[:3]
 
57
else:
 
58
    version_string = '%d.%d.%d%s%d' % version_info
 
59
__version__ = version_string
 
60
 
 
61
MINIMUM_DULWICH_VERSION = (0, 1, 1)
 
62
COMPATIBLE_BZR_VERSIONS = [(1, 13, 0)]
 
63
 
 
64
if getattr(sys, "frozen", None):
 
65
    # allow import additional libs from ./_lib for bzr.exe only
 
66
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
 
67
 
 
68
_versions_checked = False
 
69
def lazy_check_versions():
 
70
    global _versions_checked
 
71
    if _versions_checked:
 
72
        return
 
73
    _versions_checked = True
 
74
    try:
 
75
        from dulwich import __version__ as dulwich_version
 
76
    except ImportError:
 
77
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
78
    else:
 
79
        if dulwich_version < MINIMUM_DULWICH_VERSION:
 
80
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
 
81
 
 
82
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
83
 
 
84
bzrdir.format_registry.register_lazy('git', 
 
85
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
86
    help='GIT repository.', native=False, experimental=True,
 
87
    )
 
88
 
 
89
from bzrlib.revisionspec import revspec_registry
 
90
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
91
    "RevisionSpec_git")
 
92
 
 
93
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
94
    _lock_class = TransportLock
 
95
 
 
96
    def is_supported(self):
 
97
        return True
 
98
 
 
99
 
 
100
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
101
    """The .git directory control format."""
 
102
 
 
103
    @classmethod
 
104
    def _known_formats(self):
 
105
        return set([LocalGitBzrDirFormat()])
 
106
 
 
107
    def open(self, transport, _found=None):
 
108
        """Open this directory.
 
109
 
 
110
        """
 
111
        import dulwich as git
 
112
        # we dont grok readonly - git isn't integrated with transport.
 
113
        url = transport.base
 
114
        if url.startswith('readonly+'):
 
115
            url = url[len('readonly+'):]
 
116
 
 
117
        try:
 
118
            gitrepo = git.repo.Repo(transport.local_abspath("."))
 
119
        except bzr_errors.NotLocalUrl:
 
120
            raise bzr_errors.NotBranchError(path=transport.base)
 
121
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
122
        lockfiles = GitLockableFiles(transport, GitLock())
 
123
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
124
 
 
125
    @classmethod
 
126
    def probe_transport(klass, transport):
 
127
        """Our format is present if the transport ends in '.not/'."""
 
128
        from bzrlib.transport.local import LocalTransport
 
129
 
 
130
        if not isinstance(transport, LocalTransport):
 
131
            raise bzr_errors.NotBranchError(path=transport.base)
 
132
 
 
133
        # This should quickly filter out most things that are not 
 
134
        # git repositories, saving us the trouble from loading dulwich.
 
135
        if not transport.has(".git") and not transport.has("objects"):
 
136
            raise bzr_errors.NotBranchError(path=transport.base)
 
137
 
 
138
        import dulwich as git
 
139
        format = klass()
 
140
        try:
 
141
            format.open(transport)
 
142
            return format
 
143
        except git.errors.NotGitRepository, e:
 
144
            raise bzr_errors.NotBranchError(path=transport.base)
 
145
        raise bzr_errors.NotBranchError(path=transport.base)
 
146
 
 
147
    def get_format_description(self):
 
148
        return "Local Git Repository"
 
149
 
 
150
    def get_format_string(self):
 
151
        return "Local Git Repository"
 
152
 
 
153
    def initialize_on_transport(self, transport):
 
154
        from bzrlib.transport.local import LocalTransport
 
155
 
 
156
        if not isinstance(transport, LocalTransport):
 
157
            raise NotImplementedError(self.initialize, 
 
158
                "Can't create Git Repositories/branches on "
 
159
                "non-local transports")
 
160
 
 
161
        from dulwich.repo import Repo
 
162
        Repo.create(transport.local_abspath(".")) 
 
163
        return self.open(transport)
 
164
 
 
165
    def is_supported(self):
 
166
        return True
 
167
 
 
168
 
 
169
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
170
    """The .git directory control format."""
 
171
 
 
172
    @classmethod
 
173
    def _known_formats(self):
 
174
        return set([RemoteGitBzrDirFormat()])
 
175
 
 
176
    def open(self, transport, _found=None):
 
177
        """Open this directory.
 
178
 
 
179
        """
 
180
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
181
        if not isinstance(transport, GitSmartTransport):
 
182
            raise bzr_errors.NotBranchError(transport.base)
 
183
        # we dont grok readonly - git isn't integrated with transport.
 
184
        url = transport.base
 
185
        if url.startswith('readonly+'):
 
186
            url = url[len('readonly+'):]
 
187
 
 
188
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
189
        lockfiles = GitLockableFiles(transport, GitLock())
 
190
        return RemoteGitDir(transport, lockfiles, self)
 
191
 
 
192
    @classmethod
 
193
    def probe_transport(klass, transport):
 
194
        """Our format is present if the transport ends in '.not/'."""
 
195
        # little ugly, but works
 
196
        format = klass()
 
197
        from bzrlib.plugins.git.remote import GitSmartTransport
 
198
        if not isinstance(transport, GitSmartTransport):
 
199
            raise bzr_errors.NotBranchError(transport.base)
 
200
        # The only way to know a path exists and contains a valid repository 
 
201
        # is to do a request against it:
 
202
        try:
 
203
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
 
204
                                 lambda x: mutter("git: %s" % x))
 
205
        except errors.git_errors.GitProtocolError:
 
206
            raise bzr_errors.NotBranchError(path=transport.base)
 
207
        else:
 
208
            return format
 
209
        raise bzr_errors.NotBranchError(path=transport.base)
 
210
 
 
211
    def get_format_description(self):
 
212
        return "Remote Git Repository"
 
213
 
 
214
    def get_format_string(self):
 
215
        return "Remote Git Repository"
 
216
 
 
217
    def initialize_on_transport(self, transport):
 
218
        raise bzr_errors.UninitializableFormat(self)
 
219
 
 
220
 
 
221
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
222
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
223
 
 
224
register_transport_proto('git://', 
 
225
        help="Access using the Git smart server protocol.")
 
226
register_transport_proto('git+ssh://', 
 
227
        help="Access using the Git smart server protocol over SSH.")
 
228
 
 
229
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
230
                        'TCPGitSmartTransport')
 
231
 
 
232
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
233
                        'SSHGitSmartTransport')
 
234
 
 
235
foreign_vcs_registry.register_lazy("git", 
 
236
                        "bzrlib.plugins.git.mapping", 
 
237
                        "foreign_git",
 
238
                        "Stupid content tracker")
 
239
 
 
240
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
 
241
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
242
 
 
243
def get_rich_root_format():
 
244
    try:
 
245
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
246
    except KeyError:
 
247
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
31
248
 
32
249
def test_suite():
33
250
    from bzrlib.plugins.git import tests