/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

More work on roundtrip push support.

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