/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 bzrlib/bzrdir.py

(jelmer) Convert bzrlib.smtp_connection to use config stacks. (Jelmer
 Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
 
1
# Copyright (C) 2006-2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
 
18
 
 
19
At format 7 this was split out into Branch, Repository and Checkout control
 
20
directories.
 
21
 
 
22
Note: This module has a lot of ``open`` functions/methods that return
 
23
references to in-memory objects. As a rule, there are no matching ``close``
 
24
methods. To free any associated resources, simply stop referencing the
 
25
objects returned.
 
26
"""
 
27
 
 
28
from __future__ import absolute_import
 
29
 
 
30
import sys
 
31
 
 
32
from bzrlib.lazy_import import lazy_import
 
33
lazy_import(globals(), """
 
34
import bzrlib
 
35
from bzrlib import (
 
36
    branch as _mod_branch,
 
37
    cleanup,
 
38
    errors,
 
39
    fetch,
 
40
    graph,
 
41
    lockable_files,
 
42
    lockdir,
 
43
    osutils,
 
44
    pyutils,
 
45
    remote,
 
46
    repository,
 
47
    revision as _mod_revision,
 
48
    transport as _mod_transport,
 
49
    ui,
 
50
    urlutils,
 
51
    vf_search,
 
52
    win32utils,
 
53
    workingtree_3,
 
54
    workingtree_4,
 
55
    )
 
56
from bzrlib.repofmt import knitpack_repo
 
57
from bzrlib.transport import (
 
58
    do_catching_redirections,
 
59
    local,
 
60
    )
 
61
from bzrlib.i18n import gettext
 
62
""")
 
63
 
 
64
from bzrlib.trace import (
 
65
    mutter,
 
66
    note,
 
67
    )
 
68
 
 
69
from bzrlib import (
 
70
    config,
 
71
    controldir,
 
72
    registry,
 
73
    )
 
74
from bzrlib.symbol_versioning import (
 
75
    deprecated_in,
 
76
    deprecated_method,
 
77
    )
 
78
 
 
79
 
 
80
class BzrDir(controldir.ControlDir):
 
81
    """A .bzr control diretory.
 
82
 
 
83
    BzrDir instances let you create or open any of the things that can be
 
84
    found within .bzr - checkouts, branches and repositories.
 
85
 
 
86
    :ivar transport:
 
87
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
 
88
    :ivar root_transport:
 
89
        a transport connected to the directory this bzr was opened from
 
90
        (i.e. the parent directory holding the .bzr directory).
 
91
 
 
92
    Everything in the bzrdir should have the same file permissions.
 
93
 
 
94
    :cvar hooks: An instance of BzrDirHooks.
 
95
    """
 
96
 
 
97
    def break_lock(self):
 
98
        """Invoke break_lock on the first object in the bzrdir.
 
99
 
 
100
        If there is a tree, the tree is opened and break_lock() called.
 
101
        Otherwise, branch is tried, and finally repository.
 
102
        """
 
103
        # XXX: This seems more like a UI function than something that really
 
104
        # belongs in this class.
 
105
        try:
 
106
            thing_to_unlock = self.open_workingtree()
 
107
        except (errors.NotLocalUrl, errors.NoWorkingTree):
 
108
            try:
 
109
                thing_to_unlock = self.open_branch()
 
110
            except errors.NotBranchError:
 
111
                try:
 
112
                    thing_to_unlock = self.open_repository()
 
113
                except errors.NoRepositoryPresent:
 
114
                    return
 
115
        thing_to_unlock.break_lock()
 
116
 
 
117
    def check_conversion_target(self, target_format):
 
118
        """Check that a bzrdir as a whole can be converted to a new format."""
 
119
        # The only current restriction is that the repository content can be 
 
120
        # fetched compatibly with the target.
 
121
        target_repo_format = target_format.repository_format
 
122
        try:
 
123
            self.open_repository()._format.check_conversion_target(
 
124
                target_repo_format)
 
125
        except errors.NoRepositoryPresent:
 
126
            # No repo, no problem.
 
127
            pass
 
128
 
 
129
    def clone_on_transport(self, transport, revision_id=None,
 
130
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
131
        create_prefix=False, use_existing_dir=True, no_tree=False):
 
132
        """Clone this bzrdir and its contents to transport verbatim.
 
133
 
 
134
        :param transport: The transport for the location to produce the clone
 
135
            at.  If the target directory does not exist, it will be created.
 
136
        :param revision_id: The tip revision-id to use for any branch or
 
137
            working tree.  If not None, then the clone operation may tune
 
138
            itself to download less data.
 
139
        :param force_new_repo: Do not use a shared repository for the target,
 
140
                               even if one is available.
 
141
        :param preserve_stacking: When cloning a stacked branch, stack the
 
142
            new branch on top of the other branch's stacked-on branch.
 
143
        :param create_prefix: Create any missing directories leading up to
 
144
            to_transport.
 
145
        :param use_existing_dir: Use an existing directory if one exists.
 
146
        :param no_tree: If set to true prevents creation of a working tree.
 
147
        """
 
148
        # Overview: put together a broad description of what we want to end up
 
149
        # with; then make as few api calls as possible to do it.
 
150
 
 
151
        # We may want to create a repo/branch/tree, if we do so what format
 
152
        # would we want for each:
 
153
        require_stacking = (stacked_on is not None)
 
154
        format = self.cloning_metadir(require_stacking)
 
155
 
 
156
        # Figure out what objects we want:
 
157
        try:
 
158
            local_repo = self.find_repository()
 
159
        except errors.NoRepositoryPresent:
 
160
            local_repo = None
 
161
        try:
 
162
            local_branch = self.open_branch()
 
163
        except errors.NotBranchError:
 
164
            local_branch = None
 
165
        else:
 
166
            # enable fallbacks when branch is not a branch reference
 
167
            if local_branch.repository.has_same_location(local_repo):
 
168
                local_repo = local_branch.repository
 
169
            if preserve_stacking:
 
170
                try:
 
171
                    stacked_on = local_branch.get_stacked_on_url()
 
172
                except (errors.UnstackableBranchFormat,
 
173
                        errors.UnstackableRepositoryFormat,
 
174
                        errors.NotStacked):
 
175
                    pass
 
176
        # Bug: We create a metadir without knowing if it can support stacking,
 
177
        # we should look up the policy needs first, or just use it as a hint,
 
178
        # or something.
 
179
        if local_repo:
 
180
            make_working_trees = local_repo.make_working_trees() and not no_tree
 
181
            want_shared = local_repo.is_shared()
 
182
            repo_format_name = format.repository_format.network_name()
 
183
        else:
 
184
            make_working_trees = False
 
185
            want_shared = False
 
186
            repo_format_name = None
 
187
 
 
188
        result_repo, result, require_stacking, repository_policy = \
 
189
            format.initialize_on_transport_ex(transport,
 
190
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
191
            force_new_repo=force_new_repo, stacked_on=stacked_on,
 
192
            stack_on_pwd=self.root_transport.base,
 
193
            repo_format_name=repo_format_name,
 
194
            make_working_trees=make_working_trees, shared_repo=want_shared)
 
195
        if repo_format_name:
 
196
            try:
 
197
                # If the result repository is in the same place as the
 
198
                # resulting bzr dir, it will have no content, further if the
 
199
                # result is not stacked then we know all content should be
 
200
                # copied, and finally if we are copying up to a specific
 
201
                # revision_id then we can use the pending-ancestry-result which
 
202
                # does not require traversing all of history to describe it.
 
203
                if (result_repo.user_url == result.user_url
 
204
                    and not require_stacking and
 
205
                    revision_id is not None):
 
206
                    fetch_spec = vf_search.PendingAncestryResult(
 
207
                        [revision_id], local_repo)
 
208
                    result_repo.fetch(local_repo, fetch_spec=fetch_spec)
 
209
                else:
 
210
                    result_repo.fetch(local_repo, revision_id=revision_id)
 
211
            finally:
 
212
                result_repo.unlock()
 
213
        else:
 
214
            if result_repo is not None:
 
215
                raise AssertionError('result_repo not None(%r)' % result_repo)
 
216
        # 1 if there is a branch present
 
217
        #   make sure its content is available in the target repository
 
218
        #   clone it.
 
219
        if local_branch is not None:
 
220
            result_branch = local_branch.clone(result, revision_id=revision_id,
 
221
                repository_policy=repository_policy)
 
222
        try:
 
223
            # Cheaper to check if the target is not local, than to try making
 
224
            # the tree and fail.
 
225
            result.root_transport.local_abspath('.')
 
226
            if result_repo is None or result_repo.make_working_trees():
 
227
                self.open_workingtree().clone(result, revision_id=revision_id)
 
228
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
229
            pass
 
230
        return result
 
231
 
 
232
    # TODO: This should be given a Transport, and should chdir up; otherwise
 
233
    # this will open a new connection.
 
234
    def _make_tail(self, url):
 
235
        t = _mod_transport.get_transport(url)
 
236
        t.ensure_base()
 
237
 
 
238
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
 
239
                                    stack_on_pwd=None, require_stacking=False):
 
240
        """Return an object representing a policy to use.
 
241
 
 
242
        This controls whether a new repository is created, and the format of
 
243
        that repository, or some existing shared repository used instead.
 
244
 
 
245
        If stack_on is supplied, will not seek a containing shared repo.
 
246
 
 
247
        :param force_new_repo: If True, require a new repository to be created.
 
248
        :param stack_on: If supplied, the location to stack on.  If not
 
249
            supplied, a default_stack_on location may be used.
 
250
        :param stack_on_pwd: If stack_on is relative, the location it is
 
251
            relative to.
 
252
        """
 
253
        def repository_policy(found_bzrdir):
 
254
            stack_on = None
 
255
            stack_on_pwd = None
 
256
            config = found_bzrdir.get_config()
 
257
            stop = False
 
258
            stack_on = config.get_default_stack_on()
 
259
            if stack_on is not None:
 
260
                stack_on_pwd = found_bzrdir.user_url
 
261
                stop = True
 
262
            # does it have a repository ?
 
263
            try:
 
264
                repository = found_bzrdir.open_repository()
 
265
            except errors.NoRepositoryPresent:
 
266
                repository = None
 
267
            else:
 
268
                if (found_bzrdir.user_url != self.user_url 
 
269
                    and not repository.is_shared()):
 
270
                    # Don't look higher, can't use a higher shared repo.
 
271
                    repository = None
 
272
                    stop = True
 
273
                else:
 
274
                    stop = True
 
275
            if not stop:
 
276
                return None, False
 
277
            if repository:
 
278
                return UseExistingRepository(repository, stack_on,
 
279
                    stack_on_pwd, require_stacking=require_stacking), True
 
280
            else:
 
281
                return CreateRepository(self, stack_on, stack_on_pwd,
 
282
                    require_stacking=require_stacking), True
 
283
 
 
284
        if not force_new_repo:
 
285
            if stack_on is None:
 
286
                policy = self._find_containing(repository_policy)
 
287
                if policy is not None:
 
288
                    return policy
 
289
            else:
 
290
                try:
 
291
                    return UseExistingRepository(self.open_repository(),
 
292
                        stack_on, stack_on_pwd,
 
293
                        require_stacking=require_stacking)
 
294
                except errors.NoRepositoryPresent:
 
295
                    pass
 
296
        return CreateRepository(self, stack_on, stack_on_pwd,
 
297
                                require_stacking=require_stacking)
 
298
 
 
299
    def _find_or_create_repository(self, force_new_repo):
 
300
        """Create a new repository if needed, returning the repository."""
 
301
        policy = self.determine_repository_policy(force_new_repo)
 
302
        return policy.acquire_repository()[0]
 
303
 
 
304
    def _find_source_repo(self, add_cleanup, source_branch):
 
305
        """Find the source branch and repo for a sprout operation.
 
306
        
 
307
        This is helper intended for use by _sprout.
 
308
 
 
309
        :returns: (source_branch, source_repository).  Either or both may be
 
310
            None.  If not None, they will be read-locked (and their unlock(s)
 
311
            scheduled via the add_cleanup param).
 
312
        """
 
313
        if source_branch is not None:
 
314
            add_cleanup(source_branch.lock_read().unlock)
 
315
            return source_branch, source_branch.repository
 
316
        try:
 
317
            source_branch = self.open_branch()
 
318
            source_repository = source_branch.repository
 
319
        except errors.NotBranchError:
 
320
            source_branch = None
 
321
            try:
 
322
                source_repository = self.open_repository()
 
323
            except errors.NoRepositoryPresent:
 
324
                source_repository = None
 
325
            else:
 
326
                add_cleanup(source_repository.lock_read().unlock)
 
327
        else:
 
328
            add_cleanup(source_branch.lock_read().unlock)
 
329
        return source_branch, source_repository
 
330
 
 
331
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
332
               recurse='down', possible_transports=None,
 
333
               accelerator_tree=None, hardlink=False, stacked=False,
 
334
               source_branch=None, create_tree_if_local=True):
 
335
        """Create a copy of this controldir prepared for use as a new line of
 
336
        development.
 
337
 
 
338
        If url's last component does not exist, it will be created.
 
339
 
 
340
        Attributes related to the identity of the source branch like
 
341
        branch nickname will be cleaned, a working tree is created
 
342
        whether one existed before or not; and a local branch is always
 
343
        created.
 
344
 
 
345
        if revision_id is not None, then the clone operation may tune
 
346
            itself to download less data.
 
347
 
 
348
        :param accelerator_tree: A tree which can be used for retrieving file
 
349
            contents more quickly than the revision tree, i.e. a workingtree.
 
350
            The revision tree will be used for cases where accelerator_tree's
 
351
            content is different.
 
352
        :param hardlink: If true, hard-link files from accelerator_tree,
 
353
            where possible.
 
354
        :param stacked: If true, create a stacked branch referring to the
 
355
            location of this control directory.
 
356
        :param create_tree_if_local: If true, a working-tree will be created
 
357
            when working locally.
 
358
        """
 
359
        operation = cleanup.OperationWithCleanups(self._sprout)
 
360
        return operation.run(url, revision_id=revision_id,
 
361
            force_new_repo=force_new_repo, recurse=recurse,
 
362
            possible_transports=possible_transports,
 
363
            accelerator_tree=accelerator_tree, hardlink=hardlink,
 
364
            stacked=stacked, source_branch=source_branch,
 
365
            create_tree_if_local=create_tree_if_local)
 
366
 
 
367
    def _sprout(self, op, url, revision_id=None, force_new_repo=False,
 
368
               recurse='down', possible_transports=None,
 
369
               accelerator_tree=None, hardlink=False, stacked=False,
 
370
               source_branch=None, create_tree_if_local=True):
 
371
        add_cleanup = op.add_cleanup
 
372
        fetch_spec_factory = fetch.FetchSpecFactory()
 
373
        if revision_id is not None:
 
374
            fetch_spec_factory.add_revision_ids([revision_id])
 
375
            fetch_spec_factory.source_branch_stop_revision_id = revision_id
 
376
        if possible_transports is None:
 
377
            possible_transports = []
 
378
        else:
 
379
            possible_transports = list(possible_transports) + [
 
380
                self.root_transport]
 
381
        target_transport = _mod_transport.get_transport(url,
 
382
            possible_transports)
 
383
        target_transport.ensure_base()
 
384
        cloning_format = self.cloning_metadir(stacked)
 
385
        # Create/update the result branch
 
386
        try:
 
387
            result = controldir.ControlDir.open_from_transport(target_transport)
 
388
        except errors.NotBranchError:
 
389
            result = cloning_format.initialize_on_transport(target_transport)
 
390
        source_branch, source_repository = self._find_source_repo(
 
391
            add_cleanup, source_branch)
 
392
        fetch_spec_factory.source_branch = source_branch
 
393
        # if a stacked branch wasn't requested, we don't create one
 
394
        # even if the origin was stacked
 
395
        if stacked and source_branch is not None:
 
396
            stacked_branch_url = self.root_transport.base
 
397
        else:
 
398
            stacked_branch_url = None
 
399
        repository_policy = result.determine_repository_policy(
 
400
            force_new_repo, stacked_branch_url, require_stacking=stacked)
 
401
        result_repo, is_new_repo = repository_policy.acquire_repository(
 
402
            possible_transports=possible_transports)
 
403
        add_cleanup(result_repo.lock_write().unlock)
 
404
        fetch_spec_factory.source_repo = source_repository
 
405
        fetch_spec_factory.target_repo = result_repo
 
406
        if stacked or (len(result_repo._fallback_repositories) != 0):
 
407
            target_repo_kind = fetch.TargetRepoKinds.STACKED
 
408
        elif is_new_repo:
 
409
            target_repo_kind = fetch.TargetRepoKinds.EMPTY
 
410
        else:
 
411
            target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
 
412
        fetch_spec_factory.target_repo_kind = target_repo_kind
 
413
        if source_repository is not None:
 
414
            fetch_spec = fetch_spec_factory.make_fetch_spec()
 
415
            result_repo.fetch(source_repository, fetch_spec=fetch_spec)
 
416
 
 
417
        if source_branch is None:
 
418
            # this is for sprouting a controldir without a branch; is that
 
419
            # actually useful?
 
420
            # Not especially, but it's part of the contract.
 
421
            result_branch = result.create_branch()
 
422
        else:
 
423
            result_branch = source_branch.sprout(result,
 
424
                revision_id=revision_id, repository_policy=repository_policy,
 
425
                repository=result_repo)
 
426
        mutter("created new branch %r" % (result_branch,))
 
427
 
 
428
        # Create/update the result working tree
 
429
        if (create_tree_if_local and not result.has_workingtree() and
 
430
            isinstance(target_transport, local.LocalTransport) and
 
431
            (result_repo is None or result_repo.make_working_trees())):
 
432
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
 
433
                hardlink=hardlink, from_branch=result_branch)
 
434
            wt.lock_write()
 
435
            try:
 
436
                if wt.path2id('') is None:
 
437
                    try:
 
438
                        wt.set_root_id(self.open_workingtree.get_root_id())
 
439
                    except errors.NoWorkingTree:
 
440
                        pass
 
441
            finally:
 
442
                wt.unlock()
 
443
        else:
 
444
            wt = None
 
445
        if recurse == 'down':
 
446
            basis = None
 
447
            if wt is not None:
 
448
                basis = wt.basis_tree()
 
449
            elif result_branch is not None:
 
450
                basis = result_branch.basis_tree()
 
451
            elif source_branch is not None:
 
452
                basis = source_branch.basis_tree()
 
453
            if basis is not None:
 
454
                add_cleanup(basis.lock_read().unlock)
 
455
                subtrees = basis.iter_references()
 
456
            else:
 
457
                subtrees = []
 
458
            for path, file_id in subtrees:
 
459
                target = urlutils.join(url, urlutils.escape(path))
 
460
                sublocation = source_branch.reference_parent(file_id, path)
 
461
                sublocation.bzrdir.sprout(target,
 
462
                    basis.get_reference_revision(file_id, path),
 
463
                    force_new_repo=force_new_repo, recurse=recurse,
 
464
                    stacked=stacked)
 
465
        return result
 
466
 
 
467
    @deprecated_method(deprecated_in((2, 3, 0)))
 
468
    def generate_backup_name(self, base):
 
469
        return self._available_backup_name(base)
 
470
 
 
471
    def _available_backup_name(self, base):
 
472
        """Find a non-existing backup file name based on base.
 
473
 
 
474
        See bzrlib.osutils.available_backup_name about race conditions.
 
475
        """
 
476
        return osutils.available_backup_name(base, self.root_transport.has)
 
477
 
 
478
    def backup_bzrdir(self):
 
479
        """Backup this bzr control directory.
 
480
 
 
481
        :return: Tuple with old path name and new path name
 
482
        """
 
483
 
 
484
        pb = ui.ui_factory.nested_progress_bar()
 
485
        try:
 
486
            old_path = self.root_transport.abspath('.bzr')
 
487
            backup_dir = self._available_backup_name('backup.bzr')
 
488
            new_path = self.root_transport.abspath(backup_dir)
 
489
            ui.ui_factory.note(gettext('making backup of {0}\n  to {1}').format(
 
490
                urlutils.unescape_for_display(old_path, 'utf-8'),
 
491
                urlutils.unescape_for_display(new_path, 'utf-8')))
 
492
            self.root_transport.copy_tree('.bzr', backup_dir)
 
493
            return (old_path, new_path)
 
494
        finally:
 
495
            pb.finished()
 
496
 
 
497
    def retire_bzrdir(self, limit=10000):
 
498
        """Permanently disable the bzrdir.
 
499
 
 
500
        This is done by renaming it to give the user some ability to recover
 
501
        if there was a problem.
 
502
 
 
503
        This will have horrible consequences if anyone has anything locked or
 
504
        in use.
 
505
        :param limit: number of times to retry
 
506
        """
 
507
        i  = 0
 
508
        while True:
 
509
            try:
 
510
                to_path = '.bzr.retired.%d' % i
 
511
                self.root_transport.rename('.bzr', to_path)
 
512
                note(gettext("renamed {0} to {1}").format(
 
513
                    self.root_transport.abspath('.bzr'), to_path))
 
514
                return
 
515
            except (errors.TransportError, IOError, errors.PathError):
 
516
                i += 1
 
517
                if i > limit:
 
518
                    raise
 
519
                else:
 
520
                    pass
 
521
 
 
522
    def _find_containing(self, evaluate):
 
523
        """Find something in a containing control directory.
 
524
 
 
525
        This method will scan containing control dirs, until it finds what
 
526
        it is looking for, decides that it will never find it, or runs out
 
527
        of containing control directories to check.
 
528
 
 
529
        It is used to implement find_repository and
 
530
        determine_repository_policy.
 
531
 
 
532
        :param evaluate: A function returning (value, stop).  If stop is True,
 
533
            the value will be returned.
 
534
        """
 
535
        found_bzrdir = self
 
536
        while True:
 
537
            result, stop = evaluate(found_bzrdir)
 
538
            if stop:
 
539
                return result
 
540
            next_transport = found_bzrdir.root_transport.clone('..')
 
541
            if (found_bzrdir.user_url == next_transport.base):
 
542
                # top of the file system
 
543
                return None
 
544
            # find the next containing bzrdir
 
545
            try:
 
546
                found_bzrdir = self.open_containing_from_transport(
 
547
                    next_transport)[0]
 
548
            except errors.NotBranchError:
 
549
                return None
 
550
 
 
551
    def find_repository(self):
 
552
        """Find the repository that should be used.
 
553
 
 
554
        This does not require a branch as we use it to find the repo for
 
555
        new branches as well as to hook existing branches up to their
 
556
        repository.
 
557
        """
 
558
        def usable_repository(found_bzrdir):
 
559
            # does it have a repository ?
 
560
            try:
 
561
                repository = found_bzrdir.open_repository()
 
562
            except errors.NoRepositoryPresent:
 
563
                return None, False
 
564
            if found_bzrdir.user_url == self.user_url:
 
565
                return repository, True
 
566
            elif repository.is_shared():
 
567
                return repository, True
 
568
            else:
 
569
                return None, True
 
570
 
 
571
        found_repo = self._find_containing(usable_repository)
 
572
        if found_repo is None:
 
573
            raise errors.NoRepositoryPresent(self)
 
574
        return found_repo
 
575
 
 
576
    def _find_creation_modes(self):
 
577
        """Determine the appropriate modes for files and directories.
 
578
 
 
579
        They're always set to be consistent with the base directory,
 
580
        assuming that this transport allows setting modes.
 
581
        """
 
582
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
583
        # this off or override it for particular locations? -- mbp 20080512
 
584
        if self._mode_check_done:
 
585
            return
 
586
        self._mode_check_done = True
 
587
        try:
 
588
            st = self.transport.stat('.')
 
589
        except errors.TransportNotPossible:
 
590
            self._dir_mode = None
 
591
            self._file_mode = None
 
592
        else:
 
593
            # Check the directory mode, but also make sure the created
 
594
            # directories and files are read-write for this user. This is
 
595
            # mostly a workaround for filesystems which lie about being able to
 
596
            # write to a directory (cygwin & win32)
 
597
            if (st.st_mode & 07777 == 00000):
 
598
                # FTP allows stat but does not return dir/file modes
 
599
                self._dir_mode = None
 
600
                self._file_mode = None
 
601
            else:
 
602
                self._dir_mode = (st.st_mode & 07777) | 00700
 
603
                # Remove the sticky and execute bits for files
 
604
                self._file_mode = self._dir_mode & ~07111
 
605
 
 
606
    def _get_file_mode(self):
 
607
        """Return Unix mode for newly created files, or None.
 
608
        """
 
609
        if not self._mode_check_done:
 
610
            self._find_creation_modes()
 
611
        return self._file_mode
 
612
 
 
613
    def _get_dir_mode(self):
 
614
        """Return Unix mode for newly created directories, or None.
 
615
        """
 
616
        if not self._mode_check_done:
 
617
            self._find_creation_modes()
 
618
        return self._dir_mode
 
619
 
 
620
    def get_config(self):
 
621
        """Get configuration for this BzrDir."""
 
622
        return config.BzrDirConfig(self)
 
623
 
 
624
    def _get_config(self):
 
625
        """By default, no configuration is available."""
 
626
        return None
 
627
 
 
628
    def __init__(self, _transport, _format):
 
629
        """Initialize a Bzr control dir object.
 
630
 
 
631
        Only really common logic should reside here, concrete classes should be
 
632
        made with varying behaviours.
 
633
 
 
634
        :param _format: the format that is creating this BzrDir instance.
 
635
        :param _transport: the transport this dir is based at.
 
636
        """
 
637
        self._format = _format
 
638
        # these are also under the more standard names of 
 
639
        # control_transport and user_transport
 
640
        self.transport = _transport.clone('.bzr')
 
641
        self.root_transport = _transport
 
642
        self._mode_check_done = False
 
643
 
 
644
    @property 
 
645
    def user_transport(self):
 
646
        return self.root_transport
 
647
 
 
648
    @property
 
649
    def control_transport(self):
 
650
        return self.transport
 
651
 
 
652
    def is_control_filename(self, filename):
 
653
        """True if filename is the name of a path which is reserved for bzrdir's.
 
654
 
 
655
        :param filename: A filename within the root transport of this bzrdir.
 
656
 
 
657
        This is true IF and ONLY IF the filename is part of the namespace reserved
 
658
        for bzr control dirs. Currently this is the '.bzr' directory in the root
 
659
        of the root_transport. 
 
660
        """
 
661
        # this might be better on the BzrDirFormat class because it refers to
 
662
        # all the possible bzrdir disk formats.
 
663
        # This method is tested via the workingtree is_control_filename tests-
 
664
        # it was extracted from WorkingTree.is_control_filename. If the method's
 
665
        # contract is extended beyond the current trivial implementation, please
 
666
        # add new tests for it to the appropriate place.
 
667
        return filename == '.bzr' or filename.startswith('.bzr/')
 
668
 
 
669
    def _cloning_metadir(self):
 
670
        """Produce a metadir suitable for cloning with.
 
671
 
 
672
        :returns: (destination_bzrdir_format, source_repository)
 
673
        """
 
674
        result_format = self._format.__class__()
 
675
        try:
 
676
            try:
 
677
                branch = self.open_branch(ignore_fallbacks=True)
 
678
                source_repository = branch.repository
 
679
                result_format._branch_format = branch._format
 
680
            except errors.NotBranchError:
 
681
                source_branch = None
 
682
                source_repository = self.open_repository()
 
683
        except errors.NoRepositoryPresent:
 
684
            source_repository = None
 
685
        else:
 
686
            # XXX TODO: This isinstance is here because we have not implemented
 
687
            # the fix recommended in bug # 103195 - to delegate this choice the
 
688
            # repository itself.
 
689
            repo_format = source_repository._format
 
690
            if isinstance(repo_format, remote.RemoteRepositoryFormat):
 
691
                source_repository._ensure_real()
 
692
                repo_format = source_repository._real_repository._format
 
693
            result_format.repository_format = repo_format
 
694
        try:
 
695
            # TODO: Couldn't we just probe for the format in these cases,
 
696
            # rather than opening the whole tree?  It would be a little
 
697
            # faster. mbp 20070401
 
698
            tree = self.open_workingtree(recommend_upgrade=False)
 
699
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
700
            result_format.workingtree_format = None
 
701
        else:
 
702
            result_format.workingtree_format = tree._format.__class__()
 
703
        return result_format, source_repository
 
704
 
 
705
    def cloning_metadir(self, require_stacking=False):
 
706
        """Produce a metadir suitable for cloning or sprouting with.
 
707
 
 
708
        These operations may produce workingtrees (yes, even though they're
 
709
        "cloning" something that doesn't have a tree), so a viable workingtree
 
710
        format must be selected.
 
711
 
 
712
        :require_stacking: If True, non-stackable formats will be upgraded
 
713
            to similar stackable formats.
 
714
        :returns: a ControlDirFormat with all component formats either set
 
715
            appropriately or set to None if that component should not be
 
716
            created.
 
717
        """
 
718
        format, repository = self._cloning_metadir()
 
719
        if format._workingtree_format is None:
 
720
            # No tree in self.
 
721
            if repository is None:
 
722
                # No repository either
 
723
                return format
 
724
            # We have a repository, so set a working tree? (Why? This seems to
 
725
            # contradict the stated return value in the docstring).
 
726
            tree_format = repository._format._matchingbzrdir.workingtree_format
 
727
            format.workingtree_format = tree_format.__class__()
 
728
        if require_stacking:
 
729
            format.require_stacking()
 
730
        return format
 
731
 
 
732
    def get_branch_transport(self, branch_format, name=None):
 
733
        """Get the transport for use by branch format in this BzrDir.
 
734
 
 
735
        Note that bzr dirs that do not support format strings will raise
 
736
        IncompatibleFormat if the branch format they are given has
 
737
        a format string, and vice versa.
 
738
 
 
739
        If branch_format is None, the transport is returned with no
 
740
        checking. If it is not None, then the returned transport is
 
741
        guaranteed to point to an existing directory ready for use.
 
742
        """
 
743
        raise NotImplementedError(self.get_branch_transport)
 
744
 
 
745
    def get_repository_transport(self, repository_format):
 
746
        """Get the transport for use by repository format in this BzrDir.
 
747
 
 
748
        Note that bzr dirs that do not support format strings will raise
 
749
        IncompatibleFormat if the repository format they are given has
 
750
        a format string, and vice versa.
 
751
 
 
752
        If repository_format is None, the transport is returned with no
 
753
        checking. If it is not None, then the returned transport is
 
754
        guaranteed to point to an existing directory ready for use.
 
755
        """
 
756
        raise NotImplementedError(self.get_repository_transport)
 
757
 
 
758
    def get_workingtree_transport(self, tree_format):
 
759
        """Get the transport for use by workingtree format in this BzrDir.
 
760
 
 
761
        Note that bzr dirs that do not support format strings will raise
 
762
        IncompatibleFormat if the workingtree format they are given has a
 
763
        format string, and vice versa.
 
764
 
 
765
        If workingtree_format is None, the transport is returned with no
 
766
        checking. If it is not None, then the returned transport is
 
767
        guaranteed to point to an existing directory ready for use.
 
768
        """
 
769
        raise NotImplementedError(self.get_workingtree_transport)
 
770
 
 
771
    @classmethod
 
772
    def create(cls, base, format=None, possible_transports=None):
 
773
        """Create a new BzrDir at the url 'base'.
 
774
 
 
775
        :param format: If supplied, the format of branch to create.  If not
 
776
            supplied, the default is used.
 
777
        :param possible_transports: If supplied, a list of transports that
 
778
            can be reused to share a remote connection.
 
779
        """
 
780
        if cls is not BzrDir:
 
781
            raise AssertionError("BzrDir.create always creates the "
 
782
                "default format, not one of %r" % cls)
 
783
        return controldir.ControlDir.create(base, format=format,
 
784
                possible_transports=possible_transports)
 
785
 
 
786
    def __repr__(self):
 
787
        return "<%s at %r>" % (self.__class__.__name__, self.user_url)
 
788
 
 
789
 
 
790
class BzrDirMeta1(BzrDir):
 
791
    """A .bzr meta version 1 control object.
 
792
 
 
793
    This is the first control object where the
 
794
    individual aspects are really split out: there are separate repository,
 
795
    workingtree and branch subdirectories and any subset of the three can be
 
796
    present within a BzrDir.
 
797
    """
 
798
 
 
799
    def can_convert_format(self):
 
800
        """See BzrDir.can_convert_format()."""
 
801
        return True
 
802
 
 
803
    def create_branch(self, name=None, repository=None,
 
804
            append_revisions_only=None):
 
805
        """See BzrDir.create_branch."""
 
806
        if name is None:
 
807
            name = self._get_selected_branch()
 
808
        return self._format.get_branch_format().initialize(self, name=name,
 
809
                repository=repository,
 
810
                append_revisions_only=append_revisions_only)
 
811
 
 
812
    def destroy_branch(self, name=None):
 
813
        """See BzrDir.create_branch."""
 
814
        if name is not None:
 
815
            raise errors.NoColocatedBranchSupport(self)
 
816
        self.transport.delete_tree('branch')
 
817
 
 
818
    def create_repository(self, shared=False):
 
819
        """See BzrDir.create_repository."""
 
820
        return self._format.repository_format.initialize(self, shared)
 
821
 
 
822
    def destroy_repository(self):
 
823
        """See BzrDir.destroy_repository."""
 
824
        try:
 
825
            self.transport.delete_tree('repository')
 
826
        except errors.NoSuchFile:
 
827
            raise errors.NoRepositoryPresent(self)
 
828
 
 
829
    def create_workingtree(self, revision_id=None, from_branch=None,
 
830
                           accelerator_tree=None, hardlink=False):
 
831
        """See BzrDir.create_workingtree."""
 
832
        return self._format.workingtree_format.initialize(
 
833
            self, revision_id, from_branch=from_branch,
 
834
            accelerator_tree=accelerator_tree, hardlink=hardlink)
 
835
 
 
836
    def destroy_workingtree(self):
 
837
        """See BzrDir.destroy_workingtree."""
 
838
        wt = self.open_workingtree(recommend_upgrade=False)
 
839
        repository = wt.branch.repository
 
840
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
 
841
        # We ignore the conflicts returned by wt.revert since we're about to
 
842
        # delete the wt metadata anyway, all that should be left here are
 
843
        # detritus. But see bug #634470 about subtree .bzr dirs.
 
844
        conflicts = wt.revert(old_tree=empty)
 
845
        self.destroy_workingtree_metadata()
 
846
 
 
847
    def destroy_workingtree_metadata(self):
 
848
        self.transport.delete_tree('checkout')
 
849
 
 
850
    def find_branch_format(self, name=None):
 
851
        """Find the branch 'format' for this bzrdir.
 
852
 
 
853
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
854
        """
 
855
        from bzrlib.branch import BranchFormatMetadir
 
856
        return BranchFormatMetadir.find_format(self, name=name)
 
857
 
 
858
    def _get_mkdir_mode(self):
 
859
        """Figure out the mode to use when creating a bzrdir subdir."""
 
860
        temp_control = lockable_files.LockableFiles(self.transport, '',
 
861
                                     lockable_files.TransportLock)
 
862
        return temp_control._dir_mode
 
863
 
 
864
    def get_branch_reference(self, name=None):
 
865
        """See BzrDir.get_branch_reference()."""
 
866
        from bzrlib.branch import BranchFormatMetadir
 
867
        format = BranchFormatMetadir.find_format(self, name=name)
 
868
        return format.get_reference(self, name=name)
 
869
 
 
870
    def get_branch_transport(self, branch_format, name=None):
 
871
        """See BzrDir.get_branch_transport()."""
 
872
        if name is not None:
 
873
            raise errors.NoColocatedBranchSupport(self)
 
874
        # XXX: this shouldn't implicitly create the directory if it's just
 
875
        # promising to get a transport -- mbp 20090727
 
876
        if branch_format is None:
 
877
            return self.transport.clone('branch')
 
878
        try:
 
879
            branch_format.get_format_string()
 
880
        except NotImplementedError:
 
881
            raise errors.IncompatibleFormat(branch_format, self._format)
 
882
        try:
 
883
            self.transport.mkdir('branch', mode=self._get_mkdir_mode())
 
884
        except errors.FileExists:
 
885
            pass
 
886
        return self.transport.clone('branch')
 
887
 
 
888
    def get_repository_transport(self, repository_format):
 
889
        """See BzrDir.get_repository_transport()."""
 
890
        if repository_format is None:
 
891
            return self.transport.clone('repository')
 
892
        try:
 
893
            repository_format.get_format_string()
 
894
        except NotImplementedError:
 
895
            raise errors.IncompatibleFormat(repository_format, self._format)
 
896
        try:
 
897
            self.transport.mkdir('repository', mode=self._get_mkdir_mode())
 
898
        except errors.FileExists:
 
899
            pass
 
900
        return self.transport.clone('repository')
 
901
 
 
902
    def get_workingtree_transport(self, workingtree_format):
 
903
        """See BzrDir.get_workingtree_transport()."""
 
904
        if workingtree_format is None:
 
905
            return self.transport.clone('checkout')
 
906
        try:
 
907
            workingtree_format.get_format_string()
 
908
        except NotImplementedError:
 
909
            raise errors.IncompatibleFormat(workingtree_format, self._format)
 
910
        try:
 
911
            self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
 
912
        except errors.FileExists:
 
913
            pass
 
914
        return self.transport.clone('checkout')
 
915
 
 
916
    def has_workingtree(self):
 
917
        """Tell if this bzrdir contains a working tree.
 
918
 
 
919
        Note: if you're going to open the working tree, you should just go
 
920
        ahead and try, and not ask permission first.
 
921
        """
 
922
        from bzrlib.workingtree import WorkingTreeFormatMetaDir
 
923
        try:
 
924
            WorkingTreeFormatMetaDir.find_format_string(self)
 
925
        except errors.NoWorkingTree:
 
926
            return False
 
927
        return True
 
928
 
 
929
    def needs_format_conversion(self, format):
 
930
        """See BzrDir.needs_format_conversion()."""
 
931
        if (not isinstance(self._format, format.__class__) or
 
932
            self._format.get_format_string() != format.get_format_string()):
 
933
            # it is not a meta dir format, conversion is needed.
 
934
            return True
 
935
        # we might want to push this down to the repository?
 
936
        try:
 
937
            if not isinstance(self.open_repository()._format,
 
938
                              format.repository_format.__class__):
 
939
                # the repository needs an upgrade.
 
940
                return True
 
941
        except errors.NoRepositoryPresent:
 
942
            pass
 
943
        for branch in self.list_branches():
 
944
            if not isinstance(branch._format,
 
945
                              format.get_branch_format().__class__):
 
946
                # the branch needs an upgrade.
 
947
                return True
 
948
        try:
 
949
            my_wt = self.open_workingtree(recommend_upgrade=False)
 
950
            if not isinstance(my_wt._format,
 
951
                              format.workingtree_format.__class__):
 
952
                # the workingtree needs an upgrade.
 
953
                return True
 
954
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
955
            pass
 
956
        return False
 
957
 
 
958
    def open_branch(self, name=None, unsupported=False,
 
959
                    ignore_fallbacks=False, possible_transports=None):
 
960
        """See ControlDir.open_branch."""
 
961
        if name is None:
 
962
            name = self._get_selected_branch()
 
963
        format = self.find_branch_format(name=name)
 
964
        format.check_support_status(unsupported)
 
965
        return format.open(self, name=name,
 
966
            _found=True, ignore_fallbacks=ignore_fallbacks,
 
967
            possible_transports=possible_transports)
 
968
 
 
969
    def open_repository(self, unsupported=False):
 
970
        """See BzrDir.open_repository."""
 
971
        from bzrlib.repository import RepositoryFormatMetaDir
 
972
        format = RepositoryFormatMetaDir.find_format(self)
 
973
        format.check_support_status(unsupported)
 
974
        return format.open(self, _found=True)
 
975
 
 
976
    def open_workingtree(self, unsupported=False,
 
977
            recommend_upgrade=True):
 
978
        """See BzrDir.open_workingtree."""
 
979
        from bzrlib.workingtree import WorkingTreeFormatMetaDir
 
980
        format = WorkingTreeFormatMetaDir.find_format(self)
 
981
        format.check_support_status(unsupported, recommend_upgrade,
 
982
            basedir=self.root_transport.base)
 
983
        return format.open(self, _found=True)
 
984
 
 
985
    def _get_config(self):
 
986
        return config.TransportConfig(self.transport, 'control.conf')
 
987
 
 
988
 
 
989
class BzrDirMeta1Colo(BzrDirMeta1):
 
990
    """BzrDirMeta1 with support for colocated branches.
 
991
 
 
992
    This format is experimental, and will eventually be merged back into
 
993
    BzrDirMeta1.
 
994
    """
 
995
 
 
996
    def __init__(self, _transport, _format):
 
997
        super(BzrDirMeta1Colo, self).__init__(_transport, _format)
 
998
        self.control_files = lockable_files.LockableFiles(self.control_transport,
 
999
            self._format._lock_file_name, self._format._lock_class)
 
1000
 
 
1001
    def _get_branch_path(self, name):
 
1002
        """Obtain the branch path to use.
 
1003
 
 
1004
        This uses the API specified branch name first, and then falls back to
 
1005
        the branch name specified in the URL. If neither of those is specified,
 
1006
        it uses the default branch.
 
1007
 
 
1008
        :param name: Optional branch name to use
 
1009
        :return: Relative path to branch
 
1010
        """
 
1011
        if name is None:
 
1012
            return 'branch'
 
1013
        return urlutils.join('branches', name.encode("utf-8"))
 
1014
 
 
1015
    def _read_branch_list(self):
 
1016
        """Read the branch list.
 
1017
 
 
1018
        :return: List of utf-8 encoded branch names.
 
1019
        """
 
1020
        try:
 
1021
            f = self.control_transport.get('branch-list')
 
1022
        except errors.NoSuchFile:
 
1023
            return []
 
1024
 
 
1025
        ret = []
 
1026
        try:
 
1027
            for name in f:
 
1028
                ret.append(name.rstrip("\n"))
 
1029
        finally:
 
1030
            f.close()
 
1031
        return ret
 
1032
 
 
1033
    def _write_branch_list(self, branches):
 
1034
        """Write out the branch list.
 
1035
 
 
1036
        :param branches: List of utf-8 branch names to write
 
1037
        """
 
1038
        self.transport.put_bytes('branch-list',
 
1039
            "".join([name+"\n" for name in branches]))
 
1040
 
 
1041
    def destroy_branch(self, name=None):
 
1042
        """See BzrDir.create_branch."""
 
1043
        if name is None:
 
1044
            name = self._get_selected_branch()
 
1045
        path = self._get_branch_path(name)
 
1046
        if name is not None:
 
1047
            self.control_files.lock_write()
 
1048
            try:
 
1049
                branches = self._read_branch_list()
 
1050
                try:
 
1051
                    branches.remove(name.encode("utf-8"))
 
1052
                except ValueError:
 
1053
                    raise errors.NotBranchError(name)
 
1054
                self._write_branch_list(branches)
 
1055
            finally:
 
1056
                self.control_files.unlock()
 
1057
        self.transport.delete_tree(path)
 
1058
 
 
1059
    def get_branches(self):
 
1060
        """See ControlDir.get_branches."""
 
1061
        ret = {}
 
1062
        try:
 
1063
            ret[None] = self.open_branch()
 
1064
        except (errors.NotBranchError, errors.NoRepositoryPresent):
 
1065
            pass
 
1066
 
 
1067
        for name in self._read_branch_list():
 
1068
            ret[name] = self.open_branch(name.decode('utf-8'))
 
1069
 
 
1070
        return ret
 
1071
 
 
1072
    def get_branch_transport(self, branch_format, name=None):
 
1073
        """See BzrDir.get_branch_transport()."""
 
1074
        path = self._get_branch_path(name)
 
1075
        # XXX: this shouldn't implicitly create the directory if it's just
 
1076
        # promising to get a transport -- mbp 20090727
 
1077
        if branch_format is None:
 
1078
            return self.transport.clone(path)
 
1079
        try:
 
1080
            branch_format.get_format_string()
 
1081
        except NotImplementedError:
 
1082
            raise errors.IncompatibleFormat(branch_format, self._format)
 
1083
        if name is not None:
 
1084
            try:
 
1085
                self.transport.mkdir('branches', mode=self._get_mkdir_mode())
 
1086
            except errors.FileExists:
 
1087
                pass
 
1088
            branches = self._read_branch_list()
 
1089
            utf8_name = name.encode("utf-8")
 
1090
            if not utf8_name in branches:
 
1091
                self.control_files.lock_write()
 
1092
                try:
 
1093
                    branches = self._read_branch_list()
 
1094
                    branches.append(utf8_name)
 
1095
                    self._write_branch_list(branches)
 
1096
                finally:
 
1097
                    self.control_files.unlock()
 
1098
        try:
 
1099
            self.transport.mkdir(path, mode=self._get_mkdir_mode())
 
1100
        except errors.FileExists:
 
1101
            pass
 
1102
        return self.transport.clone(path)
 
1103
 
 
1104
 
 
1105
class BzrDirMetaComponentFormat(controldir.ControlComponentFormat):
 
1106
    """Base class for all formats of things living in metadirs.
 
1107
 
 
1108
    This class manages the format string that is stored in the 'format'
 
1109
    or 'branch-format' file.
 
1110
 
 
1111
    All classes for (branch-, repository-, workingtree-) formats that
 
1112
    live in meta directories and have their own 'format' file
 
1113
    (i.e. different from .bzr/branch-format) derive from this class,
 
1114
    as well as the relevant base class for their kind
 
1115
    (BranchFormat, WorkingTreeFormat, RepositoryFormat).
 
1116
    """
 
1117
 
 
1118
    @classmethod
 
1119
    def get_format_string(cls):
 
1120
        """Return the ASCII format string that identifies this format."""
 
1121
        raise NotImplementedError(cls.get_format_string)
 
1122
 
 
1123
    @classmethod
 
1124
    def from_string(cls, format_string):
 
1125
        if format_string != cls.get_format_string():
 
1126
            raise ValueError("Invalid format header %r" % format_string)
 
1127
        return cls()
 
1128
 
 
1129
    @classmethod
 
1130
    def _find_format(klass, registry, kind, format_string):
 
1131
        try:
 
1132
            cls = registry.get(format_string)
 
1133
        except KeyError:
 
1134
            raise errors.UnknownFormatError(format=format_string, kind=kind)
 
1135
        return cls
 
1136
 
 
1137
    def network_name(self):
 
1138
        """A simple byte string uniquely identifying this format for RPC calls.
 
1139
 
 
1140
        Metadir branch formats use their format string.
 
1141
        """
 
1142
        return self.get_format_string()
 
1143
 
 
1144
    def __eq__(self, other):
 
1145
        return (self.__class__ is other.__class__)
 
1146
 
 
1147
 
 
1148
class BzrProber(controldir.Prober):
 
1149
    """Prober for formats that use a .bzr/ control directory."""
 
1150
 
 
1151
    formats = registry.FormatRegistry(controldir.network_format_registry)
 
1152
    """The known .bzr formats."""
 
1153
 
 
1154
    @classmethod
 
1155
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1156
    def register_bzrdir_format(klass, format):
 
1157
        klass.formats.register(format.get_format_string(), format)
 
1158
 
 
1159
    @classmethod
 
1160
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1161
    def unregister_bzrdir_format(klass, format):
 
1162
        klass.formats.remove(format.get_format_string())
 
1163
 
 
1164
    @classmethod
 
1165
    def probe_transport(klass, transport):
 
1166
        """Return the .bzrdir style format present in a directory."""
 
1167
        try:
 
1168
            format_string = transport.get_bytes(".bzr/branch-format")
 
1169
        except errors.NoSuchFile:
 
1170
            raise errors.NotBranchError(path=transport.base)
 
1171
        try:
 
1172
            cls = klass.formats.get(format_string)
 
1173
        except KeyError:
 
1174
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
 
1175
        return cls.from_string(format_string)
 
1176
 
 
1177
    @classmethod
 
1178
    def known_formats(cls):
 
1179
        result = set()
 
1180
        for name, format in cls.formats.iteritems():
 
1181
            if callable(format):
 
1182
                format = format()
 
1183
            result.add(format)
 
1184
        return result
 
1185
 
 
1186
 
 
1187
controldir.ControlDirFormat.register_prober(BzrProber)
 
1188
 
 
1189
 
 
1190
class RemoteBzrProber(controldir.Prober):
 
1191
    """Prober for remote servers that provide a Bazaar smart server."""
 
1192
 
 
1193
    @classmethod
 
1194
    def probe_transport(klass, transport):
 
1195
        """Return a RemoteBzrDirFormat object if it looks possible."""
 
1196
        try:
 
1197
            medium = transport.get_smart_medium()
 
1198
        except (NotImplementedError, AttributeError,
 
1199
                errors.TransportNotPossible, errors.NoSmartMedium,
 
1200
                errors.SmartProtocolError):
 
1201
            # no smart server, so not a branch for this format type.
 
1202
            raise errors.NotBranchError(path=transport.base)
 
1203
        else:
 
1204
            # Decline to open it if the server doesn't support our required
 
1205
            # version (3) so that the VFS-based transport will do it.
 
1206
            if medium.should_probe():
 
1207
                try:
 
1208
                    server_version = medium.protocol_version()
 
1209
                except errors.SmartProtocolError:
 
1210
                    # Apparently there's no usable smart server there, even though
 
1211
                    # the medium supports the smart protocol.
 
1212
                    raise errors.NotBranchError(path=transport.base)
 
1213
                if server_version != '2':
 
1214
                    raise errors.NotBranchError(path=transport.base)
 
1215
            from bzrlib.remote import RemoteBzrDirFormat
 
1216
            return RemoteBzrDirFormat()
 
1217
 
 
1218
    @classmethod
 
1219
    def known_formats(cls):
 
1220
        from bzrlib.remote import RemoteBzrDirFormat
 
1221
        return set([RemoteBzrDirFormat()])
 
1222
 
 
1223
 
 
1224
class BzrDirFormat(controldir.ControlDirFormat):
 
1225
    """ControlDirFormat base class for .bzr/ directories.
 
1226
 
 
1227
    Formats are placed in a dict by their format string for reference
 
1228
    during bzrdir opening. These should be subclasses of BzrDirFormat
 
1229
    for consistency.
 
1230
 
 
1231
    Once a format is deprecated, just deprecate the initialize and open
 
1232
    methods on the format class. Do not deprecate the object, as the
 
1233
    object will be created every system load.
 
1234
    """
 
1235
 
 
1236
    _lock_file_name = 'branch-lock'
 
1237
 
 
1238
    # _lock_class must be set in subclasses to the lock type, typ.
 
1239
    # TransportLock or LockDir
 
1240
 
 
1241
    @classmethod
 
1242
    def get_format_string(cls):
 
1243
        """Return the ASCII format string that identifies this format."""
 
1244
        raise NotImplementedError(cls.get_format_string)
 
1245
 
 
1246
    def initialize_on_transport(self, transport):
 
1247
        """Initialize a new bzrdir in the base directory of a Transport."""
 
1248
        try:
 
1249
            # can we hand off the request to the smart server rather than using
 
1250
            # vfs calls?
 
1251
            client_medium = transport.get_smart_medium()
 
1252
        except errors.NoSmartMedium:
 
1253
            return self._initialize_on_transport_vfs(transport)
 
1254
        else:
 
1255
            # Current RPC's only know how to create bzr metadir1 instances, so
 
1256
            # we still delegate to vfs methods if the requested format is not a
 
1257
            # metadir1
 
1258
            if type(self) != BzrDirMetaFormat1:
 
1259
                return self._initialize_on_transport_vfs(transport)
 
1260
            from bzrlib.remote import RemoteBzrDirFormat
 
1261
            remote_format = RemoteBzrDirFormat()
 
1262
            self._supply_sub_formats_to(remote_format)
 
1263
            return remote_format.initialize_on_transport(transport)
 
1264
 
 
1265
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
1266
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
1267
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
1268
        shared_repo=False, vfs_only=False):
 
1269
        """Create this format on transport.
 
1270
 
 
1271
        The directory to initialize will be created.
 
1272
 
 
1273
        :param force_new_repo: Do not use a shared repository for the target,
 
1274
                               even if one is available.
 
1275
        :param create_prefix: Create any missing directories leading up to
 
1276
            to_transport.
 
1277
        :param use_existing_dir: Use an existing directory if one exists.
 
1278
        :param stacked_on: A url to stack any created branch on, None to follow
 
1279
            any target stacking policy.
 
1280
        :param stack_on_pwd: If stack_on is relative, the location it is
 
1281
            relative to.
 
1282
        :param repo_format_name: If non-None, a repository will be
 
1283
            made-or-found. Should none be found, or if force_new_repo is True
 
1284
            the repo_format_name is used to select the format of repository to
 
1285
            create.
 
1286
        :param make_working_trees: Control the setting of make_working_trees
 
1287
            for a new shared repository when one is made. None to use whatever
 
1288
            default the format has.
 
1289
        :param shared_repo: Control whether made repositories are shared or
 
1290
            not.
 
1291
        :param vfs_only: If True do not attempt to use a smart server
 
1292
        :return: repo, bzrdir, require_stacking, repository_policy. repo is
 
1293
            None if none was created or found, bzrdir is always valid.
 
1294
            require_stacking is the result of examining the stacked_on
 
1295
            parameter and any stacking policy found for the target.
 
1296
        """
 
1297
        if not vfs_only:
 
1298
            # Try to hand off to a smart server 
 
1299
            try:
 
1300
                client_medium = transport.get_smart_medium()
 
1301
            except errors.NoSmartMedium:
 
1302
                pass
 
1303
            else:
 
1304
                from bzrlib.remote import RemoteBzrDirFormat
 
1305
                # TODO: lookup the local format from a server hint.
 
1306
                remote_dir_format = RemoteBzrDirFormat()
 
1307
                remote_dir_format._network_name = self.network_name()
 
1308
                self._supply_sub_formats_to(remote_dir_format)
 
1309
                return remote_dir_format.initialize_on_transport_ex(transport,
 
1310
                    use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
1311
                    force_new_repo=force_new_repo, stacked_on=stacked_on,
 
1312
                    stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
1313
                    make_working_trees=make_working_trees, shared_repo=shared_repo)
 
1314
        # XXX: Refactor the create_prefix/no_create_prefix code into a
 
1315
        #      common helper function
 
1316
        # The destination may not exist - if so make it according to policy.
 
1317
        def make_directory(transport):
 
1318
            transport.mkdir('.')
 
1319
            return transport
 
1320
        def redirected(transport, e, redirection_notice):
 
1321
            note(redirection_notice)
 
1322
            return transport._redirected_to(e.source, e.target)
 
1323
        try:
 
1324
            transport = do_catching_redirections(make_directory, transport,
 
1325
                redirected)
 
1326
        except errors.FileExists:
 
1327
            if not use_existing_dir:
 
1328
                raise
 
1329
        except errors.NoSuchFile:
 
1330
            if not create_prefix:
 
1331
                raise
 
1332
            transport.create_prefix()
 
1333
 
 
1334
        require_stacking = (stacked_on is not None)
 
1335
        # Now the target directory exists, but doesn't have a .bzr
 
1336
        # directory. So we need to create it, along with any work to create
 
1337
        # all of the dependent branches, etc.
 
1338
 
 
1339
        result = self.initialize_on_transport(transport)
 
1340
        if repo_format_name:
 
1341
            try:
 
1342
                # use a custom format
 
1343
                result._format.repository_format = \
 
1344
                    repository.network_format_registry.get(repo_format_name)
 
1345
            except AttributeError:
 
1346
                # The format didn't permit it to be set.
 
1347
                pass
 
1348
            # A repository is desired, either in-place or shared.
 
1349
            repository_policy = result.determine_repository_policy(
 
1350
                force_new_repo, stacked_on, stack_on_pwd,
 
1351
                require_stacking=require_stacking)
 
1352
            result_repo, is_new_repo = repository_policy.acquire_repository(
 
1353
                make_working_trees, shared_repo)
 
1354
            if not require_stacking and repository_policy._require_stacking:
 
1355
                require_stacking = True
 
1356
                result._format.require_stacking()
 
1357
            result_repo.lock_write()
 
1358
        else:
 
1359
            result_repo = None
 
1360
            repository_policy = None
 
1361
        return result_repo, result, require_stacking, repository_policy
 
1362
 
 
1363
    def _initialize_on_transport_vfs(self, transport):
 
1364
        """Initialize a new bzrdir using VFS calls.
 
1365
 
 
1366
        :param transport: The transport to create the .bzr directory in.
 
1367
        :return: A
 
1368
        """
 
1369
        # Since we are creating a .bzr directory, inherit the
 
1370
        # mode from the root directory
 
1371
        temp_control = lockable_files.LockableFiles(transport,
 
1372
                            '', lockable_files.TransportLock)
 
1373
        temp_control._transport.mkdir('.bzr',
 
1374
                                      # FIXME: RBC 20060121 don't peek under
 
1375
                                      # the covers
 
1376
                                      mode=temp_control._dir_mode)
 
1377
        if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
 
1378
            win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
 
1379
        file_mode = temp_control._file_mode
 
1380
        del temp_control
 
1381
        bzrdir_transport = transport.clone('.bzr')
 
1382
        utf8_files = [('README',
 
1383
                       "This is a Bazaar control directory.\n"
 
1384
                       "Do not change any files in this directory.\n"
 
1385
                       "See http://bazaar.canonical.com/ for more information about Bazaar.\n"),
 
1386
                      ('branch-format', self.get_format_string()),
 
1387
                      ]
 
1388
        # NB: no need to escape relative paths that are url safe.
 
1389
        control_files = lockable_files.LockableFiles(bzrdir_transport,
 
1390
            self._lock_file_name, self._lock_class)
 
1391
        control_files.create_lock()
 
1392
        control_files.lock_write()
 
1393
        try:
 
1394
            for (filename, content) in utf8_files:
 
1395
                bzrdir_transport.put_bytes(filename, content,
 
1396
                    mode=file_mode)
 
1397
        finally:
 
1398
            control_files.unlock()
 
1399
        return self.open(transport, _found=True)
 
1400
 
 
1401
    def open(self, transport, _found=False):
 
1402
        """Return an instance of this format for the dir transport points at.
 
1403
 
 
1404
        _found is a private parameter, do not use it.
 
1405
        """
 
1406
        if not _found:
 
1407
            found_format = controldir.ControlDirFormat.find_format(transport)
 
1408
            if not isinstance(found_format, self.__class__):
 
1409
                raise AssertionError("%s was asked to open %s, but it seems to need "
 
1410
                        "format %s"
 
1411
                        % (self, transport, found_format))
 
1412
            # Allow subclasses - use the found format.
 
1413
            self._supply_sub_formats_to(found_format)
 
1414
            return found_format._open(transport)
 
1415
        return self._open(transport)
 
1416
 
 
1417
    def _open(self, transport):
 
1418
        """Template method helper for opening BzrDirectories.
 
1419
 
 
1420
        This performs the actual open and any additional logic or parameter
 
1421
        passing.
 
1422
        """
 
1423
        raise NotImplementedError(self._open)
 
1424
 
 
1425
    def _supply_sub_formats_to(self, other_format):
 
1426
        """Give other_format the same values for sub formats as this has.
 
1427
 
 
1428
        This method is expected to be used when parameterising a
 
1429
        RemoteBzrDirFormat instance with the parameters from a
 
1430
        BzrDirMetaFormat1 instance.
 
1431
 
 
1432
        :param other_format: other_format is a format which should be
 
1433
            compatible with whatever sub formats are supported by self.
 
1434
        :return: None.
 
1435
        """
 
1436
 
 
1437
    def supports_transport(self, transport):
 
1438
        # bzr formats can be opened over all known transports
 
1439
        return True
 
1440
 
 
1441
 
 
1442
class BzrDirMetaFormat1(BzrDirFormat):
 
1443
    """Bzr meta control format 1
 
1444
 
 
1445
    This is the first format with split out working tree, branch and repository
 
1446
    disk storage.
 
1447
 
 
1448
    It has:
 
1449
 
 
1450
    - Format 3 working trees [optional]
 
1451
    - Format 5 branches [optional]
 
1452
    - Format 7 repositories [optional]
 
1453
    """
 
1454
 
 
1455
    _lock_class = lockdir.LockDir
 
1456
 
 
1457
    fixed_components = False
 
1458
 
 
1459
    colocated_branches = False
 
1460
 
 
1461
    def __init__(self):
 
1462
        self._workingtree_format = None
 
1463
        self._branch_format = None
 
1464
        self._repository_format = None
 
1465
 
 
1466
    def __eq__(self, other):
 
1467
        if other.__class__ is not self.__class__:
 
1468
            return False
 
1469
        if other.repository_format != self.repository_format:
 
1470
            return False
 
1471
        if other.workingtree_format != self.workingtree_format:
 
1472
            return False
 
1473
        return True
 
1474
 
 
1475
    def __ne__(self, other):
 
1476
        return not self == other
 
1477
 
 
1478
    def get_branch_format(self):
 
1479
        if self._branch_format is None:
 
1480
            from bzrlib.branch import format_registry as branch_format_registry
 
1481
            self._branch_format = branch_format_registry.get_default()
 
1482
        return self._branch_format
 
1483
 
 
1484
    def set_branch_format(self, format):
 
1485
        self._branch_format = format
 
1486
 
 
1487
    def require_stacking(self, stack_on=None, possible_transports=None,
 
1488
            _skip_repo=False):
 
1489
        """We have a request to stack, try to ensure the formats support it.
 
1490
 
 
1491
        :param stack_on: If supplied, it is the URL to a branch that we want to
 
1492
            stack on. Check to see if that format supports stacking before
 
1493
            forcing an upgrade.
 
1494
        """
 
1495
        # Stacking is desired. requested by the target, but does the place it
 
1496
        # points at support stacking? If it doesn't then we should
 
1497
        # not implicitly upgrade. We check this here.
 
1498
        new_repo_format = None
 
1499
        new_branch_format = None
 
1500
 
 
1501
        # a bit of state for get_target_branch so that we don't try to open it
 
1502
        # 2 times, for both repo *and* branch
 
1503
        target = [None, False, None] # target_branch, checked, upgrade anyway
 
1504
        def get_target_branch():
 
1505
            if target[1]:
 
1506
                # We've checked, don't check again
 
1507
                return target
 
1508
            if stack_on is None:
 
1509
                # No target format, that means we want to force upgrading
 
1510
                target[:] = [None, True, True]
 
1511
                return target
 
1512
            try:
 
1513
                target_dir = BzrDir.open(stack_on,
 
1514
                    possible_transports=possible_transports)
 
1515
            except errors.NotBranchError:
 
1516
                # Nothing there, don't change formats
 
1517
                target[:] = [None, True, False]
 
1518
                return target
 
1519
            except errors.JailBreak:
 
1520
                # JailBreak, JFDI and upgrade anyway
 
1521
                target[:] = [None, True, True]
 
1522
                return target
 
1523
            try:
 
1524
                target_branch = target_dir.open_branch()
 
1525
            except errors.NotBranchError:
 
1526
                # No branch, don't upgrade formats
 
1527
                target[:] = [None, True, False]
 
1528
                return target
 
1529
            target[:] = [target_branch, True, False]
 
1530
            return target
 
1531
 
 
1532
        if (not _skip_repo and
 
1533
                 not self.repository_format.supports_external_lookups):
 
1534
            # We need to upgrade the Repository.
 
1535
            target_branch, _, do_upgrade = get_target_branch()
 
1536
            if target_branch is None:
 
1537
                # We don't have a target branch, should we upgrade anyway?
 
1538
                if do_upgrade:
 
1539
                    # stack_on is inaccessible, JFDI.
 
1540
                    # TODO: bad monkey, hard-coded formats...
 
1541
                    if self.repository_format.rich_root_data:
 
1542
                        new_repo_format = knitpack_repo.RepositoryFormatKnitPack5RichRoot()
 
1543
                    else:
 
1544
                        new_repo_format = knitpack_repo.RepositoryFormatKnitPack5()
 
1545
            else:
 
1546
                # If the target already supports stacking, then we know the
 
1547
                # project is already able to use stacking, so auto-upgrade
 
1548
                # for them
 
1549
                new_repo_format = target_branch.repository._format
 
1550
                if not new_repo_format.supports_external_lookups:
 
1551
                    # target doesn't, source doesn't, so don't auto upgrade
 
1552
                    # repo
 
1553
                    new_repo_format = None
 
1554
            if new_repo_format is not None:
 
1555
                self.repository_format = new_repo_format
 
1556
                note(gettext('Source repository format does not support stacking,'
 
1557
                     ' using format:\n  %s'),
 
1558
                     new_repo_format.get_format_description())
 
1559
 
 
1560
        if not self.get_branch_format().supports_stacking():
 
1561
            # We just checked the repo, now lets check if we need to
 
1562
            # upgrade the branch format
 
1563
            target_branch, _, do_upgrade = get_target_branch()
 
1564
            if target_branch is None:
 
1565
                if do_upgrade:
 
1566
                    # TODO: bad monkey, hard-coded formats...
 
1567
                    from bzrlib.branch import BzrBranchFormat7
 
1568
                    new_branch_format = BzrBranchFormat7()
 
1569
            else:
 
1570
                new_branch_format = target_branch._format
 
1571
                if not new_branch_format.supports_stacking():
 
1572
                    new_branch_format = None
 
1573
            if new_branch_format is not None:
 
1574
                # Does support stacking, use its format.
 
1575
                self.set_branch_format(new_branch_format)
 
1576
                note(gettext('Source branch format does not support stacking,'
 
1577
                     ' using format:\n  %s'),
 
1578
                     new_branch_format.get_format_description())
 
1579
 
 
1580
    def get_converter(self, format=None):
 
1581
        """See BzrDirFormat.get_converter()."""
 
1582
        if format is None:
 
1583
            format = BzrDirFormat.get_default_format()
 
1584
        if (type(self) is BzrDirMetaFormat1 and
 
1585
            type(format) is BzrDirMetaFormat1Colo):
 
1586
            return ConvertMetaToColo(format)
 
1587
        if (type(self) is BzrDirMetaFormat1Colo and
 
1588
            type(format) is BzrDirMetaFormat1):
 
1589
            return ConvertMetaRemoveColo(format)
 
1590
        if not isinstance(self, format.__class__):
 
1591
            # converting away from metadir is not implemented
 
1592
            raise NotImplementedError(self.get_converter)
 
1593
        return ConvertMetaToMeta(format)
 
1594
 
 
1595
    @classmethod
 
1596
    def get_format_string(cls):
 
1597
        """See BzrDirFormat.get_format_string()."""
 
1598
        return "Bazaar-NG meta directory, format 1\n"
 
1599
 
 
1600
    def get_format_description(self):
 
1601
        """See BzrDirFormat.get_format_description()."""
 
1602
        return "Meta directory format 1"
 
1603
 
 
1604
    @classmethod
 
1605
    def from_string(cls, format_string):
 
1606
        if format_string != cls.get_format_string():
 
1607
            raise ValueError("Invalid format string %r" % format_string)
 
1608
        return cls()
 
1609
 
 
1610
    def network_name(self):
 
1611
        return self.get_format_string()
 
1612
 
 
1613
    def _open(self, transport):
 
1614
        """See BzrDirFormat._open."""
 
1615
        # Create a new format instance because otherwise initialisation of new
 
1616
        # metadirs share the global default format object leading to alias
 
1617
        # problems.
 
1618
        format = BzrDirMetaFormat1()
 
1619
        self._supply_sub_formats_to(format)
 
1620
        return BzrDirMeta1(transport, format)
 
1621
 
 
1622
    def __return_repository_format(self):
 
1623
        """Circular import protection."""
 
1624
        if self._repository_format:
 
1625
            return self._repository_format
 
1626
        from bzrlib.repository import format_registry
 
1627
        return format_registry.get_default()
 
1628
 
 
1629
    def _set_repository_format(self, value):
 
1630
        """Allow changing the repository format for metadir formats."""
 
1631
        self._repository_format = value
 
1632
 
 
1633
    repository_format = property(__return_repository_format,
 
1634
        _set_repository_format)
 
1635
 
 
1636
    def _supply_sub_formats_to(self, other_format):
 
1637
        """Give other_format the same values for sub formats as this has.
 
1638
 
 
1639
        This method is expected to be used when parameterising a
 
1640
        RemoteBzrDirFormat instance with the parameters from a
 
1641
        BzrDirMetaFormat1 instance.
 
1642
 
 
1643
        :param other_format: other_format is a format which should be
 
1644
            compatible with whatever sub formats are supported by self.
 
1645
        :return: None.
 
1646
        """
 
1647
        if getattr(self, '_repository_format', None) is not None:
 
1648
            other_format.repository_format = self.repository_format
 
1649
        if self._branch_format is not None:
 
1650
            other_format._branch_format = self._branch_format
 
1651
        if self._workingtree_format is not None:
 
1652
            other_format.workingtree_format = self.workingtree_format
 
1653
 
 
1654
    def __get_workingtree_format(self):
 
1655
        if self._workingtree_format is None:
 
1656
            from bzrlib.workingtree import (
 
1657
                format_registry as wt_format_registry,
 
1658
                )
 
1659
            self._workingtree_format = wt_format_registry.get_default()
 
1660
        return self._workingtree_format
 
1661
 
 
1662
    def __set_workingtree_format(self, wt_format):
 
1663
        self._workingtree_format = wt_format
 
1664
 
 
1665
    def __repr__(self):
 
1666
        return "<%r>" % (self.__class__.__name__,)
 
1667
 
 
1668
    workingtree_format = property(__get_workingtree_format,
 
1669
                                  __set_workingtree_format)
 
1670
 
 
1671
 
 
1672
# Register bzr formats
 
1673
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
 
1674
    BzrDirMetaFormat1)
 
1675
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
 
1676
 
 
1677
 
 
1678
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
 
1679
    """BzrDirMeta1 format with support for colocated branches."""
 
1680
 
 
1681
    colocated_branches = True
 
1682
 
 
1683
    @classmethod
 
1684
    def get_format_string(cls):
 
1685
        """See BzrDirFormat.get_format_string()."""
 
1686
        return "Bazaar meta directory, format 1 (with colocated branches)\n"
 
1687
 
 
1688
    def get_format_description(self):
 
1689
        """See BzrDirFormat.get_format_description()."""
 
1690
        return "Meta directory format 1 with support for colocated branches"
 
1691
 
 
1692
    def _open(self, transport):
 
1693
        """See BzrDirFormat._open."""
 
1694
        # Create a new format instance because otherwise initialisation of new
 
1695
        # metadirs share the global default format object leading to alias
 
1696
        # problems.
 
1697
        format = BzrDirMetaFormat1Colo()
 
1698
        self._supply_sub_formats_to(format)
 
1699
        return BzrDirMeta1Colo(transport, format)
 
1700
 
 
1701
 
 
1702
BzrProber.formats.register(BzrDirMetaFormat1Colo.get_format_string(),
 
1703
    BzrDirMetaFormat1Colo)
 
1704
 
 
1705
 
 
1706
class ConvertMetaToMeta(controldir.Converter):
 
1707
    """Converts the components of metadirs."""
 
1708
 
 
1709
    def __init__(self, target_format):
 
1710
        """Create a metadir to metadir converter.
 
1711
 
 
1712
        :param target_format: The final metadir format that is desired.
 
1713
        """
 
1714
        self.target_format = target_format
 
1715
 
 
1716
    def convert(self, to_convert, pb):
 
1717
        """See Converter.convert()."""
 
1718
        self.bzrdir = to_convert
 
1719
        self.pb = ui.ui_factory.nested_progress_bar()
 
1720
        self.count = 0
 
1721
        self.total = 1
 
1722
        self.step('checking repository format')
 
1723
        try:
 
1724
            repo = self.bzrdir.open_repository()
 
1725
        except errors.NoRepositoryPresent:
 
1726
            pass
 
1727
        else:
 
1728
            if not isinstance(repo._format, self.target_format.repository_format.__class__):
 
1729
                from bzrlib.repository import CopyConverter
 
1730
                ui.ui_factory.note(gettext('starting repository conversion'))
 
1731
                converter = CopyConverter(self.target_format.repository_format)
 
1732
                converter.convert(repo, pb)
 
1733
        for branch in self.bzrdir.list_branches():
 
1734
            # TODO: conversions of Branch and Tree should be done by
 
1735
            # InterXFormat lookups/some sort of registry.
 
1736
            # Avoid circular imports
 
1737
            old = branch._format.__class__
 
1738
            new = self.target_format.get_branch_format().__class__
 
1739
            while old != new:
 
1740
                if (old == _mod_branch.BzrBranchFormat5 and
 
1741
                    new in (_mod_branch.BzrBranchFormat6,
 
1742
                        _mod_branch.BzrBranchFormat7,
 
1743
                        _mod_branch.BzrBranchFormat8)):
 
1744
                    branch_converter = _mod_branch.Converter5to6()
 
1745
                elif (old == _mod_branch.BzrBranchFormat6 and
 
1746
                    new in (_mod_branch.BzrBranchFormat7,
 
1747
                            _mod_branch.BzrBranchFormat8)):
 
1748
                    branch_converter = _mod_branch.Converter6to7()
 
1749
                elif (old == _mod_branch.BzrBranchFormat7 and
 
1750
                      new is _mod_branch.BzrBranchFormat8):
 
1751
                    branch_converter = _mod_branch.Converter7to8()
 
1752
                else:
 
1753
                    raise errors.BadConversionTarget("No converter", new,
 
1754
                        branch._format)
 
1755
                branch_converter.convert(branch)
 
1756
                branch = self.bzrdir.open_branch()
 
1757
                old = branch._format.__class__
 
1758
        try:
 
1759
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
 
1760
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
1761
            pass
 
1762
        else:
 
1763
            # TODO: conversions of Branch and Tree should be done by
 
1764
            # InterXFormat lookups
 
1765
            if (isinstance(tree, workingtree_3.WorkingTree3) and
 
1766
                not isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
1767
                isinstance(self.target_format.workingtree_format,
 
1768
                    workingtree_4.DirStateWorkingTreeFormat)):
 
1769
                workingtree_4.Converter3to4().convert(tree)
 
1770
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
1771
                not isinstance(tree, workingtree_4.WorkingTree5) and
 
1772
                isinstance(self.target_format.workingtree_format,
 
1773
                    workingtree_4.WorkingTreeFormat5)):
 
1774
                workingtree_4.Converter4to5().convert(tree)
 
1775
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
1776
                not isinstance(tree, workingtree_4.WorkingTree6) and
 
1777
                isinstance(self.target_format.workingtree_format,
 
1778
                    workingtree_4.WorkingTreeFormat6)):
 
1779
                workingtree_4.Converter4or5to6().convert(tree)
 
1780
        self.pb.finished()
 
1781
        return to_convert
 
1782
 
 
1783
 
 
1784
class ConvertMetaToColo(controldir.Converter):
 
1785
    """Add colocated branch support."""
 
1786
 
 
1787
    def __init__(self, target_format):
 
1788
        """Create a converter.that upgrades a metadir to the colo format.
 
1789
 
 
1790
        :param target_format: The final metadir format that is desired.
 
1791
        """
 
1792
        self.target_format = target_format
 
1793
 
 
1794
    def convert(self, to_convert, pb):
 
1795
        """See Converter.convert()."""
 
1796
        to_convert.transport.put_bytes('branch-format',
 
1797
            self.target_format.get_format_string())
 
1798
        return BzrDir.open_from_transport(to_convert.root_transport)
 
1799
 
 
1800
 
 
1801
class ConvertMetaRemoveColo(controldir.Converter):
 
1802
    """Remove colocated branch support from a bzrdir."""
 
1803
 
 
1804
    def __init__(self, target_format):
 
1805
        """Create a converter.that downgrades a colocated branch metadir
 
1806
        to a regular metadir.
 
1807
 
 
1808
        :param target_format: The final metadir format that is desired.
 
1809
        """
 
1810
        self.target_format = target_format
 
1811
 
 
1812
    def convert(self, to_convert, pb):
 
1813
        """See Converter.convert()."""
 
1814
        to_convert.control_files.lock_write()
 
1815
        try:
 
1816
            branches = to_convert.list_branches()
 
1817
            if len(branches) > 1:
 
1818
                raise errors.BzrError("remove all but a single "
 
1819
                    "colocated branch when downgrading")
 
1820
        finally:
 
1821
            to_convert.control_files.unlock()
 
1822
        to_convert.transport.put_bytes('branch-format',
 
1823
            self.target_format.get_format_string())
 
1824
        return BzrDir.open_from_transport(to_convert.root_transport)
 
1825
 
 
1826
 
 
1827
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
 
1828
 
 
1829
 
 
1830
class RepositoryAcquisitionPolicy(object):
 
1831
    """Abstract base class for repository acquisition policies.
 
1832
 
 
1833
    A repository acquisition policy decides how a BzrDir acquires a repository
 
1834
    for a branch that is being created.  The most basic policy decision is
 
1835
    whether to create a new repository or use an existing one.
 
1836
    """
 
1837
    def __init__(self, stack_on, stack_on_pwd, require_stacking):
 
1838
        """Constructor.
 
1839
 
 
1840
        :param stack_on: A location to stack on
 
1841
        :param stack_on_pwd: If stack_on is relative, the location it is
 
1842
            relative to.
 
1843
        :param require_stacking: If True, it is a failure to not stack.
 
1844
        """
 
1845
        self._stack_on = stack_on
 
1846
        self._stack_on_pwd = stack_on_pwd
 
1847
        self._require_stacking = require_stacking
 
1848
 
 
1849
    def configure_branch(self, branch):
 
1850
        """Apply any configuration data from this policy to the branch.
 
1851
 
 
1852
        Default implementation sets repository stacking.
 
1853
        """
 
1854
        if self._stack_on is None:
 
1855
            return
 
1856
        if self._stack_on_pwd is None:
 
1857
            stack_on = self._stack_on
 
1858
        else:
 
1859
            try:
 
1860
                stack_on = urlutils.rebase_url(self._stack_on,
 
1861
                    self._stack_on_pwd,
 
1862
                    branch.user_url)
 
1863
            except errors.InvalidRebaseURLs:
 
1864
                stack_on = self._get_full_stack_on()
 
1865
        try:
 
1866
            branch.set_stacked_on_url(stack_on)
 
1867
        except (errors.UnstackableBranchFormat,
 
1868
                errors.UnstackableRepositoryFormat):
 
1869
            if self._require_stacking:
 
1870
                raise
 
1871
 
 
1872
    def requires_stacking(self):
 
1873
        """Return True if this policy requires stacking."""
 
1874
        return self._stack_on is not None and self._require_stacking
 
1875
 
 
1876
    def _get_full_stack_on(self):
 
1877
        """Get a fully-qualified URL for the stack_on location."""
 
1878
        if self._stack_on is None:
 
1879
            return None
 
1880
        if self._stack_on_pwd is None:
 
1881
            return self._stack_on
 
1882
        else:
 
1883
            return urlutils.join(self._stack_on_pwd, self._stack_on)
 
1884
 
 
1885
    def _add_fallback(self, repository, possible_transports=None):
 
1886
        """Add a fallback to the supplied repository, if stacking is set."""
 
1887
        stack_on = self._get_full_stack_on()
 
1888
        if stack_on is None:
 
1889
            return
 
1890
        try:
 
1891
            stacked_dir = BzrDir.open(stack_on,
 
1892
                                      possible_transports=possible_transports)
 
1893
        except errors.JailBreak:
 
1894
            # We keep the stacking details, but we are in the server code so
 
1895
            # actually stacking is not needed.
 
1896
            return
 
1897
        try:
 
1898
            stacked_repo = stacked_dir.open_branch().repository
 
1899
        except errors.NotBranchError:
 
1900
            stacked_repo = stacked_dir.open_repository()
 
1901
        try:
 
1902
            repository.add_fallback_repository(stacked_repo)
 
1903
        except errors.UnstackableRepositoryFormat:
 
1904
            if self._require_stacking:
 
1905
                raise
 
1906
        else:
 
1907
            self._require_stacking = True
 
1908
 
 
1909
    def acquire_repository(self, make_working_trees=None, shared=False,
 
1910
            possible_transports=None):
 
1911
        """Acquire a repository for this bzrdir.
 
1912
 
 
1913
        Implementations may create a new repository or use a pre-exising
 
1914
        repository.
 
1915
 
 
1916
        :param make_working_trees: If creating a repository, set
 
1917
            make_working_trees to this value (if non-None)
 
1918
        :param shared: If creating a repository, make it shared if True
 
1919
        :return: A repository, is_new_flag (True if the repository was
 
1920
            created).
 
1921
        """
 
1922
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
 
1923
 
 
1924
 
 
1925
class CreateRepository(RepositoryAcquisitionPolicy):
 
1926
    """A policy of creating a new repository"""
 
1927
 
 
1928
    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
 
1929
                 require_stacking=False):
 
1930
        """Constructor.
 
1931
 
 
1932
        :param bzrdir: The bzrdir to create the repository on.
 
1933
        :param stack_on: A location to stack on
 
1934
        :param stack_on_pwd: If stack_on is relative, the location it is
 
1935
            relative to.
 
1936
        """
 
1937
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
 
1938
                                             require_stacking)
 
1939
        self._bzrdir = bzrdir
 
1940
 
 
1941
    def acquire_repository(self, make_working_trees=None, shared=False,
 
1942
            possible_transports=None):
 
1943
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
 
1944
 
 
1945
        Creates the desired repository in the bzrdir we already have.
 
1946
        """
 
1947
        if possible_transports is None:
 
1948
            possible_transports = []
 
1949
        else:
 
1950
            possible_transports = list(possible_transports)
 
1951
        possible_transports.append(self._bzrdir.root_transport)
 
1952
        stack_on = self._get_full_stack_on()
 
1953
        if stack_on:
 
1954
            format = self._bzrdir._format
 
1955
            format.require_stacking(stack_on=stack_on,
 
1956
                                    possible_transports=possible_transports)
 
1957
            if not self._require_stacking:
 
1958
                # We have picked up automatic stacking somewhere.
 
1959
                note(gettext('Using default stacking branch {0} at {1}').format(
 
1960
                    self._stack_on, self._stack_on_pwd))
 
1961
        repository = self._bzrdir.create_repository(shared=shared)
 
1962
        self._add_fallback(repository,
 
1963
                           possible_transports=possible_transports)
 
1964
        if make_working_trees is not None:
 
1965
            repository.set_make_working_trees(make_working_trees)
 
1966
        return repository, True
 
1967
 
 
1968
 
 
1969
class UseExistingRepository(RepositoryAcquisitionPolicy):
 
1970
    """A policy of reusing an existing repository"""
 
1971
 
 
1972
    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
 
1973
                 require_stacking=False):
 
1974
        """Constructor.
 
1975
 
 
1976
        :param repository: The repository to use.
 
1977
        :param stack_on: A location to stack on
 
1978
        :param stack_on_pwd: If stack_on is relative, the location it is
 
1979
            relative to.
 
1980
        """
 
1981
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
 
1982
                                             require_stacking)
 
1983
        self._repository = repository
 
1984
 
 
1985
    def acquire_repository(self, make_working_trees=None, shared=False,
 
1986
            possible_transports=None):
 
1987
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
 
1988
 
 
1989
        Returns an existing repository to use.
 
1990
        """
 
1991
        if possible_transports is None:
 
1992
            possible_transports = []
 
1993
        else:
 
1994
            possible_transports = list(possible_transports)
 
1995
        possible_transports.append(self._repository.bzrdir.transport)
 
1996
        self._add_fallback(self._repository,
 
1997
                       possible_transports=possible_transports)
 
1998
        return self._repository, False
 
1999
 
 
2000
 
 
2001
def register_metadir(registry, key,
 
2002
         repository_format, help, native=True, deprecated=False,
 
2003
         branch_format=None,
 
2004
         tree_format=None,
 
2005
         hidden=False,
 
2006
         experimental=False,
 
2007
         alias=False, bzrdir_format=None):
 
2008
    """Register a metadir subformat.
 
2009
 
 
2010
    These all use a meta bzrdir, but can be parameterized by the
 
2011
    Repository/Branch/WorkingTreeformats.
 
2012
 
 
2013
    :param repository_format: The fully-qualified repository format class
 
2014
        name as a string.
 
2015
    :param branch_format: Fully-qualified branch format class name as
 
2016
        a string.
 
2017
    :param tree_format: Fully-qualified tree format class name as
 
2018
        a string.
 
2019
    """
 
2020
    if bzrdir_format is None:
 
2021
        bzrdir_format = BzrDirMetaFormat1
 
2022
    # This should be expanded to support setting WorkingTree and Branch
 
2023
    # formats, once the API supports that.
 
2024
    def _load(full_name):
 
2025
        mod_name, factory_name = full_name.rsplit('.', 1)
 
2026
        try:
 
2027
            factory = pyutils.get_named_object(mod_name, factory_name)
 
2028
        except ImportError, e:
 
2029
            raise ImportError('failed to load %s: %s' % (full_name, e))
 
2030
        except AttributeError:
 
2031
            raise AttributeError('no factory %s in module %r'
 
2032
                % (full_name, sys.modules[mod_name]))
 
2033
        return factory()
 
2034
 
 
2035
    def helper():
 
2036
        bd = bzrdir_format()
 
2037
        if branch_format is not None:
 
2038
            bd.set_branch_format(_load(branch_format))
 
2039
        if tree_format is not None:
 
2040
            bd.workingtree_format = _load(tree_format)
 
2041
        if repository_format is not None:
 
2042
            bd.repository_format = _load(repository_format)
 
2043
        return bd
 
2044
    registry.register(key, helper, help, native, deprecated, hidden,
 
2045
        experimental, alias)
 
2046
 
 
2047
register_metadir(controldir.format_registry, 'knit',
 
2048
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2049
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
 
2050
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
2051
    tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
 
2052
    hidden=True,
 
2053
    deprecated=True)
 
2054
register_metadir(controldir.format_registry, 'dirstate',
 
2055
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2056
    help='Format using dirstate for working trees. '
 
2057
        'Compatible with bzr 0.8 and '
 
2058
        'above when accessed over the network. Introduced in bzr 0.15.',
 
2059
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
2060
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2061
    hidden=True,
 
2062
    deprecated=True)
 
2063
register_metadir(controldir.format_registry, 'dirstate-tags',
 
2064
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2065
    help='Variant of dirstate with support for tags. '
 
2066
        'Introduced in bzr 0.15.',
 
2067
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2068
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2069
    hidden=True,
 
2070
    deprecated=True)
 
2071
register_metadir(controldir.format_registry, 'rich-root',
 
2072
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
 
2073
    help='Variant of dirstate with better handling of tree roots. '
 
2074
        'Introduced in bzr 1.0',
 
2075
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2076
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2077
    hidden=True,
 
2078
    deprecated=True)
 
2079
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
 
2080
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
2081
    help='Variant of dirstate with support for nested trees. '
 
2082
         'Introduced in 0.15.',
 
2083
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2084
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2085
    experimental=True,
 
2086
    hidden=True,
 
2087
    )
 
2088
register_metadir(controldir.format_registry, 'pack-0.92',
 
2089
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
 
2090
    help='Pack-based format used in 1.x series. Introduced in 0.92. '
 
2091
        'Interoperates with bzr repositories before 0.92 but cannot be '
 
2092
        'read by bzr < 0.92. '
 
2093
        ,
 
2094
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2095
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2096
    deprecated=True,
 
2097
    )
 
2098
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
 
2099
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
 
2100
    help='Pack-based format used in 1.x series, with subtree support. '
 
2101
        'Introduced in 0.92. Interoperates with '
 
2102
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
 
2103
        ,
 
2104
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2105
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2106
    hidden=True,
 
2107
    deprecated=True,
 
2108
    experimental=True,
 
2109
    )
 
2110
register_metadir(controldir.format_registry, 'rich-root-pack',
 
2111
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
 
2112
    help='A variant of pack-0.92 that supports rich-root data '
 
2113
         '(needed for bzr-svn and bzr-git). Introduced in 1.0.',
 
2114
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2115
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2116
    hidden=True,
 
2117
    deprecated=True,
 
2118
    )
 
2119
register_metadir(controldir.format_registry, '1.6',
 
2120
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
 
2121
    help='A format that allows a branch to indicate that there is another '
 
2122
         '(stacked) repository that should be used to access data that is '
 
2123
         'not present locally.',
 
2124
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2125
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2126
    hidden=True,
 
2127
    deprecated=True,
 
2128
    )
 
2129
register_metadir(controldir.format_registry, '1.6.1-rich-root',
 
2130
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
 
2131
    help='A variant of 1.6 that supports rich-root data '
 
2132
         '(needed for bzr-svn and bzr-git).',
 
2133
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2134
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2135
    hidden=True,
 
2136
    deprecated=True,
 
2137
    )
 
2138
register_metadir(controldir.format_registry, '1.9',
 
2139
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
 
2140
    help='A repository format using B+tree indexes. These indexes '
 
2141
         'are smaller in size, have smarter caching and provide faster '
 
2142
         'performance for most operations.',
 
2143
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2144
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2145
    hidden=True,
 
2146
    deprecated=True,
 
2147
    )
 
2148
register_metadir(controldir.format_registry, '1.9-rich-root',
 
2149
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
 
2150
    help='A variant of 1.9 that supports rich-root data '
 
2151
         '(needed for bzr-svn and bzr-git).',
 
2152
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2153
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
 
2154
    hidden=True,
 
2155
    deprecated=True,
 
2156
    )
 
2157
register_metadir(controldir.format_registry, '1.14',
 
2158
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
 
2159
    help='A working-tree format that supports content filtering.',
 
2160
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2161
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
 
2162
    hidden=True,
 
2163
    deprecated=True,
 
2164
    )
 
2165
register_metadir(controldir.format_registry, '1.14-rich-root',
 
2166
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
 
2167
    help='A variant of 1.14 that supports rich-root data '
 
2168
         '(needed for bzr-svn and bzr-git).',
 
2169
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2170
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
 
2171
    hidden=True,
 
2172
    deprecated=True,
 
2173
    )
 
2174
# The following un-numbered 'development' formats should always just be aliases.
 
2175
register_metadir(controldir.format_registry, 'development-subtree',
 
2176
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
 
2177
    help='Current development format, subtree variant. Can convert data to and '
 
2178
        'from pack-0.92-subtree (and anything compatible with '
 
2179
        'pack-0.92-subtree) format repositories. Repositories and branches in '
 
2180
        'this format can only be read by bzr.dev. Please read '
 
2181
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
2182
        'before use.',
 
2183
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2184
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
 
2185
    experimental=True,
 
2186
    hidden=True,
 
2187
    alias=False, # Restore to being an alias when an actual development subtree format is added
 
2188
                 # This current non-alias status is simply because we did not introduce a
 
2189
                 # chk based subtree format.
 
2190
    )
 
2191
register_metadir(controldir.format_registry, 'development5-subtree',
 
2192
    'bzrlib.repofmt.knitpack_repo.RepositoryFormatPackDevelopment2Subtree',
 
2193
    help='Development format, subtree variant. Can convert data to and '
 
2194
        'from pack-0.92-subtree (and anything compatible with '
 
2195
        'pack-0.92-subtree) format repositories. Repositories and branches in '
 
2196
        'this format can only be read by bzr.dev. Please read '
 
2197
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
2198
        'before use.',
 
2199
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2200
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
 
2201
    experimental=True,
 
2202
    hidden=True,
 
2203
    alias=False,
 
2204
    )
 
2205
 
 
2206
register_metadir(controldir.format_registry, 'development-colo',
 
2207
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
 
2208
    help='The 2a format with experimental support for colocated branches.\n',
 
2209
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2210
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
 
2211
    experimental=True,
 
2212
    bzrdir_format=BzrDirMetaFormat1Colo,
 
2213
    )
 
2214
 
 
2215
 
 
2216
# And the development formats above will have aliased one of the following:
 
2217
 
 
2218
# Finally, the current format.
 
2219
register_metadir(controldir.format_registry, '2a',
 
2220
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
 
2221
    help='Format for the bzr 2.0 series.\n'
 
2222
        'Uses group-compress storage.\n'
 
2223
        'Provides rich roots which are a one-way transition.\n',
 
2224
        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
 
2225
        # 'rich roots. Supported by bzr 1.16 and later.',
 
2226
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2227
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
 
2228
    experimental=False,
 
2229
    )
 
2230
 
 
2231
# The following format should be an alias for the rich root equivalent 
 
2232
# of the default format
 
2233
register_metadir(controldir.format_registry, 'default-rich-root',
 
2234
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
 
2235
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2236
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
 
2237
    alias=True,
 
2238
    hidden=True,
 
2239
    help='Same as 2a.')
 
2240
 
 
2241
# The current format that is made on 'bzr init'.
 
2242
format_name = config.GlobalStack().get('default_format')
 
2243
controldir.format_registry.set_default(format_name)
 
2244
 
 
2245
# XXX 2010-08-20 JRV: There is still a lot of code relying on
 
2246
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
 
2247
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
 
2248
format_registry = controldir.format_registry