/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 user_url/control_url.

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
    errors as bzr_errors,
 
47
    osutils,
 
48
    )
 
49
try:
 
50
    from bzrlib.controldir import (
 
51
        ControlDirFormat,
 
52
        ControlDir,
 
53
        Prober,
 
54
        format_registry,
 
55
        )
 
56
except ImportError:
 
57
    # bzr < 2.3
 
58
    from bzrlib.bzrdir import (
 
59
        BzrDirFormat,
 
60
        BzrDir,
 
61
        format_registry,
 
62
        )
 
63
    ControlDir = BzrDir
 
64
    ControlDirFormat = BzrDirFormat
 
65
    Prober = object
 
66
    has_controldir = False
 
67
else:
 
68
    has_controldir = True
 
69
 
 
70
from bzrlib.foreign import (
 
71
    foreign_vcs_registry,
 
72
    )
 
73
from bzrlib.help_topics import (
 
74
    topic_registry,
 
75
    )
 
76
from bzrlib.lockable_files import (
 
77
    TransportLock,
 
78
    )
 
79
from bzrlib.transport import (
 
80
    register_lazy_transport,
 
81
    register_transport_proto,
 
82
    )
 
83
from bzrlib.commands import (
 
84
    plugin_cmds,
 
85
    )
 
86
from bzrlib.version_info_formats.format_rio import (
 
87
    RioVersionInfoBuilder,
 
88
    )
 
89
from bzrlib.send import (
 
90
    format_registry as send_format_registry,
 
91
    )
 
92
 
 
93
 
 
94
if getattr(sys, "frozen", None):
 
95
    # allow import additional libs from ./_lib for bzr.exe only
 
96
    sys.path.append(os.path.normpath(
 
97
        os.path.join(os.path.dirname(__file__), '_lib')))
 
98
 
 
99
 
 
100
def import_dulwich():
 
101
    try:
 
102
        from dulwich import __version__ as dulwich_version
 
103
    except ImportError:
 
104
        raise bzr_errors.DependencyNotPresent("dulwich",
 
105
            "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
106
    else:
 
107
        if dulwich_version < dulwich_minimum_version:
 
108
            raise bzr_errors.DependencyNotPresent("dulwich",
 
109
                "bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
 
110
                    dulwich_minimum_version)
 
111
 
 
112
 
 
113
_versions_checked = False
 
114
def lazy_check_versions():
 
115
    global _versions_checked
 
116
    if _versions_checked:
 
117
        return
 
118
    import_dulwich()
 
119
    _versions_checked = True
 
120
 
 
121
format_registry.register_lazy('git',
 
122
    "bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
 
123
    help='GIT repository.', native=False, experimental=False,
 
124
    )
 
125
 
 
126
format_registry.register_lazy('git-bare',
 
127
    "bzrlib.plugins.git.dir", "BareLocalGitControlDirFormat",
 
128
    help='Bare GIT repository (no working tree).', native=False,
 
129
    experimental=False,
 
130
    )
 
131
 
 
132
from bzrlib.revisionspec import revspec_registry
 
133
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
134
    "RevisionSpec_git")
 
135
 
 
136
try:
 
137
    from bzrlib.revisionspec import dwim_revspecs
 
138
except ImportError:
 
139
    pass
 
140
else:
 
141
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
142
    dwim_revspecs.append(RevisionSpec_git)
 
143
 
 
144
 
 
145
class GitControlDirFormat(ControlDirFormat):
 
146
 
 
147
    _lock_class = TransportLock
 
148
 
 
149
    colocated_branches = True
 
150
 
 
151
    def __eq__(self, other):
 
152
        return type(self) == type(other)
 
153
 
 
154
    def is_supported(self):
 
155
        return True
 
156
 
 
157
    def network_name(self):
 
158
        return "git"
 
159
 
 
160
 
 
161
class LocalGitProber(Prober):
 
162
 
 
163
    def probe_transport(self, transport):
 
164
        try:
 
165
            if not transport.has_any(['info/refs', '.git/branches',
 
166
                                      'branches']):
 
167
                raise bzr_errors.NotBranchError(path=transport.base)
 
168
        except bzr_errors.NoSuchFile:
 
169
            raise bzr_errors.NotBranchError(path=transport.base)
 
170
        from bzrlib import urlutils
 
171
        if urlutils.split(transport.base)[1] == ".git":
 
172
            raise bzr_errors.NotBranchError(path=transport.base)
 
173
        lazy_check_versions()
 
174
        import dulwich
 
175
        from bzrlib.plugins.git.transportgit import TransportRepo
 
176
        try:
 
177
            gitrepo = TransportRepo(transport)
 
178
        except dulwich.errors.NotGitRepository, e:
 
179
            raise bzr_errors.NotBranchError(path=transport.base)
 
180
        else:
 
181
            if gitrepo.bare:
 
182
                return BareLocalGitControlDirFormat()
 
183
            else:
 
184
                return LocalGitControlDirFormat()
 
185
 
 
186
 
 
187
class LocalGitControlDirFormat(GitControlDirFormat):
 
188
    """The .git directory control format."""
 
189
 
 
190
    bare = False
 
191
 
 
192
    @classmethod
 
193
    def _known_formats(self):
 
194
        return set([LocalGitControlDirFormat()])
 
195
 
 
196
    def open(self, transport, _found=None):
 
197
        """Open this directory.
 
198
 
 
199
        """
 
200
        lazy_check_versions()
 
201
        from bzrlib.plugins.git.transportgit import TransportRepo
 
202
        gitrepo = TransportRepo(transport)
 
203
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
204
        lockfiles = GitLockableFiles(transport, GitLock())
 
205
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
206
 
 
207
    @classmethod
 
208
    def probe_transport(klass, transport):
 
209
        prober = LocalGitProber()
 
210
        return prober.probe_transport(transport)
 
211
 
 
212
    def get_format_description(self):
 
213
        return "Local Git Repository"
 
214
 
 
215
    def initialize_on_transport(self, transport):
 
216
        from bzrlib.transport.local import LocalTransport
 
217
 
 
218
        if not isinstance(transport, LocalTransport):
 
219
            raise NotImplementedError(self.initialize,
 
220
                "Can't create Git Repositories/branches on "
 
221
                "non-local transports")
 
222
        lazy_check_versions()
 
223
        from dulwich.repo import Repo
 
224
        path = transport.local_abspath(".").encode(osutils._fs_enc)
 
225
        if self.bare:
 
226
            Repo.init_bare(path)
 
227
        else:
 
228
            Repo.init(path)
 
229
        return self.open(transport)
 
230
 
 
231
    def is_supported(self):
 
232
        return True
 
233
 
 
234
 
 
235
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
 
236
 
 
237
    bare = True
 
238
    supports_workingtrees = False
 
239
 
 
240
    @classmethod
 
241
    def _known_formats(self):
 
242
        return set([RemoteGitControlDirFormat()])
 
243
 
 
244
    def get_format_description(self):
 
245
        return "Local Git Repository (bare)"
 
246
 
 
247
 
 
248
class RemoteGitProber(Prober):
 
249
 
 
250
    def probe_transport(self, transport):
 
251
        url = transport.base
 
252
        if url.startswith('readonly+'):
 
253
            url = url[len('readonly+'):]
 
254
        if (not url.startswith("git://") and not url.startswith("git+")):
 
255
            raise bzr_errors.NotBranchError(transport.base)
 
256
        # little ugly, but works
 
257
        from bzrlib.plugins.git.remote import GitSmartTransport
 
258
        if not isinstance(transport, GitSmartTransport):
 
259
            raise bzr_errors.NotBranchError(transport.base)
 
260
        return RemoteGitControlDirFormat()
 
261
 
 
262
 
 
263
 
 
264
class RemoteGitControlDirFormat(GitControlDirFormat):
 
265
    """The .git directory control format."""
 
266
 
 
267
    supports_workingtrees = False
 
268
 
 
269
    @classmethod
 
270
    def _known_formats(self):
 
271
        return set([RemoteGitControlDirFormat()])
 
272
 
 
273
    def open(self, transport, _found=None):
 
274
        """Open this directory.
 
275
 
 
276
        """
 
277
        # we dont grok readonly - git isn't integrated with transport.
 
278
        url = transport.base
 
279
        if url.startswith('readonly+'):
 
280
            url = url[len('readonly+'):]
 
281
        if (not url.startswith("git://") and not url.startswith("git+")):
 
282
            raise bzr_errors.NotBranchError(transport.base)
 
283
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
284
        if not isinstance(transport, GitSmartTransport):
 
285
            raise bzr_errors.NotBranchError(transport.base)
 
286
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
287
        lockfiles = GitLockableFiles(transport, GitLock())
 
288
        return RemoteGitDir(transport, lockfiles, self)
 
289
 
 
290
    @classmethod
 
291
    def probe_transport(klass, transport):
 
292
        """Our format is present if the transport ends in '.not/'."""
 
293
        prober = RemoteGitProber()
 
294
        return prober.probe_transport(transport)
 
295
 
 
296
    def get_format_description(self):
 
297
        return "Remote Git Repository"
 
298
 
 
299
    def initialize_on_transport(self, transport):
 
300
        raise bzr_errors.UninitializableFormat(self)
 
301
 
 
302
 
 
303
if has_controldir:
 
304
    ControlDirFormat.register_format(LocalGitControlDirFormat())
 
305
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
 
306
    ControlDirFormat.register_format(RemoteGitControlDirFormat())
 
307
    ControlDirFormat.register_prober(LocalGitProber)
 
308
    ControlDirFormat.register_prober(RemoteGitProber)
 
309
else:
 
310
    ControlDirFormat.register_control_format(LocalGitControlDirFormat)
 
311
    ControlDirFormat.register_control_format(BareLocalGitControlDirFormat)
 
312
    ControlDirFormat.register_control_format(RemoteGitControlDirFormat)
 
313
 
 
314
register_transport_proto('git://',
 
315
        help="Access using the Git smart server protocol.")
 
316
register_transport_proto('git+ssh://',
 
317
        help="Access using the Git smart server protocol over SSH.")
 
318
 
 
319
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
320
                        'TCPGitSmartTransport')
 
321
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
322
                        'SSHGitSmartTransport')
 
323
 
 
324
foreign_vcs_registry.register_lazy("git",
 
325
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
326
 
 
327
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
328
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
329
    "bzrlib.plugins.git.commands")
 
330
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
331
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
332
 
 
333
def update_stanza(rev, stanza):
 
334
    mapping = getattr(rev, "mapping", None)
 
335
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
336
        stanza.add("git-commit", rev.foreign_revid)
 
337
 
 
338
 
 
339
RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza, None)
 
340
 
 
341
 
 
342
from bzrlib.transport import transport_server_registry
 
343
transport_server_registry.register_lazy('git',
 
344
    'bzrlib.plugins.git.server',
 
345
    'serve_git',
 
346
    'Git Smart server protocol over TCP. (default port: 9418)')
 
347
 
 
348
 
 
349
from bzrlib.repository import (
 
350
    network_format_registry as repository_network_format_registry,
 
351
    )
 
352
repository_network_format_registry.register_lazy('git',
 
353
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
354
 
 
355
try:
 
356
    from bzrlib.controldir import (
 
357
        network_format_registry as controldir_network_format_registry,
 
358
        )
 
359
except ImportError:
 
360
    from bzrlib.bzrdir import (
 
361
        network_format_registry as controldir_network_format_registry,
 
362
        )
 
363
controldir_network_format_registry.register('git', GitControlDirFormat)
 
364
 
 
365
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
366
                                   'send_git', 'Git am-style diff format')
 
367
 
 
368
topic_registry.register_lazy('git',
 
369
                             'bzrlib.plugins.git.help',
 
370
                             'help_git', 'Using Bazaar with Git')
 
371
 
 
372
try:
 
373
    from bzrlib.diff import format_registry as diff_format_registry
 
374
except ImportError:
 
375
    pass
 
376
else:
 
377
    diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
378
        'GitDiffTree', 'Git am-style diff format')
 
379
 
 
380
def test_suite():
 
381
    from bzrlib.plugins.git import tests
 
382
    return tests.test_suite()