/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

Fix branch cloning.

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
 
from bzrlib import (
30
 
    bzrdir,
31
 
    errors as bzr_errors,
32
 
    )
33
 
from bzrlib.foreign import (
34
 
    foreign_vcs_registry,
35
 
    )
36
 
from bzrlib.lockable_files import (
37
 
    TransportLock,
38
 
    )
39
 
from bzrlib.transport import (
40
 
    register_lazy_transport,
41
 
    )
42
 
from bzrlib.commands import (
43
 
    plugin_cmds,
44
 
    )
45
 
from bzrlib.trace import (
46
 
    warning,
47
 
    )
48
 
 
49
 
# versions ending in 'exp' mean experimental mappings
50
 
# versions ending in 'dev' mean development version
51
 
# versions ending in 'final' mean release (well tested, etc)
52
 
version_info = (0, 2, 0, 'dev', 0)
53
 
 
54
 
if version_info[3] == 'final':
55
 
    version_string = '%d.%d.%d' % version_info[:3]
56
 
else:
57
 
    version_string = '%d.%d.%d%s%d' % version_info
58
 
__version__ = version_string
59
 
 
60
 
MINIMUM_DULWICH_VERSION = (0, 1, 1)
61
 
COMPATIBLE_BZR_VERSIONS = [(1, 13, 0)]
62
 
 
63
 
if getattr(sys, "frozen", None):
64
 
    # allow import additional libs from ./_lib for bzr.exe only
65
 
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
66
 
 
67
 
_versions_checked = False
68
 
def lazy_check_versions():
69
 
    global _versions_checked
70
 
    if _versions_checked:
71
 
        return
72
 
    _versions_checked = True
73
 
    try:
74
 
        from dulwich import __version__ as dulwich_version
75
 
    except ImportError:
76
 
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
77
 
    else:
78
 
        if dulwich_version < MINIMUM_DULWICH_VERSION:
79
 
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
80
 
 
81
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
82
 
 
83
 
bzrdir.format_registry.register_lazy('git', 
84
 
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
85
 
    help='GIT repository.', native=False, experimental=True,
86
 
    )
87
 
 
88
 
from bzrlib.revisionspec import revspec_registry
89
 
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
90
 
    "RevisionSpec_git")
91
 
 
92
 
class GitBzrDirFormat(bzrdir.BzrDirFormat):
93
 
    _lock_class = TransportLock
94
 
 
95
 
    def is_supported(self):
96
 
        return True
97
 
 
98
 
 
99
 
class LocalGitBzrDirFormat(GitBzrDirFormat):
100
 
    """The .git directory control format."""
101
 
 
102
 
    @classmethod
103
 
    def _known_formats(self):
104
 
        return set([LocalGitBzrDirFormat()])
105
 
 
106
 
    def open(self, transport, _found=None):
107
 
        """Open this directory.
108
 
 
109
 
        """
110
 
        import dulwich as git
111
 
        # we dont grok readonly - git isn't integrated with transport.
112
 
        url = transport.base
113
 
        if url.startswith('readonly+'):
114
 
            url = url[len('readonly+'):]
115
 
 
116
 
        try:
117
 
            gitrepo = git.repo.Repo(transport.local_abspath("."))
118
 
        except bzr_errors.NotLocalUrl:
119
 
            raise bzr_errors.NotBranchError(path=transport.base)
120
 
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
121
 
        lockfiles = GitLockableFiles(transport, GitLock())
122
 
        return LocalGitDir(transport, lockfiles, gitrepo, self)
123
 
 
124
 
    @classmethod
125
 
    def probe_transport(klass, transport):
126
 
        """Our format is present if the transport ends in '.not/'."""
127
 
        from bzrlib.transport.local import LocalTransport
128
 
 
129
 
        if not isinstance(transport, LocalTransport):
130
 
            raise bzr_errors.NotBranchError(path=transport.base)
131
 
 
132
 
        # This should quickly filter out most things that are not 
133
 
        # git repositories, saving us the trouble from loading dulwich.
134
 
        if not transport.has(".git") and not transport.has("objects"):
135
 
            raise bzr_errors.NotBranchError(path=transport.base)
136
 
 
137
 
        import dulwich as git
138
 
        format = klass()
139
 
        try:
140
 
            format.open(transport)
141
 
            return format
142
 
        except git.errors.NotGitRepository, e:
143
 
            raise bzr_errors.NotBranchError(path=transport.base)
144
 
        raise bzr_errors.NotBranchError(path=transport.base)
145
 
 
146
 
    def get_format_description(self):
147
 
        return "Local Git Repository"
148
 
 
149
 
    def get_format_string(self):
150
 
        return "Local Git Repository"
151
 
 
152
 
    def initialize_on_transport(self, transport):
153
 
        from bzrlib.transport.local import LocalTransport
154
 
 
155
 
        if not isinstance(transport, LocalTransport):
156
 
            raise NotImplementedError(self.initialize, 
157
 
                "Can't create Git Repositories/branches on "
158
 
                "non-local transports")
159
 
 
160
 
        from dulwich.repo import Repo
161
 
        Repo.create(transport.local_abspath(".")) 
162
 
        return self.open(transport)
163
 
 
164
 
    def is_supported(self):
165
 
        return True
166
 
 
167
 
 
168
 
class RemoteGitBzrDirFormat(GitBzrDirFormat):
169
 
    """The .git directory control format."""
170
 
 
171
 
    @classmethod
172
 
    def _known_formats(self):
173
 
        return set([RemoteGitBzrDirFormat()])
174
 
 
175
 
    def open(self, transport, _found=None):
176
 
        """Open this directory.
177
 
 
178
 
        """
179
 
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
180
 
        if not isinstance(transport, GitSmartTransport):
181
 
            raise bzr_errors.NotBranchError(transport.base)
182
 
        # we dont grok readonly - git isn't integrated with transport.
183
 
        url = transport.base
184
 
        if url.startswith('readonly+'):
185
 
            url = url[len('readonly+'):]
186
 
 
187
 
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
188
 
        lockfiles = GitLockableFiles(transport, GitLock())
189
 
        return RemoteGitDir(transport, lockfiles, self)
190
 
 
191
 
    @classmethod
192
 
    def probe_transport(klass, transport):
193
 
        """Our format is present if the transport ends in '.not/'."""
194
 
        # little ugly, but works
195
 
        format = klass()
196
 
        from bzrlib.plugins.git.remote import GitSmartTransport
197
 
        if not isinstance(transport, GitSmartTransport):
198
 
            raise bzr_errors.NotBranchError(transport.base)
199
 
        # The only way to know a path exists and contains a valid repository 
200
 
        # is to do a request against it:
201
 
        try:
202
 
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
203
 
                                 lambda x: mutter("git: %s" % x))
204
 
        except errors.git_errors.GitProtocolError:
205
 
            raise bzr_errors.NotBranchError(path=transport.base)
206
 
        else:
207
 
            return format
208
 
        raise bzr_errors.NotBranchError(path=transport.base)
209
 
 
210
 
    def get_format_description(self):
211
 
        return "Remote Git Repository"
212
 
 
213
 
    def get_format_string(self):
214
 
        return "Remote Git Repository"
215
 
 
216
 
    def initialize_on_transport(self, transport):
217
 
        raise bzr_errors.UninitializableFormat(self)
218
 
 
 
21
try:
 
22
    import dulwich as git
 
23
except ImportError:
 
24
    import os, sys
 
25
    sys.path.insert(0, os.path.join(os.path.dirname(__file__), "dulwich"))
 
26
    import dulwich as git
 
27
from bzrlib import bzrdir
 
28
from bzrlib.foreign import ForeignVcs, VcsMappingRegistry, foreign_vcs_registry
 
29
from bzrlib.plugins.git.dir import LocalGitBzrDirFormat, RemoteGitBzrDirFormat
 
30
from bzrlib.transport import register_lazy_transport
 
31
from bzrlib.commands import Command, register_command
 
32
from bzrlib.option import Option
 
33
 
 
34
bzrdir.format_registry.register(
 
35
    'git', LocalGitBzrDirFormat,
 
36
    help='GIT repository.', 
 
37
    native=False, experimental=True,
 
38
    )
219
39
 
220
40
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
221
41
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
223
43
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
224
44
                        'GitSmartTransport')
225
45
 
226
 
foreign_vcs_registry.register_lazy("git", 
227
 
                        "bzrlib.plugins.git.mapping", 
228
 
                        "foreign_git",
229
 
                        "Stupid content tracker")
230
 
 
231
 
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
232
 
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
233
 
 
234
 
def get_rich_root_format():
235
 
    try:
236
 
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
237
 
    except KeyError:
238
 
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
46
 
 
47
class ForeignGit(ForeignVcs):
 
48
    """Foreign Git."""
 
49
 
 
50
 
 
51
git_mapping_registry = VcsMappingRegistry()
 
52
git_mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",
 
53
                                   "BzrGitMappingExperimental")
 
54
foreign_vcs_registry.register("git", ForeignGit(git_mapping_registry), 
 
55
                                      "Stupid content tracker")
 
56
 
 
57
 
 
58
class cmd_git_serve(Command):
 
59
    """Provide access to a Bazaar branch using the git protocol.
 
60
 
 
61
    This command is experimental and doesn't do much yet.
 
62
    """
 
63
    takes_options = [
 
64
        Option('inet',
 
65
               help='serve on stdin/out for use from inetd or sshd'),
 
66
        Option('directory',
 
67
               help='serve contents of directory',
 
68
               type=unicode)
 
69
    ]
 
70
 
 
71
    def run(self, inet=None, port=None, directory=None):
 
72
        from dulwich.server import TCPGitServer
 
73
        from bzrlib.plugins.git.server import BzrBackend
 
74
        from bzrlib.trace import warning
 
75
        import os
 
76
 
 
77
        warning("server support in bzr-git is experimental.")
 
78
 
 
79
        if directory is None:
 
80
            directory = os.getcwd()
 
81
 
 
82
        backend = BzrBackend(directory)
 
83
 
 
84
        if inet:
 
85
            #def send_fn(data):
 
86
            #    sys.stdout.write(data)
 
87
            #    sys.stdout.flush()
 
88
            #server = GitServer(sys.stdin.read, send_fn)
 
89
            raise NotImplementedError
 
90
        else:
 
91
            server = TCPGitServer(backend, 'localhost')
 
92
            server.serve_forever()
 
93
 
 
94
register_command(cmd_git_serve)
 
95
 
239
96
 
240
97
def test_suite():
241
98
    from bzrlib.plugins.git import tests