/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

Import RemoteGitBranch._get_config().

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