/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

https://launchpad.net/bugs/771184
Only actually fetch tags if "branch.fetch_tags" is set to true.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
 
1
# Copyright (C) 2006-2009 Canonical Ltd
 
2
 
 
3
# Authors: Robert Collins <robert.collins@canonical.com>
 
4
#          Jelmer Vernooij <jelmer@samba.org>
 
5
#          John Carr <john.carr@unrouted.co.uk>
 
6
#
 
7
# This program is free software; you can redistribute it and/or modify
 
8
# it under the terms of the GNU General Public License as published by
 
9
# the Free Software Foundation; either version 2 of the License, or
 
10
# (at your option) any later version.
 
11
#
 
12
# This program is distributed in the hope that it will be useful,
 
13
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
# GNU General Public License for more details.
 
16
#
 
17
# You should have received a copy of the GNU General Public License
 
18
# along with this program; if not, write to the Free Software
 
19
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
 
 
21
 
 
22
"""A GIT branch and repository format implementation for bzr."""
 
23
 
 
24
import os
 
25
import sys
 
26
 
 
27
import bzrlib
 
28
import bzrlib.api
 
29
 
 
30
from info import (
 
31
    bzr_compatible_versions,
 
32
    bzr_plugin_version as version_info,
 
33
    dulwich_minimum_version,
 
34
    )
 
35
 
 
36
if version_info[3] == 'final':
 
37
    version_string = '%d.%d.%d' % version_info[:3]
 
38
else:
 
39
    version_string = '%d.%d.%d%s%d' % version_info
 
40
__version__ = version_string
 
41
 
 
42
bzrlib.api.require_any_api(bzrlib, bzr_compatible_versions)
 
43
 
 
44
 
 
45
from bzrlib import (
 
46
    errors as bzr_errors,
 
47
    )
 
48
 
 
49
from bzrlib.controldir import (
 
50
    ControlDirFormat,
 
51
    Prober,
 
52
    format_registry,
 
53
    network_format_registry as controldir_network_format_registry,
 
54
    )
 
55
 
 
56
from bzrlib.foreign import (
 
57
    foreign_vcs_registry,
 
58
    )
 
59
from bzrlib.help_topics import (
 
60
    topic_registry,
 
61
    )
 
62
from bzrlib.transport import (
 
63
    register_lazy_transport,
 
64
    register_transport_proto,
 
65
    )
 
66
from bzrlib.commands import (
 
67
    plugin_cmds,
 
68
    )
 
69
from bzrlib.send import (
 
70
    format_registry as send_format_registry,
 
71
    )
 
72
 
 
73
 
 
74
if getattr(sys, "frozen", None):
 
75
    # allow import additional libs from ./_lib for bzr.exe only
 
76
    sys.path.append(os.path.normpath(
 
77
        os.path.join(os.path.dirname(__file__), '_lib')))
 
78
 
 
79
 
 
80
def import_dulwich():
 
81
    try:
 
82
        from dulwich import __version__ as dulwich_version
 
83
    except ImportError:
 
84
        raise bzr_errors.DependencyNotPresent("dulwich",
 
85
            "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
86
    else:
 
87
        if dulwich_version < dulwich_minimum_version:
 
88
            raise bzr_errors.DependencyNotPresent("dulwich",
 
89
                "bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
 
90
                    dulwich_minimum_version)
 
91
 
 
92
 
 
93
_versions_checked = False
 
94
def lazy_check_versions():
 
95
    global _versions_checked
 
96
    if _versions_checked:
 
97
        return
 
98
    import_dulwich()
 
99
    _versions_checked = True
 
100
 
 
101
format_registry.register_lazy('git',
 
102
    "bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
 
103
    help='GIT repository.', native=False, experimental=False,
 
104
    )
 
105
 
 
106
format_registry.register_lazy('git-bare',
 
107
    "bzrlib.plugins.git.dir", "BareLocalGitControlDirFormat",
 
108
    help='Bare GIT repository (no working tree).', native=False,
 
109
    experimental=False,
 
110
    )
 
111
 
 
112
from bzrlib.revisionspec import revspec_registry
 
113
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
114
    "RevisionSpec_git")
 
115
 
 
116
from bzrlib.revisionspec import dwim_revspecs, RevisionSpec_dwim
 
117
if getattr(RevisionSpec_dwim, "append_possible_lazy_revspec", None):
 
118
    RevisionSpec_dwim.append_possible_lazy_revspec(
 
119
        "bzrlib.plugins.git.revspec", "RevisionSpec_git")
 
120
else: # bzr < 2.4
 
121
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
122
    dwim_revspecs.append(RevisionSpec_git)
 
123
 
 
124
 
 
125
class LocalGitProber(Prober):
 
126
 
 
127
    def probe_transport(self, transport):
 
128
        try:
 
129
            if not transport.has_any(['info/refs', '.git/HEAD', 'HEAD', 'objects', '.git/objects']):
 
130
                raise bzr_errors.NotBranchError(path=transport.base)
 
131
        except bzr_errors.NoSuchFile:
 
132
            raise bzr_errors.NotBranchError(path=transport.base)
 
133
        from bzrlib import urlutils
 
134
        if urlutils.split(transport.base)[1] == ".git":
 
135
            raise bzr_errors.NotBranchError(path=transport.base)
 
136
        lazy_check_versions()
 
137
        import dulwich
 
138
        from bzrlib.plugins.git.transportgit import TransportRepo
 
139
        try:
 
140
            gitrepo = TransportRepo(transport)
 
141
        except dulwich.errors.NotGitRepository, e:
 
142
            raise bzr_errors.NotBranchError(path=transport.base)
 
143
        else:
 
144
            from bzrlib.plugins.git.dir import (
 
145
                BareLocalGitControlDirFormat,
 
146
                LocalGitControlDirFormat,
 
147
                )
 
148
            if gitrepo.bare:
 
149
                return BareLocalGitControlDirFormat()
 
150
            else:
 
151
                return LocalGitControlDirFormat()
 
152
 
 
153
    @classmethod
 
154
    def known_formats(cls):
 
155
        from bzrlib.plugins.git.dir import (
 
156
            BareLocalGitControlDirFormat,
 
157
            LocalGitControlDirFormat,
 
158
            )
 
159
        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
 
160
 
 
161
 
 
162
class RemoteGitProber(Prober):
 
163
 
 
164
    def probe_transport(self, transport):
 
165
        url = transport.base
 
166
        if url.startswith('readonly+'):
 
167
            url = url[len('readonly+'):]
 
168
        if (not url.startswith("git://") and not url.startswith("git+")):
 
169
            raise bzr_errors.NotBranchError(transport.base)
 
170
        # little ugly, but works
 
171
        from bzrlib.plugins.git.remote import (
 
172
            GitSmartTransport,
 
173
            RemoteGitControlDirFormat,
 
174
            )
 
175
        if not isinstance(transport, GitSmartTransport):
 
176
            raise bzr_errors.NotBranchError(transport.base)
 
177
        return RemoteGitControlDirFormat()
 
178
 
 
179
    @classmethod
 
180
    def known_formats(cls):
 
181
        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
182
        return set([RemoteGitControlDirFormat()])
 
183
 
 
184
 
 
185
if not getattr(Prober, "known_formats", None): # bzr < 2.4
 
186
    from bzrlib.plugins.git.dir import (
 
187
        LocalGitControlDirFormat, BareLocalGitControlDirFormat,
 
188
        )
 
189
    from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
190
    ControlDirFormat.register_format(LocalGitControlDirFormat())
 
191
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
 
192
    ControlDirFormat.register_format(RemoteGitControlDirFormat())
 
193
    # Provide RevisionTree.get_file_revision, so various parts of bzr-svn
 
194
    # can avoid inventories.
 
195
    from bzrlib.revisiontree import RevisionTree
 
196
    def get_file_revision(tree, file_id, path=None):
 
197
        return tree.inventory[file_id].revision
 
198
    RevisionTree.get_file_revision = get_file_revision
 
199
 
 
200
ControlDirFormat.register_prober(LocalGitProber)
 
201
ControlDirFormat.register_prober(RemoteGitProber)
 
202
 
 
203
register_transport_proto('git://',
 
204
        help="Access using the Git smart server protocol.")
 
205
register_transport_proto('git+ssh://',
 
206
        help="Access using the Git smart server protocol over SSH.")
 
207
 
 
208
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
209
                        'TCPGitSmartTransport')
 
210
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
211
                        'SSHGitSmartTransport')
 
212
 
 
213
foreign_vcs_registry.register_lazy("git",
 
214
    "bzrlib.plugins.git.mapping", "foreign_vcs_git", "Stupid content tracker")
 
215
 
 
216
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
217
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
218
    "bzrlib.plugins.git.commands")
 
219
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
220
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
221
 
 
222
def extract_git_foreign_revid(rev):
 
223
    try:
 
224
        foreign_revid = rev.foreign_revid
 
225
    except AttributeError:
 
226
        from bzrlib.plugins.git.mapping import mapping_registry
 
227
        foreign_revid, mapping = \
 
228
            mapping_registry.parse_revision_id(rev.revision_id)
 
229
        return foreign_revid
 
230
    else:
 
231
        from bzrlib.plugins.git.mapping import foreign_vcs_git
 
232
        if rev.mapping.vcs == foreign_vcs_git:
 
233
            return foreign_revid
 
234
        else:
 
235
            raise bzr_errors.InvalidRevisionId(rev.revision_id, None)
 
236
 
 
237
 
 
238
def update_stanza(rev, stanza):
 
239
    mapping = getattr(rev, "mapping", None)
 
240
    try:
 
241
        git_commit = extract_git_foreign_revid(rev)
 
242
    except bzr_errors.InvalidRevisionId:
 
243
        pass
 
244
    else:
 
245
        stanza.add("git-commit", git_commit)
 
246
 
 
247
try:
 
248
    from bzrlib.hooks import install_lazy_named_hook
 
249
except ImportError: # Compatibility with bzr < 2.4
 
250
    from bzrlib.version_info_formats.format_rio import (
 
251
        RioVersionInfoBuilder,
 
252
        )
 
253
    RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza,
 
254
        "git commits")
 
255
else:
 
256
    install_lazy_named_hook("bzrlib.version_info_formats.format_rio",
 
257
        "RioVersionInfoBuilder.hooks", "revision", update_stanza,
 
258
        "git commits")
 
259
 
 
260
 
 
261
from bzrlib.transport import transport_server_registry
 
262
transport_server_registry.register_lazy('git',
 
263
    'bzrlib.plugins.git.server',
 
264
    'serve_git',
 
265
    'Git Smart server protocol over TCP. (default port: 9418)')
 
266
 
 
267
 
 
268
from bzrlib.repository import (
 
269
    format_registry as repository_format_registry,
 
270
    network_format_registry as repository_network_format_registry,
 
271
    )
 
272
repository_network_format_registry.register_lazy('git',
 
273
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
274
 
 
275
try:
 
276
    register_extra_lazy_repository_format = getattr(repository_format_registry,
 
277
        "register_extra_lazy")
 
278
except AttributeError: # bzr < 2.4
 
279
    pass
 
280
else:
 
281
    register_extra_lazy_repository_format('bzrlib.plugins.git.repository',
 
282
        'GitRepositoryFormat')
 
283
 
 
284
from bzrlib.branch import (
 
285
    network_format_registry as branch_network_format_registry,
 
286
    )
 
287
branch_network_format_registry.register_lazy('git',
 
288
    'bzrlib.plugins.git.branch', 'GitBranchFormat')
 
289
 
 
290
try:
 
291
    from bzrlib.branch import (
 
292
        format_registry as branch_format_registry,
 
293
        )
 
294
except ImportError: # bzr < 2.4
 
295
    pass
 
296
else:
 
297
    branch_format_registry.register_extra_lazy(
 
298
        'bzrlib.plugins.git.branch',
 
299
        'GitBranchFormat',
 
300
        )
 
301
 
 
302
try:
 
303
    from bzrlib.workingtree import (
 
304
        format_registry as workingtree_format_registry,
 
305
        )
 
306
except ImportError: # bzr < 2.4
 
307
    pass
 
308
else:
 
309
    workingtree_format_registry.register_extra_lazy(
 
310
        'bzrlib.plugins.git.workingtree',
 
311
        'GitWorkingTreeFormat',
 
312
        )
 
313
 
 
314
controldir_network_format_registry.register_lazy('git',
 
315
    "bzrlib.plugins.git.dir", "GitControlDirFormat")
 
316
 
 
317
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
318
                                   'send_git', 'Git am-style diff format')
 
319
 
 
320
topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
 
321
    'Using Bazaar with Git')
 
322
 
 
323
from bzrlib.diff import format_registry as diff_format_registry
 
324
diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
325
    'GitDiffTree', 'Git am-style diff format')
 
326
 
 
327
 
 
328
def update_git_cache(repository, revid):
 
329
    """Update the git cache after a local commit."""
 
330
    if getattr(repository, "_git", None) is not None:
 
331
        return # No need to update cache for git repositories
 
332
 
 
333
    from bzrlib.plugins.git.object_store import BazaarObjectStore
 
334
    if not repository.control_transport.has("git"):
 
335
        return # No existing cache, don't bother updating
 
336
    store = BazaarObjectStore(repository)
 
337
    store.lock_write()
 
338
    try:
 
339
        store._update_sha_map_revision(revid)
 
340
    finally:
 
341
        store.unlock()
 
342
 
 
343
 
 
344
def post_commit_update_cache(local_branch, master_branch, old_revno, old_revid,
 
345
        new_revno, new_revid):
 
346
    if local_branch is not None:
 
347
        update_git_cache(local_branch.repository, new_revid)
 
348
    update_git_cache(master_branch.repository, new_revid)
 
349
 
 
350
 
 
351
try:
 
352
    from bzrlib.hooks import install_lazy_named_hook
 
353
except ImportError: # Compatibility with bzr < 2.4
 
354
    pass
 
355
else:
 
356
    install_lazy_named_hook("bzrlib.branch",
 
357
        "Branch.hooks", "post_commit", post_commit_update_cache,
 
358
        "git cache")
 
359
 
 
360
 
 
361
def test_suite():
 
362
    from bzrlib.plugins.git import tests
 
363
    return tests.test_suite()