← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: John Arbash Meinel
  • Date: 2009-08-25 18:45:40 UTC
  • mto: (4634.6.15 2.0)
  • mto: This revision was merged to the branch mainline in revision 4667.
  • Revision ID: john@arbash-meinel.com-20090825184540-6dn3xjq62xhgj2gq
Add support for skipping ghost nodes.

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