/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
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
34
MINIMUM_DULWICH_VERSION = (0, 1, 0)
37
 
COMPATIBLE_BZR_VERSIONS = [(1, 11, 0), (1, 12, 0)]
38
 
 
39
 
if getattr(sys, "frozen", None):
40
 
    # allow import additional libs from ./_lib for bzr.exe only
41
 
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
 
35
COMPATIBLE_BZR_VERSIONS = [(1, 12, 0)]
42
36
 
43
37
_versions_checked = False
44
38
def lazy_check_versions():
49
43
    try:
50
44
        from dulwich import __version__ as dulwich_version
51
45
    except ImportError:
52
 
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
46
        warning("Please install dulwich, https://launchpad.net/dulwich")
 
47
        raise
53
48
    else:
54
49
        if dulwich_version < MINIMUM_DULWICH_VERSION:
55
 
            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
56
52
 
57
53
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
58
54
 
61
57
    help='GIT repository.', native=False, experimental=True,
62
58
    )
63
59
 
64
 
try:
65
 
    from bzrlib.revisionspec import revspec_registry
66
 
    revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
67
 
        "RevisionSpec_git")
68
 
except ImportError:
69
 
    lazy_check_versions()
70
 
    from bzrlib.revisionspec import SPEC_TYPES
71
 
    from bzrlib.plugins.git.revspec import RevisionSpec_git
72
 
    SPEC_TYPES.append(RevisionSpec_git)
73
 
 
74
60
class GitBzrDirFormat(bzrdir.BzrDirFormat):
75
61
    _lock_class = TransportLock
76
62
 
97
83
 
98
84
        try:
99
85
            gitrepo = git.repo.Repo(transport.local_abspath("."))
100
 
        except bzr_errors.NotLocalUrl:
101
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
86
        except errors.bzr_errors.NotLocalUrl:
 
87
            raise errors.bzr_errors.NotBranchError(path=transport.base)
102
88
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
103
89
        lockfiles = GitLockableFiles(transport, GitLock())
104
90
        return LocalGitDir(transport, lockfiles, gitrepo, self)
109
95
        from bzrlib.transport.local import LocalTransport
110
96
 
111
97
        if not isinstance(transport, LocalTransport):
112
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
98
            raise errors.bzr_errors.NotBranchError(path=transport.base)
113
99
 
114
100
        # This should quickly filter out most things that are not 
115
101
        # git repositories, saving us the trouble from loading dulwich.
116
102
        if not transport.has(".git") and not transport.has("objects"):
117
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
103
            raise errors.bzr_errors.NotBranchError(path=transport.base)
118
104
 
119
105
        import dulwich as git
120
106
        format = klass()
122
108
            format.open(transport)
123
109
            return format
124
110
        except git.errors.NotGitRepository, e:
125
 
            raise bzr_errors.NotBranchError(path=transport.base)
126
 
        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)
127
113
 
128
114
    def get_format_description(self):
129
115
        return "Local Git Repository"
160
146
        """
161
147
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
162
148
        if not isinstance(transport, GitSmartTransport):
163
 
            raise bzr_errors.NotBranchError(transport.base)
 
149
            raise errors.bzr_errors.NotBranchError(transport.base)
164
150
        # we dont grok readonly - git isn't integrated with transport.
165
151
        url = transport.base
166
152
        if url.startswith('readonly+'):
177
163
        format = klass()
178
164
        from bzrlib.plugins.git.remote import GitSmartTransport
179
165
        if not isinstance(transport, GitSmartTransport):
180
 
            raise bzr_errors.NotBranchError(transport.base)
 
166
            raise errors.bzr_errors.NotBranchError(transport.base)
181
167
        # The only way to know a path exists and contains a valid repository 
182
168
        # is to do a request against it:
183
169
        try:
184
170
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
185
171
                                 lambda x: mutter("git: %s" % x))
186
172
        except errors.git_errors.GitProtocolError:
187
 
            raise bzr_errors.NotBranchError(path=transport.base)
 
173
            raise errors.bzr_errors.NotBranchError(path=transport.base)
188
174
        else:
189
175
            return format
190
 
        raise bzr_errors.NotBranchError(path=transport.base)
 
176
        raise errors.bzr_errors.NotBranchError(path=transport.base)
191
177
 
192
178
    def get_format_description(self):
193
179
        return "Remote Git Repository"
196
182
        return "Remote Git Repository"
197
183
 
198
184
    def initialize_on_transport(self, transport):
199
 
        raise bzr_errors.UninitializableFormat(self)
 
185
        raise errors.bzr_errors.UninitializableFormat(self)
200
186
 
201
187
 
202
188
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
210
196
                        "foreign_git",
211
197
                        "Stupid content tracker")
212
198
 
213
 
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
214
 
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
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
 
215
269
 
216
270
def test_suite():
217
271
    from bzrlib.plugins.git import tests