/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

Create cache dir if it doesn't exist yet.

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
27
 
from bzrlib.foreign import foreign_vcs_registry
28
 
from bzrlib.lockable_files import TransportLock
29
 
from bzrlib.transport import register_lazy_transport
30
 
from bzrlib.commands import Command, register_command
31
 
from bzrlib.option import Option
32
 
from bzrlib.trace import warning
33
 
 
34
 
MINIMUM_DULWICH_VERSION = (0, 1, 0)
35
 
COMPATIBLE_BZR_VERSIONS = [(1, 12, 0)]
 
29
 
 
30
# versions ending in 'exp' mean experimental mappings
 
31
# versions ending in 'dev' mean development version
 
32
# versions ending in 'final' mean release (well tested, etc)
 
33
version_info = (0, 3, 3, 'dev', 0)
 
34
 
 
35
if version_info[3] == 'final':
 
36
    version_string = '%d.%d.%d' % version_info[:3]
 
37
else:
 
38
    version_string = '%d.%d.%d%s%d' % version_info
 
39
__version__ = version_string
 
40
 
 
41
MINIMUM_DULWICH_VERSION = (0, 3, 1)
 
42
COMPATIBLE_BZR_VERSIONS = [(1, 14, 0), (1, 15, 0)]
 
43
 
 
44
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
45
 
 
46
 
 
47
from bzrlib import (
 
48
    bzrdir,
 
49
    errors as bzr_errors,
 
50
    osutils,
 
51
    )
 
52
from bzrlib.foreign import (
 
53
    foreign_vcs_registry,
 
54
    )
 
55
from bzrlib.lockable_files import (
 
56
    TransportLock,
 
57
    )
 
58
from bzrlib.transport import (
 
59
    register_lazy_transport,
 
60
    register_transport_proto,
 
61
    )
 
62
from bzrlib.commands import (
 
63
    plugin_cmds,
 
64
    )
 
65
from bzrlib.trace import (
 
66
    warning,
 
67
    )
 
68
from bzrlib.version_info_formats.format_rio import (
 
69
    RioVersionInfoBuilder,
 
70
    )
 
71
 
 
72
 
 
73
if getattr(sys, "frozen", None):
 
74
    # allow import additional libs from ./_lib for bzr.exe only
 
75
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
36
76
 
37
77
_versions_checked = False
38
78
def lazy_check_versions():
43
83
    try:
44
84
        from dulwich import __version__ as dulwich_version
45
85
    except ImportError:
46
 
        warning("Please install dulwich, https://launchpad.net/dulwich")
47
 
        raise
 
86
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
48
87
    else:
49
88
        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
52
 
 
53
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
89
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
54
90
 
55
91
bzrdir.format_registry.register_lazy('git', 
56
92
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
57
93
    help='GIT repository.', native=False, experimental=True,
58
94
    )
59
95
 
 
96
from bzrlib.revisionspec import revspec_registry
 
97
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
98
    "RevisionSpec_git")
 
99
 
 
100
 
60
101
class GitBzrDirFormat(bzrdir.BzrDirFormat):
61
102
    _lock_class = TransportLock
62
103
 
63
104
    def is_supported(self):
64
105
        return True
65
106
 
 
107
    def network_name(self):
 
108
        return "git"
 
109
 
66
110
 
67
111
class LocalGitBzrDirFormat(GitBzrDirFormat):
68
112
    """The .git directory control format."""
82
126
            url = url[len('readonly+'):]
83
127
 
84
128
        try:
85
 
            gitrepo = git.repo.Repo(transport.local_abspath("."))
86
 
        except errors.bzr_errors.NotLocalUrl:
87
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
129
            gitrepo = git.repo.Repo(transport.local_abspath(".").encode(osutils._fs_enc))
 
130
        except bzr_errors.NotLocalUrl:
 
131
            raise bzr_errors.NotBranchError(path=transport.base)
88
132
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
89
133
        lockfiles = GitLockableFiles(transport, GitLock())
90
134
        return LocalGitDir(transport, lockfiles, gitrepo, self)
95
139
        from bzrlib.transport.local import LocalTransport
96
140
 
97
141
        if not isinstance(transport, LocalTransport):
98
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
142
            raise bzr_errors.NotBranchError(path=transport.base)
99
143
 
100
144
        # This should quickly filter out most things that are not 
101
145
        # git repositories, saving us the trouble from loading dulwich.
102
146
        if not transport.has(".git") and not transport.has("objects"):
103
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
147
            raise bzr_errors.NotBranchError(path=transport.base)
104
148
 
105
149
        import dulwich as git
106
150
        format = klass()
108
152
            format.open(transport)
109
153
            return format
110
154
        except git.errors.NotGitRepository, e:
111
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
112
 
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
155
            raise bzr_errors.NotBranchError(path=transport.base)
 
156
        raise bzr_errors.NotBranchError(path=transport.base)
113
157
 
114
158
    def get_format_description(self):
115
159
        return "Local Git Repository"
126
170
                "non-local transports")
127
171
 
128
172
        from dulwich.repo import Repo
129
 
        Repo.create(transport.local_abspath(".")) 
 
173
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
130
174
        return self.open(transport)
131
175
 
132
176
    def is_supported(self):
144
188
        """Open this directory.
145
189
 
146
190
        """
 
191
        # we dont grok readonly - git isn't integrated with transport.
 
192
        url = transport.base
 
193
        if url.startswith('readonly+'):
 
194
            url = url[len('readonly+'):]
 
195
        if (not url.startswith("git://") and 
 
196
            not url.startswith("git+")):
 
197
            raise bzr_errors.NotBranchError(transport.base)
147
198
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
148
199
        if not isinstance(transport, GitSmartTransport):
149
 
            raise errors.bzr_errors.NotBranchError(transport.base)
150
 
        # we dont grok readonly - git isn't integrated with transport.
151
 
        url = transport.base
152
 
        if url.startswith('readonly+'):
153
 
            url = url[len('readonly+'):]
154
 
 
 
200
            raise bzr_errors.NotBranchError(transport.base)
155
201
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
156
202
        lockfiles = GitLockableFiles(transport, GitLock())
157
203
        return RemoteGitDir(transport, lockfiles, self)
159
205
    @classmethod
160
206
    def probe_transport(klass, transport):
161
207
        """Our format is present if the transport ends in '.not/'."""
 
208
        url = transport.base
 
209
        if url.startswith('readonly+'):
 
210
            url = url[len('readonly+'):]
 
211
        if (not url.startswith("git://") and 
 
212
            not url.startswith("git+")):
 
213
            raise bzr_errors.NotBranchError(transport.base)
162
214
        # little ugly, but works
163
215
        format = klass()
164
216
        from bzrlib.plugins.git.remote import GitSmartTransport
165
217
        if not isinstance(transport, GitSmartTransport):
166
 
            raise errors.bzr_errors.NotBranchError(transport.base)
167
 
        # The only way to know a path exists and contains a valid repository 
168
 
        # is to do a request against it:
169
 
        try:
170
 
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
171
 
                                 lambda x: mutter("git: %s" % x))
172
 
        except errors.git_errors.GitProtocolError:
173
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
174
 
        else:
175
 
            return format
176
 
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
218
            raise bzr_errors.NotBranchError(transport.base)
 
219
        return format
177
220
 
178
221
    def get_format_description(self):
179
222
        return "Remote Git Repository"
182
225
        return "Remote Git Repository"
183
226
 
184
227
    def initialize_on_transport(self, transport):
185
 
        raise errors.bzr_errors.UninitializableFormat(self)
 
228
        raise bzr_errors.UninitializableFormat(self)
186
229
 
187
230
 
188
231
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
189
232
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
190
233
 
 
234
register_transport_proto('git://', 
 
235
        help="Access using the Git smart server protocol.")
 
236
register_transport_proto('git+ssh://', 
 
237
        help="Access using the Git smart server protocol over SSH.")
 
238
 
191
239
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
192
 
                        'GitSmartTransport')
 
240
                        'TCPGitSmartTransport')
 
241
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
242
                        'SSHGitSmartTransport')
193
243
 
194
244
foreign_vcs_registry.register_lazy("git", 
195
 
                        "bzrlib.plugins.git.mapping", 
196
 
                        "foreign_git",
197
 
                        "Stupid content tracker")
198
 
 
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
 
 
 
245
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
246
 
 
247
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
248
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
 
249
    "bzrlib.plugins.git.commands")
 
250
 
 
251
def update_stanza(rev, stanza):
 
252
    mapping = getattr(rev, "mapping", None)
 
253
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
254
        stanza.add("git-commit", rev.foreign_revid)
 
255
 
 
256
 
 
257
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
258
if rio_hooks is not None:
 
259
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
260
 
 
261
 
 
262
try:
 
263
    from bzrlib.transport import transport_server_registry
 
264
except ImportError:
 
265
    pass
 
266
else:
 
267
    transport_server_registry.register_lazy('git',
 
268
        'bzrlib.plugins.git.server', 
 
269
        'serve_git',
 
270
        'Git Smart server protocol over TCP. (default port: 9418)')
 
271
 
 
272
 
 
273
from bzrlib.repository import network_format_registry as repository_network_format_registry
 
274
repository_network_format_registry.register_lazy('git', 
 
275
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
276
 
 
277
from bzrlib.bzrdir import network_format_registry as bzrdir_network_format_registry
 
278
bzrdir_network_format_registry.register('git', GitBzrDirFormat)
 
279
 
 
280
 
 
281
def get_rich_root_format(stacked=False):
 
282
    if stacked:
 
283
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
284
    else:
 
285
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
269
286
 
270
287
def test_suite():
271
288
    from bzrlib.plugins.git import tests