/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

Merge in dulwich.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
# Copyright (C) 2006-2009 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 Canonical Ltd
3
2
# Authors: Robert Collins <robert.collins@canonical.com>
4
 
#          Jelmer Vernooij <jelmer@samba.org>
5
 
#          John Carr <john.carr@unrouted.co.uk>
6
3
#
7
4
# This program is free software; you can redistribute it and/or modify
8
5
# it under the terms of the GNU General Public License as published by
21
18
 
22
19
"""A GIT branch and repository format implementation for bzr."""
23
20
 
24
 
import os
25
 
import sys
26
 
 
27
 
import bzrlib
28
 
import bzrlib.api
29
 
 
30
 
# versions ending in 'exp' mean experimental mappings
31
 
# versions ending in 'dev' mean development version
32
 
# versions ending in 'final' mean release (well tested, etc)
33
 
version_info = (0, 3, 1, 'final', 0)
34
 
 
35
 
if version_info[3] == 'final':
36
 
    version_string = '%d.%d.%d' % version_info[:3]
37
 
else:
38
 
    version_string = '%d.%d.%d%s%d' % version_info
39
 
__version__ = version_string
40
 
 
41
 
MINIMUM_DULWICH_VERSION = (0, 3, 1)
42
 
COMPATIBLE_BZR_VERSIONS = [(1, 14, 0), (1, 15, 0)]
43
 
 
44
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
45
 
 
46
 
 
47
 
from bzrlib import (
48
 
    bzrdir,
49
 
    errors as bzr_errors,
50
 
    osutils,
51
 
    )
52
 
from bzrlib.foreign import (
53
 
    foreign_vcs_registry,
54
 
    )
55
 
from bzrlib.lockable_files import (
56
 
    TransportLock,
57
 
    )
58
 
from bzrlib.transport import (
59
 
    register_lazy_transport,
60
 
    register_transport_proto,
61
 
    )
62
 
from bzrlib.commands import (
63
 
    plugin_cmds,
64
 
    )
65
 
from bzrlib.trace import (
66
 
    warning,
67
 
    )
68
 
from bzrlib.version_info_formats.format_rio import (
69
 
    RioVersionInfoBuilder,
70
 
    )
71
 
 
72
 
 
73
 
if getattr(sys, "frozen", None):
74
 
    # allow import additional libs from ./_lib for bzr.exe only
75
 
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
76
 
 
77
 
_versions_checked = False
78
 
def lazy_check_versions():
79
 
    global _versions_checked
80
 
    if _versions_checked:
81
 
        return
82
 
    _versions_checked = True
83
 
    try:
84
 
        from dulwich import __version__ as dulwich_version
85
 
    except ImportError:
86
 
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
87
 
    else:
88
 
        if dulwich_version < MINIMUM_DULWICH_VERSION:
89
 
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
90
 
 
91
 
bzrdir.format_registry.register_lazy('git', 
92
 
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
93
 
    help='GIT repository.', native=False, experimental=True,
94
 
    )
95
 
 
96
 
from bzrlib.revisionspec import revspec_registry
97
 
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
98
 
    "RevisionSpec_git")
99
 
 
100
 
 
101
 
class GitBzrDirFormat(bzrdir.BzrDirFormat):
102
 
    _lock_class = TransportLock
103
 
 
104
 
    def is_supported(self):
105
 
        return True
106
 
 
107
 
 
108
 
class LocalGitBzrDirFormat(GitBzrDirFormat):
109
 
    """The .git directory control format."""
110
 
 
111
 
    @classmethod
112
 
    def _known_formats(self):
113
 
        return set([LocalGitBzrDirFormat()])
114
 
 
115
 
    def open(self, transport, _found=None):
116
 
        """Open this directory.
117
 
 
118
 
        """
119
 
        import dulwich as git
120
 
        # we dont grok readonly - git isn't integrated with transport.
121
 
        url = transport.base
122
 
        if url.startswith('readonly+'):
123
 
            url = url[len('readonly+'):]
124
 
 
125
 
        try:
126
 
            gitrepo = git.repo.Repo(transport.local_abspath(".").encode(osutils._fs_enc))
127
 
        except bzr_errors.NotLocalUrl:
128
 
            raise bzr_errors.NotBranchError(path=transport.base)
129
 
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
130
 
        lockfiles = GitLockableFiles(transport, GitLock())
131
 
        return LocalGitDir(transport, lockfiles, gitrepo, self)
132
 
 
133
 
    @classmethod
134
 
    def probe_transport(klass, transport):
135
 
        """Our format is present if the transport ends in '.not/'."""
136
 
        from bzrlib.transport.local import LocalTransport
137
 
 
138
 
        if not isinstance(transport, LocalTransport):
139
 
            raise bzr_errors.NotBranchError(path=transport.base)
140
 
 
141
 
        # This should quickly filter out most things that are not 
142
 
        # git repositories, saving us the trouble from loading dulwich.
143
 
        if not transport.has(".git") and not transport.has("objects"):
144
 
            raise bzr_errors.NotBranchError(path=transport.base)
145
 
 
146
 
        import dulwich as git
147
 
        format = klass()
148
 
        try:
149
 
            format.open(transport)
150
 
            return format
151
 
        except git.errors.NotGitRepository, e:
152
 
            raise bzr_errors.NotBranchError(path=transport.base)
153
 
        raise bzr_errors.NotBranchError(path=transport.base)
154
 
 
155
 
    def get_format_description(self):
156
 
        return "Local Git Repository"
157
 
 
158
 
    def get_format_string(self):
159
 
        return "Local Git Repository"
160
 
 
161
 
    def initialize_on_transport(self, transport):
162
 
        from bzrlib.transport.local import LocalTransport
163
 
 
164
 
        if not isinstance(transport, LocalTransport):
165
 
            raise NotImplementedError(self.initialize, 
166
 
                "Can't create Git Repositories/branches on "
167
 
                "non-local transports")
168
 
 
169
 
        from dulwich.repo import Repo
170
 
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
171
 
        return self.open(transport)
172
 
 
173
 
    def is_supported(self):
174
 
        return True
175
 
 
176
 
 
177
 
class RemoteGitBzrDirFormat(GitBzrDirFormat):
178
 
    """The .git directory control format."""
179
 
 
180
 
    @classmethod
181
 
    def _known_formats(self):
182
 
        return set([RemoteGitBzrDirFormat()])
183
 
 
184
 
    def open(self, transport, _found=None):
185
 
        """Open this directory.
186
 
 
187
 
        """
188
 
        # we dont grok readonly - git isn't integrated with transport.
189
 
        url = transport.base
190
 
        if url.startswith('readonly+'):
191
 
            url = url[len('readonly+'):]
192
 
        if (not url.startswith("git://") and 
193
 
            not url.startswith("git+")):
194
 
            raise bzr_errors.NotBranchError(transport.base)
195
 
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
196
 
        if not isinstance(transport, GitSmartTransport):
197
 
            raise bzr_errors.NotBranchError(transport.base)
198
 
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
199
 
        lockfiles = GitLockableFiles(transport, GitLock())
200
 
        return RemoteGitDir(transport, lockfiles, self)
201
 
 
202
 
    @classmethod
203
 
    def probe_transport(klass, transport):
204
 
        """Our format is present if the transport ends in '.not/'."""
205
 
        url = transport.base
206
 
        if url.startswith('readonly+'):
207
 
            url = url[len('readonly+'):]
208
 
        if (not url.startswith("git://") and 
209
 
            not url.startswith("git+")):
210
 
            raise bzr_errors.NotBranchError(transport.base)
211
 
        # little ugly, but works
212
 
        format = klass()
213
 
        from bzrlib.plugins.git.remote import GitSmartTransport
214
 
        if not isinstance(transport, GitSmartTransport):
215
 
            raise bzr_errors.NotBranchError(transport.base)
216
 
        return format
217
 
 
218
 
    def get_format_description(self):
219
 
        return "Remote Git Repository"
220
 
 
221
 
    def get_format_string(self):
222
 
        return "Remote Git Repository"
223
 
 
224
 
    def initialize_on_transport(self, transport):
225
 
        raise bzr_errors.UninitializableFormat(self)
226
 
 
227
 
 
228
 
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
229
 
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
230
 
 
231
 
register_transport_proto('git://', 
232
 
        help="Access using the Git smart server protocol.")
233
 
register_transport_proto('git+ssh://', 
234
 
        help="Access using the Git smart server protocol over SSH.")
235
 
 
236
 
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
237
 
                        'TCPGitSmartTransport')
238
 
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
239
 
                        'SSHGitSmartTransport')
240
 
 
241
 
foreign_vcs_registry.register_lazy("git", 
242
 
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
243
 
 
244
 
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
245
 
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
246
 
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
247
 
    "bzrlib.plugins.git.commands")
248
 
 
249
 
def update_stanza(rev, stanza):
250
 
    mapping = getattr(rev, "mapping", None)
251
 
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
252
 
        stanza.add("git-commit", rev.foreign_revid)
253
 
 
254
 
 
255
 
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
256
 
if rio_hooks is not None:
257
 
    rio_hooks.install_named_hook('revision', update_stanza, None)
258
 
 
259
 
def get_rich_root_format(stacked=False):
260
 
    if stacked:
261
 
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
262
 
    else:
263
 
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
21
from bzrlib import bzrdir
 
22
from bzrlib.foreign import ForeignVcs, VcsMappingRegistry, foreign_vcs_registry
 
23
from bzrlib.plugins.git.dir import GitBzrDirFormat
 
24
 
 
25
bzrdir.format_registry.register(
 
26
    'git', GitBzrDirFormat,
 
27
    help='GIT repository.', 
 
28
    native=False, experimental=True,
 
29
    )
 
30
 
 
31
bzrdir.BzrDirFormat.register_control_format(GitBzrDirFormat)
 
32
 
 
33
 
 
34
class ForeignGit(ForeignVcs):
 
35
    """Foreign Git."""
 
36
 
 
37
 
 
38
git_mapping_registry = VcsMappingRegistry()
 
39
git_mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",
 
40
                                   "BzrGitMappingExperimental")
 
41
foreign_vcs_registry.register("git", ForeignGit(git_mapping_registry), 
 
42
                                      "Stupid content tracker")
 
43
 
264
44
 
265
45
def test_suite():
266
46
    from bzrlib.plugins.git import tests