/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

Add more tests for fetch code.

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
 
29
from bzrlib import bzrdir, errors as bzr_errors
27
30
from bzrlib.foreign import foreign_vcs_registry
28
31
from bzrlib.lockable_files import TransportLock
29
32
from bzrlib.transport import register_lazy_transport
30
 
from bzrlib.commands import Command, register_command
31
 
from bzrlib.option import Option
 
33
from bzrlib.commands import plugin_cmds
32
34
from bzrlib.trace import warning
33
35
 
34
 
MINIMUM_DULWICH_VERSION = (0, 1, 0)
35
 
COMPATIBLE_BZR_VERSIONS = [(1, 12, 0)]
 
36
# versions ending in 'exp' mean experimental mappings
 
37
# versions ending in 'dev' mean development version
 
38
# versions ending in 'final' mean release (well tested, etc)
 
39
version_info = (0, 2, 0, 'dev', 0)
 
40
 
 
41
if version_info[3] == 'final':
 
42
    version_string = '%d.%d.%d' % version_info[:3]
 
43
else:
 
44
    version_string = '%d.%d.%d%s%d' % version_info
 
45
__version__ = version_string
 
46
 
 
47
MINIMUM_DULWICH_VERSION = (0, 1, 1)
 
48
COMPATIBLE_BZR_VERSIONS = [(1, 13, 0)]
 
49
 
 
50
if getattr(sys, "frozen", None):
 
51
    # allow import additional libs from ./_lib for bzr.exe only
 
52
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
36
53
 
37
54
_versions_checked = False
38
55
def lazy_check_versions():
43
60
    try:
44
61
        from dulwich import __version__ as dulwich_version
45
62
    except ImportError:
46
 
        warning("Please install dulwich, https://launchpad.net/dulwich")
47
 
        raise
 
63
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
48
64
    else:
49
65
        if dulwich_version < MINIMUM_DULWICH_VERSION:
50
 
            warning("Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
51
 
            raise ImportError
 
66
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
52
67
 
53
68
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
54
69
 
57
72
    help='GIT repository.', native=False, experimental=True,
58
73
    )
59
74
 
 
75
try:
 
76
    from bzrlib.revisionspec import revspec_registry
 
77
    revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
78
        "RevisionSpec_git")
 
79
except ImportError:
 
80
    lazy_check_versions()
 
81
    from bzrlib.revisionspec import SPEC_TYPES
 
82
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
83
    SPEC_TYPES.append(RevisionSpec_git)
 
84
 
60
85
class GitBzrDirFormat(bzrdir.BzrDirFormat):
61
86
    _lock_class = TransportLock
62
87
 
83
108
 
84
109
        try:
85
110
            gitrepo = git.repo.Repo(transport.local_abspath("."))
86
 
        except errors.bzr_errors.NotLocalUrl:
87
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
111
        except bzr_errors.NotLocalUrl:
 
112
            raise bzr_errors.NotBranchError(path=transport.base)
88
113
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
89
114
        lockfiles = GitLockableFiles(transport, GitLock())
90
115
        return LocalGitDir(transport, lockfiles, gitrepo, self)
95
120
        from bzrlib.transport.local import LocalTransport
96
121
 
97
122
        if not isinstance(transport, LocalTransport):
98
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
123
            raise bzr_errors.NotBranchError(path=transport.base)
99
124
 
100
125
        # This should quickly filter out most things that are not 
101
126
        # git repositories, saving us the trouble from loading dulwich.
102
127
        if not transport.has(".git") and not transport.has("objects"):
103
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
128
            raise bzr_errors.NotBranchError(path=transport.base)
104
129
 
105
130
        import dulwich as git
106
131
        format = klass()
108
133
            format.open(transport)
109
134
            return format
110
135
        except git.errors.NotGitRepository, e:
111
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
112
 
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
136
            raise bzr_errors.NotBranchError(path=transport.base)
 
137
        raise bzr_errors.NotBranchError(path=transport.base)
113
138
 
114
139
    def get_format_description(self):
115
140
        return "Local Git Repository"
146
171
        """
147
172
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
148
173
        if not isinstance(transport, GitSmartTransport):
149
 
            raise errors.bzr_errors.NotBranchError(transport.base)
 
174
            raise bzr_errors.NotBranchError(transport.base)
150
175
        # we dont grok readonly - git isn't integrated with transport.
151
176
        url = transport.base
152
177
        if url.startswith('readonly+'):
163
188
        format = klass()
164
189
        from bzrlib.plugins.git.remote import GitSmartTransport
165
190
        if not isinstance(transport, GitSmartTransport):
166
 
            raise errors.bzr_errors.NotBranchError(transport.base)
 
191
            raise bzr_errors.NotBranchError(transport.base)
167
192
        # The only way to know a path exists and contains a valid repository 
168
193
        # is to do a request against it:
169
194
        try:
170
195
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
171
196
                                 lambda x: mutter("git: %s" % x))
172
197
        except errors.git_errors.GitProtocolError:
173
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
198
            raise bzr_errors.NotBranchError(path=transport.base)
174
199
        else:
175
200
            return format
176
 
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
201
        raise bzr_errors.NotBranchError(path=transport.base)
177
202
 
178
203
    def get_format_description(self):
179
204
        return "Remote Git Repository"
182
207
        return "Remote Git Repository"
183
208
 
184
209
    def initialize_on_transport(self, transport):
185
 
        raise errors.bzr_errors.UninitializableFormat(self)
 
210
        raise bzr_errors.UninitializableFormat(self)
186
211
 
187
212
 
188
213
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
196
221
                        "foreign_git",
197
222
                        "Stupid content tracker")
198
223
 
199
 
 
200
 
class cmd_git_serve(Command):
201
 
    """Provide access to a Bazaar branch using the git protocol.
202
 
 
203
 
    This command is experimental and doesn't do much yet.
204
 
    """
205
 
    takes_options = [
206
 
        Option('directory',
207
 
               help='serve contents of directory',
208
 
               type=unicode)
209
 
    ]
210
 
 
211
 
    def run(self, directory=None):
212
 
        lazy_check_versions()
213
 
        from dulwich.server import TCPGitServer
214
 
        from bzrlib.plugins.git.server import BzrBackend
215
 
        from bzrlib.trace import warning
216
 
        import os
217
 
 
218
 
        warning("server support in bzr-git is experimental.")
219
 
 
220
 
        if directory is None:
221
 
            directory = os.getcwd()
222
 
 
223
 
        backend = BzrBackend(directory)
224
 
 
225
 
        server = TCPGitServer(backend, 'localhost')
226
 
        server.serve_forever()
227
 
 
228
 
register_command(cmd_git_serve)
229
 
 
230
 
 
231
 
class cmd_git_import(Command):
232
 
    """Import all branches from a git repository.
233
 
 
234
 
    """
235
 
 
236
 
    takes_args = ["src_location", "dest_location"]
237
 
 
238
 
    def run(self, src_location, dest_location):
239
 
        from bzrlib.bzrdir import BzrDir, format_registry
240
 
        from bzrlib.errors import NoRepositoryPresent, NotBranchError
241
 
        from bzrlib.repository import Repository
242
 
        source_repo = Repository.open(src_location)
243
 
        format = format_registry.make_bzrdir('rich-root-pack')
244
 
        try:
245
 
            target_bzrdir = BzrDir.open(dest_location)
246
 
        except NotBranchError:
247
 
            target_bzrdir = BzrDir.create(dest_location, format=format)
248
 
        try:
249
 
            target_repo = target_bzrdir.open_repository()
250
 
        except NoRepositoryPresent:
251
 
            target_repo = target_bzrdir.create_repository(shared=True)
252
 
 
253
 
        target_repo.fetch(source_repo)
254
 
        for name, ref in source_repo._git.heads().iteritems():
255
 
            head_loc = os.path.join(dest_location, name)
256
 
            try:
257
 
                head_bzrdir = BzrDir.open(head_loc)
258
 
            except NotBranchError:
259
 
                head_bzrdir = BzrDir.create(head_loc, format=format)
260
 
            try:
261
 
                head_branch = head_bzrdir.open_branch()
262
 
            except NotBranchError:
263
 
                head_branch = head_bzrdir.create_branch()
264
 
            head_branch.generate_revision_history(source_repo.get_mapping().revision_id_foreign_to_bzr(ref))
265
 
 
266
 
 
267
 
register_command(cmd_git_import)
268
 
 
 
224
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
 
225
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
226
 
 
227
def get_rich_root_format():
 
228
    try:
 
229
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
230
    except KeyError:
 
231
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
269
232
 
270
233
def test_suite():
271
234
    from bzrlib.plugins.git import tests