/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

More work on roundtrip push support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
44
44
 
45
45
from bzrlib import (
46
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
 
    )
 
47
    osutils,
 
48
    )
 
49
try:
 
50
    from bzrlib.controldir import (
 
51
        ControlDirFormat,
 
52
        ControlDir,
 
53
        Prober,
 
54
        format_registry,
 
55
        )
 
56
except ImportError:
 
57
    # bzr < 2.3
 
58
    from bzrlib.bzrdir import (
 
59
        BzrDirFormat,
 
60
        BzrDir,
 
61
        format_registry,
 
62
        )
 
63
    ControlDir = BzrDir
 
64
    ControlDirFormat = BzrDirFormat
 
65
    Prober = object
 
66
    has_controldir = False
 
67
else:
 
68
    has_controldir = True
55
69
 
56
70
from bzrlib.foreign import (
57
71
    foreign_vcs_registry,
59
73
from bzrlib.help_topics import (
60
74
    topic_registry,
61
75
    )
 
76
from bzrlib.lockable_files import (
 
77
    TransportLock,
 
78
    )
62
79
from bzrlib.transport import (
63
80
    register_lazy_transport,
64
81
    register_transport_proto,
66
83
from bzrlib.commands import (
67
84
    plugin_cmds,
68
85
    )
 
86
from bzrlib.version_info_formats.format_rio import (
 
87
    RioVersionInfoBuilder,
 
88
    )
69
89
from bzrlib.send import (
70
90
    format_registry as send_format_registry,
71
91
    )
113
133
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
114
134
    "RevisionSpec_git")
115
135
 
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
 
136
try:
 
137
    from bzrlib.revisionspec import dwim_revspecs
 
138
except ImportError:
 
139
    pass
 
140
else:
121
141
    from bzrlib.plugins.git.revspec import RevisionSpec_git
122
142
    dwim_revspecs.append(RevisionSpec_git)
123
143
 
124
144
 
 
145
class GitControlDirFormat(ControlDirFormat):
 
146
 
 
147
    _lock_class = TransportLock
 
148
 
 
149
    colocated_branches = True
 
150
 
 
151
    def __eq__(self, other):
 
152
        return type(self) == type(other)
 
153
 
 
154
    def is_supported(self):
 
155
        return True
 
156
 
 
157
    def network_name(self):
 
158
        return "git"
 
159
 
 
160
 
125
161
class LocalGitProber(Prober):
126
162
 
127
163
    def probe_transport(self, transport):
128
164
        try:
129
 
            if not transport.has_any(['info/refs', '.git/HEAD', 'HEAD', 'objects', '.git/objects']):
 
165
            if not transport.has_any(['info/refs', '.git/branches',
 
166
                                      'branches']):
130
167
                raise bzr_errors.NotBranchError(path=transport.base)
131
168
        except bzr_errors.NoSuchFile:
132
169
            raise bzr_errors.NotBranchError(path=transport.base)
141
178
        except dulwich.errors.NotGitRepository, e:
142
179
            raise bzr_errors.NotBranchError(path=transport.base)
143
180
        else:
144
 
            from bzrlib.plugins.git.dir import (
145
 
                BareLocalGitControlDirFormat,
146
 
                LocalGitControlDirFormat,
147
 
                )
148
181
            if gitrepo.bare:
149
182
                return BareLocalGitControlDirFormat()
150
183
            else:
151
184
                return LocalGitControlDirFormat()
152
185
 
153
 
    @classmethod
154
 
    def known_formats(cls):
155
 
        from bzrlib.plugins.git.dir import (
156
 
            BareLocalGitControlDirFormat,
157
 
            LocalGitControlDirFormat,
158
 
            )
159
 
        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
 
186
 
 
187
class LocalGitControlDirFormat(GitControlDirFormat):
 
188
    """The .git directory control format."""
 
189
 
 
190
    bare = False
 
191
 
 
192
    @classmethod
 
193
    def _known_formats(self):
 
194
        return set([LocalGitControlDirFormat()])
 
195
 
 
196
    def open(self, transport, _found=None):
 
197
        """Open this directory.
 
198
 
 
199
        """
 
200
        lazy_check_versions()
 
201
        from bzrlib.plugins.git.transportgit import TransportRepo
 
202
        gitrepo = TransportRepo(transport)
 
203
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
204
        lockfiles = GitLockableFiles(transport, GitLock())
 
205
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
206
 
 
207
    @classmethod
 
208
    def probe_transport(klass, transport):
 
209
        prober = LocalGitProber()
 
210
        return prober.probe_transport(transport)
 
211
 
 
212
    def get_format_description(self):
 
213
        return "Local Git Repository"
 
214
 
 
215
    def initialize_on_transport(self, transport):
 
216
        from bzrlib.transport.local import LocalTransport
 
217
 
 
218
        if not isinstance(transport, LocalTransport):
 
219
            raise NotImplementedError(self.initialize,
 
220
                "Can't create Git Repositories/branches on "
 
221
                "non-local transports")
 
222
        lazy_check_versions()
 
223
        from dulwich.repo import Repo
 
224
        Repo.init(transport.local_abspath(".").encode(osutils._fs_enc),
 
225
            bare=self.bare)
 
226
        return self.open(transport)
 
227
 
 
228
    def is_supported(self):
 
229
        return True
 
230
 
 
231
 
 
232
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
 
233
 
 
234
    bare = True
 
235
    supports_workingtrees = False
 
236
 
 
237
    @classmethod
 
238
    def _known_formats(self):
 
239
        return set([RemoteGitControlDirFormat()])
 
240
 
 
241
    def get_format_description(self):
 
242
        return "Local Git Repository (bare)"
160
243
 
161
244
 
162
245
class RemoteGitProber(Prober):
168
251
        if (not url.startswith("git://") and not url.startswith("git+")):
169
252
            raise bzr_errors.NotBranchError(transport.base)
170
253
        # little ugly, but works
171
 
        from bzrlib.plugins.git.remote import (
172
 
            GitSmartTransport,
173
 
            RemoteGitControlDirFormat,
174
 
            )
 
254
        from bzrlib.plugins.git.remote import GitSmartTransport
175
255
        if not isinstance(transport, GitSmartTransport):
176
256
            raise bzr_errors.NotBranchError(transport.base)
177
257
        return RemoteGitControlDirFormat()
178
258
 
 
259
 
 
260
 
 
261
class RemoteGitControlDirFormat(GitControlDirFormat):
 
262
    """The .git directory control format."""
 
263
 
 
264
    supports_workingtrees = False
 
265
 
179
266
    @classmethod
180
 
    def known_formats(cls):
181
 
        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
267
    def _known_formats(self):
182
268
        return set([RemoteGitControlDirFormat()])
183
269
 
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
 
270
    def open(self, transport, _found=None):
 
271
        """Open this directory.
 
272
 
 
273
        """
 
274
        # we dont grok readonly - git isn't integrated with transport.
 
275
        url = transport.base
 
276
        if url.startswith('readonly+'):
 
277
            url = url[len('readonly+'):]
 
278
        if (not url.startswith("git://") and not url.startswith("git+")):
 
279
            raise bzr_errors.NotBranchError(transport.base)
 
280
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
281
        if not isinstance(transport, GitSmartTransport):
 
282
            raise bzr_errors.NotBranchError(transport.base)
 
283
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
284
        lockfiles = GitLockableFiles(transport, GitLock())
 
285
        return RemoteGitDir(transport, lockfiles, self)
 
286
 
 
287
    @classmethod
 
288
    def probe_transport(klass, transport):
 
289
        """Our format is present if the transport ends in '.not/'."""
 
290
        prober = RemoteGitProber()
 
291
        return prober.probe_transport(transport)
 
292
 
 
293
    def get_format_description(self):
 
294
        return "Remote Git Repository"
 
295
 
 
296
    def initialize_on_transport(self, transport):
 
297
        raise bzr_errors.UninitializableFormat(self)
 
298
 
 
299
 
 
300
if has_controldir:
190
301
    ControlDirFormat.register_format(LocalGitControlDirFormat())
191
302
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
192
303
    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)
 
304
    ControlDirFormat.register_prober(LocalGitProber)
 
305
    ControlDirFormat.register_prober(RemoteGitProber)
 
306
else:
 
307
    ControlDirFormat.register_control_format(LocalGitControlDirFormat)
 
308
    ControlDirFormat.register_control_format(BareLocalGitControlDirFormat)
 
309
    ControlDirFormat.register_control_format(RemoteGitControlDirFormat)
202
310
 
203
311
register_transport_proto('git://',
204
312
        help="Access using the Git smart server protocol.")
211
319
                        'SSHGitSmartTransport')
212
320
 
213
321
foreign_vcs_registry.register_lazy("git",
214
 
    "bzrlib.plugins.git.mapping", "foreign_vcs_git", "Stupid content tracker")
 
322
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
215
323
 
216
324
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
217
325
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
219
327
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
220
328
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
221
329
 
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
330
def update_stanza(rev, stanza):
239
331
    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")
 
332
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
333
        stanza.add("git-commit", rev.foreign_revid)
 
334
 
 
335
 
 
336
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
337
if rio_hooks is not None:
 
338
    rio_hooks.install_named_hook('revision', update_stanza, None)
259
339
 
260
340
 
261
341
from bzrlib.transport import transport_server_registry
266
346
 
267
347
 
268
348
from bzrlib.repository import (
269
 
    format_registry as repository_format_registry,
270
349
    network_format_registry as repository_network_format_registry,
271
350
    )
272
351
repository_network_format_registry.register_lazy('git',
273
352
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
274
353
 
275
354
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")
 
355
    from bzrlib.controldir import (
 
356
        network_format_registry as controldir_network_format_registry,
 
357
        )
 
358
except ImportError:
 
359
    from bzrlib.bzrdir import (
 
360
        network_format_registry as controldir_network_format_registry,
 
361
        )
 
362
controldir_network_format_registry.register('git', GitControlDirFormat)
316
363
 
317
364
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
318
365
                                   'send_git', 'Git am-style diff format')
319
366
 
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
 
        parent_revisions = set(repository.get_parent_map([revid])[revid])
340
 
        missing_revisions = store._missing_revisions(parent_revisions)
341
 
        if not missing_revisions:
342
 
            # Only update if the cache was up to date previously
343
 
            store._update_sha_map_revision(revid)
344
 
    finally:
345
 
        store.unlock()
346
 
 
347
 
 
348
 
def post_commit_update_cache(local_branch, master_branch, old_revno, old_revid,
349
 
        new_revno, new_revid):
350
 
    if local_branch is not None:
351
 
        update_git_cache(local_branch.repository, new_revid)
352
 
    update_git_cache(master_branch.repository, new_revid)
353
 
 
 
367
topic_registry.register_lazy('git',
 
368
                             'bzrlib.plugins.git.help',
 
369
                             'help_git', 'Using Bazaar with Git')
354
370
 
355
371
try:
356
 
    from bzrlib.hooks import install_lazy_named_hook
357
 
except ImportError: # Compatibility with bzr < 2.4
 
372
    from bzrlib.diff import format_registry as diff_format_registry
 
373
except ImportError:
358
374
    pass
359
375
else:
360
 
    install_lazy_named_hook("bzrlib.branch",
361
 
        "Branch.hooks", "post_commit", post_commit_update_cache,
362
 
        "git cache")
363
 
 
 
376
    diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
377
        'GitDiffTree', 'Git am-style diff format')
364
378
 
365
379
def test_suite():
366
380
    from bzrlib.plugins.git import tests