/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

Try to import nothing other than __init__ when not opening git repositories.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
# Copyright (C) 2006-2009 Canonical Ltd
 
1
# Copyright (C) 2006 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
 
 
27
24
import bzrlib
28
25
import bzrlib.api
29
 
from bzrlib import bzrdir, errors as bzr_errors
 
26
from bzrlib import bzrdir
30
27
from bzrlib.foreign import foreign_vcs_registry
31
28
from bzrlib.lockable_files import TransportLock
32
29
from bzrlib.transport import register_lazy_transport
33
 
from bzrlib.commands import plugin_cmds
 
30
from bzrlib.commands import Command, register_command
 
31
from bzrlib.option import Option
34
32
from bzrlib.trace import warning
35
33
 
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')))
 
34
MINIMUM_DULWICH_VERSION = (0, 1, 0)
 
35
COMPATIBLE_BZR_VERSIONS = [(1, 12, 0)]
53
36
 
54
37
_versions_checked = False
55
38
def lazy_check_versions():
60
43
    try:
61
44
        from dulwich import __version__ as dulwich_version
62
45
    except ImportError:
63
 
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
46
        warning("Please install dulwich, https://launchpad.net/dulwich")
 
47
        raise
64
48
    else:
65
49
        if dulwich_version < MINIMUM_DULWICH_VERSION:
66
 
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
 
50
            warning("Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
 
51
            raise ImportError
67
52
 
68
53
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
69
54
 
72
57
    help='GIT repository.', native=False, experimental=True,
73
58
    )
74
59
 
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
 
 
85
60
class GitBzrDirFormat(bzrdir.BzrDirFormat):
86
61
    _lock_class = TransportLock
87
62
 
108
83
 
109
84
        try:
110
85
            gitrepo = git.repo.Repo(transport.local_abspath("."))
111
 
        except bzr_errors.NotLocalUrl:
112
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
86
        except errors.bzr_errors.NotLocalUrl:
 
87
            raise errors.bzr_errors.NotBranchError(path=transport.base)
113
88
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
114
89
        lockfiles = GitLockableFiles(transport, GitLock())
115
90
        return LocalGitDir(transport, lockfiles, gitrepo, self)
120
95
        from bzrlib.transport.local import LocalTransport
121
96
 
122
97
        if not isinstance(transport, LocalTransport):
123
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
98
            raise errors.bzr_errors.NotBranchError(path=transport.base)
124
99
 
125
100
        # This should quickly filter out most things that are not 
126
101
        # git repositories, saving us the trouble from loading dulwich.
127
102
        if not transport.has(".git") and not transport.has("objects"):
128
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
103
            raise errors.bzr_errors.NotBranchError(path=transport.base)
129
104
 
130
105
        import dulwich as git
131
106
        format = klass()
133
108
            format.open(transport)
134
109
            return format
135
110
        except git.errors.NotGitRepository, e:
136
 
            raise bzr_errors.NotBranchError(path=transport.base)
137
 
        raise bzr_errors.NotBranchError(path=transport.base)
 
111
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
112
        raise errors.bzr_errors.NotBranchError(path=transport.base)
138
113
 
139
114
    def get_format_description(self):
140
115
        return "Local Git Repository"
171
146
        """
172
147
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
173
148
        if not isinstance(transport, GitSmartTransport):
174
 
            raise bzr_errors.NotBranchError(transport.base)
 
149
            raise errors.bzr_errors.NotBranchError(transport.base)
175
150
        # we dont grok readonly - git isn't integrated with transport.
176
151
        url = transport.base
177
152
        if url.startswith('readonly+'):
188
163
        format = klass()
189
164
        from bzrlib.plugins.git.remote import GitSmartTransport
190
165
        if not isinstance(transport, GitSmartTransport):
191
 
            raise bzr_errors.NotBranchError(transport.base)
 
166
            raise errors.bzr_errors.NotBranchError(transport.base)
192
167
        # The only way to know a path exists and contains a valid repository 
193
168
        # is to do a request against it:
194
169
        try:
195
170
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
196
171
                                 lambda x: mutter("git: %s" % x))
197
172
        except errors.git_errors.GitProtocolError:
198
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
173
            raise errors.bzr_errors.NotBranchError(path=transport.base)
199
174
        else:
200
175
            return format
201
 
        raise bzr_errors.NotBranchError(path=transport.base)
 
176
        raise errors.bzr_errors.NotBranchError(path=transport.base)
202
177
 
203
178
    def get_format_description(self):
204
179
        return "Remote Git Repository"
207
182
        return "Remote Git Repository"
208
183
 
209
184
    def initialize_on_transport(self, transport):
210
 
        raise bzr_errors.UninitializableFormat(self)
 
185
        raise errors.bzr_errors.UninitializableFormat(self)
211
186
 
212
187
 
213
188
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
221
196
                        "foreign_git",
222
197
                        "Stupid content tracker")
223
198
 
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")
 
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
 
232
269
 
233
270
def test_suite():
234
271
    from bzrlib.plugins.git import tests