/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

  • Committer: Jelmer Vernooij
  • Date: 2009-04-02 15:54:49 UTC
  • mto: (0.200.326 trunk)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@samba.org-20090402155449-nuqhu1fsnqk6bt0g
Check that regenerated objects have the expected sha1.

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
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
    register_transport_proto,
 
42
    )
 
43
from bzrlib.commands import (
 
44
    plugin_cmds,
 
45
    )
 
46
from bzrlib.trace import (
 
47
    warning,
 
48
    )
 
49
 
 
50
# versions ending in 'exp' mean experimental mappings
 
51
# versions ending in 'dev' mean development version
 
52
# versions ending in 'final' mean release (well tested, etc)
 
53
version_info = (0, 2, 0, 'dev', 0)
 
54
 
 
55
if version_info[3] == 'final':
 
56
    version_string = '%d.%d.%d' % version_info[:3]
 
57
else:
 
58
    version_string = '%d.%d.%d%s%d' % version_info
 
59
__version__ = version_string
 
60
 
 
61
MINIMUM_DULWICH_VERSION = (0, 1, 1)
 
62
COMPATIBLE_BZR_VERSIONS = [(1, 13, 0)]
 
63
 
 
64
if getattr(sys, "frozen", None):
 
65
    # allow import additional libs from ./_lib for bzr.exe only
 
66
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
36
67
 
37
68
_versions_checked = False
38
69
def lazy_check_versions():
43
74
    try:
44
75
        from dulwich import __version__ as dulwich_version
45
76
    except ImportError:
46
 
        warning("Please install dulwich, https://launchpad.net/dulwich")
47
 
        raise
 
77
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
48
78
    else:
49
79
        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
 
80
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
52
81
 
53
82
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
54
83
 
57
86
    help='GIT repository.', native=False, experimental=True,
58
87
    )
59
88
 
 
89
from bzrlib.revisionspec import revspec_registry
 
90
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
91
    "RevisionSpec_git")
 
92
 
60
93
class GitBzrDirFormat(bzrdir.BzrDirFormat):
61
94
    _lock_class = TransportLock
62
95
 
83
116
 
84
117
        try:
85
118
            gitrepo = git.repo.Repo(transport.local_abspath("."))
86
 
        except errors.bzr_errors.NotLocalUrl:
87
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
119
        except bzr_errors.NotLocalUrl:
 
120
            raise bzr_errors.NotBranchError(path=transport.base)
88
121
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
89
122
        lockfiles = GitLockableFiles(transport, GitLock())
90
123
        return LocalGitDir(transport, lockfiles, gitrepo, self)
95
128
        from bzrlib.transport.local import LocalTransport
96
129
 
97
130
        if not isinstance(transport, LocalTransport):
98
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
131
            raise bzr_errors.NotBranchError(path=transport.base)
99
132
 
100
133
        # This should quickly filter out most things that are not 
101
134
        # git repositories, saving us the trouble from loading dulwich.
102
135
        if not transport.has(".git") and not transport.has("objects"):
103
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
136
            raise bzr_errors.NotBranchError(path=transport.base)
104
137
 
105
138
        import dulwich as git
106
139
        format = klass()
108
141
            format.open(transport)
109
142
            return format
110
143
        except git.errors.NotGitRepository, e:
111
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
112
 
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
144
            raise bzr_errors.NotBranchError(path=transport.base)
 
145
        raise bzr_errors.NotBranchError(path=transport.base)
113
146
 
114
147
    def get_format_description(self):
115
148
        return "Local Git Repository"
144
177
        """Open this directory.
145
178
 
146
179
        """
 
180
        # we dont grok readonly - git isn't integrated with transport.
 
181
        url = transport.base
 
182
        if url.startswith('readonly+'):
 
183
            url = url[len('readonly+'):]
 
184
        if (not url.startswith("git://") and 
 
185
            not url.startswith("git+")):
 
186
            raise bzr_errors.NotBranchError(transport.base)
147
187
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
148
188
        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
 
 
 
189
            raise bzr_errors.NotBranchError(transport.base)
155
190
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
156
191
        lockfiles = GitLockableFiles(transport, GitLock())
157
192
        return RemoteGitDir(transport, lockfiles, self)
159
194
    @classmethod
160
195
    def probe_transport(klass, transport):
161
196
        """Our format is present if the transport ends in '.not/'."""
 
197
        url = transport.base
 
198
        if url.startswith('readonly+'):
 
199
            url = url[len('readonly+'):]
 
200
        if (not url.startswith("git://") and 
 
201
            not url.startswith("git+")):
 
202
            raise bzr_errors.NotBranchError(transport.base)
162
203
        # little ugly, but works
163
204
        format = klass()
164
205
        from bzrlib.plugins.git.remote import GitSmartTransport
165
206
        if not isinstance(transport, GitSmartTransport):
166
 
            raise errors.bzr_errors.NotBranchError(transport.base)
 
207
            raise bzr_errors.NotBranchError(transport.base)
167
208
        # The only way to know a path exists and contains a valid repository 
168
209
        # is to do a request against it:
169
210
        try:
170
211
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
171
212
                                 lambda x: mutter("git: %s" % x))
172
213
        except errors.git_errors.GitProtocolError:
173
 
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
214
            raise bzr_errors.NotBranchError(path=transport.base)
174
215
        else:
175
216
            return format
176
 
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
217
        raise bzr_errors.NotBranchError(path=transport.base)
177
218
 
178
219
    def get_format_description(self):
179
220
        return "Remote Git Repository"
182
223
        return "Remote Git Repository"
183
224
 
184
225
    def initialize_on_transport(self, transport):
185
 
        raise errors.bzr_errors.UninitializableFormat(self)
 
226
        raise bzr_errors.UninitializableFormat(self)
186
227
 
187
228
 
188
229
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
189
230
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
190
231
 
 
232
register_transport_proto('git://', 
 
233
        help="Access using the Git smart server protocol.")
 
234
register_transport_proto('git+ssh://', 
 
235
        help="Access using the Git smart server protocol over SSH.")
 
236
 
191
237
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
192
 
                        'GitSmartTransport')
 
238
                        'TCPGitSmartTransport')
 
239
 
 
240
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
241
                        'SSHGitSmartTransport')
193
242
 
194
243
foreign_vcs_registry.register_lazy("git", 
195
244
                        "bzrlib.plugins.git.mapping", 
196
245
                        "foreign_git",
197
246
                        "Stupid content tracker")
198
247
 
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
 
 
 
248
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
 
249
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
250
 
 
251
def get_rich_root_format():
 
252
    try:
 
253
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
254
    except KeyError:
 
255
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
269
256
 
270
257
def test_suite():
271
258
    from bzrlib.plugins.git import tests