/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

Raise about impossible arguments in send --format=git.

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
    bzrdir,
 
47
    errors as bzr_errors,
 
48
    osutils,
 
49
    )
 
50
from bzrlib.foreign import (
 
51
    foreign_vcs_registry,
 
52
    )
 
53
from bzrlib.lockable_files import (
 
54
    TransportLock,
 
55
    )
 
56
from bzrlib.transport import (
 
57
    register_lazy_transport,
 
58
    register_transport_proto,
 
59
    )
 
60
from bzrlib.commands import (
 
61
    plugin_cmds,
 
62
    )
 
63
from bzrlib.version_info_formats.format_rio import (
 
64
    RioVersionInfoBuilder,
 
65
    )
 
66
from bzrlib.send import (
 
67
    format_registry as send_format_registry,
 
68
    )
 
69
 
 
70
 
 
71
if getattr(sys, "frozen", None):
 
72
    # allow import additional libs from ./_lib for bzr.exe only
 
73
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
 
74
 
 
75
_versions_checked = False
 
76
def lazy_check_versions():
 
77
    global _versions_checked
 
78
    if _versions_checked:
 
79
        return
 
80
    _versions_checked = True
 
81
    try:
 
82
        from dulwich import __version__ as dulwich_version
 
83
    except ImportError:
 
84
        raise bzr_errors.DependencyNotPresent("dulwich", "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
85
    else:
 
86
        if dulwich_version < dulwich_minimum_version:
 
87
            raise bzr_errors.DependencyNotPresent("dulwich", "bzr-git: Dulwich is too old; at least %d.%d.%d is required" % dulwich_minimum_version)
 
88
 
 
89
bzrdir.format_registry.register_lazy('git', 
 
90
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
91
    help='GIT repository.', native=False, experimental=True,
 
92
    )
 
93
 
 
94
from bzrlib.revisionspec import revspec_registry
 
95
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
96
    "RevisionSpec_git")
 
97
 
 
98
 
 
99
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
100
 
 
101
    _lock_class = TransportLock
 
102
 
 
103
    def is_supported(self):
 
104
        return True
 
105
 
 
106
    def network_name(self):
 
107
        return "git"
 
108
 
 
109
 
 
110
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
111
    """The .git directory control format."""
 
112
 
 
113
    @classmethod
 
114
    def _known_formats(self):
 
115
        return set([LocalGitBzrDirFormat()])
 
116
 
 
117
    def open(self, transport, _found=None):
 
118
        """Open this directory.
 
119
 
 
120
        """
 
121
        lazy_check_versions()
 
122
        import dulwich
 
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 = dulwich.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
        lazy_check_versions()
 
150
        import dulwich
 
151
        format = klass()
 
152
        try:
 
153
            format.open(transport)
 
154
            return format
 
155
        except dulwich.errors.NotGitRepository, e:
 
156
            raise bzr_errors.NotBranchError(path=transport.base)
 
157
        raise bzr_errors.NotBranchError(path=transport.base)
 
158
 
 
159
    def get_format_description(self):
 
160
        return "Local Git Repository"
 
161
 
 
162
    def get_format_string(self):
 
163
        return "Local Git Repository"
 
164
 
 
165
    def initialize_on_transport(self, transport):
 
166
        from bzrlib.transport.local import LocalTransport
 
167
 
 
168
        if not isinstance(transport, LocalTransport):
 
169
            raise NotImplementedError(self.initialize, 
 
170
                "Can't create Git Repositories/branches on "
 
171
                "non-local transports")
 
172
 
 
173
        lazy_check_versions()
 
174
        from dulwich.repo import Repo
 
175
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
 
176
        return self.open(transport)
 
177
 
 
178
    def is_supported(self):
 
179
        return True
 
180
 
 
181
 
 
182
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
183
    """The .git directory control format."""
 
184
 
 
185
    @classmethod
 
186
    def _known_formats(self):
 
187
        return set([RemoteGitBzrDirFormat()])
 
188
 
 
189
    def open(self, transport, _found=None):
 
190
        """Open this directory.
 
191
 
 
192
        """
 
193
        # we dont grok readonly - git isn't integrated with transport.
 
194
        url = transport.base
 
195
        if url.startswith('readonly+'):
 
196
            url = url[len('readonly+'):]
 
197
        if (not url.startswith("git://") and 
 
198
            not url.startswith("git+")):
 
199
            raise bzr_errors.NotBranchError(transport.base)
 
200
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
201
        if not isinstance(transport, GitSmartTransport):
 
202
            raise bzr_errors.NotBranchError(transport.base)
 
203
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
204
        lockfiles = GitLockableFiles(transport, GitLock())
 
205
        return RemoteGitDir(transport, lockfiles, self)
 
206
 
 
207
    @classmethod
 
208
    def probe_transport(klass, transport):
 
209
        """Our format is present if the transport ends in '.not/'."""
 
210
        url = transport.base
 
211
        if url.startswith('readonly+'):
 
212
            url = url[len('readonly+'):]
 
213
        if (not url.startswith("git://") and 
 
214
            not url.startswith("git+")):
 
215
            raise bzr_errors.NotBranchError(transport.base)
 
216
        # little ugly, but works
 
217
        format = klass()
 
218
        from bzrlib.plugins.git.remote import GitSmartTransport
 
219
        if not isinstance(transport, GitSmartTransport):
 
220
            raise bzr_errors.NotBranchError(transport.base)
 
221
        return format
 
222
 
 
223
    def get_format_description(self):
 
224
        return "Remote Git Repository"
 
225
 
 
226
    def get_format_string(self):
 
227
        return "Remote Git Repository"
 
228
 
 
229
    def initialize_on_transport(self, transport):
 
230
        raise bzr_errors.UninitializableFormat(self)
 
231
 
 
232
 
 
233
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
234
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
235
 
 
236
register_transport_proto('git://', 
 
237
        help="Access using the Git smart server protocol.")
 
238
register_transport_proto('git+ssh://', 
 
239
        help="Access using the Git smart server protocol over SSH.")
 
240
 
 
241
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
242
                        'TCPGitSmartTransport')
 
243
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
244
                        'SSHGitSmartTransport')
 
245
 
 
246
foreign_vcs_registry.register_lazy("git", 
 
247
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
248
 
 
249
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
250
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
 
251
    "bzrlib.plugins.git.commands")
 
252
 
 
253
def update_stanza(rev, stanza):
 
254
    mapping = getattr(rev, "mapping", None)
 
255
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
256
        stanza.add("git-commit", rev.foreign_revid)
 
257
 
 
258
 
 
259
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
260
if rio_hooks is not None:
 
261
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
262
 
 
263
 
 
264
from bzrlib.transport import transport_server_registry
 
265
transport_server_registry.register_lazy('git',
 
266
    'bzrlib.plugins.git.server', 
 
267
    'serve_git',
 
268
    'Git Smart server protocol over TCP. (default port: 9418)')
 
269
 
 
270
 
 
271
from bzrlib.repository import network_format_registry as repository_network_format_registry
 
272
repository_network_format_registry.register_lazy('git', 
 
273
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
274
 
 
275
from bzrlib.bzrdir import network_format_registry as bzrdir_network_format_registry
 
276
bzrdir_network_format_registry.register('git', GitBzrDirFormat)
 
277
 
 
278
 
 
279
def get_rich_root_format(stacked=False):
 
280
    if stacked:
 
281
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
282
    else:
 
283
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
284
 
 
285
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
286
                                   'send_git', 'Git am-style diff format')
 
287
 
 
288
def test_suite():
 
289
    from bzrlib.plugins.git import tests
 
290
    return tests.test_suite()