/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

Add NEWS entry about hg-git support.

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
        lazy_check_versions()
 
173
        from dulwich.repo import Repo
 
174
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
 
175
        return self.open(transport)
 
176
 
 
177
    def is_supported(self):
 
178
        return True
 
179
 
 
180
 
 
181
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
182
    """The .git directory control format."""
 
183
 
 
184
    @classmethod
 
185
    def _known_formats(self):
 
186
        return set([RemoteGitBzrDirFormat()])
 
187
 
 
188
    def open(self, transport, _found=None):
 
189
        """Open this directory.
 
190
 
 
191
        """
 
192
        # we dont grok readonly - git isn't integrated with transport.
 
193
        url = transport.base
 
194
        if url.startswith('readonly+'):
 
195
            url = url[len('readonly+'):]
 
196
        if (not url.startswith("git://") and 
 
197
            not url.startswith("git+")):
 
198
            raise bzr_errors.NotBranchError(transport.base)
 
199
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
200
        if not isinstance(transport, GitSmartTransport):
 
201
            raise bzr_errors.NotBranchError(transport.base)
 
202
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
203
        lockfiles = GitLockableFiles(transport, GitLock())
 
204
        return RemoteGitDir(transport, lockfiles, self)
 
205
 
 
206
    @classmethod
 
207
    def probe_transport(klass, transport):
 
208
        """Our format is present if the transport ends in '.not/'."""
 
209
        url = transport.base
 
210
        if url.startswith('readonly+'):
 
211
            url = url[len('readonly+'):]
 
212
        if (not url.startswith("git://") and 
 
213
            not url.startswith("git+")):
 
214
            raise bzr_errors.NotBranchError(transport.base)
 
215
        # little ugly, but works
 
216
        format = klass()
 
217
        from bzrlib.plugins.git.remote import GitSmartTransport
 
218
        if not isinstance(transport, GitSmartTransport):
 
219
            raise bzr_errors.NotBranchError(transport.base)
 
220
        return format
 
221
 
 
222
    def get_format_description(self):
 
223
        return "Remote Git Repository"
 
224
 
 
225
    def get_format_string(self):
 
226
        return "Remote Git Repository"
 
227
 
 
228
    def initialize_on_transport(self, transport):
 
229
        raise bzr_errors.UninitializableFormat(self)
 
230
 
 
231
 
 
232
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
233
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
234
 
 
235
register_transport_proto('git://', 
 
236
        help="Access using the Git smart server protocol.")
 
237
register_transport_proto('git+ssh://', 
 
238
        help="Access using the Git smart server protocol over SSH.")
 
239
 
 
240
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
241
                        'TCPGitSmartTransport')
 
242
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
243
                        'SSHGitSmartTransport')
 
244
 
 
245
foreign_vcs_registry.register_lazy("git", 
 
246
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
247
 
 
248
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
249
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
 
250
    "bzrlib.plugins.git.commands")
 
251
 
 
252
def update_stanza(rev, stanza):
 
253
    mapping = getattr(rev, "mapping", None)
 
254
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
255
        stanza.add("git-commit", rev.foreign_revid)
 
256
 
 
257
 
 
258
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
259
if rio_hooks is not None:
 
260
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
261
 
 
262
 
 
263
from bzrlib.transport import transport_server_registry
 
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
from bzrlib.repository import network_format_registry as repository_network_format_registry
 
271
repository_network_format_registry.register_lazy('git', 
 
272
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
273
 
 
274
from bzrlib.bzrdir import network_format_registry as bzrdir_network_format_registry
 
275
bzrdir_network_format_registry.register('git', GitBzrDirFormat)
 
276
 
 
277
 
 
278
def get_rich_root_format(stacked=False):
 
279
    if stacked:
 
280
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
281
    else:
 
282
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
283
 
 
284
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
285
                                   'send_git', 'Git am-style diff format')
 
286
 
 
287
def test_suite():
 
288
    from bzrlib.plugins.git import tests
 
289
    return tests.test_suite()