← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:54:05 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506235405-wii4elupfhzl3jvy
Add __str__ to the new helper classes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
18
18
 
27
27
 
28
28
# TODO: Move old formats into a plugin to make this file smaller.
29
29
 
30
 
from cStringIO import StringIO
31
30
import os
 
31
import sys
 
32
import warnings
32
33
 
33
34
from bzrlib.lazy_import import lazy_import
34
35
lazy_import(globals(), """
35
36
from stat import S_ISDIR
36
37
import textwrap
37
 
from warnings import warn
38
38
 
39
39
import bzrlib
40
40
from bzrlib import (
 
41
    branch,
 
42
    config,
41
43
    errors,
42
44
    graph,
43
45
    lockable_files,
44
46
    lockdir,
45
 
    registry,
 
47
    osutils,
46
48
    remote,
 
49
    repository,
47
50
    revision as _mod_revision,
48
 
    symbol_versioning,
49
51
    ui,
50
52
    urlutils,
 
53
    versionedfile,
 
54
    win32utils,
 
55
    workingtree,
 
56
    workingtree_4,
51
57
    xml4,
52
58
    xml5,
53
 
    workingtree,
54
 
    workingtree_4,
55
59
    )
56
60
from bzrlib.osutils import (
57
 
    sha_strings,
58
61
    sha_string,
59
62
    )
 
63
from bzrlib.push import (
 
64
    PushResult,
 
65
    )
 
66
from bzrlib.repofmt import pack_repo
60
67
from bzrlib.smart.client import _SmartClient
61
 
from bzrlib.smart import protocol
62
 
from bzrlib.store.revision.text import TextRevisionStore
63
 
from bzrlib.store.text import TextStore
64
68
from bzrlib.store.versioned import WeaveStore
65
69
from bzrlib.transactions import WriteTransaction
66
70
from bzrlib.transport import (
67
71
    do_catching_redirections,
68
72
    get_transport,
 
73
    local,
69
74
    )
70
75
from bzrlib.weave import Weave
71
76
""")
73
78
from bzrlib.trace import (
74
79
    mutter,
75
80
    note,
76
 
    )
77
 
from bzrlib.transport.local import LocalTransport
78
 
from bzrlib.symbol_versioning import (
79
 
    deprecated_function,
80
 
    deprecated_method,
81
 
    zero_ninetyone,
82
 
    )
83
 
 
84
 
 
85
 
class BzrDir(object):
 
81
    warning,
 
82
    )
 
83
 
 
84
from bzrlib import (
 
85
    hooks,
 
86
    registry,
 
87
    symbol_versioning,
 
88
    )
 
89
    
 
90
    
 
91
class ControlComponent(object):
 
92
    """Abstract base class for control directory components.
 
93
    
 
94
    This provides interfaces that are common across bzrdirs, 
 
95
    repositories, branches, and workingtree control directories.
 
96
    
 
97
    They all expose two urls and transports: the *user* URL is the 
 
98
    one that stops above the control directory (eg .bzr) and that 
 
99
    should normally be used in messages, and the *control* URL is
 
100
    under that in eg .bzr/checkout and is used to read the control
 
101
    files.
 
102
    
 
103
    This can be used as a mixin and is intended to fit with 
 
104
    foreign formats.
 
105
    """
 
106
    
 
107
    @property
 
108
    def control_transport(self):
 
109
        raise NotImplementedError
 
110
   
 
111
    @property
 
112
    def control_url(self):
 
113
        return self.control_transport.base
 
114
    
 
115
    @property
 
116
    def user_transport(self):
 
117
        raise NotImplementedError
 
118
        
 
119
    @property
 
120
    def user_url(self):
 
121
        return self.user_transport.base
 
122
    
 
123
 
 
124
class BzrDir(ControlComponent):
86
125
    """A .bzr control diretory.
87
 
    
 
126
 
88
127
    BzrDir instances let you create or open any of the things that can be
89
128
    found within .bzr - checkouts, branches and repositories.
90
 
    
91
 
    transport
 
129
 
 
130
    :ivar transport:
92
131
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
93
 
    root_transport
 
132
    :ivar root_transport:
94
133
        a transport connected to the directory this bzr was opened from
95
134
        (i.e. the parent directory holding the .bzr directory).
 
135
 
 
136
    Everything in the bzrdir should have the same file permissions.
 
137
 
 
138
    :cvar hooks: An instance of BzrDirHooks.
96
139
    """
97
140
 
98
141
    def break_lock(self):
120
163
        return True
121
164
 
122
165
    def check_conversion_target(self, target_format):
 
166
        """Check that a bzrdir as a whole can be converted to a new format."""
 
167
        # The only current restriction is that the repository content can be 
 
168
        # fetched compatibly with the target.
123
169
        target_repo_format = target_format.repository_format
124
 
        source_repo_format = self._format.repository_format
125
 
        source_repo_format.check_conversion_target(target_repo_format)
 
170
        try:
 
171
            self.open_repository()._format.check_conversion_target(
 
172
                target_repo_format)
 
173
        except errors.NoRepositoryPresent:
 
174
            # No repo, no problem.
 
175
            pass
126
176
 
127
177
    @staticmethod
128
178
    def _check_supported(format, allow_unsupported,
130
180
        basedir=None):
131
181
        """Give an error or warning on old formats.
132
182
 
133
 
        :param format: may be any kind of format - workingtree, branch, 
 
183
        :param format: may be any kind of format - workingtree, branch,
134
184
        or repository.
135
185
 
136
 
        :param allow_unsupported: If true, allow opening 
137
 
        formats that are strongly deprecated, and which may 
 
186
        :param allow_unsupported: If true, allow opening
 
187
        formats that are strongly deprecated, and which may
138
188
        have limited functionality.
139
189
 
140
190
        :param recommend_upgrade: If true (default), warn
152
202
                format.get_format_description(),
153
203
                basedir)
154
204
 
155
 
    def clone(self, url, revision_id=None, force_new_repo=False):
 
205
    def clone(self, url, revision_id=None, force_new_repo=False,
 
206
              preserve_stacking=False):
156
207
        """Clone this bzrdir and its contents to url verbatim.
157
208
 
158
 
        If url's last component does not exist, it will be created.
159
 
 
160
 
        if revision_id is not None, then the clone operation may tune
 
209
        :param url: The url create the clone at.  If url's last component does
 
210
            not exist, it will be created.
 
211
        :param revision_id: The tip revision-id to use for any branch or
 
212
            working tree.  If not None, then the clone operation may tune
161
213
            itself to download less data.
162
 
        :param force_new_repo: Do not use a shared repository for the target 
 
214
        :param force_new_repo: Do not use a shared repository for the target
163
215
                               even if one is available.
 
216
        :param preserve_stacking: When cloning a stacked branch, stack the
 
217
            new branch on top of the other branch's stacked-on branch.
164
218
        """
165
219
        return self.clone_on_transport(get_transport(url),
166
220
                                       revision_id=revision_id,
167
 
                                       force_new_repo=force_new_repo)
 
221
                                       force_new_repo=force_new_repo,
 
222
                                       preserve_stacking=preserve_stacking)
168
223
 
169
224
    def clone_on_transport(self, transport, revision_id=None,
170
 
                           force_new_repo=False):
 
225
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
226
        create_prefix=False, use_existing_dir=True):
171
227
        """Clone this bzrdir and its contents to transport verbatim.
172
228
 
173
 
        If the target directory does not exist, it will be created.
174
 
 
175
 
        if revision_id is not None, then the clone operation may tune
 
229
        :param transport: The transport for the location to produce the clone
 
230
            at.  If the target directory does not exist, it will be created.
 
231
        :param revision_id: The tip revision-id to use for any branch or
 
232
            working tree.  If not None, then the clone operation may tune
176
233
            itself to download less data.
177
 
        :param force_new_repo: Do not use a shared repository for the target 
 
234
        :param force_new_repo: Do not use a shared repository for the target,
178
235
                               even if one is available.
 
236
        :param preserve_stacking: When cloning a stacked branch, stack the
 
237
            new branch on top of the other branch's stacked-on branch.
 
238
        :param create_prefix: Create any missing directories leading up to
 
239
            to_transport.
 
240
        :param use_existing_dir: Use an existing directory if one exists.
179
241
        """
180
 
        transport.ensure_base()
181
 
        result = self._format.initialize_on_transport(transport)
 
242
        # Overview: put together a broad description of what we want to end up
 
243
        # with; then make as few api calls as possible to do it.
 
244
        
 
245
        # We may want to create a repo/branch/tree, if we do so what format
 
246
        # would we want for each:
 
247
        require_stacking = (stacked_on is not None)
 
248
        format = self.cloning_metadir(require_stacking)
 
249
        
 
250
        # Figure out what objects we want:
182
251
        try:
183
252
            local_repo = self.find_repository()
184
253
        except errors.NoRepositoryPresent:
185
254
            local_repo = None
 
255
        try:
 
256
            local_branch = self.open_branch()
 
257
        except errors.NotBranchError:
 
258
            local_branch = None
 
259
        else:
 
260
            # enable fallbacks when branch is not a branch reference
 
261
            if local_branch.repository.has_same_location(local_repo):
 
262
                local_repo = local_branch.repository
 
263
            if preserve_stacking:
 
264
                try:
 
265
                    stacked_on = local_branch.get_stacked_on_url()
 
266
                except (errors.UnstackableBranchFormat,
 
267
                        errors.UnstackableRepositoryFormat,
 
268
                        errors.NotStacked):
 
269
                    pass
 
270
        # Bug: We create a metadir without knowing if it can support stacking,
 
271
        # we should look up the policy needs first, or just use it as a hint,
 
272
        # or something.
186
273
        if local_repo:
187
 
            # may need to copy content in
188
 
            if force_new_repo:
189
 
                result_repo = local_repo.clone(
190
 
                    result,
191
 
                    revision_id=revision_id)
192
 
                result_repo.set_make_working_trees(local_repo.make_working_trees())
193
 
            else:
194
 
                try:
195
 
                    result_repo = result.find_repository()
196
 
                    # fetch content this dir needs.
 
274
            make_working_trees = local_repo.make_working_trees()
 
275
            want_shared = local_repo.is_shared()
 
276
            repo_format_name = format.repository_format.network_name()
 
277
        else:
 
278
            make_working_trees = False
 
279
            want_shared = False
 
280
            repo_format_name = None
 
281
 
 
282
        result_repo, result, require_stacking, repository_policy = \
 
283
            format.initialize_on_transport_ex(transport,
 
284
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
285
            force_new_repo=force_new_repo, stacked_on=stacked_on,
 
286
            stack_on_pwd=self.root_transport.base,
 
287
            repo_format_name=repo_format_name,
 
288
            make_working_trees=make_working_trees, shared_repo=want_shared)
 
289
        if repo_format_name:
 
290
            try:
 
291
                # If the result repository is in the same place as the
 
292
                # resulting bzr dir, it will have no content, further if the
 
293
                # result is not stacked then we know all content should be
 
294
                # copied, and finally if we are copying up to a specific
 
295
                # revision_id then we can use the pending-ancestry-result which
 
296
                # does not require traversing all of history to describe it.
 
297
                if (result_repo.user_url == result.user_url
 
298
                    and not require_stacking and
 
299
                    revision_id is not None):
 
300
                    fetch_spec = graph.PendingAncestryResult(
 
301
                        [revision_id], local_repo)
 
302
                    result_repo.fetch(local_repo, fetch_spec=fetch_spec)
 
303
                else:
197
304
                    result_repo.fetch(local_repo, revision_id=revision_id)
198
 
                except errors.NoRepositoryPresent:
199
 
                    # needed to make one anyway.
200
 
                    result_repo = local_repo.clone(
201
 
                        result,
202
 
                        revision_id=revision_id)
203
 
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
 
305
            finally:
 
306
                result_repo.unlock()
 
307
        else:
 
308
            if result_repo is not None:
 
309
                raise AssertionError('result_repo not None(%r)' % result_repo)
204
310
        # 1 if there is a branch present
205
311
        #   make sure its content is available in the target repository
206
312
        #   clone it.
207
 
        try:
208
 
            self.open_branch().clone(result, revision_id=revision_id)
209
 
        except errors.NotBranchError:
210
 
            pass
211
 
        try:
212
 
            self.open_workingtree().clone(result)
 
313
        if local_branch is not None:
 
314
            result_branch = local_branch.clone(result, revision_id=revision_id,
 
315
                repository_policy=repository_policy)
 
316
        try:
 
317
            # Cheaper to check if the target is not local, than to try making
 
318
            # the tree and fail.
 
319
            result.root_transport.local_abspath('.')
 
320
            if result_repo is None or result_repo.make_working_trees():
 
321
                self.open_workingtree().clone(result)
213
322
        except (errors.NoWorkingTree, errors.NotLocalUrl):
214
323
            pass
215
324
        return result
223
332
    @classmethod
224
333
    def create(cls, base, format=None, possible_transports=None):
225
334
        """Create a new BzrDir at the url 'base'.
226
 
        
 
335
 
227
336
        :param format: If supplied, the format of branch to create.  If not
228
337
            supplied, the default is used.
229
 
        :param possible_transports: If supplied, a list of transports that 
 
338
        :param possible_transports: If supplied, a list of transports that
230
339
            can be reused to share a remote connection.
231
340
        """
232
341
        if cls is not BzrDir:
238
347
            format = BzrDirFormat.get_default_format()
239
348
        return format.initialize_on_transport(t)
240
349
 
241
 
    def create_branch(self):
 
350
    @staticmethod
 
351
    def find_bzrdirs(transport, evaluate=None, list_current=None):
 
352
        """Find bzrdirs recursively from current location.
 
353
 
 
354
        This is intended primarily as a building block for more sophisticated
 
355
        functionality, like finding trees under a directory, or finding
 
356
        branches that use a given repository.
 
357
        :param evaluate: An optional callable that yields recurse, value,
 
358
            where recurse controls whether this bzrdir is recursed into
 
359
            and value is the value to yield.  By default, all bzrdirs
 
360
            are recursed into, and the return value is the bzrdir.
 
361
        :param list_current: if supplied, use this function to list the current
 
362
            directory, instead of Transport.list_dir
 
363
        :return: a generator of found bzrdirs, or whatever evaluate returns.
 
364
        """
 
365
        if list_current is None:
 
366
            def list_current(transport):
 
367
                return transport.list_dir('')
 
368
        if evaluate is None:
 
369
            def evaluate(bzrdir):
 
370
                return True, bzrdir
 
371
 
 
372
        pending = [transport]
 
373
        while len(pending) > 0:
 
374
            current_transport = pending.pop()
 
375
            recurse = True
 
376
            try:
 
377
                bzrdir = BzrDir.open_from_transport(current_transport)
 
378
            except errors.NotBranchError:
 
379
                pass
 
380
            else:
 
381
                recurse, value = evaluate(bzrdir)
 
382
                yield value
 
383
            try:
 
384
                subdirs = list_current(current_transport)
 
385
            except errors.NoSuchFile:
 
386
                continue
 
387
            if recurse:
 
388
                for subdir in sorted(subdirs, reverse=True):
 
389
                    pending.append(current_transport.clone(subdir))
 
390
 
 
391
    def list_branches(self):
 
392
        """Return a sequence of all branches local to this control directory.
 
393
 
 
394
        """
 
395
        try:
 
396
            return [self.open_branch()]
 
397
        except errors.NotBranchError:
 
398
            return []
 
399
 
 
400
    @staticmethod
 
401
    def find_branches(transport):
 
402
        """Find all branches under a transport.
 
403
 
 
404
        This will find all branches below the transport, including branches
 
405
        inside other branches.  Where possible, it will use
 
406
        Repository.find_branches.
 
407
 
 
408
        To list all the branches that use a particular Repository, see
 
409
        Repository.find_branches
 
410
        """
 
411
        def evaluate(bzrdir):
 
412
            try:
 
413
                repository = bzrdir.open_repository()
 
414
            except errors.NoRepositoryPresent:
 
415
                pass
 
416
            else:
 
417
                return False, ([], repository)
 
418
            return True, (bzrdir.list_branches(), None)
 
419
        ret = []
 
420
        for branches, repo in BzrDir.find_bzrdirs(transport,
 
421
                                                  evaluate=evaluate):
 
422
            if repo is not None:
 
423
                ret.extend(repo.find_branches())
 
424
            if branches is not None:
 
425
                ret.extend(branches)
 
426
        return ret
 
427
 
 
428
    def destroy_repository(self):
 
429
        """Destroy the repository in this BzrDir"""
 
430
        raise NotImplementedError(self.destroy_repository)
 
431
 
 
432
    def create_branch(self, name=None):
242
433
        """Create a branch in this BzrDir.
243
434
 
 
435
        :param name: Name of the colocated branch to create, None for
 
436
            the default branch.
 
437
 
244
438
        The bzrdir's format will control what branch format is created.
245
439
        For more control see BranchFormatXX.create(a_bzrdir).
246
440
        """
247
441
        raise NotImplementedError(self.create_branch)
248
442
 
249
 
    def destroy_branch(self):
250
 
        """Destroy the branch in this BzrDir"""
 
443
    def destroy_branch(self, name=None):
 
444
        """Destroy a branch in this BzrDir.
 
445
        
 
446
        :param name: Name of the branch to destroy, None for the default 
 
447
            branch.
 
448
        """
251
449
        raise NotImplementedError(self.destroy_branch)
252
450
 
253
451
    @staticmethod
255
453
        """Create a new BzrDir, Branch and Repository at the url 'base'.
256
454
 
257
455
        This will use the current default BzrDirFormat unless one is
258
 
        specified, and use whatever 
 
456
        specified, and use whatever
259
457
        repository format that that uses via bzrdir.create_branch and
260
458
        create_repository. If a shared repository is available that is used
261
459
        preferentially.
271
469
        bzrdir._find_or_create_repository(force_new_repo)
272
470
        return bzrdir.create_branch()
273
471
 
 
472
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
 
473
                                    stack_on_pwd=None, require_stacking=False):
 
474
        """Return an object representing a policy to use.
 
475
 
 
476
        This controls whether a new repository is created, and the format of
 
477
        that repository, or some existing shared repository used instead.
 
478
 
 
479
        If stack_on is supplied, will not seek a containing shared repo.
 
480
 
 
481
        :param force_new_repo: If True, require a new repository to be created.
 
482
        :param stack_on: If supplied, the location to stack on.  If not
 
483
            supplied, a default_stack_on location may be used.
 
484
        :param stack_on_pwd: If stack_on is relative, the location it is
 
485
            relative to.
 
486
        """
 
487
        def repository_policy(found_bzrdir):
 
488
            stack_on = None
 
489
            stack_on_pwd = None
 
490
            config = found_bzrdir.get_config()
 
491
            stop = False
 
492
            stack_on = config.get_default_stack_on()
 
493
            if stack_on is not None:
 
494
                stack_on_pwd = found_bzrdir.user_url
 
495
                stop = True
 
496
            # does it have a repository ?
 
497
            try:
 
498
                repository = found_bzrdir.open_repository()
 
499
            except errors.NoRepositoryPresent:
 
500
                repository = None
 
501
            else:
 
502
                if (found_bzrdir.user_url != self.user_url 
 
503
                    and not repository.is_shared()):
 
504
                    # Don't look higher, can't use a higher shared repo.
 
505
                    repository = None
 
506
                    stop = True
 
507
                else:
 
508
                    stop = True
 
509
            if not stop:
 
510
                return None, False
 
511
            if repository:
 
512
                return UseExistingRepository(repository, stack_on,
 
513
                    stack_on_pwd, require_stacking=require_stacking), True
 
514
            else:
 
515
                return CreateRepository(self, stack_on, stack_on_pwd,
 
516
                    require_stacking=require_stacking), True
 
517
 
 
518
        if not force_new_repo:
 
519
            if stack_on is None:
 
520
                policy = self._find_containing(repository_policy)
 
521
                if policy is not None:
 
522
                    return policy
 
523
            else:
 
524
                try:
 
525
                    return UseExistingRepository(self.open_repository(),
 
526
                        stack_on, stack_on_pwd,
 
527
                        require_stacking=require_stacking)
 
528
                except errors.NoRepositoryPresent:
 
529
                    pass
 
530
        return CreateRepository(self, stack_on, stack_on_pwd,
 
531
                                require_stacking=require_stacking)
 
532
 
274
533
    def _find_or_create_repository(self, force_new_repo):
275
534
        """Create a new repository if needed, returning the repository."""
276
 
        if force_new_repo:
277
 
            return self.create_repository()
278
 
        try:
279
 
            return self.find_repository()
280
 
        except errors.NoRepositoryPresent:
281
 
            return self.create_repository()
282
 
        
 
535
        policy = self.determine_repository_policy(force_new_repo)
 
536
        return policy.acquire_repository()[0]
 
537
 
283
538
    @staticmethod
284
539
    def create_branch_convenience(base, force_new_repo=False,
285
540
                                  force_new_tree=None, format=None,
291
546
        not.
292
547
 
293
548
        This will use the current default BzrDirFormat unless one is
294
 
        specified, and use whatever 
 
549
        specified, and use whatever
295
550
        repository format that that uses via bzrdir.create_branch and
296
551
        create_repository. If a shared repository is available that is used
297
552
        preferentially. Whatever repository is used, its tree creation policy
299
554
 
300
555
        The created Branch object is returned.
301
556
        If a working tree cannot be made due to base not being a file:// url,
302
 
        no error is raised unless force_new_tree is True, in which case no 
 
557
        no error is raised unless force_new_tree is True, in which case no
303
558
        data is created on disk and NotLocalUrl is raised.
304
559
 
305
560
        :param base: The URL to create the branch at.
306
561
        :param force_new_repo: If True a new repository is always created.
307
 
        :param force_new_tree: If True or False force creation of a tree or 
 
562
        :param force_new_tree: If True or False force creation of a tree or
308
563
                               prevent such creation respectively.
309
564
        :param format: Override for the bzrdir format to create.
310
565
        :param possible_transports: An optional reusable transports list.
312
567
        if force_new_tree:
313
568
            # check for non local urls
314
569
            t = get_transport(base, possible_transports)
315
 
            if not isinstance(t, LocalTransport):
 
570
            if not isinstance(t, local.LocalTransport):
316
571
                raise errors.NotLocalUrl(base)
317
572
        bzrdir = BzrDir.create(base, format, possible_transports)
318
573
        repo = bzrdir._find_or_create_repository(force_new_repo)
326
581
        return result
327
582
 
328
583
    @staticmethod
329
 
    @deprecated_function(zero_ninetyone)
330
 
    def create_repository(base, shared=False, format=None):
331
 
        """Create a new BzrDir and Repository at the url 'base'.
332
 
 
333
 
        If no format is supplied, this will default to the current default
334
 
        BzrDirFormat by default, and use whatever repository format that that
335
 
        uses for bzrdirformat.create_repository.
336
 
 
337
 
        :param shared: Create a shared repository rather than a standalone
338
 
                       repository.
339
 
        The Repository object is returned.
340
 
 
341
 
        This must be overridden as an instance method in child classes, where
342
 
        it should take no parameters and construct whatever repository format
343
 
        that child class desires.
344
 
 
345
 
        This method is deprecated, please call create_repository on a bzrdir
346
 
        instance instead.
347
 
        """
348
 
        bzrdir = BzrDir.create(base, format)
349
 
        return bzrdir.create_repository(shared)
350
 
 
351
 
    @staticmethod
352
584
    def create_standalone_workingtree(base, format=None):
353
585
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
354
586
 
355
587
        'base' must be a local path or a file:// url.
356
588
 
357
589
        This will use the current default BzrDirFormat unless one is
358
 
        specified, and use whatever 
 
590
        specified, and use whatever
359
591
        repository format that that uses for bzrdirformat.create_workingtree,
360
592
        create_branch and create_repository.
361
593
 
363
595
        :return: The WorkingTree object.
364
596
        """
365
597
        t = get_transport(base)
366
 
        if not isinstance(t, LocalTransport):
 
598
        if not isinstance(t, local.LocalTransport):
367
599
            raise errors.NotLocalUrl(base)
368
600
        bzrdir = BzrDir.create_branch_and_repo(base,
369
601
                                               force_new_repo=True,
370
602
                                               format=format).bzrdir
371
603
        return bzrdir.create_workingtree()
372
604
 
373
 
    def create_workingtree(self, revision_id=None):
 
605
    def create_workingtree(self, revision_id=None, from_branch=None,
 
606
        accelerator_tree=None, hardlink=False):
374
607
        """Create a working tree at this BzrDir.
375
 
        
376
 
        revision_id: create it as of this revision id.
 
608
 
 
609
        :param revision_id: create it as of this revision id.
 
610
        :param from_branch: override bzrdir branch (for lightweight checkouts)
 
611
        :param accelerator_tree: A tree which can be used for retrieving file
 
612
            contents more quickly than the revision tree, i.e. a workingtree.
 
613
            The revision tree will be used for cases where accelerator_tree's
 
614
            content is different.
377
615
        """
378
616
        raise NotImplementedError(self.create_workingtree)
379
617
 
 
618
    def backup_bzrdir(self):
 
619
        """Backup this bzr control directory.
 
620
 
 
621
        :return: Tuple with old path name and new path name
 
622
        """
 
623
        def name_gen(base='backup.bzr'):
 
624
            counter = 1
 
625
            name = "%s.~%d~" % (base, counter)
 
626
            while self.root_transport.has(name):
 
627
                counter += 1
 
628
                name = "%s.~%d~" % (base, counter)
 
629
            return name
 
630
 
 
631
        backup_dir=name_gen()
 
632
        pb = ui.ui_factory.nested_progress_bar()
 
633
        try:
 
634
            # FIXME: bug 300001 -- the backup fails if the backup directory
 
635
            # already exists, but it should instead either remove it or make
 
636
            # a new backup directory.
 
637
            #
 
638
            old_path = self.root_transport.abspath('.bzr')
 
639
            new_path = self.root_transport.abspath(backup_dir)
 
640
            ui.ui_factory.note('making backup of %s\n  to %s' % (old_path, new_path,))
 
641
            self.root_transport.copy_tree('.bzr', backup_dir)
 
642
            return (old_path, new_path)
 
643
        finally:
 
644
            pb.finished()
 
645
 
380
646
    def retire_bzrdir(self, limit=10000):
381
647
        """Permanently disable the bzrdir.
382
648
 
417
683
        """
418
684
        raise NotImplementedError(self.destroy_workingtree_metadata)
419
685
 
 
686
    def _find_containing(self, evaluate):
 
687
        """Find something in a containing control directory.
 
688
 
 
689
        This method will scan containing control dirs, until it finds what
 
690
        it is looking for, decides that it will never find it, or runs out
 
691
        of containing control directories to check.
 
692
 
 
693
        It is used to implement find_repository and
 
694
        determine_repository_policy.
 
695
 
 
696
        :param evaluate: A function returning (value, stop).  If stop is True,
 
697
            the value will be returned.
 
698
        """
 
699
        found_bzrdir = self
 
700
        while True:
 
701
            result, stop = evaluate(found_bzrdir)
 
702
            if stop:
 
703
                return result
 
704
            next_transport = found_bzrdir.root_transport.clone('..')
 
705
            if (found_bzrdir.user_url == next_transport.base):
 
706
                # top of the file system
 
707
                return None
 
708
            # find the next containing bzrdir
 
709
            try:
 
710
                found_bzrdir = BzrDir.open_containing_from_transport(
 
711
                    next_transport)[0]
 
712
            except errors.NotBranchError:
 
713
                return None
 
714
 
420
715
    def find_repository(self):
421
716
        """Find the repository that should be used.
422
717
 
424
719
        new branches as well as to hook existing branches up to their
425
720
        repository.
426
721
        """
427
 
        try:
428
 
            return self.open_repository()
429
 
        except errors.NoRepositoryPresent:
430
 
            pass
431
 
        next_transport = self.root_transport.clone('..')
432
 
        while True:
433
 
            # find the next containing bzrdir
434
 
            try:
435
 
                found_bzrdir = BzrDir.open_containing_from_transport(
436
 
                    next_transport)[0]
437
 
            except errors.NotBranchError:
438
 
                # none found
439
 
                raise errors.NoRepositoryPresent(self)
 
722
        def usable_repository(found_bzrdir):
440
723
            # does it have a repository ?
441
724
            try:
442
725
                repository = found_bzrdir.open_repository()
443
726
            except errors.NoRepositoryPresent:
444
 
                next_transport = found_bzrdir.root_transport.clone('..')
445
 
                if (found_bzrdir.root_transport.base == next_transport.base):
446
 
                    # top of the file system
447
 
                    break
448
 
                else:
449
 
                    continue
450
 
            if ((found_bzrdir.root_transport.base ==
451
 
                 self.root_transport.base) or repository.is_shared()):
452
 
                return repository
 
727
                return None, False
 
728
            if found_bzrdir.user_url == self.user_url:
 
729
                return repository, True
 
730
            elif repository.is_shared():
 
731
                return repository, True
453
732
            else:
454
 
                raise errors.NoRepositoryPresent(self)
455
 
        raise errors.NoRepositoryPresent(self)
 
733
                return None, True
 
734
 
 
735
        found_repo = self._find_containing(usable_repository)
 
736
        if found_repo is None:
 
737
            raise errors.NoRepositoryPresent(self)
 
738
        return found_repo
456
739
 
457
740
    def get_branch_reference(self):
458
741
        """Return the referenced URL for the branch in this bzrdir.
463
746
        """
464
747
        return None
465
748
 
466
 
    def get_branch_transport(self, branch_format):
 
749
    def get_branch_transport(self, branch_format, name=None):
467
750
        """Get the transport for use by branch format in this BzrDir.
468
751
 
469
752
        Note that bzr dirs that do not support format strings will raise
470
753
        IncompatibleFormat if the branch format they are given has
471
754
        a format string, and vice versa.
472
755
 
473
 
        If branch_format is None, the transport is returned with no 
 
756
        If branch_format is None, the transport is returned with no
474
757
        checking. If it is not None, then the returned transport is
475
758
        guaranteed to point to an existing directory ready for use.
476
759
        """
477
760
        raise NotImplementedError(self.get_branch_transport)
478
 
        
 
761
 
 
762
    def _find_creation_modes(self):
 
763
        """Determine the appropriate modes for files and directories.
 
764
 
 
765
        They're always set to be consistent with the base directory,
 
766
        assuming that this transport allows setting modes.
 
767
        """
 
768
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
769
        # this off or override it for particular locations? -- mbp 20080512
 
770
        if self._mode_check_done:
 
771
            return
 
772
        self._mode_check_done = True
 
773
        try:
 
774
            st = self.transport.stat('.')
 
775
        except errors.TransportNotPossible:
 
776
            self._dir_mode = None
 
777
            self._file_mode = None
 
778
        else:
 
779
            # Check the directory mode, but also make sure the created
 
780
            # directories and files are read-write for this user. This is
 
781
            # mostly a workaround for filesystems which lie about being able to
 
782
            # write to a directory (cygwin & win32)
 
783
            if (st.st_mode & 07777 == 00000):
 
784
                # FTP allows stat but does not return dir/file modes
 
785
                self._dir_mode = None
 
786
                self._file_mode = None
 
787
            else:
 
788
                self._dir_mode = (st.st_mode & 07777) | 00700
 
789
                # Remove the sticky and execute bits for files
 
790
                self._file_mode = self._dir_mode & ~07111
 
791
 
 
792
    def _get_file_mode(self):
 
793
        """Return Unix mode for newly created files, or None.
 
794
        """
 
795
        if not self._mode_check_done:
 
796
            self._find_creation_modes()
 
797
        return self._file_mode
 
798
 
 
799
    def _get_dir_mode(self):
 
800
        """Return Unix mode for newly created directories, or None.
 
801
        """
 
802
        if not self._mode_check_done:
 
803
            self._find_creation_modes()
 
804
        return self._dir_mode
 
805
 
479
806
    def get_repository_transport(self, repository_format):
480
807
        """Get the transport for use by repository format in this BzrDir.
481
808
 
483
810
        IncompatibleFormat if the repository format they are given has
484
811
        a format string, and vice versa.
485
812
 
486
 
        If repository_format is None, the transport is returned with no 
 
813
        If repository_format is None, the transport is returned with no
487
814
        checking. If it is not None, then the returned transport is
488
815
        guaranteed to point to an existing directory ready for use.
489
816
        """
490
817
        raise NotImplementedError(self.get_repository_transport)
491
 
        
 
818
 
492
819
    def get_workingtree_transport(self, tree_format):
493
820
        """Get the transport for use by workingtree format in this BzrDir.
494
821
 
496
823
        IncompatibleFormat if the workingtree format they are given has a
497
824
        format string, and vice versa.
498
825
 
499
 
        If workingtree_format is None, the transport is returned with no 
 
826
        If workingtree_format is None, the transport is returned with no
500
827
        checking. If it is not None, then the returned transport is
501
828
        guaranteed to point to an existing directory ready for use.
502
829
        """
503
830
        raise NotImplementedError(self.get_workingtree_transport)
504
 
        
 
831
 
 
832
    def get_config(self):
 
833
        """Get configuration for this BzrDir."""
 
834
        return config.BzrDirConfig(self)
 
835
 
 
836
    def _get_config(self):
 
837
        """By default, no configuration is available."""
 
838
        return None
 
839
 
505
840
    def __init__(self, _transport, _format):
506
841
        """Initialize a Bzr control dir object.
507
 
        
 
842
 
508
843
        Only really common logic should reside here, concrete classes should be
509
844
        made with varying behaviours.
510
845
 
512
847
        :param _transport: the transport this dir is based at.
513
848
        """
514
849
        self._format = _format
 
850
        # these are also under the more standard names of 
 
851
        # control_transport and user_transport
515
852
        self.transport = _transport.clone('.bzr')
516
853
        self.root_transport = _transport
 
854
        self._mode_check_done = False
 
855
        
 
856
    @property 
 
857
    def user_transport(self):
 
858
        return self.root_transport
 
859
        
 
860
    @property
 
861
    def control_transport(self):
 
862
        return self.transport
517
863
 
518
864
    def is_control_filename(self, filename):
519
865
        """True if filename is the name of a path which is reserved for bzrdir's.
520
 
        
 
866
 
521
867
        :param filename: A filename within the root transport of this bzrdir.
522
868
 
523
869
        This is true IF and ONLY IF the filename is part of the namespace reserved
526
872
        this in the future - for instance to make bzr talk with svn working
527
873
        trees.
528
874
        """
529
 
        # this might be better on the BzrDirFormat class because it refers to 
530
 
        # all the possible bzrdir disk formats. 
531
 
        # This method is tested via the workingtree is_control_filename tests- 
 
875
        # this might be better on the BzrDirFormat class because it refers to
 
876
        # all the possible bzrdir disk formats.
 
877
        # This method is tested via the workingtree is_control_filename tests-
532
878
        # it was extracted from WorkingTree.is_control_filename. If the method's
533
879
        # contract is extended beyond the current trivial implementation, please
534
880
        # add new tests for it to the appropriate place.
536
882
 
537
883
    def needs_format_conversion(self, format=None):
538
884
        """Return true if this bzrdir needs convert_format run on it.
539
 
        
540
 
        For instance, if the repository format is out of date but the 
 
885
 
 
886
        For instance, if the repository format is out of date but the
541
887
        branch and working tree are not, this should return True.
542
888
 
543
889
        :param format: Optional parameter indicating a specific desired
549
895
    def open_unsupported(base):
550
896
        """Open a branch which is not supported."""
551
897
        return BzrDir.open(base, _unsupported=True)
552
 
        
 
898
 
553
899
    @staticmethod
554
900
    def open(base, _unsupported=False, possible_transports=None):
555
901
        """Open an existing bzrdir, rooted at 'base' (url).
556
 
        
 
902
 
557
903
        :param _unsupported: a private parameter to the BzrDir class.
558
904
        """
559
905
        t = get_transport(base, possible_transports=possible_transports)
567
913
        :param transport: Transport containing the bzrdir.
568
914
        :param _unsupported: private.
569
915
        """
 
916
        for hook in BzrDir.hooks['pre_open']:
 
917
            hook(transport)
 
918
        # Keep initial base since 'transport' may be modified while following
 
919
        # the redirections.
570
920
        base = transport.base
571
 
 
572
921
        def find_format(transport):
573
922
            return transport, BzrDirFormat.find_format(
574
923
                transport, _server_formats=_server_formats)
575
924
 
576
925
        def redirected(transport, e, redirection_notice):
577
 
            qualified_source = e.get_source_url()
578
 
            relpath = transport.relpath(qualified_source)
579
 
            if not e.target.endswith(relpath):
580
 
                # Not redirected to a branch-format, not a branch
581
 
                raise errors.NotBranchError(path=e.target)
582
 
            target = e.target[:-len(relpath)]
 
926
            redirected_transport = transport._redirected_to(e.source, e.target)
 
927
            if redirected_transport is None:
 
928
                raise errors.NotBranchError(base)
583
929
            note('%s is%s redirected to %s',
584
 
                 transport.base, e.permanently, target)
585
 
            # Let's try with a new transport
586
 
            # FIXME: If 'transport' has a qualifier, this should
587
 
            # be applied again to the new transport *iff* the
588
 
            # schemes used are the same. Uncomment this code
589
 
            # once the function (and tests) exist.
590
 
            # -- vila20070212
591
 
            #target = urlutils.copy_url_qualifiers(original, target)
592
 
            return get_transport(target)
 
930
                 transport.base, e.permanently, redirected_transport.base)
 
931
            return redirected_transport
593
932
 
594
933
        try:
595
934
            transport, format = do_catching_redirections(find_format,
601
940
        BzrDir._check_supported(format, _unsupported)
602
941
        return format.open(transport, _found=True)
603
942
 
604
 
    def open_branch(self, unsupported=False):
 
943
    def open_branch(self, name=None, unsupported=False,
 
944
                    ignore_fallbacks=False):
605
945
        """Open the branch object at this BzrDir if one is present.
606
946
 
607
947
        If unsupported is True, then no longer supported branch formats can
608
948
        still be opened.
609
 
        
 
949
 
610
950
        TODO: static convenience version of this?
611
951
        """
612
952
        raise NotImplementedError(self.open_branch)
614
954
    @staticmethod
615
955
    def open_containing(url, possible_transports=None):
616
956
        """Open an existing branch which contains url.
617
 
        
 
957
 
618
958
        :param url: url to search from.
619
959
        See open_containing_from_transport for more detail.
620
960
        """
621
961
        transport = get_transport(url, possible_transports)
622
962
        return BzrDir.open_containing_from_transport(transport)
623
 
    
 
963
 
624
964
    @staticmethod
625
965
    def open_containing_from_transport(a_transport):
626
966
        """Open an existing branch which contains a_transport.base.
629
969
 
630
970
        Basically we keep looking up until we find the control directory or
631
971
        run into the root.  If there isn't one, raises NotBranchError.
632
 
        If there is one and it is either an unrecognised format or an unsupported 
 
972
        If there is one and it is either an unrecognised format or an unsupported
633
973
        format, UnknownFormatError or UnsupportedFormatError are raised.
634
974
        If there is one, it is returned, along with the unused portion of url.
635
975
 
636
 
        :return: The BzrDir that contains the path, and a Unicode path 
 
976
        :return: The BzrDir that contains the path, and a Unicode path
637
977
                for the rest of the URL.
638
978
        """
639
979
        # this gets the normalised url back. I.e. '.' -> the full path.
654
994
                raise errors.NotBranchError(path=url)
655
995
            a_transport = new_t
656
996
 
 
997
    def _get_tree_branch(self):
 
998
        """Return the branch and tree, if any, for this bzrdir.
 
999
 
 
1000
        Return None for tree if not present or inaccessible.
 
1001
        Raise NotBranchError if no branch is present.
 
1002
        :return: (tree, branch)
 
1003
        """
 
1004
        try:
 
1005
            tree = self.open_workingtree()
 
1006
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
1007
            tree = None
 
1008
            branch = self.open_branch()
 
1009
        else:
 
1010
            branch = tree.branch
 
1011
        return tree, branch
 
1012
 
 
1013
    @classmethod
 
1014
    def open_tree_or_branch(klass, location):
 
1015
        """Return the branch and working tree at a location.
 
1016
 
 
1017
        If there is no tree at the location, tree will be None.
 
1018
        If there is no branch at the location, an exception will be
 
1019
        raised
 
1020
        :return: (tree, branch)
 
1021
        """
 
1022
        bzrdir = klass.open(location)
 
1023
        return bzrdir._get_tree_branch()
 
1024
 
657
1025
    @classmethod
658
1026
    def open_containing_tree_or_branch(klass, location):
659
1027
        """Return the branch and working tree contained by a location.
665
1033
        relpath is the portion of the path that is contained by the branch.
666
1034
        """
667
1035
        bzrdir, relpath = klass.open_containing(location)
668
 
        try:
669
 
            tree = bzrdir.open_workingtree()
670
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
671
 
            tree = None
672
 
            branch = bzrdir.open_branch()
673
 
        else:
674
 
            branch = tree.branch
 
1036
        tree, branch = bzrdir._get_tree_branch()
675
1037
        return tree, branch, relpath
676
1038
 
 
1039
    @classmethod
 
1040
    def open_containing_tree_branch_or_repository(klass, location):
 
1041
        """Return the working tree, branch and repo contained by a location.
 
1042
 
 
1043
        Returns (tree, branch, repository, relpath).
 
1044
        If there is no tree containing the location, tree will be None.
 
1045
        If there is no branch containing the location, branch will be None.
 
1046
        If there is no repository containing the location, repository will be
 
1047
        None.
 
1048
        relpath is the portion of the path that is contained by the innermost
 
1049
        BzrDir.
 
1050
 
 
1051
        If no tree, branch or repository is found, a NotBranchError is raised.
 
1052
        """
 
1053
        bzrdir, relpath = klass.open_containing(location)
 
1054
        try:
 
1055
            tree, branch = bzrdir._get_tree_branch()
 
1056
        except errors.NotBranchError:
 
1057
            try:
 
1058
                repo = bzrdir.find_repository()
 
1059
                return None, None, repo, relpath
 
1060
            except (errors.NoRepositoryPresent):
 
1061
                raise errors.NotBranchError(location)
 
1062
        return tree, branch, branch.repository, relpath
 
1063
 
677
1064
    def open_repository(self, _unsupported=False):
678
1065
        """Open the repository object at this BzrDir if one is present.
679
1066
 
687
1074
        raise NotImplementedError(self.open_repository)
688
1075
 
689
1076
    def open_workingtree(self, _unsupported=False,
690
 
            recommend_upgrade=True):
 
1077
                         recommend_upgrade=True, from_branch=None):
691
1078
        """Open the workingtree object at this BzrDir if one is present.
692
1079
 
693
1080
        :param recommend_upgrade: Optional keyword parameter, when True (the
694
1081
            default), emit through the ui module a recommendation that the user
695
1082
            upgrade the working tree when the workingtree being opened is old
696
1083
            (but still fully supported).
 
1084
        :param from_branch: override bzrdir branch (for lightweight checkouts)
697
1085
        """
698
1086
        raise NotImplementedError(self.open_workingtree)
699
1087
 
700
 
    def has_branch(self):
 
1088
    def has_branch(self, name=None):
701
1089
        """Tell if this bzrdir contains a branch.
702
 
        
 
1090
 
703
1091
        Note: if you're going to open the branch, you should just go ahead
704
 
        and try, and not ask permission first.  (This method just opens the 
705
 
        branch and discards it, and that's somewhat expensive.) 
 
1092
        and try, and not ask permission first.  (This method just opens the
 
1093
        branch and discards it, and that's somewhat expensive.)
706
1094
        """
707
1095
        try:
708
 
            self.open_branch()
 
1096
            self.open_branch(name)
709
1097
            return True
710
1098
        except errors.NotBranchError:
711
1099
            return False
715
1103
 
716
1104
        This will still raise an exception if the bzrdir has a workingtree that
717
1105
        is remote & inaccessible.
718
 
        
 
1106
 
719
1107
        Note: if you're going to open the working tree, you should just go ahead
720
 
        and try, and not ask permission first.  (This method just opens the 
721
 
        workingtree and discards it, and that's somewhat expensive.) 
 
1108
        and try, and not ask permission first.  (This method just opens the
 
1109
        workingtree and discards it, and that's somewhat expensive.)
722
1110
        """
723
1111
        try:
724
1112
            self.open_workingtree(recommend_upgrade=False)
727
1115
            return False
728
1116
 
729
1117
    def _cloning_metadir(self):
730
 
        """Produce a metadir suitable for cloning with."""
 
1118
        """Produce a metadir suitable for cloning with.
 
1119
 
 
1120
        :returns: (destination_bzrdir_format, source_repository)
 
1121
        """
731
1122
        result_format = self._format.__class__()
732
1123
        try:
733
1124
            try:
734
 
                branch = self.open_branch()
 
1125
                branch = self.open_branch(ignore_fallbacks=True)
735
1126
                source_repository = branch.repository
 
1127
                result_format._branch_format = branch._format
736
1128
            except errors.NotBranchError:
737
1129
                source_branch = None
738
1130
                source_repository = self.open_repository()
743
1135
            # the fix recommended in bug # 103195 - to delegate this choice the
744
1136
            # repository itself.
745
1137
            repo_format = source_repository._format
746
 
            if not isinstance(repo_format, remote.RemoteRepositoryFormat):
747
 
                result_format.repository_format = repo_format
 
1138
            if isinstance(repo_format, remote.RemoteRepositoryFormat):
 
1139
                source_repository._ensure_real()
 
1140
                repo_format = source_repository._real_repository._format
 
1141
            result_format.repository_format = repo_format
748
1142
        try:
749
1143
            # TODO: Couldn't we just probe for the format in these cases,
750
1144
            # rather than opening the whole tree?  It would be a little
756
1150
            result_format.workingtree_format = tree._format.__class__()
757
1151
        return result_format, source_repository
758
1152
 
759
 
    def cloning_metadir(self):
 
1153
    def cloning_metadir(self, require_stacking=False):
760
1154
        """Produce a metadir suitable for cloning or sprouting with.
761
1155
 
762
1156
        These operations may produce workingtrees (yes, even though they're
763
1157
        "cloning" something that doesn't have a tree), so a viable workingtree
764
1158
        format must be selected.
 
1159
 
 
1160
        :require_stacking: If True, non-stackable formats will be upgraded
 
1161
            to similar stackable formats.
 
1162
        :returns: a BzrDirFormat with all component formats either set
 
1163
            appropriately or set to None if that component should not be
 
1164
            created.
765
1165
        """
766
1166
        format, repository = self._cloning_metadir()
767
1167
        if format._workingtree_format is None:
 
1168
            # No tree in self.
768
1169
            if repository is None:
 
1170
                # No repository either
769
1171
                return format
 
1172
            # We have a repository, so set a working tree? (Why? This seems to
 
1173
            # contradict the stated return value in the docstring).
770
1174
            tree_format = repository._format._matchingbzrdir.workingtree_format
771
1175
            format.workingtree_format = tree_format.__class__()
 
1176
        if require_stacking:
 
1177
            format.require_stacking()
772
1178
        return format
773
1179
 
774
1180
    def checkout_metadir(self):
775
1181
        return self.cloning_metadir()
776
1182
 
777
1183
    def sprout(self, url, revision_id=None, force_new_repo=False,
778
 
               recurse='down', possible_transports=None):
 
1184
               recurse='down', possible_transports=None,
 
1185
               accelerator_tree=None, hardlink=False, stacked=False,
 
1186
               source_branch=None, create_tree_if_local=True):
779
1187
        """Create a copy of this bzrdir prepared for use as a new line of
780
1188
        development.
781
1189
 
788
1196
 
789
1197
        if revision_id is not None, then the clone operation may tune
790
1198
            itself to download less data.
 
1199
        :param accelerator_tree: A tree which can be used for retrieving file
 
1200
            contents more quickly than the revision tree, i.e. a workingtree.
 
1201
            The revision tree will be used for cases where accelerator_tree's
 
1202
            content is different.
 
1203
        :param hardlink: If true, hard-link files from accelerator_tree,
 
1204
            where possible.
 
1205
        :param stacked: If true, create a stacked branch referring to the
 
1206
            location of this control directory.
 
1207
        :param create_tree_if_local: If true, a working-tree will be created
 
1208
            when working locally.
791
1209
        """
792
1210
        target_transport = get_transport(url, possible_transports)
793
1211
        target_transport.ensure_base()
794
 
        cloning_format = self.cloning_metadir()
 
1212
        cloning_format = self.cloning_metadir(stacked)
 
1213
        # Create/update the result branch
795
1214
        result = cloning_format.initialize_on_transport(target_transport)
796
 
        try:
797
 
            source_branch = self.open_branch()
 
1215
        # if a stacked branch wasn't requested, we don't create one
 
1216
        # even if the origin was stacked
 
1217
        stacked_branch_url = None
 
1218
        if source_branch is not None:
 
1219
            if stacked:
 
1220
                stacked_branch_url = self.root_transport.base
798
1221
            source_repository = source_branch.repository
799
 
        except errors.NotBranchError:
800
 
            source_branch = None
801
 
            try:
802
 
                source_repository = self.open_repository()
803
 
            except errors.NoRepositoryPresent:
804
 
                source_repository = None
805
 
        if force_new_repo:
806
 
            result_repo = None
807
 
        else:
808
 
            try:
809
 
                result_repo = result.find_repository()
810
 
            except errors.NoRepositoryPresent:
811
 
                result_repo = None
812
 
        if source_repository is None and result_repo is not None:
813
 
            pass
814
 
        elif source_repository is None and result_repo is None:
815
 
            # no repo available, make a new one
816
 
            result.create_repository()
817
 
        elif source_repository is not None and result_repo is None:
818
 
            # have source, and want to make a new target repo
819
 
            result_repo = source_repository.sprout(result,
820
 
                                                   revision_id=revision_id)
821
 
        else:
822
 
            # fetch needed content into target.
823
 
            if source_repository is not None:
824
 
                # would rather do 
825
 
                # source_repository.copy_content_into(result_repo,
826
 
                #                                     revision_id=revision_id)
827
 
                # so we can override the copy method
 
1222
        else:
 
1223
            try:
 
1224
                source_branch = self.open_branch()
 
1225
                source_repository = source_branch.repository
 
1226
                if stacked:
 
1227
                    stacked_branch_url = self.root_transport.base
 
1228
            except errors.NotBranchError:
 
1229
                source_branch = None
 
1230
                try:
 
1231
                    source_repository = self.open_repository()
 
1232
                except errors.NoRepositoryPresent:
 
1233
                    source_repository = None
 
1234
        repository_policy = result.determine_repository_policy(
 
1235
            force_new_repo, stacked_branch_url, require_stacking=stacked)
 
1236
        result_repo, is_new_repo = repository_policy.acquire_repository()
 
1237
        if is_new_repo and revision_id is not None and not stacked:
 
1238
            fetch_spec = graph.PendingAncestryResult(
 
1239
                [revision_id], source_repository)
 
1240
        else:
 
1241
            fetch_spec = None
 
1242
        if source_repository is not None:
 
1243
            # Fetch while stacked to prevent unstacked fetch from
 
1244
            # Branch.sprout.
 
1245
            if fetch_spec is None:
828
1246
                result_repo.fetch(source_repository, revision_id=revision_id)
829
 
        if source_branch is not None:
830
 
            source_branch.sprout(result, revision_id=revision_id)
 
1247
            else:
 
1248
                result_repo.fetch(source_repository, fetch_spec=fetch_spec)
 
1249
 
 
1250
        if source_branch is None:
 
1251
            # this is for sprouting a bzrdir without a branch; is that
 
1252
            # actually useful?
 
1253
            # Not especially, but it's part of the contract.
 
1254
            result_branch = result.create_branch()
831
1255
        else:
832
 
            result.create_branch()
833
 
        if isinstance(target_transport, LocalTransport) and (
834
 
            result_repo is None or result_repo.make_working_trees()):
835
 
            wt = result.create_workingtree()
 
1256
            result_branch = source_branch.sprout(result,
 
1257
                revision_id=revision_id, repository_policy=repository_policy)
 
1258
        mutter("created new branch %r" % (result_branch,))
 
1259
 
 
1260
        # Create/update the result working tree
 
1261
        if (create_tree_if_local and
 
1262
            isinstance(target_transport, local.LocalTransport) and
 
1263
            (result_repo is None or result_repo.make_working_trees())):
 
1264
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
 
1265
                hardlink=hardlink)
836
1266
            wt.lock_write()
837
1267
            try:
838
1268
                if wt.path2id('') is None:
849
1279
                basis = wt.basis_tree()
850
1280
                basis.lock_read()
851
1281
                subtrees = basis.iter_references()
852
 
                recurse_branch = wt.branch
 
1282
            elif result_branch is not None:
 
1283
                basis = result_branch.basis_tree()
 
1284
                basis.lock_read()
 
1285
                subtrees = basis.iter_references()
853
1286
            elif source_branch is not None:
854
1287
                basis = source_branch.basis_tree()
855
1288
                basis.lock_read()
856
1289
                subtrees = basis.iter_references()
857
 
                recurse_branch = source_branch
858
1290
            else:
859
1291
                subtrees = []
860
1292
                basis = None
864
1296
                    sublocation = source_branch.reference_parent(file_id, path)
865
1297
                    sublocation.bzrdir.sprout(target,
866
1298
                        basis.get_reference_revision(file_id, path),
867
 
                        force_new_repo=force_new_repo, recurse=recurse)
 
1299
                        force_new_repo=force_new_repo, recurse=recurse,
 
1300
                        stacked=stacked)
868
1301
            finally:
869
1302
                if basis is not None:
870
1303
                    basis.unlock()
871
1304
        return result
872
1305
 
 
1306
    def push_branch(self, source, revision_id=None, overwrite=False, 
 
1307
        remember=False, create_prefix=False):
 
1308
        """Push the source branch into this BzrDir."""
 
1309
        br_to = None
 
1310
        # If we can open a branch, use its direct repository, otherwise see
 
1311
        # if there is a repository without a branch.
 
1312
        try:
 
1313
            br_to = self.open_branch()
 
1314
        except errors.NotBranchError:
 
1315
            # Didn't find a branch, can we find a repository?
 
1316
            repository_to = self.find_repository()
 
1317
        else:
 
1318
            # Found a branch, so we must have found a repository
 
1319
            repository_to = br_to.repository
 
1320
 
 
1321
        push_result = PushResult()
 
1322
        push_result.source_branch = source
 
1323
        if br_to is None:
 
1324
            # We have a repository but no branch, copy the revisions, and then
 
1325
            # create a branch.
 
1326
            repository_to.fetch(source.repository, revision_id=revision_id)
 
1327
            br_to = source.clone(self, revision_id=revision_id)
 
1328
            if source.get_push_location() is None or remember:
 
1329
                source.set_push_location(br_to.base)
 
1330
            push_result.stacked_on = None
 
1331
            push_result.branch_push_result = None
 
1332
            push_result.old_revno = None
 
1333
            push_result.old_revid = _mod_revision.NULL_REVISION
 
1334
            push_result.target_branch = br_to
 
1335
            push_result.master_branch = None
 
1336
            push_result.workingtree_updated = False
 
1337
        else:
 
1338
            # We have successfully opened the branch, remember if necessary:
 
1339
            if source.get_push_location() is None or remember:
 
1340
                source.set_push_location(br_to.base)
 
1341
            try:
 
1342
                tree_to = self.open_workingtree()
 
1343
            except errors.NotLocalUrl:
 
1344
                push_result.branch_push_result = source.push(br_to, 
 
1345
                    overwrite, stop_revision=revision_id)
 
1346
                push_result.workingtree_updated = False
 
1347
            except errors.NoWorkingTree:
 
1348
                push_result.branch_push_result = source.push(br_to,
 
1349
                    overwrite, stop_revision=revision_id)
 
1350
                push_result.workingtree_updated = None # Not applicable
 
1351
            else:
 
1352
                tree_to.lock_write()
 
1353
                try:
 
1354
                    push_result.branch_push_result = source.push(
 
1355
                        tree_to.branch, overwrite, stop_revision=revision_id)
 
1356
                    tree_to.update()
 
1357
                finally:
 
1358
                    tree_to.unlock()
 
1359
                push_result.workingtree_updated = True
 
1360
            push_result.old_revno = push_result.branch_push_result.old_revno
 
1361
            push_result.old_revid = push_result.branch_push_result.old_revid
 
1362
            push_result.target_branch = \
 
1363
                push_result.branch_push_result.target_branch
 
1364
        return push_result
 
1365
 
 
1366
 
 
1367
class BzrDirHooks(hooks.Hooks):
 
1368
    """Hooks for BzrDir operations."""
 
1369
 
 
1370
    def __init__(self):
 
1371
        """Create the default hooks."""
 
1372
        hooks.Hooks.__init__(self)
 
1373
        self.create_hook(hooks.HookPoint('pre_open',
 
1374
            "Invoked before attempting to open a BzrDir with the transport "
 
1375
            "that the open will use.", (1, 14), None))
 
1376
        self.create_hook(hooks.HookPoint('post_repo_init',
 
1377
            "Invoked after a repository has been initialized. "
 
1378
            "post_repo_init is called with a "
 
1379
            "bzrlib.bzrdir.RepoInitHookParams.",
 
1380
            (2, 2), None))
 
1381
 
 
1382
# install the default hooks
 
1383
BzrDir.hooks = BzrDirHooks()
 
1384
 
 
1385
 
 
1386
class RepoInitHookParams(object):
 
1387
    """Object holding parameters passed to *_repo_init hooks.
 
1388
 
 
1389
    There are 4 fields that hooks may wish to access:
 
1390
 
 
1391
    :ivar repository: Repository created
 
1392
    :ivar format: Repository format
 
1393
    :ivar bzrdir: The bzrdir for the repository
 
1394
    :ivar shared: The repository is shared
 
1395
    """
 
1396
 
 
1397
    def __init__(self, repository, format, a_bzrdir, shared):
 
1398
        """Create a group of RepoInitHook parameters.
 
1399
 
 
1400
        :param repository: Repository created
 
1401
        :param format: Repository format
 
1402
        :param bzrdir: The bzrdir for the repository
 
1403
        :param shared: The repository is shared
 
1404
        """
 
1405
        self.repository = repository
 
1406
        self.format = format
 
1407
        self.bzrdir = a_bzrdir
 
1408
        self.shared = shared
 
1409
 
 
1410
    def __eq__(self, other):
 
1411
        return self.__dict__ == other.__dict__
 
1412
 
 
1413
    def __repr__(self):
 
1414
        if self.repository:
 
1415
            return "<%s for %s>" % (self.__class__.__name__,
 
1416
                self.repository)
 
1417
        else:
 
1418
            return "<%s for %s>" % (self.__class__.__name__,
 
1419
                self.bzrdir)
 
1420
 
873
1421
 
874
1422
class BzrDirPreSplitOut(BzrDir):
875
1423
    """A common class for the all-in-one formats."""
877
1425
    def __init__(self, _transport, _format):
878
1426
        """See BzrDir.__init__."""
879
1427
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
880
 
        assert self._format._lock_class == lockable_files.TransportLock
881
 
        assert self._format._lock_file_name == 'branch-lock'
882
1428
        self._control_files = lockable_files.LockableFiles(
883
1429
                                            self.get_branch_transport(None),
884
1430
                                            self._format._lock_file_name,
888
1434
        """Pre-splitout bzrdirs do not suffer from stale locks."""
889
1435
        raise NotImplementedError(self.break_lock)
890
1436
 
891
 
    def clone(self, url, revision_id=None, force_new_repo=False):
892
 
        """See BzrDir.clone()."""
893
 
        from bzrlib.workingtree import WorkingTreeFormat2
 
1437
    def cloning_metadir(self, require_stacking=False):
 
1438
        """Produce a metadir suitable for cloning with."""
 
1439
        if require_stacking:
 
1440
            return format_registry.make_bzrdir('1.6')
 
1441
        return self._format.__class__()
 
1442
 
 
1443
    def clone(self, url, revision_id=None, force_new_repo=False,
 
1444
              preserve_stacking=False):
 
1445
        """See BzrDir.clone().
 
1446
 
 
1447
        force_new_repo has no effect, since this family of formats always
 
1448
        require a new repository.
 
1449
        preserve_stacking has no effect, since no source branch using this
 
1450
        family of formats can be stacked, so there is no stacking to preserve.
 
1451
        """
894
1452
        self._make_tail(url)
895
1453
        result = self._format._initialize_for_clone(url)
896
1454
        self.open_repository().clone(result, revision_id=revision_id)
897
1455
        from_branch = self.open_branch()
898
1456
        from_branch.clone(result, revision_id=revision_id)
899
1457
        try:
900
 
            self.open_workingtree().clone(result)
 
1458
            tree = self.open_workingtree()
901
1459
        except errors.NotLocalUrl:
902
1460
            # make a new one, this format always has to have one.
903
 
            try:
904
 
                WorkingTreeFormat2().initialize(result)
905
 
            except errors.NotLocalUrl:
906
 
                # but we cannot do it for remote trees.
907
 
                to_branch = result.open_branch()
908
 
                WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
 
1461
            result._init_workingtree()
 
1462
        else:
 
1463
            tree.clone(result)
909
1464
        return result
910
1465
 
911
 
    def create_branch(self):
 
1466
    def create_branch(self, name=None):
912
1467
        """See BzrDir.create_branch."""
913
 
        return self.open_branch()
 
1468
        return self._format.get_branch_format().initialize(self, name=name)
914
1469
 
915
 
    def destroy_branch(self):
 
1470
    def destroy_branch(self, name=None):
916
1471
        """See BzrDir.destroy_branch."""
917
1472
        raise errors.UnsupportedOperation(self.destroy_branch, self)
918
1473
 
922
1477
            raise errors.IncompatibleFormat('shared repository', self._format)
923
1478
        return self.open_repository()
924
1479
 
925
 
    def create_workingtree(self, revision_id=None):
 
1480
    def destroy_repository(self):
 
1481
        """See BzrDir.destroy_repository."""
 
1482
        raise errors.UnsupportedOperation(self.destroy_repository, self)
 
1483
 
 
1484
    def create_workingtree(self, revision_id=None, from_branch=None,
 
1485
                           accelerator_tree=None, hardlink=False):
926
1486
        """See BzrDir.create_workingtree."""
 
1487
        # The workingtree is sometimes created when the bzrdir is created,
 
1488
        # but not when cloning.
 
1489
 
927
1490
        # this looks buggy but is not -really-
928
1491
        # because this format creates the workingtree when the bzrdir is
929
1492
        # created
931
1494
        # and that will have set it for us, its only
932
1495
        # specific uses of create_workingtree in isolation
933
1496
        # that can do wonky stuff here, and that only
934
 
        # happens for creating checkouts, which cannot be 
 
1497
        # happens for creating checkouts, which cannot be
935
1498
        # done on this format anyway. So - acceptable wart.
936
 
        result = self.open_workingtree(recommend_upgrade=False)
 
1499
        if hardlink:
 
1500
            warning("can't support hardlinked working trees in %r"
 
1501
                % (self,))
 
1502
        try:
 
1503
            result = self.open_workingtree(recommend_upgrade=False)
 
1504
        except errors.NoSuchFile:
 
1505
            result = self._init_workingtree()
937
1506
        if revision_id is not None:
938
1507
            if revision_id == _mod_revision.NULL_REVISION:
939
1508
                result.set_parent_ids([])
941
1510
                result.set_parent_ids([revision_id])
942
1511
        return result
943
1512
 
 
1513
    def _init_workingtree(self):
 
1514
        from bzrlib.workingtree import WorkingTreeFormat2
 
1515
        try:
 
1516
            return WorkingTreeFormat2().initialize(self)
 
1517
        except errors.NotLocalUrl:
 
1518
            # Even though we can't access the working tree, we need to
 
1519
            # create its control files.
 
1520
            return WorkingTreeFormat2()._stub_initialize_on_transport(
 
1521
                self.transport, self._control_files._file_mode)
 
1522
 
944
1523
    def destroy_workingtree(self):
945
1524
        """See BzrDir.destroy_workingtree."""
946
1525
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
947
1526
 
948
1527
    def destroy_workingtree_metadata(self):
949
1528
        """See BzrDir.destroy_workingtree_metadata."""
950
 
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
 
1529
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
951
1530
                                          self)
952
1531
 
953
 
    def get_branch_transport(self, branch_format):
 
1532
    def get_branch_transport(self, branch_format, name=None):
954
1533
        """See BzrDir.get_branch_transport()."""
 
1534
        if name is not None:
 
1535
            raise errors.NoColocatedBranchSupport(self)
955
1536
        if branch_format is None:
956
1537
            return self.transport
957
1538
        try:
985
1566
        # if the format is not the same as the system default,
986
1567
        # an upgrade is needed.
987
1568
        if format is None:
 
1569
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
1570
                % 'needs_format_conversion(format=None)')
988
1571
            format = BzrDirFormat.get_default_format()
989
1572
        return not isinstance(self._format, format.__class__)
990
1573
 
991
 
    def open_branch(self, unsupported=False):
 
1574
    def open_branch(self, name=None, unsupported=False,
 
1575
                    ignore_fallbacks=False):
992
1576
        """See BzrDir.open_branch."""
993
1577
        from bzrlib.branch import BzrBranchFormat4
994
1578
        format = BzrBranchFormat4()
995
1579
        self._check_supported(format, unsupported)
996
 
        return format.open(self, _found=True)
 
1580
        return format.open(self, name, _found=True)
997
1581
 
998
1582
    def sprout(self, url, revision_id=None, force_new_repo=False,
999
 
               possible_transports=None):
 
1583
               possible_transports=None, accelerator_tree=None,
 
1584
               hardlink=False, stacked=False, create_tree_if_local=True,
 
1585
               source_branch=None):
1000
1586
        """See BzrDir.sprout()."""
 
1587
        if source_branch is not None:
 
1588
            my_branch = self.open_branch()
 
1589
            if source_branch.base != my_branch.base:
 
1590
                raise AssertionError(
 
1591
                    "source branch %r is not within %r with branch %r" %
 
1592
                    (source_branch, self, my_branch))
 
1593
        if stacked:
 
1594
            raise errors.UnstackableBranchFormat(
 
1595
                self._format, self.root_transport.base)
 
1596
        if not create_tree_if_local:
 
1597
            raise errors.MustHaveWorkingTree(
 
1598
                self._format, self.root_transport.base)
1001
1599
        from bzrlib.workingtree import WorkingTreeFormat2
1002
1600
        self._make_tail(url)
1003
1601
        result = self._format._initialize_for_clone(url)
1009
1607
            self.open_branch().sprout(result, revision_id=revision_id)
1010
1608
        except errors.NotBranchError:
1011
1609
            pass
 
1610
 
1012
1611
        # we always want a working tree
1013
 
        WorkingTreeFormat2().initialize(result)
 
1612
        WorkingTreeFormat2().initialize(result,
 
1613
                                        accelerator_tree=accelerator_tree,
 
1614
                                        hardlink=hardlink)
1014
1615
        return result
1015
1616
 
1016
1617
 
1017
1618
class BzrDir4(BzrDirPreSplitOut):
1018
1619
    """A .bzr version 4 control object.
1019
 
    
 
1620
 
1020
1621
    This is a deprecated format and may be removed after sept 2006.
1021
1622
    """
1022
1623
 
1026
1627
 
1027
1628
    def needs_format_conversion(self, format=None):
1028
1629
        """Format 4 dirs are always in need of conversion."""
 
1630
        if format is None:
 
1631
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
1632
                % 'needs_format_conversion(format=None)')
1029
1633
        return True
1030
1634
 
1031
1635
    def open_repository(self):
1040
1644
    This is a deprecated format and may be removed after sept 2006.
1041
1645
    """
1042
1646
 
 
1647
    def has_workingtree(self):
 
1648
        """See BzrDir.has_workingtree."""
 
1649
        return True
 
1650
    
1043
1651
    def open_repository(self):
1044
1652
        """See BzrDir.open_repository."""
1045
1653
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1061
1669
    This is a deprecated format and may be removed after sept 2006.
1062
1670
    """
1063
1671
 
 
1672
    def has_workingtree(self):
 
1673
        """See BzrDir.has_workingtree."""
 
1674
        return True
 
1675
    
1064
1676
    def open_repository(self):
1065
1677
        """See BzrDir.open_repository."""
1066
1678
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1077
1689
 
1078
1690
class BzrDirMeta1(BzrDir):
1079
1691
    """A .bzr meta version 1 control object.
1080
 
    
1081
 
    This is the first control object where the 
 
1692
 
 
1693
    This is the first control object where the
1082
1694
    individual aspects are really split out: there are separate repository,
1083
1695
    workingtree and branch subdirectories and any subset of the three can be
1084
1696
    present within a BzrDir.
1088
1700
        """See BzrDir.can_convert_format()."""
1089
1701
        return True
1090
1702
 
1091
 
    def create_branch(self):
 
1703
    def create_branch(self, name=None):
1092
1704
        """See BzrDir.create_branch."""
1093
 
        return self._format.get_branch_format().initialize(self)
 
1705
        return self._format.get_branch_format().initialize(self, name=name)
1094
1706
 
1095
 
    def destroy_branch(self):
 
1707
    def destroy_branch(self, name=None):
1096
1708
        """See BzrDir.create_branch."""
 
1709
        if name is not None:
 
1710
            raise errors.NoColocatedBranchSupport(self)
1097
1711
        self.transport.delete_tree('branch')
1098
1712
 
1099
1713
    def create_repository(self, shared=False):
1100
1714
        """See BzrDir.create_repository."""
1101
1715
        return self._format.repository_format.initialize(self, shared)
1102
1716
 
1103
 
    def create_workingtree(self, revision_id=None):
 
1717
    def destroy_repository(self):
 
1718
        """See BzrDir.destroy_repository."""
 
1719
        self.transport.delete_tree('repository')
 
1720
 
 
1721
    def create_workingtree(self, revision_id=None, from_branch=None,
 
1722
                           accelerator_tree=None, hardlink=False):
1104
1723
        """See BzrDir.create_workingtree."""
1105
 
        from bzrlib.workingtree import WorkingTreeFormat
1106
 
        return self._format.workingtree_format.initialize(self, revision_id)
 
1724
        return self._format.workingtree_format.initialize(
 
1725
            self, revision_id, from_branch=from_branch,
 
1726
            accelerator_tree=accelerator_tree, hardlink=hardlink)
1107
1727
 
1108
1728
    def destroy_workingtree(self):
1109
1729
        """See BzrDir.destroy_workingtree."""
1136
1756
        format = BranchFormat.find_format(self)
1137
1757
        return format.get_reference(self)
1138
1758
 
1139
 
    def get_branch_transport(self, branch_format):
 
1759
    def get_branch_transport(self, branch_format, name=None):
1140
1760
        """See BzrDir.get_branch_transport()."""
 
1761
        if name is not None:
 
1762
            raise errors.NoColocatedBranchSupport(self)
 
1763
        # XXX: this shouldn't implicitly create the directory if it's just
 
1764
        # promising to get a transport -- mbp 20090727
1141
1765
        if branch_format is None:
1142
1766
            return self.transport.clone('branch')
1143
1767
        try:
1178
1802
            pass
1179
1803
        return self.transport.clone('checkout')
1180
1804
 
 
1805
    def has_workingtree(self):
 
1806
        """Tell if this bzrdir contains a working tree.
 
1807
 
 
1808
        This will still raise an exception if the bzrdir has a workingtree that
 
1809
        is remote & inaccessible.
 
1810
 
 
1811
        Note: if you're going to open the working tree, you should just go
 
1812
        ahead and try, and not ask permission first.
 
1813
        """
 
1814
        from bzrlib.workingtree import WorkingTreeFormat
 
1815
        try:
 
1816
            WorkingTreeFormat.find_format(self)
 
1817
        except errors.NoWorkingTree:
 
1818
            return False
 
1819
        return True
 
1820
 
1181
1821
    def needs_format_conversion(self, format=None):
1182
1822
        """See BzrDir.needs_format_conversion()."""
1183
1823
        if format is None:
 
1824
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
1825
                % 'needs_format_conversion(format=None)')
 
1826
        if format is None:
1184
1827
            format = BzrDirFormat.get_default_format()
1185
1828
        if not isinstance(self._format, format.__class__):
1186
1829
            # it is not a meta dir format, conversion is needed.
1193
1836
                return True
1194
1837
        except errors.NoRepositoryPresent:
1195
1838
            pass
1196
 
        try:
1197
 
            if not isinstance(self.open_branch()._format,
 
1839
        for branch in self.list_branches():
 
1840
            if not isinstance(branch._format,
1198
1841
                              format.get_branch_format().__class__):
1199
1842
                # the branch needs an upgrade.
1200
1843
                return True
1201
 
        except errors.NotBranchError:
1202
 
            pass
1203
1844
        try:
1204
1845
            my_wt = self.open_workingtree(recommend_upgrade=False)
1205
1846
            if not isinstance(my_wt._format,
1210
1851
            pass
1211
1852
        return False
1212
1853
 
1213
 
    def open_branch(self, unsupported=False):
 
1854
    def open_branch(self, name=None, unsupported=False,
 
1855
                    ignore_fallbacks=False):
1214
1856
        """See BzrDir.open_branch."""
1215
1857
        format = self.find_branch_format()
1216
1858
        self._check_supported(format, unsupported)
1217
 
        return format.open(self, _found=True)
 
1859
        return format.open(self, name=name,
 
1860
            _found=True, ignore_fallbacks=ignore_fallbacks)
1218
1861
 
1219
1862
    def open_repository(self, unsupported=False):
1220
1863
        """See BzrDir.open_repository."""
1233
1876
            basedir=self.root_transport.base)
1234
1877
        return format.open(self, _found=True)
1235
1878
 
 
1879
    def _get_config(self):
 
1880
        return config.TransportConfig(self.transport, 'control.conf')
 
1881
 
1236
1882
 
1237
1883
class BzrDirFormat(object):
1238
1884
    """An encapsulation of the initialization and open routines for a format.
1242
1888
     * a format string,
1243
1889
     * an open routine.
1244
1890
 
1245
 
    Formats are placed in a dict by their format string for reference 
 
1891
    Formats are placed in a dict by their format string for reference
1246
1892
    during bzrdir opening. These should be subclasses of BzrDirFormat
1247
1893
    for consistency.
1248
1894
 
1249
1895
    Once a format is deprecated, just deprecate the initialize and open
1250
 
    methods on the format class. Do not deprecate the object, as the 
 
1896
    methods on the format class. Do not deprecate the object, as the
1251
1897
    object will be created every system load.
 
1898
 
 
1899
    :cvar colocated_branches: Whether this formats supports colocated branches.
1252
1900
    """
1253
1901
 
1254
1902
    _default_format = None
1259
1907
 
1260
1908
    _control_formats = []
1261
1909
    """The registered control formats - .bzr, ....
1262
 
    
 
1910
 
1263
1911
    This is a list of BzrDirFormat objects.
1264
1912
    """
1265
1913
 
1271
1919
 
1272
1920
    _lock_file_name = 'branch-lock'
1273
1921
 
 
1922
    colocated_branches = False
 
1923
    """Whether co-located branches are supported for this control dir format.
 
1924
    """
 
1925
 
1274
1926
    # _lock_class must be set in subclasses to the lock type, typ.
1275
1927
    # TransportLock or LockDir
1276
1928
 
1293
1945
    def probe_transport(klass, transport):
1294
1946
        """Return the .bzrdir style format present in a directory."""
1295
1947
        try:
1296
 
            format_string = transport.get(".bzr/branch-format").read()
 
1948
            format_string = transport.get_bytes(".bzr/branch-format")
1297
1949
        except errors.NoSuchFile:
1298
1950
            raise errors.NotBranchError(path=transport.base)
1299
1951
 
1300
1952
        try:
1301
1953
            return klass._formats[format_string]
1302
1954
        except KeyError:
1303
 
            raise errors.UnknownFormatError(format=format_string)
 
1955
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1304
1956
 
1305
1957
    @classmethod
1306
1958
    def get_default_format(klass):
1324
1976
        current default format. In the case of plugins we can/should provide
1325
1977
        some means for them to extend the range of returnable converters.
1326
1978
 
1327
 
        :param format: Optional format to override the default format of the 
 
1979
        :param format: Optional format to override the default format of the
1328
1980
                       library.
1329
1981
        """
1330
1982
        raise NotImplementedError(self.get_converter)
1331
1983
 
1332
1984
    def initialize(self, url, possible_transports=None):
1333
1985
        """Create a bzr control dir at this url and return an opened copy.
1334
 
        
 
1986
 
 
1987
        While not deprecated, this method is very specific and its use will
 
1988
        lead to many round trips to setup a working environment. See
 
1989
        initialize_on_transport_ex for a [nearly] all-in-one method.
 
1990
 
1335
1991
        Subclasses should typically override initialize_on_transport
1336
1992
        instead of this method.
1337
1993
        """
1340
1996
 
1341
1997
    def initialize_on_transport(self, transport):
1342
1998
        """Initialize a new bzrdir in the base directory of a Transport."""
1343
 
        # Since we don't have a .bzr directory, inherit the
 
1999
        try:
 
2000
            # can we hand off the request to the smart server rather than using
 
2001
            # vfs calls?
 
2002
            client_medium = transport.get_smart_medium()
 
2003
        except errors.NoSmartMedium:
 
2004
            return self._initialize_on_transport_vfs(transport)
 
2005
        else:
 
2006
            # Current RPC's only know how to create bzr metadir1 instances, so
 
2007
            # we still delegate to vfs methods if the requested format is not a
 
2008
            # metadir1
 
2009
            if type(self) != BzrDirMetaFormat1:
 
2010
                return self._initialize_on_transport_vfs(transport)
 
2011
            remote_format = RemoteBzrDirFormat()
 
2012
            self._supply_sub_formats_to(remote_format)
 
2013
            return remote_format.initialize_on_transport(transport)
 
2014
 
 
2015
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
2016
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
2017
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
2018
        shared_repo=False, vfs_only=False):
 
2019
        """Create this format on transport.
 
2020
 
 
2021
        The directory to initialize will be created.
 
2022
 
 
2023
        :param force_new_repo: Do not use a shared repository for the target,
 
2024
                               even if one is available.
 
2025
        :param create_prefix: Create any missing directories leading up to
 
2026
            to_transport.
 
2027
        :param use_existing_dir: Use an existing directory if one exists.
 
2028
        :param stacked_on: A url to stack any created branch on, None to follow
 
2029
            any target stacking policy.
 
2030
        :param stack_on_pwd: If stack_on is relative, the location it is
 
2031
            relative to.
 
2032
        :param repo_format_name: If non-None, a repository will be
 
2033
            made-or-found. Should none be found, or if force_new_repo is True
 
2034
            the repo_format_name is used to select the format of repository to
 
2035
            create.
 
2036
        :param make_working_trees: Control the setting of make_working_trees
 
2037
            for a new shared repository when one is made. None to use whatever
 
2038
            default the format has.
 
2039
        :param shared_repo: Control whether made repositories are shared or
 
2040
            not.
 
2041
        :param vfs_only: If True do not attempt to use a smart server
 
2042
        :return: repo, bzrdir, require_stacking, repository_policy. repo is
 
2043
            None if none was created or found, bzrdir is always valid.
 
2044
            require_stacking is the result of examining the stacked_on
 
2045
            parameter and any stacking policy found for the target.
 
2046
        """
 
2047
        if not vfs_only:
 
2048
            # Try to hand off to a smart server 
 
2049
            try:
 
2050
                client_medium = transport.get_smart_medium()
 
2051
            except errors.NoSmartMedium:
 
2052
                pass
 
2053
            else:
 
2054
                # TODO: lookup the local format from a server hint.
 
2055
                remote_dir_format = RemoteBzrDirFormat()
 
2056
                remote_dir_format._network_name = self.network_name()
 
2057
                self._supply_sub_formats_to(remote_dir_format)
 
2058
                return remote_dir_format.initialize_on_transport_ex(transport,
 
2059
                    use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
2060
                    force_new_repo=force_new_repo, stacked_on=stacked_on,
 
2061
                    stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
2062
                    make_working_trees=make_working_trees, shared_repo=shared_repo)
 
2063
        # XXX: Refactor the create_prefix/no_create_prefix code into a
 
2064
        #      common helper function
 
2065
        # The destination may not exist - if so make it according to policy.
 
2066
        def make_directory(transport):
 
2067
            transport.mkdir('.')
 
2068
            return transport
 
2069
        def redirected(transport, e, redirection_notice):
 
2070
            note(redirection_notice)
 
2071
            return transport._redirected_to(e.source, e.target)
 
2072
        try:
 
2073
            transport = do_catching_redirections(make_directory, transport,
 
2074
                redirected)
 
2075
        except errors.FileExists:
 
2076
            if not use_existing_dir:
 
2077
                raise
 
2078
        except errors.NoSuchFile:
 
2079
            if not create_prefix:
 
2080
                raise
 
2081
            transport.create_prefix()
 
2082
 
 
2083
        require_stacking = (stacked_on is not None)
 
2084
        # Now the target directory exists, but doesn't have a .bzr
 
2085
        # directory. So we need to create it, along with any work to create
 
2086
        # all of the dependent branches, etc.
 
2087
 
 
2088
        result = self.initialize_on_transport(transport)
 
2089
        if repo_format_name:
 
2090
            try:
 
2091
                # use a custom format
 
2092
                result._format.repository_format = \
 
2093
                    repository.network_format_registry.get(repo_format_name)
 
2094
            except AttributeError:
 
2095
                # The format didn't permit it to be set.
 
2096
                pass
 
2097
            # A repository is desired, either in-place or shared.
 
2098
            repository_policy = result.determine_repository_policy(
 
2099
                force_new_repo, stacked_on, stack_on_pwd,
 
2100
                require_stacking=require_stacking)
 
2101
            result_repo, is_new_repo = repository_policy.acquire_repository(
 
2102
                make_working_trees, shared_repo)
 
2103
            if not require_stacking and repository_policy._require_stacking:
 
2104
                require_stacking = True
 
2105
                result._format.require_stacking()
 
2106
            result_repo.lock_write()
 
2107
        else:
 
2108
            result_repo = None
 
2109
            repository_policy = None
 
2110
        return result_repo, result, require_stacking, repository_policy
 
2111
 
 
2112
    def _initialize_on_transport_vfs(self, transport):
 
2113
        """Initialize a new bzrdir using VFS calls.
 
2114
 
 
2115
        :param transport: The transport to create the .bzr directory in.
 
2116
        :return: A
 
2117
        """
 
2118
        # Since we are creating a .bzr directory, inherit the
1344
2119
        # mode from the root directory
1345
2120
        temp_control = lockable_files.LockableFiles(transport,
1346
2121
                            '', lockable_files.TransportLock)
1348
2123
                                      # FIXME: RBC 20060121 don't peek under
1349
2124
                                      # the covers
1350
2125
                                      mode=temp_control._dir_mode)
 
2126
        if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
 
2127
            win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1351
2128
        file_mode = temp_control._file_mode
1352
2129
        del temp_control
1353
 
        mutter('created control directory in ' + transport.base)
1354
 
        control = transport.clone('.bzr')
1355
 
        utf8_files = [('README', 
1356
 
                       "This is a Bazaar-NG control directory.\n"
1357
 
                       "Do not change any files in this directory.\n"),
 
2130
        bzrdir_transport = transport.clone('.bzr')
 
2131
        utf8_files = [('README',
 
2132
                       "This is a Bazaar control directory.\n"
 
2133
                       "Do not change any files in this directory.\n"
 
2134
                       "See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1358
2135
                      ('branch-format', self.get_format_string()),
1359
2136
                      ]
1360
2137
        # NB: no need to escape relative paths that are url safe.
1361
 
        control_files = lockable_files.LockableFiles(control,
1362
 
                            self._lock_file_name, self._lock_class)
 
2138
        control_files = lockable_files.LockableFiles(bzrdir_transport,
 
2139
            self._lock_file_name, self._lock_class)
1363
2140
        control_files.create_lock()
1364
2141
        control_files.lock_write()
1365
2142
        try:
1366
 
            for file, content in utf8_files:
1367
 
                control_files.put_utf8(file, content)
 
2143
            for (filename, content) in utf8_files:
 
2144
                bzrdir_transport.put_bytes(filename, content,
 
2145
                    mode=file_mode)
1368
2146
        finally:
1369
2147
            control_files.unlock()
1370
2148
        return self.open(transport, _found=True)
1373
2151
        """Is this format supported?
1374
2152
 
1375
2153
        Supported formats must be initializable and openable.
1376
 
        Unsupported formats may not support initialization or committing or 
 
2154
        Unsupported formats may not support initialization or committing or
1377
2155
        some other features depending on the reason for not being supported.
1378
2156
        """
1379
2157
        return True
1380
2158
 
 
2159
    def network_name(self):
 
2160
        """A simple byte string uniquely identifying this format for RPC calls.
 
2161
 
 
2162
        Bzr control formats use thir disk format string to identify the format
 
2163
        over the wire. Its possible that other control formats have more
 
2164
        complex detection requirements, so we permit them to use any unique and
 
2165
        immutable string they desire.
 
2166
        """
 
2167
        raise NotImplementedError(self.network_name)
 
2168
 
1381
2169
    def same_model(self, target_format):
1382
 
        return (self.repository_format.rich_root_data == 
 
2170
        return (self.repository_format.rich_root_data ==
1383
2171
            target_format.rich_root_data)
1384
2172
 
1385
2173
    @classmethod
1386
2174
    def known_formats(klass):
1387
2175
        """Return all the known formats.
1388
 
        
 
2176
 
1389
2177
        Concrete formats should override _known_formats.
1390
2178
        """
1391
 
        # There is double indirection here to make sure that control 
1392
 
        # formats used by more than one dir format will only be probed 
 
2179
        # There is double indirection here to make sure that control
 
2180
        # formats used by more than one dir format will only be probed
1393
2181
        # once. This can otherwise be quite expensive for remote connections.
1394
2182
        result = set()
1395
2183
        for format in klass._control_formats:
1396
2184
            result.update(format._known_formats())
1397
2185
        return result
1398
 
    
 
2186
 
1399
2187
    @classmethod
1400
2188
    def _known_formats(klass):
1401
2189
        """Return the known format instances for this control format."""
1403
2191
 
1404
2192
    def open(self, transport, _found=False):
1405
2193
        """Return an instance of this format for the dir transport points at.
1406
 
        
 
2194
 
1407
2195
        _found is a private parameter, do not use it.
1408
2196
        """
1409
2197
        if not _found:
1410
2198
            found_format = BzrDirFormat.find_format(transport)
1411
2199
            if not isinstance(found_format, self.__class__):
1412
2200
                raise AssertionError("%s was asked to open %s, but it seems to need "
1413
 
                        "format %s" 
 
2201
                        "format %s"
1414
2202
                        % (self, transport, found_format))
 
2203
            # Allow subclasses - use the found format.
 
2204
            self._supply_sub_formats_to(found_format)
 
2205
            return found_format._open(transport)
1415
2206
        return self._open(transport)
1416
2207
 
1417
2208
    def _open(self, transport):
1425
2216
    @classmethod
1426
2217
    def register_format(klass, format):
1427
2218
        klass._formats[format.get_format_string()] = format
 
2219
        # bzr native formats have a network name of their format string.
 
2220
        network_format_registry.register(format.get_format_string(), format.__class__)
1428
2221
 
1429
2222
    @classmethod
1430
2223
    def register_control_format(klass, format):
1431
2224
        """Register a format that does not use '.bzr' for its control dir.
1432
2225
 
1433
2226
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1434
 
        which BzrDirFormat can inherit from, and renamed to register_format 
 
2227
        which BzrDirFormat can inherit from, and renamed to register_format
1435
2228
        there. It has been done without that for now for simplicity of
1436
2229
        implementation.
1437
2230
        """
1449
2242
        klass._control_server_formats.append(format)
1450
2243
 
1451
2244
    @classmethod
1452
 
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
1453
 
    def set_default_format(klass, format):
1454
 
        klass._set_default_format(format)
1455
 
 
1456
 
    @classmethod
1457
2245
    def _set_default_format(klass, format):
1458
2246
        """Set default format (for testing behavior of defaults only)"""
1459
2247
        klass._default_format = format
1460
2248
 
1461
2249
    def __str__(self):
1462
2250
        # Trim the newline
1463
 
        return self.get_format_string().rstrip()
 
2251
        return self.get_format_description().rstrip()
 
2252
 
 
2253
    def _supply_sub_formats_to(self, other_format):
 
2254
        """Give other_format the same values for sub formats as this has.
 
2255
 
 
2256
        This method is expected to be used when parameterising a
 
2257
        RemoteBzrDirFormat instance with the parameters from a
 
2258
        BzrDirMetaFormat1 instance.
 
2259
 
 
2260
        :param other_format: other_format is a format which should be
 
2261
            compatible with whatever sub formats are supported by self.
 
2262
        :return: None.
 
2263
        """
1464
2264
 
1465
2265
    @classmethod
1466
2266
    def unregister_format(klass, format):
1467
 
        assert klass._formats[format.get_format_string()] is format
1468
2267
        del klass._formats[format.get_format_string()]
1469
2268
 
1470
2269
    @classmethod
1499
2298
        """See BzrDirFormat.get_converter()."""
1500
2299
        # there is one and only one upgrade path here.
1501
2300
        return ConvertBzrDir4To5()
1502
 
        
 
2301
 
1503
2302
    def initialize_on_transport(self, transport):
1504
2303
        """Format 4 branches cannot be created."""
1505
2304
        raise errors.UninitializableFormat(self)
1508
2307
        """Format 4 is not supported.
1509
2308
 
1510
2309
        It is not supported because the model changed from 4 to 5 and the
1511
 
        conversion logic is expensive - so doing it on the fly was not 
 
2310
        conversion logic is expensive - so doing it on the fly was not
1512
2311
        feasible.
1513
2312
        """
1514
2313
        return False
1515
2314
 
 
2315
    def network_name(self):
 
2316
        return self.get_format_string()
 
2317
 
1516
2318
    def _open(self, transport):
1517
2319
        """See BzrDirFormat._open."""
1518
2320
        return BzrDir4(transport, self)
1524
2326
    repository_format = property(__return_repository_format)
1525
2327
 
1526
2328
 
1527
 
class BzrDirFormat5(BzrDirFormat):
 
2329
class BzrDirFormatAllInOne(BzrDirFormat):
 
2330
    """Common class for formats before meta-dirs."""
 
2331
 
 
2332
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
2333
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
2334
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
2335
        shared_repo=False):
 
2336
        """See BzrDirFormat.initialize_on_transport_ex."""
 
2337
        require_stacking = (stacked_on is not None)
 
2338
        # Format 5 cannot stack, but we've been asked to - actually init
 
2339
        # a Meta1Dir
 
2340
        if require_stacking:
 
2341
            format = BzrDirMetaFormat1()
 
2342
            return format.initialize_on_transport_ex(transport,
 
2343
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
2344
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
2345
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
2346
                make_working_trees=make_working_trees, shared_repo=shared_repo)
 
2347
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
 
2348
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
2349
            force_new_repo=force_new_repo, stacked_on=stacked_on,
 
2350
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
2351
            make_working_trees=make_working_trees, shared_repo=shared_repo)
 
2352
 
 
2353
 
 
2354
class BzrDirFormat5(BzrDirFormatAllInOne):
1528
2355
    """Bzr control format 5.
1529
2356
 
1530
2357
    This format is a combined format for working tree, branch and repository.
1531
2358
    It has:
1532
 
     - Format 2 working trees [always] 
1533
 
     - Format 4 branches [always] 
 
2359
     - Format 2 working trees [always]
 
2360
     - Format 4 branches [always]
1534
2361
     - Format 5 repositories [always]
1535
2362
       Unhashed stores in the repository.
1536
2363
    """
1541
2368
        """See BzrDirFormat.get_format_string()."""
1542
2369
        return "Bazaar-NG branch, format 5\n"
1543
2370
 
 
2371
    def get_branch_format(self):
 
2372
        from bzrlib import branch
 
2373
        return branch.BzrBranchFormat4()
 
2374
 
1544
2375
    def get_format_description(self):
1545
2376
        """See BzrDirFormat.get_format_description()."""
1546
2377
        return "All-in-one format 5"
1552
2383
 
1553
2384
    def _initialize_for_clone(self, url):
1554
2385
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1555
 
        
 
2386
 
1556
2387
    def initialize_on_transport(self, transport, _cloning=False):
1557
2388
        """Format 5 dirs always have working tree, branch and repository.
1558
 
        
 
2389
 
1559
2390
        Except when they are being cloned.
1560
2391
        """
1561
2392
        from bzrlib.branch import BzrBranchFormat4
1562
2393
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1563
 
        from bzrlib.workingtree import WorkingTreeFormat2
1564
2394
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1565
2395
        RepositoryFormat5().initialize(result, _internal=True)
1566
2396
        if not _cloning:
1567
2397
            branch = BzrBranchFormat4().initialize(result)
1568
 
            try:
1569
 
                WorkingTreeFormat2().initialize(result)
1570
 
            except errors.NotLocalUrl:
1571
 
                # Even though we can't access the working tree, we need to
1572
 
                # create its control files.
1573
 
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
 
2398
            result._init_workingtree()
1574
2399
        return result
1575
2400
 
 
2401
    def network_name(self):
 
2402
        return self.get_format_string()
 
2403
 
1576
2404
    def _open(self, transport):
1577
2405
        """See BzrDirFormat._open."""
1578
2406
        return BzrDir5(transport, self)
1584
2412
    repository_format = property(__return_repository_format)
1585
2413
 
1586
2414
 
1587
 
class BzrDirFormat6(BzrDirFormat):
 
2415
class BzrDirFormat6(BzrDirFormatAllInOne):
1588
2416
    """Bzr control format 6.
1589
2417
 
1590
2418
    This format is a combined format for working tree, branch and repository.
1591
2419
    It has:
1592
 
     - Format 2 working trees [always] 
1593
 
     - Format 4 branches [always] 
 
2420
     - Format 2 working trees [always]
 
2421
     - Format 4 branches [always]
1594
2422
     - Format 6 repositories [always]
1595
2423
    """
1596
2424
 
1604
2432
        """See BzrDirFormat.get_format_description()."""
1605
2433
        return "All-in-one format 6"
1606
2434
 
 
2435
    def get_branch_format(self):
 
2436
        from bzrlib import branch
 
2437
        return branch.BzrBranchFormat4()
 
2438
 
1607
2439
    def get_converter(self, format=None):
1608
2440
        """See BzrDirFormat.get_converter()."""
1609
2441
        # there is one and only one upgrade path here.
1610
2442
        return ConvertBzrDir6ToMeta()
1611
 
        
 
2443
 
1612
2444
    def _initialize_for_clone(self, url):
1613
2445
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1614
2446
 
1615
2447
    def initialize_on_transport(self, transport, _cloning=False):
1616
2448
        """Format 6 dirs always have working tree, branch and repository.
1617
 
        
 
2449
 
1618
2450
        Except when they are being cloned.
1619
2451
        """
1620
2452
        from bzrlib.branch import BzrBranchFormat4
1621
2453
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1622
 
        from bzrlib.workingtree import WorkingTreeFormat2
1623
2454
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1624
2455
        RepositoryFormat6().initialize(result, _internal=True)
1625
2456
        if not _cloning:
1626
2457
            branch = BzrBranchFormat4().initialize(result)
1627
 
            try:
1628
 
                WorkingTreeFormat2().initialize(result)
1629
 
            except errors.NotLocalUrl:
1630
 
                # Even though we can't access the working tree, we need to
1631
 
                # create its control files.
1632
 
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
 
2458
            result._init_workingtree()
1633
2459
        return result
1634
2460
 
 
2461
    def network_name(self):
 
2462
        return self.get_format_string()
 
2463
 
1635
2464
    def _open(self, transport):
1636
2465
        """See BzrDirFormat._open."""
1637
2466
        return BzrDir6(transport, self)
1659
2488
    def __init__(self):
1660
2489
        self._workingtree_format = None
1661
2490
        self._branch_format = None
 
2491
        self._repository_format = None
1662
2492
 
1663
2493
    def __eq__(self, other):
1664
2494
        if other.__class__ is not self.__class__:
1681
2511
    def set_branch_format(self, format):
1682
2512
        self._branch_format = format
1683
2513
 
 
2514
    def require_stacking(self, stack_on=None, possible_transports=None,
 
2515
            _skip_repo=False):
 
2516
        """We have a request to stack, try to ensure the formats support it.
 
2517
 
 
2518
        :param stack_on: If supplied, it is the URL to a branch that we want to
 
2519
            stack on. Check to see if that format supports stacking before
 
2520
            forcing an upgrade.
 
2521
        """
 
2522
        # Stacking is desired. requested by the target, but does the place it
 
2523
        # points at support stacking? If it doesn't then we should
 
2524
        # not implicitly upgrade. We check this here.
 
2525
        new_repo_format = None
 
2526
        new_branch_format = None
 
2527
 
 
2528
        # a bit of state for get_target_branch so that we don't try to open it
 
2529
        # 2 times, for both repo *and* branch
 
2530
        target = [None, False, None] # target_branch, checked, upgrade anyway
 
2531
        def get_target_branch():
 
2532
            if target[1]:
 
2533
                # We've checked, don't check again
 
2534
                return target
 
2535
            if stack_on is None:
 
2536
                # No target format, that means we want to force upgrading
 
2537
                target[:] = [None, True, True]
 
2538
                return target
 
2539
            try:
 
2540
                target_dir = BzrDir.open(stack_on,
 
2541
                    possible_transports=possible_transports)
 
2542
            except errors.NotBranchError:
 
2543
                # Nothing there, don't change formats
 
2544
                target[:] = [None, True, False]
 
2545
                return target
 
2546
            except errors.JailBreak:
 
2547
                # JailBreak, JFDI and upgrade anyway
 
2548
                target[:] = [None, True, True]
 
2549
                return target
 
2550
            try:
 
2551
                target_branch = target_dir.open_branch()
 
2552
            except errors.NotBranchError:
 
2553
                # No branch, don't upgrade formats
 
2554
                target[:] = [None, True, False]
 
2555
                return target
 
2556
            target[:] = [target_branch, True, False]
 
2557
            return target
 
2558
 
 
2559
        if (not _skip_repo and
 
2560
                 not self.repository_format.supports_external_lookups):
 
2561
            # We need to upgrade the Repository.
 
2562
            target_branch, _, do_upgrade = get_target_branch()
 
2563
            if target_branch is None:
 
2564
                # We don't have a target branch, should we upgrade anyway?
 
2565
                if do_upgrade:
 
2566
                    # stack_on is inaccessible, JFDI.
 
2567
                    # TODO: bad monkey, hard-coded formats...
 
2568
                    if self.repository_format.rich_root_data:
 
2569
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
 
2570
                    else:
 
2571
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5()
 
2572
            else:
 
2573
                # If the target already supports stacking, then we know the
 
2574
                # project is already able to use stacking, so auto-upgrade
 
2575
                # for them
 
2576
                new_repo_format = target_branch.repository._format
 
2577
                if not new_repo_format.supports_external_lookups:
 
2578
                    # target doesn't, source doesn't, so don't auto upgrade
 
2579
                    # repo
 
2580
                    new_repo_format = None
 
2581
            if new_repo_format is not None:
 
2582
                self.repository_format = new_repo_format
 
2583
                note('Source repository format does not support stacking,'
 
2584
                     ' using format:\n  %s',
 
2585
                     new_repo_format.get_format_description())
 
2586
 
 
2587
        if not self.get_branch_format().supports_stacking():
 
2588
            # We just checked the repo, now lets check if we need to
 
2589
            # upgrade the branch format
 
2590
            target_branch, _, do_upgrade = get_target_branch()
 
2591
            if target_branch is None:
 
2592
                if do_upgrade:
 
2593
                    # TODO: bad monkey, hard-coded formats...
 
2594
                    new_branch_format = branch.BzrBranchFormat7()
 
2595
            else:
 
2596
                new_branch_format = target_branch._format
 
2597
                if not new_branch_format.supports_stacking():
 
2598
                    new_branch_format = None
 
2599
            if new_branch_format is not None:
 
2600
                # Does support stacking, use its format.
 
2601
                self.set_branch_format(new_branch_format)
 
2602
                note('Source branch format does not support stacking,'
 
2603
                     ' using format:\n  %s',
 
2604
                     new_branch_format.get_format_description())
 
2605
 
1684
2606
    def get_converter(self, format=None):
1685
2607
        """See BzrDirFormat.get_converter()."""
1686
2608
        if format is None:
1698
2620
        """See BzrDirFormat.get_format_description()."""
1699
2621
        return "Meta directory format 1"
1700
2622
 
 
2623
    def network_name(self):
 
2624
        return self.get_format_string()
 
2625
 
1701
2626
    def _open(self, transport):
1702
2627
        """See BzrDirFormat._open."""
1703
 
        return BzrDirMeta1(transport, self)
 
2628
        # Create a new format instance because otherwise initialisation of new
 
2629
        # metadirs share the global default format object leading to alias
 
2630
        # problems.
 
2631
        format = BzrDirMetaFormat1()
 
2632
        self._supply_sub_formats_to(format)
 
2633
        return BzrDirMeta1(transport, format)
1704
2634
 
1705
2635
    def __return_repository_format(self):
1706
2636
        """Circular import protection."""
1707
 
        if getattr(self, '_repository_format', None):
 
2637
        if self._repository_format:
1708
2638
            return self._repository_format
1709
2639
        from bzrlib.repository import RepositoryFormat
1710
2640
        return RepositoryFormat.get_default_format()
1711
2641
 
1712
 
    def __set_repository_format(self, value):
1713
 
        """Allow changint the repository format for metadir formats."""
 
2642
    def _set_repository_format(self, value):
 
2643
        """Allow changing the repository format for metadir formats."""
1714
2644
        self._repository_format = value
1715
2645
 
1716
 
    repository_format = property(__return_repository_format, __set_repository_format)
 
2646
    repository_format = property(__return_repository_format,
 
2647
        _set_repository_format)
 
2648
 
 
2649
    def _supply_sub_formats_to(self, other_format):
 
2650
        """Give other_format the same values for sub formats as this has.
 
2651
 
 
2652
        This method is expected to be used when parameterising a
 
2653
        RemoteBzrDirFormat instance with the parameters from a
 
2654
        BzrDirMetaFormat1 instance.
 
2655
 
 
2656
        :param other_format: other_format is a format which should be
 
2657
            compatible with whatever sub formats are supported by self.
 
2658
        :return: None.
 
2659
        """
 
2660
        if getattr(self, '_repository_format', None) is not None:
 
2661
            other_format.repository_format = self.repository_format
 
2662
        if self._branch_format is not None:
 
2663
            other_format._branch_format = self._branch_format
 
2664
        if self._workingtree_format is not None:
 
2665
            other_format.workingtree_format = self.workingtree_format
1717
2666
 
1718
2667
    def __get_workingtree_format(self):
1719
2668
        if self._workingtree_format is None:
1728
2677
                                  __set_workingtree_format)
1729
2678
 
1730
2679
 
 
2680
network_format_registry = registry.FormatRegistry()
 
2681
"""Registry of formats indexed by their network name.
 
2682
 
 
2683
The network name for a BzrDirFormat is an identifier that can be used when
 
2684
referring to formats with smart server operations. See
 
2685
BzrDirFormat.network_name() for more detail.
 
2686
"""
 
2687
 
 
2688
 
1731
2689
# Register bzr control format
1732
2690
BzrDirFormat.register_control_format(BzrDirFormat)
1733
2691
 
1765
2723
        self.absent_revisions = set()
1766
2724
        self.text_count = 0
1767
2725
        self.revisions = {}
1768
 
        
 
2726
 
1769
2727
    def convert(self, to_convert, pb):
1770
2728
        """See Converter.convert()."""
1771
2729
        self.bzrdir = to_convert
1772
 
        self.pb = pb
1773
 
        self.pb.note('starting upgrade from format 4 to 5')
1774
 
        if isinstance(self.bzrdir.transport, LocalTransport):
1775
 
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1776
 
        self._convert_to_weaves()
1777
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
2730
        if pb is not None:
 
2731
            warnings.warn("pb parameter to convert() is deprecated")
 
2732
        self.pb = ui.ui_factory.nested_progress_bar()
 
2733
        try:
 
2734
            ui.ui_factory.note('starting upgrade from format 4 to 5')
 
2735
            if isinstance(self.bzrdir.transport, local.LocalTransport):
 
2736
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
 
2737
            self._convert_to_weaves()
 
2738
            return BzrDir.open(self.bzrdir.user_url)
 
2739
        finally:
 
2740
            self.pb.finished()
1778
2741
 
1779
2742
    def _convert_to_weaves(self):
1780
 
        self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
 
2743
        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
1781
2744
        try:
1782
2745
            # TODO permissions
1783
2746
            stat = self.bzrdir.transport.stat('weaves')
1811
2774
        self.pb.clear()
1812
2775
        self._write_all_weaves()
1813
2776
        self._write_all_revs()
1814
 
        self.pb.note('upgraded to weaves:')
1815
 
        self.pb.note('  %6d revisions and inventories', len(self.revisions))
1816
 
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
1817
 
        self.pb.note('  %6d texts', self.text_count)
 
2777
        ui.ui_factory.note('upgraded to weaves:')
 
2778
        ui.ui_factory.note('  %6d revisions and inventories' % len(self.revisions))
 
2779
        ui.ui_factory.note('  %6d revisions not present' % len(self.absent_revisions))
 
2780
        ui.ui_factory.note('  %6d texts' % self.text_count)
1818
2781
        self._cleanup_spare_files_after_format4()
1819
 
        self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
 
2782
        self.branch._transport.put_bytes(
 
2783
            'branch-format',
 
2784
            BzrDirFormat5().get_format_string(),
 
2785
            mode=self.bzrdir._get_file_mode())
1820
2786
 
1821
2787
    def _cleanup_spare_files_after_format4(self):
1822
2788
        # FIXME working tree upgrade foo.
1831
2797
 
1832
2798
    def _convert_working_inv(self):
1833
2799
        inv = xml4.serializer_v4.read_inventory(
1834
 
                    self.branch.control_files.get('inventory'))
 
2800
                self.branch._transport.get('inventory'))
1835
2801
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
1836
 
        # FIXME inventory is a working tree change.
1837
 
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
 
2802
        self.branch._transport.put_bytes('inventory', new_inv_xml,
 
2803
            mode=self.bzrdir._get_file_mode())
1838
2804
 
1839
2805
    def _write_all_weaves(self):
1840
2806
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1860
2826
        self.bzrdir.transport.mkdir('revision-store')
1861
2827
        revision_transport = self.bzrdir.transport.clone('revision-store')
1862
2828
        # TODO permissions
1863
 
        _revision_store = TextRevisionStore(TextStore(revision_transport,
1864
 
                                                      prefixed=False,
1865
 
                                                      compressed=True))
 
2829
        from bzrlib.xml5 import serializer_v5
 
2830
        from bzrlib.repofmt.weaverepo import RevisionTextStore
 
2831
        revision_store = RevisionTextStore(revision_transport,
 
2832
            serializer_v5, False, versionedfile.PrefixMapper(),
 
2833
            lambda:True, lambda:True)
1866
2834
        try:
1867
 
            transaction = WriteTransaction()
1868
2835
            for i, rev_id in enumerate(self.converted_revs):
1869
2836
                self.pb.update('write revision', i, len(self.converted_revs))
1870
 
                _revision_store.add_revision(self.revisions[rev_id], transaction)
 
2837
                text = serializer_v5.write_revision_to_string(
 
2838
                    self.revisions[rev_id])
 
2839
                key = (rev_id,)
 
2840
                revision_store.add_lines(key, None, osutils.split_lines(text))
1871
2841
        finally:
1872
2842
            self.pb.clear()
1873
 
            
 
2843
 
1874
2844
    def _load_one_rev(self, rev_id):
1875
2845
        """Load a revision object into memory.
1876
2846
 
1881
2851
                       len(self.known_revisions))
1882
2852
        if not self.branch.repository.has_revision(rev_id):
1883
2853
            self.pb.clear()
1884
 
            self.pb.note('revision {%s} not present in branch; '
1885
 
                         'will be converted as a ghost',
 
2854
            ui.ui_factory.note('revision {%s} not present in branch; '
 
2855
                         'will be converted as a ghost' %
1886
2856
                         rev_id)
1887
2857
            self.absent_revisions.add(rev_id)
1888
2858
        else:
1889
 
            rev = self.branch.repository._revision_store.get_revision(rev_id,
1890
 
                self.branch.repository.get_transaction())
 
2859
            rev = self.branch.repository.get_revision(rev_id)
1891
2860
            for parent_id in rev.parent_ids:
1892
2861
                self.known_revisions.add(parent_id)
1893
2862
                self.to_read.append(parent_id)
1894
2863
            self.revisions[rev_id] = rev
1895
2864
 
1896
2865
    def _load_old_inventory(self, rev_id):
1897
 
        assert rev_id not in self.converted_revs
1898
2866
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1899
2867
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
1900
2868
        inv.revision_id = rev_id
1901
2869
        rev = self.revisions[rev_id]
1902
 
        if rev.inventory_sha1:
1903
 
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1904
 
                'inventory sha mismatch for {%s}' % rev_id
1905
2870
        return inv
1906
2871
 
1907
2872
    def _load_updated_inventory(self, rev_id):
1908
 
        assert rev_id in self.converted_revs
1909
2873
        inv_xml = self.inv_weave.get_text(rev_id)
1910
 
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
2874
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
1911
2875
        return inv
1912
2876
 
1913
2877
    def _convert_one_rev(self, rev_id):
1921
2885
        self.converted_revs.add(rev_id)
1922
2886
 
1923
2887
    def _store_new_inv(self, rev, inv, present_parents):
1924
 
        # the XML is now updated with text versions
1925
 
        if __debug__:
1926
 
            entries = inv.iter_entries()
1927
 
            entries.next()
1928
 
            for path, ie in entries:
1929
 
                assert getattr(ie, 'revision', None) is not None, \
1930
 
                    'no revision on {%s} in {%s}' % \
1931
 
                    (file_id, rev.revision_id)
1932
2888
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1933
2889
        new_inv_sha1 = sha_string(new_inv_xml)
1934
2890
        self.inv_weave.add_lines(rev.revision_id,
1963
2919
            self.text_weaves[file_id] = w
1964
2920
        text_changed = False
1965
2921
        parent_candiate_entries = ie.parent_candidates(parent_invs)
1966
 
        for old_revision in parent_candiate_entries.keys():
1967
 
            # if this fails, its a ghost ?
1968
 
            assert old_revision in self.converted_revs, \
1969
 
                "Revision {%s} not in converted_revs" % old_revision
1970
2922
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
1971
 
        # XXX: Note that this is unordered - and this is tolerable because 
 
2923
        # XXX: Note that this is unordered - and this is tolerable because
1972
2924
        # the previous code was also unordered.
1973
2925
        previous_entries = dict((head, parent_candiate_entries[head]) for head
1974
2926
            in heads)
1975
2927
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1976
2928
        del ie.text_id
1977
 
        assert getattr(ie, 'revision', None) is not None
1978
2929
 
1979
 
    def get_parents(self, revision_ids):
1980
 
        for revision_id in revision_ids:
1981
 
            yield self.revisions[revision_id].parent_ids
 
2930
    def get_parent_map(self, revision_ids):
 
2931
        """See graph.StackedParentsProvider.get_parent_map"""
 
2932
        return dict((revision_id, self.revisions[revision_id])
 
2933
                    for revision_id in revision_ids
 
2934
                     if revision_id in self.revisions)
1982
2935
 
1983
2936
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1984
2937
        # TODO: convert this logic, which is ~= snapshot to
1985
2938
        # a call to:. This needs the path figured out. rather than a work_tree
1986
2939
        # a v4 revision_tree can be given, or something that looks enough like
1987
2940
        # one to give the file content to the entry if it needs it.
1988
 
        # and we need something that looks like a weave store for snapshot to 
 
2941
        # and we need something that looks like a weave store for snapshot to
1989
2942
        # save against.
1990
2943
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1991
2944
        if len(previous_revisions) == 1:
1994
2947
                ie.revision = previous_ie.revision
1995
2948
                return
1996
2949
        if ie.has_text():
1997
 
            text = self.branch.repository.weave_store.get(ie.text_id)
 
2950
            text = self.branch.repository._text_store.get(ie.text_id)
1998
2951
            file_lines = text.readlines()
1999
 
            assert sha_strings(file_lines) == ie.text_sha1
2000
 
            assert sum(map(len, file_lines)) == ie.text_size
2001
2952
            w.add_lines(rev_id, previous_revisions, file_lines)
2002
2953
            self.text_count += 1
2003
2954
        else:
2033
2984
    def convert(self, to_convert, pb):
2034
2985
        """See Converter.convert()."""
2035
2986
        self.bzrdir = to_convert
2036
 
        self.pb = pb
2037
 
        self.pb.note('starting upgrade from format 5 to 6')
2038
 
        self._convert_to_prefixed()
2039
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
2987
        pb = ui.ui_factory.nested_progress_bar()
 
2988
        try:
 
2989
            ui.ui_factory.note('starting upgrade from format 5 to 6')
 
2990
            self._convert_to_prefixed()
 
2991
            return BzrDir.open(self.bzrdir.user_url)
 
2992
        finally:
 
2993
            pb.finished()
2040
2994
 
2041
2995
    def _convert_to_prefixed(self):
2042
2996
        from bzrlib.store import TransportStore
2043
2997
        self.bzrdir.transport.delete('branch-format')
2044
2998
        for store_name in ["weaves", "revision-store"]:
2045
 
            self.pb.note("adding prefixes to %s" % store_name)
 
2999
            ui.ui_factory.note("adding prefixes to %s" % store_name)
2046
3000
            store_transport = self.bzrdir.transport.clone(store_name)
2047
3001
            store = TransportStore(store_transport, prefixed=True)
2048
3002
            for urlfilename in store_transport.list_dir('.'):
2050
3004
                if (filename.endswith(".weave") or
2051
3005
                    filename.endswith(".gz") or
2052
3006
                    filename.endswith(".sig")):
2053
 
                    file_id = os.path.splitext(filename)[0]
 
3007
                    file_id, suffix = os.path.splitext(filename)
2054
3008
                else:
2055
3009
                    file_id = filename
2056
 
                prefix_dir = store.hash_prefix(file_id)
 
3010
                    suffix = ''
 
3011
                new_name = store._mapper.map((file_id,)) + suffix
2057
3012
                # FIXME keep track of the dirs made RBC 20060121
2058
3013
                try:
2059
 
                    store_transport.move(filename, prefix_dir + '/' + filename)
 
3014
                    store_transport.move(filename, new_name)
2060
3015
                except errors.NoSuchFile: # catches missing dirs strangely enough
2061
 
                    store_transport.mkdir(prefix_dir)
2062
 
                    store_transport.move(filename, prefix_dir + '/' + filename)
2063
 
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
 
3016
                    store_transport.mkdir(osutils.dirname(new_name))
 
3017
                    store_transport.move(filename, new_name)
 
3018
        self.bzrdir.transport.put_bytes(
 
3019
            'branch-format',
 
3020
            BzrDirFormat6().get_format_string(),
 
3021
            mode=self.bzrdir._get_file_mode())
2064
3022
 
2065
3023
 
2066
3024
class ConvertBzrDir6ToMeta(Converter):
2071
3029
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2072
3030
        from bzrlib.branch import BzrBranchFormat5
2073
3031
        self.bzrdir = to_convert
2074
 
        self.pb = pb
 
3032
        self.pb = ui.ui_factory.nested_progress_bar()
2075
3033
        self.count = 0
2076
3034
        self.total = 20 # the steps we know about
2077
3035
        self.garbage_inventories = []
 
3036
        self.dir_mode = self.bzrdir._get_dir_mode()
 
3037
        self.file_mode = self.bzrdir._get_file_mode()
2078
3038
 
2079
 
        self.pb.note('starting upgrade from format 6 to metadir')
2080
 
        self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
 
3039
        ui.ui_factory.note('starting upgrade from format 6 to metadir')
 
3040
        self.bzrdir.transport.put_bytes(
 
3041
                'branch-format',
 
3042
                "Converting to format 6",
 
3043
                mode=self.file_mode)
2081
3044
        # its faster to move specific files around than to open and use the apis...
2082
3045
        # first off, nuke ancestry.weave, it was never used.
2083
3046
        try:
2093
3056
            if name.startswith('basis-inventory.'):
2094
3057
                self.garbage_inventories.append(name)
2095
3058
        # create new directories for repository, working tree and branch
2096
 
        self.dir_mode = self.bzrdir._control_files._dir_mode
2097
 
        self.file_mode = self.bzrdir._control_files._file_mode
2098
3059
        repository_names = [('inventory.weave', True),
2099
3060
                            ('revision-store', True),
2100
3061
                            ('weaves', True)]
2102
3063
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2103
3064
        self.make_lock('repository')
2104
3065
        # we hard code the formats here because we are converting into
2105
 
        # the meta format. The meta format upgrader can take this to a 
 
3066
        # the meta format. The meta format upgrader can take this to a
2106
3067
        # future format within each component.
2107
3068
        self.put_format('repository', RepositoryFormat7())
2108
3069
        for entry in repository_names:
2131
3092
        else:
2132
3093
            has_checkout = True
2133
3094
        if not has_checkout:
2134
 
            self.pb.note('No working tree.')
 
3095
            ui.ui_factory.note('No working tree.')
2135
3096
            # If some checkout files are there, we may as well get rid of them.
2136
3097
            for name, mandatory in checkout_files:
2137
3098
                if name in bzrcontents:
2148
3109
            for entry in checkout_files:
2149
3110
                self.move_entry('checkout', entry)
2150
3111
            if last_revision is not None:
2151
 
                self.bzrdir._control_files.put_utf8(
 
3112
                self.bzrdir.transport.put_bytes(
2152
3113
                    'checkout/last-revision', last_revision)
2153
 
        self.bzrdir._control_files.put_utf8(
2154
 
            'branch-format', BzrDirMetaFormat1().get_format_string())
2155
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
3114
        self.bzrdir.transport.put_bytes(
 
3115
            'branch-format',
 
3116
            BzrDirMetaFormat1().get_format_string(),
 
3117
            mode=self.file_mode)
 
3118
        self.pb.finished()
 
3119
        return BzrDir.open(self.bzrdir.user_url)
2156
3120
 
2157
3121
    def make_lock(self, name):
2158
3122
        """Make a lock for the new control dir name."""
2175
3139
                raise
2176
3140
 
2177
3141
    def put_format(self, dirname, format):
2178
 
        self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
 
3142
        self.bzrdir.transport.put_bytes('%s/format' % dirname,
 
3143
            format.get_format_string(),
 
3144
            self.file_mode)
2179
3145
 
2180
3146
 
2181
3147
class ConvertMetaToMeta(Converter):
2191
3157
    def convert(self, to_convert, pb):
2192
3158
        """See Converter.convert()."""
2193
3159
        self.bzrdir = to_convert
2194
 
        self.pb = pb
 
3160
        self.pb = ui.ui_factory.nested_progress_bar()
2195
3161
        self.count = 0
2196
3162
        self.total = 1
2197
3163
        self.step('checking repository format')
2202
3168
        else:
2203
3169
            if not isinstance(repo._format, self.target_format.repository_format.__class__):
2204
3170
                from bzrlib.repository import CopyConverter
2205
 
                self.pb.note('starting repository conversion')
 
3171
                ui.ui_factory.note('starting repository conversion')
2206
3172
                converter = CopyConverter(self.target_format.repository_format)
2207
3173
                converter.convert(repo, pb)
2208
 
        try:
2209
 
            branch = self.bzrdir.open_branch()
2210
 
        except errors.NotBranchError:
2211
 
            pass
2212
 
        else:
 
3174
        for branch in self.bzrdir.list_branches():
2213
3175
            # TODO: conversions of Branch and Tree should be done by
2214
 
            # InterXFormat lookups
 
3176
            # InterXFormat lookups/some sort of registry.
2215
3177
            # Avoid circular imports
2216
3178
            from bzrlib import branch as _mod_branch
2217
 
            if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
2218
 
                self.target_format.get_branch_format().__class__ is
2219
 
                _mod_branch.BzrBranchFormat6):
2220
 
                branch_converter = _mod_branch.Converter5to6()
 
3179
            old = branch._format.__class__
 
3180
            new = self.target_format.get_branch_format().__class__
 
3181
            while old != new:
 
3182
                if (old == _mod_branch.BzrBranchFormat5 and
 
3183
                    new in (_mod_branch.BzrBranchFormat6,
 
3184
                        _mod_branch.BzrBranchFormat7,
 
3185
                        _mod_branch.BzrBranchFormat8)):
 
3186
                    branch_converter = _mod_branch.Converter5to6()
 
3187
                elif (old == _mod_branch.BzrBranchFormat6 and
 
3188
                    new in (_mod_branch.BzrBranchFormat7,
 
3189
                            _mod_branch.BzrBranchFormat8)):
 
3190
                    branch_converter = _mod_branch.Converter6to7()
 
3191
                elif (old == _mod_branch.BzrBranchFormat7 and
 
3192
                      new is _mod_branch.BzrBranchFormat8):
 
3193
                    branch_converter = _mod_branch.Converter7to8()
 
3194
                else:
 
3195
                    raise errors.BadConversionTarget("No converter", new,
 
3196
                        branch._format)
2221
3197
                branch_converter.convert(branch)
 
3198
                branch = self.bzrdir.open_branch()
 
3199
                old = branch._format.__class__
2222
3200
        try:
2223
3201
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2224
3202
        except (errors.NoWorkingTree, errors.NotLocalUrl):
2227
3205
            # TODO: conversions of Branch and Tree should be done by
2228
3206
            # InterXFormat lookups
2229
3207
            if (isinstance(tree, workingtree.WorkingTree3) and
2230
 
                not isinstance(tree, workingtree_4.WorkingTree4) and
 
3208
                not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2231
3209
                isinstance(self.target_format.workingtree_format,
2232
 
                    workingtree_4.WorkingTreeFormat4)):
 
3210
                    workingtree_4.DirStateWorkingTreeFormat)):
2233
3211
                workingtree_4.Converter3to4().convert(tree)
 
3212
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
3213
                not isinstance(tree, workingtree_4.WorkingTree5) and
 
3214
                isinstance(self.target_format.workingtree_format,
 
3215
                    workingtree_4.WorkingTreeFormat5)):
 
3216
                workingtree_4.Converter4to5().convert(tree)
 
3217
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
3218
                not isinstance(tree, workingtree_4.WorkingTree6) and
 
3219
                isinstance(self.target_format.workingtree_format,
 
3220
                    workingtree_4.WorkingTreeFormat6)):
 
3221
                workingtree_4.Converter4or5to6().convert(tree)
 
3222
        self.pb.finished()
2234
3223
        return to_convert
2235
3224
 
2236
3225
 
2237
 
# This is not in remote.py because it's small, and needs to be registered.
2238
 
# Putting it in remote.py creates a circular import problem.
 
3226
# This is not in remote.py because it's relatively small, and needs to be
 
3227
# registered. Putting it in remote.py creates a circular import problem.
2239
3228
# we can make it a lazy object if the control formats is turned into something
2240
3229
# like a registry.
2241
3230
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2242
3231
    """Format representing bzrdirs accessed via a smart server"""
2243
3232
 
 
3233
    def __init__(self):
 
3234
        BzrDirMetaFormat1.__init__(self)
 
3235
        # XXX: It's a bit ugly that the network name is here, because we'd
 
3236
        # like to believe that format objects are stateless or at least
 
3237
        # immutable,  However, we do at least avoid mutating the name after
 
3238
        # it's returned.  See <https://bugs.edge.launchpad.net/bzr/+bug/504102>
 
3239
        self._network_name = None
 
3240
 
 
3241
    def __repr__(self):
 
3242
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
3243
            self._network_name)
 
3244
 
2244
3245
    def get_format_description(self):
 
3246
        if self._network_name:
 
3247
            real_format = network_format_registry.get(self._network_name)
 
3248
            return 'Remote: ' + real_format.get_format_description()
2245
3249
        return 'bzr remote bzrdir'
2246
 
    
 
3250
 
 
3251
    def get_format_string(self):
 
3252
        raise NotImplementedError(self.get_format_string)
 
3253
 
 
3254
    def network_name(self):
 
3255
        if self._network_name:
 
3256
            return self._network_name
 
3257
        else:
 
3258
            raise AssertionError("No network name set.")
 
3259
 
2247
3260
    @classmethod
2248
3261
    def probe_transport(klass, transport):
2249
3262
        """Return a RemoteBzrDirFormat object if it looks possible."""
2250
3263
        try:
2251
 
            client = transport.get_smart_client()
 
3264
            medium = transport.get_smart_medium()
2252
3265
        except (NotImplementedError, AttributeError,
2253
 
                errors.TransportNotPossible):
 
3266
                errors.TransportNotPossible, errors.NoSmartMedium,
 
3267
                errors.SmartProtocolError):
2254
3268
            # no smart server, so not a branch for this format type.
2255
3269
            raise errors.NotBranchError(path=transport.base)
2256
3270
        else:
2257
 
            # Send a 'hello' request in protocol version one, and decline to
2258
 
            # open it if the server doesn't support our required version (2) so
2259
 
            # that the VFS-based transport will do it.
2260
 
            request = client.get_request()
2261
 
            smart_protocol = protocol.SmartClientRequestProtocolOne(request)
2262
 
            server_version = smart_protocol.query_version()
2263
 
            if server_version != 2:
2264
 
                raise errors.NotBranchError(path=transport.base)
 
3271
            # Decline to open it if the server doesn't support our required
 
3272
            # version (3) so that the VFS-based transport will do it.
 
3273
            if medium.should_probe():
 
3274
                try:
 
3275
                    server_version = medium.protocol_version()
 
3276
                except errors.SmartProtocolError:
 
3277
                    # Apparently there's no usable smart server there, even though
 
3278
                    # the medium supports the smart protocol.
 
3279
                    raise errors.NotBranchError(path=transport.base)
 
3280
                if server_version != '2':
 
3281
                    raise errors.NotBranchError(path=transport.base)
2265
3282
            return klass()
2266
3283
 
2267
3284
    def initialize_on_transport(self, transport):
2268
3285
        try:
2269
3286
            # hand off the request to the smart server
2270
 
            shared_medium = transport.get_shared_medium()
 
3287
            client_medium = transport.get_smart_medium()
2271
3288
        except errors.NoSmartMedium:
2272
3289
            # TODO: lookup the local format from a server hint.
2273
3290
            local_dir_format = BzrDirMetaFormat1()
2274
3291
            return local_dir_format.initialize_on_transport(transport)
2275
 
        client = _SmartClient(shared_medium)
 
3292
        client = _SmartClient(client_medium)
2276
3293
        path = client.remote_path_from_transport(transport)
2277
 
        response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
2278
 
                                                    path)
2279
 
        assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
2280
 
        return remote.RemoteBzrDir(transport)
 
3294
        try:
 
3295
            response = client.call('BzrDirFormat.initialize', path)
 
3296
        except errors.ErrorFromSmartServer, err:
 
3297
            remote._translate_error(err, path=path)
 
3298
        if response[0] != 'ok':
 
3299
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
3300
        format = RemoteBzrDirFormat()
 
3301
        self._supply_sub_formats_to(format)
 
3302
        return remote.RemoteBzrDir(transport, format)
 
3303
 
 
3304
    def parse_NoneTrueFalse(self, arg):
 
3305
        if not arg:
 
3306
            return None
 
3307
        if arg == 'False':
 
3308
            return False
 
3309
        if arg == 'True':
 
3310
            return True
 
3311
        raise AssertionError("invalid arg %r" % arg)
 
3312
 
 
3313
    def _serialize_NoneTrueFalse(self, arg):
 
3314
        if arg is False:
 
3315
            return 'False'
 
3316
        if arg:
 
3317
            return 'True'
 
3318
        return ''
 
3319
 
 
3320
    def _serialize_NoneString(self, arg):
 
3321
        return arg or ''
 
3322
 
 
3323
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
3324
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
3325
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
3326
        shared_repo=False):
 
3327
        try:
 
3328
            # hand off the request to the smart server
 
3329
            client_medium = transport.get_smart_medium()
 
3330
        except errors.NoSmartMedium:
 
3331
            do_vfs = True
 
3332
        else:
 
3333
            # Decline to open it if the server doesn't support our required
 
3334
            # version (3) so that the VFS-based transport will do it.
 
3335
            if client_medium.should_probe():
 
3336
                try:
 
3337
                    server_version = client_medium.protocol_version()
 
3338
                    if server_version != '2':
 
3339
                        do_vfs = True
 
3340
                    else:
 
3341
                        do_vfs = False
 
3342
                except errors.SmartProtocolError:
 
3343
                    # Apparently there's no usable smart server there, even though
 
3344
                    # the medium supports the smart protocol.
 
3345
                    do_vfs = True
 
3346
            else:
 
3347
                do_vfs = False
 
3348
        if not do_vfs:
 
3349
            client = _SmartClient(client_medium)
 
3350
            path = client.remote_path_from_transport(transport)
 
3351
            if client_medium._is_remote_before((1, 16)):
 
3352
                do_vfs = True
 
3353
        if do_vfs:
 
3354
            # TODO: lookup the local format from a server hint.
 
3355
            local_dir_format = BzrDirMetaFormat1()
 
3356
            self._supply_sub_formats_to(local_dir_format)
 
3357
            return local_dir_format.initialize_on_transport_ex(transport,
 
3358
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
3359
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
3360
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
3361
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
3362
                vfs_only=True)
 
3363
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
3364
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
3365
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
3366
 
 
3367
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
3368
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
3369
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
3370
        args = []
 
3371
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
3372
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
3373
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
3374
        args.append(self._serialize_NoneString(stacked_on))
 
3375
        # stack_on_pwd is often/usually our transport
 
3376
        if stack_on_pwd:
 
3377
            try:
 
3378
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
3379
                if not stack_on_pwd:
 
3380
                    stack_on_pwd = '.'
 
3381
            except errors.PathNotChild:
 
3382
                pass
 
3383
        args.append(self._serialize_NoneString(stack_on_pwd))
 
3384
        args.append(self._serialize_NoneString(repo_format_name))
 
3385
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
3386
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
3387
        request_network_name = self._network_name or \
 
3388
            BzrDirFormat.get_default_format().network_name()
 
3389
        try:
 
3390
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
3391
                request_network_name, path, *args)
 
3392
        except errors.UnknownSmartMethod:
 
3393
            client._medium._remember_remote_is_before((1,16))
 
3394
            local_dir_format = BzrDirMetaFormat1()
 
3395
            self._supply_sub_formats_to(local_dir_format)
 
3396
            return local_dir_format.initialize_on_transport_ex(transport,
 
3397
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
3398
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
3399
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
3400
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
3401
                vfs_only=True)
 
3402
        except errors.ErrorFromSmartServer, err:
 
3403
            remote._translate_error(err, path=path)
 
3404
        repo_path = response[0]
 
3405
        bzrdir_name = response[6]
 
3406
        require_stacking = response[7]
 
3407
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
3408
        format = RemoteBzrDirFormat()
 
3409
        format._network_name = bzrdir_name
 
3410
        self._supply_sub_formats_to(format)
 
3411
        bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
 
3412
        if repo_path:
 
3413
            repo_format = remote.response_tuple_to_repo_format(response[1:])
 
3414
            if repo_path == '.':
 
3415
                repo_path = ''
 
3416
            if repo_path:
 
3417
                repo_bzrdir_format = RemoteBzrDirFormat()
 
3418
                repo_bzrdir_format._network_name = response[5]
 
3419
                repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
 
3420
                    repo_bzrdir_format)
 
3421
            else:
 
3422
                repo_bzr = bzrdir
 
3423
            final_stack = response[8] or None
 
3424
            final_stack_pwd = response[9] or None
 
3425
            if final_stack_pwd:
 
3426
                final_stack_pwd = urlutils.join(
 
3427
                    transport.base, final_stack_pwd)
 
3428
            remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
 
3429
            if len(response) > 10:
 
3430
                # Updated server verb that locks remotely.
 
3431
                repo_lock_token = response[10] or None
 
3432
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
3433
                if repo_lock_token:
 
3434
                    remote_repo.dont_leave_lock_in_place()
 
3435
            else:
 
3436
                remote_repo.lock_write()
 
3437
            policy = UseExistingRepository(remote_repo, final_stack,
 
3438
                final_stack_pwd, require_stacking)
 
3439
            policy.acquire_repository()
 
3440
        else:
 
3441
            remote_repo = None
 
3442
            policy = None
 
3443
        bzrdir._format.set_branch_format(self.get_branch_format())
 
3444
        if require_stacking:
 
3445
            # The repo has already been created, but we need to make sure that
 
3446
            # we'll make a stackable branch.
 
3447
            bzrdir._format.require_stacking(_skip_repo=True)
 
3448
        return remote_repo, bzrdir, require_stacking, policy
2281
3449
 
2282
3450
    def _open(self, transport):
2283
 
        return remote.RemoteBzrDir(transport)
 
3451
        return remote.RemoteBzrDir(transport, self)
2284
3452
 
2285
3453
    def __eq__(self, other):
2286
3454
        if not isinstance(other, RemoteBzrDirFormat):
2287
3455
            return False
2288
3456
        return self.get_format_description() == other.get_format_description()
2289
3457
 
 
3458
    def __return_repository_format(self):
 
3459
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
3460
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
3461
        # that it should use that for init() etc.
 
3462
        result = remote.RemoteRepositoryFormat()
 
3463
        custom_format = getattr(self, '_repository_format', None)
 
3464
        if custom_format:
 
3465
            if isinstance(custom_format, remote.RemoteRepositoryFormat):
 
3466
                return custom_format
 
3467
            else:
 
3468
                # We will use the custom format to create repositories over the
 
3469
                # wire; expose its details like rich_root_data for code to
 
3470
                # query
 
3471
                result._custom_format = custom_format
 
3472
        return result
 
3473
 
 
3474
    def get_branch_format(self):
 
3475
        result = BzrDirMetaFormat1.get_branch_format(self)
 
3476
        if not isinstance(result, remote.RemoteBranchFormat):
 
3477
            new_result = remote.RemoteBranchFormat()
 
3478
            new_result._custom_format = result
 
3479
            # cache the result
 
3480
            self.set_branch_format(new_result)
 
3481
            result = new_result
 
3482
        return result
 
3483
 
 
3484
    repository_format = property(__return_repository_format,
 
3485
        BzrDirMetaFormat1._set_repository_format) #.im_func)
 
3486
 
2290
3487
 
2291
3488
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2292
3489
 
2293
3490
 
2294
3491
class BzrDirFormatInfo(object):
2295
3492
 
2296
 
    def __init__(self, native, deprecated, hidden):
 
3493
    def __init__(self, native, deprecated, hidden, experimental):
2297
3494
        self.deprecated = deprecated
2298
3495
        self.native = native
2299
3496
        self.hidden = hidden
 
3497
        self.experimental = experimental
2300
3498
 
2301
3499
 
2302
3500
class BzrDirFormatRegistry(registry.Registry):
2303
3501
    """Registry of user-selectable BzrDir subformats.
2304
 
    
 
3502
 
2305
3503
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2306
3504
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
2307
3505
    """
2308
3506
 
 
3507
    def __init__(self):
 
3508
        """Create a BzrDirFormatRegistry."""
 
3509
        self._aliases = set()
 
3510
        self._registration_order = list()
 
3511
        super(BzrDirFormatRegistry, self).__init__()
 
3512
 
 
3513
    def aliases(self):
 
3514
        """Return a set of the format names which are aliases."""
 
3515
        return frozenset(self._aliases)
 
3516
 
2309
3517
    def register_metadir(self, key,
2310
3518
             repository_format, help, native=True, deprecated=False,
2311
3519
             branch_format=None,
2312
3520
             tree_format=None,
2313
 
             hidden=False):
 
3521
             hidden=False,
 
3522
             experimental=False,
 
3523
             alias=False):
2314
3524
        """Register a metadir subformat.
2315
3525
 
2316
3526
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2317
 
        by the Repository format.
 
3527
        by the Repository/Branch/WorkingTreeformats.
2318
3528
 
2319
3529
        :param repository_format: The fully-qualified repository format class
2320
3530
            name as a string.
2348
3558
            if repository_format is not None:
2349
3559
                bd.repository_format = _load(repository_format)
2350
3560
            return bd
2351
 
        self.register(key, helper, help, native, deprecated, hidden)
 
3561
        self.register(key, helper, help, native, deprecated, hidden,
 
3562
            experimental, alias)
2352
3563
 
2353
3564
    def register(self, key, factory, help, native=True, deprecated=False,
2354
 
                 hidden=False):
 
3565
                 hidden=False, experimental=False, alias=False):
2355
3566
        """Register a BzrDirFormat factory.
2356
 
        
 
3567
 
2357
3568
        The factory must be a callable that takes one parameter: the key.
2358
3569
        It must produce an instance of the BzrDirFormat when called.
2359
3570
 
2360
3571
        This function mainly exists to prevent the info object from being
2361
3572
        supplied directly.
2362
3573
        """
2363
 
        registry.Registry.register(self, key, factory, help, 
2364
 
            BzrDirFormatInfo(native, deprecated, hidden))
 
3574
        registry.Registry.register(self, key, factory, help,
 
3575
            BzrDirFormatInfo(native, deprecated, hidden, experimental))
 
3576
        if alias:
 
3577
            self._aliases.add(key)
 
3578
        self._registration_order.append(key)
2365
3579
 
2366
3580
    def register_lazy(self, key, module_name, member_name, help, native=True,
2367
 
                      deprecated=False, hidden=False):
2368
 
        registry.Registry.register_lazy(self, key, module_name, member_name, 
2369
 
            help, BzrDirFormatInfo(native, deprecated, hidden))
 
3581
        deprecated=False, hidden=False, experimental=False, alias=False):
 
3582
        registry.Registry.register_lazy(self, key, module_name, member_name,
 
3583
            help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
 
3584
        if alias:
 
3585
            self._aliases.add(key)
 
3586
        self._registration_order.append(key)
2370
3587
 
2371
3588
    def set_default(self, key):
2372
3589
        """Set the 'default' key to be a clone of the supplied key.
2373
 
        
 
3590
 
2374
3591
        This method must be called once and only once.
2375
3592
        """
2376
 
        registry.Registry.register(self, 'default', self.get(key), 
 
3593
        registry.Registry.register(self, 'default', self.get(key),
2377
3594
            self.get_help(key), info=self.get_info(key))
 
3595
        self._aliases.add('default')
2378
3596
 
2379
3597
    def set_default_repository(self, key):
2380
3598
        """Set the FormatRegistry default and Repository default.
2381
 
        
 
3599
 
2382
3600
        This is a transitional method while Repository.set_default_format
2383
3601
        is deprecated.
2384
3602
        """
2386
3604
            self.remove('default')
2387
3605
        self.set_default(key)
2388
3606
        format = self.get('default')()
2389
 
        assert isinstance(format, BzrDirMetaFormat1)
2390
3607
 
2391
3608
    def make_bzrdir(self, key):
2392
3609
        return self.get(key)()
2393
3610
 
2394
3611
    def help_topic(self, topic):
2395
 
        output = textwrap.dedent("""\
2396
 
            These formats can be used for creating branches, working trees, and
2397
 
            repositories.
2398
 
 
2399
 
            """)
 
3612
        output = ""
2400
3613
        default_realkey = None
2401
3614
        default_help = self.get_help('default')
2402
3615
        help_pairs = []
2403
 
        for key in self.keys():
 
3616
        for key in self._registration_order:
2404
3617
            if key == 'default':
2405
3618
                continue
2406
3619
            help = self.get_help(key)
2412
3625
        def wrapped(key, help, info):
2413
3626
            if info.native:
2414
3627
                help = '(native) ' + help
2415
 
            return ':%s:\n%s\n\n' % (key, 
2416
 
                    textwrap.fill(help, initial_indent='    ', 
2417
 
                    subsequent_indent='    '))
 
3628
            return ':%s:\n%s\n\n' % (key,
 
3629
                textwrap.fill(help, initial_indent='    ',
 
3630
                    subsequent_indent='    ',
 
3631
                    break_long_words=False))
2418
3632
        if default_realkey is not None:
2419
3633
            output += wrapped(default_realkey, '(default) %s' % default_help,
2420
3634
                              self.get_info('default'))
2421
3635
        deprecated_pairs = []
 
3636
        experimental_pairs = []
2422
3637
        for key, help in help_pairs:
2423
3638
            info = self.get_info(key)
2424
3639
            if info.hidden:
2425
3640
                continue
2426
3641
            elif info.deprecated:
2427
3642
                deprecated_pairs.append((key, help))
 
3643
            elif info.experimental:
 
3644
                experimental_pairs.append((key, help))
2428
3645
            else:
2429
3646
                output += wrapped(key, help, info)
 
3647
        output += "\nSee :doc:`formats-help` for more about storage formats."
 
3648
        other_output = ""
 
3649
        if len(experimental_pairs) > 0:
 
3650
            other_output += "Experimental formats are shown below.\n\n"
 
3651
            for key, help in experimental_pairs:
 
3652
                info = self.get_info(key)
 
3653
                other_output += wrapped(key, help, info)
 
3654
        else:
 
3655
            other_output += \
 
3656
                "No experimental formats are available.\n\n"
2430
3657
        if len(deprecated_pairs) > 0:
2431
 
            output += "Deprecated formats are shown below.\n\n"
 
3658
            other_output += "\nDeprecated formats are shown below.\n\n"
2432
3659
            for key, help in deprecated_pairs:
2433
3660
                info = self.get_info(key)
2434
 
                output += wrapped(key, help, info)
2435
 
 
2436
 
        return output
2437
 
 
2438
 
 
 
3661
                other_output += wrapped(key, help, info)
 
3662
        else:
 
3663
            other_output += \
 
3664
                "\nNo deprecated formats are available.\n\n"
 
3665
        other_output += \
 
3666
                "\nSee :doc:`formats-help` for more about storage formats."
 
3667
 
 
3668
        if topic == 'other-formats':
 
3669
            return other_output
 
3670
        else:
 
3671
            return output
 
3672
 
 
3673
 
 
3674
class RepositoryAcquisitionPolicy(object):
 
3675
    """Abstract base class for repository acquisition policies.
 
3676
 
 
3677
    A repository acquisition policy decides how a BzrDir acquires a repository
 
3678
    for a branch that is being created.  The most basic policy decision is
 
3679
    whether to create a new repository or use an existing one.
 
3680
    """
 
3681
    def __init__(self, stack_on, stack_on_pwd, require_stacking):
 
3682
        """Constructor.
 
3683
 
 
3684
        :param stack_on: A location to stack on
 
3685
        :param stack_on_pwd: If stack_on is relative, the location it is
 
3686
            relative to.
 
3687
        :param require_stacking: If True, it is a failure to not stack.
 
3688
        """
 
3689
        self._stack_on = stack_on
 
3690
        self._stack_on_pwd = stack_on_pwd
 
3691
        self._require_stacking = require_stacking
 
3692
 
 
3693
    def configure_branch(self, branch):
 
3694
        """Apply any configuration data from this policy to the branch.
 
3695
 
 
3696
        Default implementation sets repository stacking.
 
3697
        """
 
3698
        if self._stack_on is None:
 
3699
            return
 
3700
        if self._stack_on_pwd is None:
 
3701
            stack_on = self._stack_on
 
3702
        else:
 
3703
            try:
 
3704
                stack_on = urlutils.rebase_url(self._stack_on,
 
3705
                    self._stack_on_pwd,
 
3706
                    branch.user_url)
 
3707
            except errors.InvalidRebaseURLs:
 
3708
                stack_on = self._get_full_stack_on()
 
3709
        try:
 
3710
            branch.set_stacked_on_url(stack_on)
 
3711
        except (errors.UnstackableBranchFormat,
 
3712
                errors.UnstackableRepositoryFormat):
 
3713
            if self._require_stacking:
 
3714
                raise
 
3715
 
 
3716
    def requires_stacking(self):
 
3717
        """Return True if this policy requires stacking."""
 
3718
        return self._stack_on is not None and self._require_stacking
 
3719
 
 
3720
    def _get_full_stack_on(self):
 
3721
        """Get a fully-qualified URL for the stack_on location."""
 
3722
        if self._stack_on is None:
 
3723
            return None
 
3724
        if self._stack_on_pwd is None:
 
3725
            return self._stack_on
 
3726
        else:
 
3727
            return urlutils.join(self._stack_on_pwd, self._stack_on)
 
3728
 
 
3729
    def _add_fallback(self, repository, possible_transports=None):
 
3730
        """Add a fallback to the supplied repository, if stacking is set."""
 
3731
        stack_on = self._get_full_stack_on()
 
3732
        if stack_on is None:
 
3733
            return
 
3734
        try:
 
3735
            stacked_dir = BzrDir.open(stack_on,
 
3736
                                      possible_transports=possible_transports)
 
3737
        except errors.JailBreak:
 
3738
            # We keep the stacking details, but we are in the server code so
 
3739
            # actually stacking is not needed.
 
3740
            return
 
3741
        try:
 
3742
            stacked_repo = stacked_dir.open_branch().repository
 
3743
        except errors.NotBranchError:
 
3744
            stacked_repo = stacked_dir.open_repository()
 
3745
        try:
 
3746
            repository.add_fallback_repository(stacked_repo)
 
3747
        except errors.UnstackableRepositoryFormat:
 
3748
            if self._require_stacking:
 
3749
                raise
 
3750
        else:
 
3751
            self._require_stacking = True
 
3752
 
 
3753
    def acquire_repository(self, make_working_trees=None, shared=False):
 
3754
        """Acquire a repository for this bzrdir.
 
3755
 
 
3756
        Implementations may create a new repository or use a pre-exising
 
3757
        repository.
 
3758
        :param make_working_trees: If creating a repository, set
 
3759
            make_working_trees to this value (if non-None)
 
3760
        :param shared: If creating a repository, make it shared if True
 
3761
        :return: A repository, is_new_flag (True if the repository was
 
3762
            created).
 
3763
        """
 
3764
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
 
3765
 
 
3766
 
 
3767
class CreateRepository(RepositoryAcquisitionPolicy):
 
3768
    """A policy of creating a new repository"""
 
3769
 
 
3770
    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
 
3771
                 require_stacking=False):
 
3772
        """
 
3773
        Constructor.
 
3774
        :param bzrdir: The bzrdir to create the repository on.
 
3775
        :param stack_on: A location to stack on
 
3776
        :param stack_on_pwd: If stack_on is relative, the location it is
 
3777
            relative to.
 
3778
        """
 
3779
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
 
3780
                                             require_stacking)
 
3781
        self._bzrdir = bzrdir
 
3782
 
 
3783
    def acquire_repository(self, make_working_trees=None, shared=False):
 
3784
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
 
3785
 
 
3786
        Creates the desired repository in the bzrdir we already have.
 
3787
        """
 
3788
        stack_on = self._get_full_stack_on()
 
3789
        if stack_on:
 
3790
            format = self._bzrdir._format
 
3791
            format.require_stacking(stack_on=stack_on,
 
3792
                                    possible_transports=[self._bzrdir.root_transport])
 
3793
            if not self._require_stacking:
 
3794
                # We have picked up automatic stacking somewhere.
 
3795
                note('Using default stacking branch %s at %s', self._stack_on,
 
3796
                    self._stack_on_pwd)
 
3797
        repository = self._bzrdir.create_repository(shared=shared)
 
3798
        self._add_fallback(repository,
 
3799
                           possible_transports=[self._bzrdir.transport])
 
3800
        if make_working_trees is not None:
 
3801
            repository.set_make_working_trees(make_working_trees)
 
3802
        return repository, True
 
3803
 
 
3804
 
 
3805
class UseExistingRepository(RepositoryAcquisitionPolicy):
 
3806
    """A policy of reusing an existing repository"""
 
3807
 
 
3808
    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
 
3809
                 require_stacking=False):
 
3810
        """Constructor.
 
3811
 
 
3812
        :param repository: The repository to use.
 
3813
        :param stack_on: A location to stack on
 
3814
        :param stack_on_pwd: If stack_on is relative, the location it is
 
3815
            relative to.
 
3816
        """
 
3817
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
 
3818
                                             require_stacking)
 
3819
        self._repository = repository
 
3820
 
 
3821
    def acquire_repository(self, make_working_trees=None, shared=False):
 
3822
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
 
3823
 
 
3824
        Returns an existing repository to use.
 
3825
        """
 
3826
        self._add_fallback(self._repository,
 
3827
                       possible_transports=[self._repository.bzrdir.transport])
 
3828
        return self._repository, False
 
3829
 
 
3830
 
 
3831
# Please register new formats after old formats so that formats
 
3832
# appear in chronological order and format descriptions can build
 
3833
# on previous ones.
2439
3834
format_registry = BzrDirFormatRegistry()
 
3835
# The pre-0.8 formats have their repository format network name registered in
 
3836
# repository.py. MetaDir formats have their repository format network name
 
3837
# inferred from their disk format string.
2440
3838
format_registry.register('weave', BzrDirFormat6,
2441
3839
    'Pre-0.8 format.  Slower than knit and does not'
2442
3840
    ' support checkouts or shared repositories.',
 
3841
    hidden=True,
2443
3842
    deprecated=True)
2444
 
format_registry.register_metadir('knit',
2445
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2446
 
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
2447
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
2448
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat3')
2449
3843
format_registry.register_metadir('metaweave',
2450
3844
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
2451
3845
    'Transitional format in 0.8.  Slower than knit.',
2452
3846
    branch_format='bzrlib.branch.BzrBranchFormat5',
2453
3847
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
 
3848
    hidden=True,
 
3849
    deprecated=True)
 
3850
format_registry.register_metadir('knit',
 
3851
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
3852
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
 
3853
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
3854
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
 
3855
    hidden=True,
2454
3856
    deprecated=True)
2455
3857
format_registry.register_metadir('dirstate',
2456
3858
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2460
3862
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
2461
3863
    # directly from workingtree_4 triggers a circular import.
2462
3864
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2463
 
    )
 
3865
    hidden=True,
 
3866
    deprecated=True)
2464
3867
format_registry.register_metadir('dirstate-tags',
2465
3868
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2466
3869
    help='New in 0.15: Fast local operations and improved scaling for '
2468
3871
        ' Incompatible with bzr < 0.15.',
2469
3872
    branch_format='bzrlib.branch.BzrBranchFormat6',
2470
3873
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2471
 
    )
 
3874
    hidden=True,
 
3875
    deprecated=True)
 
3876
format_registry.register_metadir('rich-root',
 
3877
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
 
3878
    help='New in 1.0.  Better handling of tree roots.  Incompatible with'
 
3879
        ' bzr < 1.0.',
 
3880
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
3881
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3882
    hidden=True,
 
3883
    deprecated=True)
2472
3884
format_registry.register_metadir('dirstate-with-subtree',
2473
3885
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2474
3886
    help='New in 0.15: Fast local operations and improved scaling for '
2476
3888
        'bzr branches. Incompatible with bzr < 0.15.',
2477
3889
    branch_format='bzrlib.branch.BzrBranchFormat6',
2478
3890
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3891
    experimental=True,
2479
3892
    hidden=True,
2480
3893
    )
2481
 
format_registry.register_metadir('experimental',
 
3894
format_registry.register_metadir('pack-0.92',
2482
3895
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
2483
 
    help='New in XXX: Experimental format with data compatible with dirstate '
2484
 
        'format repositories. Cannot be read except with bzr.dev. '
2485
 
        'WARNING: This format is unstable and data in it will not be upgradable'
2486
 
        ' to release formats of bzr.',
 
3896
    help='New in 0.92: Pack-based format with data compatible with '
 
3897
        'dirstate-tags format repositories. Interoperates with '
 
3898
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
 
3899
        ,
2487
3900
    branch_format='bzrlib.branch.BzrBranchFormat6',
2488
3901
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2489
 
    hidden=True,
2490
3902
    )
2491
 
format_registry.register_metadir('experimental-subtree',
 
3903
format_registry.register_metadir('pack-0.92-subtree',
2492
3904
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
2493
 
    help='New in XXX: Experimental format with data compatible with '
2494
 
        'dirstate-with-subtree format repositories. Cannot be read except with'
2495
 
        ' bzr.dev. WARNING: This format is unstable and data in it will not be'
2496
 
        ' upgradable to release formats of bzr.',
2497
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
2498
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2499
 
    hidden=True,
2500
 
    )
2501
 
format_registry.set_default('dirstate-tags')
 
3905
    help='New in 0.92: Pack-based format with data compatible with '
 
3906
        'dirstate-with-subtree format repositories. Interoperates with '
 
3907
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
 
3908
        ,
 
3909
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
3910
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3911
    hidden=True,
 
3912
    experimental=True,
 
3913
    )
 
3914
format_registry.register_metadir('rich-root-pack',
 
3915
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
 
3916
    help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
 
3917
         '(needed for bzr-svn and bzr-git).',
 
3918
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
3919
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3920
    hidden=True,
 
3921
    )
 
3922
format_registry.register_metadir('1.6',
 
3923
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
 
3924
    help='A format that allows a branch to indicate that there is another '
 
3925
         '(stacked) repository that should be used to access data that is '
 
3926
         'not present locally.',
 
3927
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3928
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3929
    hidden=True,
 
3930
    )
 
3931
format_registry.register_metadir('1.6.1-rich-root',
 
3932
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
 
3933
    help='A variant of 1.6 that supports rich-root data '
 
3934
         '(needed for bzr-svn and bzr-git).',
 
3935
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3936
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3937
    hidden=True,
 
3938
    )
 
3939
format_registry.register_metadir('1.9',
 
3940
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
 
3941
    help='A repository format using B+tree indexes. These indexes '
 
3942
         'are smaller in size, have smarter caching and provide faster '
 
3943
         'performance for most operations.',
 
3944
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3945
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3946
    hidden=True,
 
3947
    )
 
3948
format_registry.register_metadir('1.9-rich-root',
 
3949
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
 
3950
    help='A variant of 1.9 that supports rich-root data '
 
3951
         '(needed for bzr-svn and bzr-git).',
 
3952
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3953
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3954
    hidden=True,
 
3955
    )
 
3956
format_registry.register_metadir('1.14',
 
3957
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
 
3958
    help='A working-tree format that supports content filtering.',
 
3959
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3960
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
 
3961
    )
 
3962
format_registry.register_metadir('1.14-rich-root',
 
3963
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
 
3964
    help='A variant of 1.14 that supports rich-root data '
 
3965
         '(needed for bzr-svn and bzr-git).',
 
3966
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3967
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
 
3968
    )
 
3969
# The following un-numbered 'development' formats should always just be aliases.
 
3970
format_registry.register_metadir('development-rich-root',
 
3971
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
 
3972
    help='Current development format. Supports rich roots. Can convert data '
 
3973
        'to and from rich-root-pack (and anything compatible with '
 
3974
        'rich-root-pack) format repositories. Repositories and branches in '
 
3975
        'this format can only be read by bzr.dev. Please read '
 
3976
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
3977
        'before use.',
 
3978
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3979
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3980
    experimental=True,
 
3981
    alias=True,
 
3982
    hidden=True,
 
3983
    )
 
3984
format_registry.register_metadir('development-subtree',
 
3985
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
 
3986
    help='Current development format, subtree variant. Can convert data to and '
 
3987
        'from pack-0.92-subtree (and anything compatible with '
 
3988
        'pack-0.92-subtree) format repositories. Repositories and branches in '
 
3989
        'this format can only be read by bzr.dev. Please read '
 
3990
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
3991
        'before use.',
 
3992
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3993
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3994
    experimental=True,
 
3995
    hidden=True,
 
3996
    alias=False, # Restore to being an alias when an actual development subtree format is added
 
3997
                 # This current non-alias status is simply because we did not introduce a
 
3998
                 # chk based subtree format.
 
3999
    )
 
4000
 
 
4001
# And the development formats above will have aliased one of the following:
 
4002
format_registry.register_metadir('development6-rich-root',
 
4003
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
 
4004
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
 
4005
        'Please read '
 
4006
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
4007
        'before use.',
 
4008
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
4009
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
4010
    hidden=True,
 
4011
    experimental=True,
 
4012
    )
 
4013
 
 
4014
format_registry.register_metadir('development7-rich-root',
 
4015
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
 
4016
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
 
4017
        'rich roots. Please read '
 
4018
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
4019
        'before use.',
 
4020
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
4021
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
4022
    hidden=True,
 
4023
    experimental=True,
 
4024
    )
 
4025
 
 
4026
format_registry.register_metadir('2a',
 
4027
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
 
4028
    help='First format for bzr 2.0 series.\n'
 
4029
        'Uses group-compress storage.\n'
 
4030
        'Provides rich roots which are a one-way transition.\n',
 
4031
        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
 
4032
        # 'rich roots. Supported by bzr 1.16 and later.',
 
4033
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
4034
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
4035
    experimental=True,
 
4036
    )
 
4037
 
 
4038
# The following format should be an alias for the rich root equivalent 
 
4039
# of the default format
 
4040
format_registry.register_metadir('default-rich-root',
 
4041
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
 
4042
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
4043
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
4044
    alias=True,
 
4045
    hidden=True,
 
4046
    help='Same as 2a.')
 
4047
 
 
4048
# The current format that is made on 'bzr init'.
 
4049
format_registry.set_default('2a')