← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006 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: remove unittest dependency; put that stuff inside the test suite
 
28
# TODO: Move old formats into a plugin to make this file smaller.
24
29
 
25
 
from copy import deepcopy
26
 
from cStringIO import StringIO
27
30
import os
 
31
import sys
 
32
 
 
33
from bzrlib.lazy_import import lazy_import
 
34
lazy_import(globals(), """
28
35
from stat import S_ISDIR
29
 
from unittest import TestSuite
 
36
import textwrap
30
37
 
31
38
import bzrlib
32
 
import bzrlib.errors as errors
33
 
from bzrlib.lockable_files import LockableFiles, TransportLock
34
 
from bzrlib.lockdir import LockDir
 
39
from bzrlib import (
 
40
    branch,
 
41
    config,
 
42
    errors,
 
43
    graph,
 
44
    lockable_files,
 
45
    lockdir,
 
46
    osutils,
 
47
    remote,
 
48
    repository,
 
49
    revision as _mod_revision,
 
50
    ui,
 
51
    urlutils,
 
52
    versionedfile,
 
53
    win32utils,
 
54
    workingtree,
 
55
    workingtree_4,
 
56
    xml4,
 
57
    xml5,
 
58
    )
35
59
from bzrlib.osutils import (
36
 
                            abspath,
37
 
                            pathjoin,
38
 
                            safe_unicode,
39
 
                            sha_strings,
40
 
                            sha_string,
41
 
                            )
42
 
from bzrlib.store.revision.text import TextRevisionStore
43
 
from bzrlib.store.text import TextStore
 
60
    sha_string,
 
61
    )
 
62
from bzrlib.push import (
 
63
    PushResult,
 
64
    )
 
65
from bzrlib.repofmt import pack_repo
 
66
from bzrlib.smart.client import _SmartClient
44
67
from bzrlib.store.versioned import WeaveStore
45
 
from bzrlib.trace import mutter
46
68
from bzrlib.transactions import WriteTransaction
47
 
from bzrlib.transport import get_transport
48
 
from bzrlib.transport.local import LocalTransport
49
 
import bzrlib.urlutils as urlutils
 
69
from bzrlib.transport import (
 
70
    do_catching_redirections,
 
71
    get_transport,
 
72
    local,
 
73
    )
50
74
from bzrlib.weave import Weave
51
 
from bzrlib.xml4 import serializer_v4
52
 
import bzrlib.xml5
 
75
""")
 
76
 
 
77
from bzrlib.trace import (
 
78
    mutter,
 
79
    note,
 
80
    warning,
 
81
    )
 
82
 
 
83
from bzrlib import (
 
84
    hooks,
 
85
    registry,
 
86
    symbol_versioning,
 
87
    )
53
88
 
54
89
 
55
90
class BzrDir(object):
56
91
    """A .bzr control diretory.
57
 
    
 
92
 
58
93
    BzrDir instances let you create or open any of the things that can be
59
94
    found within .bzr - checkouts, branches and repositories.
60
 
    
61
 
    transport
 
95
 
 
96
    :ivar transport:
62
97
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
63
 
    root_transport
64
 
        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.
65
105
    """
66
106
 
67
107
    def break_lock(self):
70
110
        If there is a tree, the tree is opened and break_lock() called.
71
111
        Otherwise, branch is tried, and finally repository.
72
112
        """
 
113
        # XXX: This seems more like a UI function than something that really
 
114
        # belongs in this class.
73
115
        try:
74
116
            thing_to_unlock = self.open_workingtree()
75
117
        except (errors.NotLocalUrl, errors.NoWorkingTree):
86
128
        """Return true if this bzrdir is one whose format we can convert from."""
87
129
        return True
88
130
 
 
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.
 
135
        target_repo_format = target_format.repository_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
 
142
 
89
143
    @staticmethod
90
 
    def _check_supported(format, allow_unsupported):
91
 
        """Check whether format is a supported format.
92
 
 
93
 
        If allow_unsupported is True, this is a no-op.
 
144
    def _check_supported(format, allow_unsupported,
 
145
        recommend_upgrade=True,
 
146
        basedir=None):
 
147
        """Give an error or warning on old formats.
 
148
 
 
149
        :param format: may be any kind of format - workingtree, branch,
 
150
        or repository.
 
151
 
 
152
        :param allow_unsupported: If true, allow opening
 
153
        formats that are strongly deprecated, and which may
 
154
        have limited functionality.
 
155
 
 
156
        :param recommend_upgrade: If true (default), warn
 
157
        the user through the ui object that they may wish
 
158
        to upgrade the object.
94
159
        """
 
160
        # TODO: perhaps move this into a base Format class; it's not BzrDir
 
161
        # specific. mbp 20070323
95
162
        if not allow_unsupported and not format.is_supported():
96
163
            # see open_downlevel to open legacy branches.
97
164
            raise errors.UnsupportedFormatError(format=format)
 
165
        if recommend_upgrade \
 
166
            and getattr(format, 'upgrade_recommended', False):
 
167
            ui.ui_factory.recommend_upgrade(
 
168
                format.get_format_description(),
 
169
                basedir)
98
170
 
99
 
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
 
171
    def clone(self, url, revision_id=None, force_new_repo=False,
 
172
              preserve_stacking=False):
100
173
        """Clone this bzrdir and its contents to url verbatim.
101
174
 
102
 
        If urls last component does not exist, it will be created.
103
 
 
104
 
        if revision_id is not None, then the clone operation may tune
105
 
            itself to download less data.
106
 
        :param force_new_repo: Do not use a shared repository for the target 
107
 
                               even if one is available.
108
 
        """
109
 
        self._make_tail(url)
110
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
111
 
        result = self._format.initialize(url)
 
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
 
179
            itself to download less data.
 
180
        :param force_new_repo: Do not use a shared repository for the target
 
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.
 
184
        """
 
185
        return self.clone_on_transport(get_transport(url),
 
186
                                       revision_id=revision_id,
 
187
                                       force_new_repo=force_new_repo,
 
188
                                       preserve_stacking=preserve_stacking)
 
189
 
 
190
    def clone_on_transport(self, transport, revision_id=None,
 
191
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
192
        create_prefix=False, use_existing_dir=True):
 
193
        """Clone this bzrdir and its contents to transport verbatim.
 
194
 
 
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
 
199
            itself to download less data.
 
200
        :param force_new_repo: Do not use a shared repository for the target,
 
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.
 
207
        """
 
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:
112
217
        try:
113
218
            local_repo = self.find_repository()
114
219
        except errors.NoRepositoryPresent:
115
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.
116
239
        if local_repo:
117
 
            # may need to copy content in
118
 
            if force_new_repo:
119
 
                result_repo = local_repo.clone(
120
 
                    result,
121
 
                    revision_id=revision_id,
122
 
                    basis=basis_repo)
123
 
                result_repo.set_make_working_trees(local_repo.make_working_trees())
124
 
            else:
125
 
                try:
126
 
                    result_repo = result.find_repository()
127
 
                    # fetch content this dir needs.
128
 
                    if basis_repo:
129
 
                        # XXX FIXME RBC 20060214 need tests for this when the basis
130
 
                        # is incomplete
131
 
                        result_repo.fetch(basis_repo, revision_id=revision_id)
 
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:
132
270
                    result_repo.fetch(local_repo, revision_id=revision_id)
133
 
                except errors.NoRepositoryPresent:
134
 
                    # needed to make one anyway.
135
 
                    result_repo = local_repo.clone(
136
 
                        result,
137
 
                        revision_id=revision_id,
138
 
                        basis=basis_repo)
139
 
                    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)
140
276
        # 1 if there is a branch present
141
277
        #   make sure its content is available in the target repository
142
278
        #   clone it.
143
 
        try:
144
 
            self.open_branch().clone(result, revision_id=revision_id)
145
 
        except errors.NotBranchError:
146
 
            pass
147
 
        try:
148
 
            self.open_workingtree().clone(result, basis=basis_tree)
 
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)
149
288
        except (errors.NoWorkingTree, errors.NotLocalUrl):
150
289
            pass
151
290
        return result
152
291
 
153
 
    def _get_basis_components(self, basis):
154
 
        """Retrieve the basis components that are available at basis."""
155
 
        if basis is None:
156
 
            return None, None, None
157
 
        try:
158
 
            basis_tree = basis.open_workingtree()
159
 
            basis_branch = basis_tree.branch
160
 
            basis_repo = basis_branch.repository
161
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
162
 
            basis_tree = None
163
 
            try:
164
 
                basis_branch = basis.open_branch()
165
 
                basis_repo = basis_branch.repository
166
 
            except errors.NotBranchError:
167
 
                basis_branch = None
168
 
                try:
169
 
                    basis_repo = basis.open_repository()
170
 
                except errors.NoRepositoryPresent:
171
 
                    basis_repo = None
172
 
        return basis_repo, basis_branch, basis_tree
173
 
 
174
292
    # TODO: This should be given a Transport, and should chdir up; otherwise
175
293
    # this will open a new connection.
176
294
    def _make_tail(self, url):
177
 
        head, tail = urlutils.split(url)
178
 
        if tail and tail != '.':
179
 
            t = bzrlib.transport.get_transport(head)
180
 
            try:
181
 
                t.mkdir(tail)
182
 
            except errors.FileExists:
183
 
                pass
 
295
        t = get_transport(url)
 
296
        t.ensure_base()
184
297
 
185
 
    # TODO: Should take a Transport
186
298
    @classmethod
187
 
    def create(cls, base):
 
299
    def create(cls, base, format=None, possible_transports=None):
188
300
        """Create a new BzrDir at the url 'base'.
189
 
        
190
 
        This will call the current default formats initialize with base
191
 
        as the only parameter.
192
301
 
193
 
        If you need a specific format, consider creating an instance
194
 
        of that and calling initialize().
 
302
        :param format: If supplied, the format of branch to create.  If not
 
303
            supplied, the default is used.
 
304
        :param possible_transports: If supplied, a list of transports that
 
305
            can be reused to share a remote connection.
195
306
        """
196
307
        if cls is not BzrDir:
197
 
            raise AssertionError("BzrDir.create always creates the default format, "
198
 
                    "not one of %r" % cls)
199
 
        head, tail = urlutils.split(base)
200
 
        if tail and tail != '.':
201
 
            t = bzrlib.transport.get_transport(head)
202
 
            try:
203
 
                t.mkdir(tail)
204
 
            except errors.FileExists:
205
 
                pass
206
 
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
 
308
            raise AssertionError("BzrDir.create always creates the default"
 
309
                " format, not one of %r" % cls)
 
310
        t = get_transport(base, possible_transports)
 
311
        t.ensure_base()
 
312
        if format is None:
 
313
            format = BzrDirFormat.get_default_format()
 
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)
207
392
 
208
393
    def create_branch(self):
209
394
        """Create a branch in this BzrDir.
210
395
 
211
 
        The bzrdirs format will control what branch format is created.
 
396
        The bzrdir's format will control what branch format is created.
212
397
        For more control see BranchFormatXX.create(a_bzrdir).
213
398
        """
214
399
        raise NotImplementedError(self.create_branch)
215
400
 
 
401
    def destroy_branch(self):
 
402
        """Destroy the branch in this BzrDir"""
 
403
        raise NotImplementedError(self.destroy_branch)
 
404
 
216
405
    @staticmethod
217
 
    def create_branch_and_repo(base, force_new_repo=False):
 
406
    def create_branch_and_repo(base, force_new_repo=False, format=None):
218
407
        """Create a new BzrDir, Branch and Repository at the url 'base'.
219
408
 
220
 
        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
221
411
        repository format that that uses via bzrdir.create_branch and
222
412
        create_repository. If a shared repository is available that is used
223
413
        preferentially.
226
416
 
227
417
        :param base: The URL to create the branch at.
228
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.
229
421
        """
230
 
        bzrdir = BzrDir.create(base)
 
422
        bzrdir = BzrDir.create(base, format)
231
423
        bzrdir._find_or_create_repository(force_new_repo)
232
424
        return bzrdir.create_branch()
233
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
 
234
487
    def _find_or_create_repository(self, force_new_repo):
235
488
        """Create a new repository if needed, returning the repository."""
236
 
        if force_new_repo:
237
 
            return self.create_repository()
238
 
        try:
239
 
            return self.find_repository()
240
 
        except errors.NoRepositoryPresent:
241
 
            return self.create_repository()
242
 
        
 
489
        policy = self.determine_repository_policy(force_new_repo)
 
490
        return policy.acquire_repository()[0]
 
491
 
243
492
    @staticmethod
244
493
    def create_branch_convenience(base, force_new_repo=False,
245
 
                                  force_new_tree=None, format=None):
 
494
                                  force_new_tree=None, format=None,
 
495
                                  possible_transports=None):
246
496
        """Create a new BzrDir, Branch and Repository at the url 'base'.
247
497
 
248
498
        This is a convenience function - it will use an existing repository
249
499
        if possible, can be told explicitly whether to create a working tree or
250
500
        not.
251
501
 
252
 
        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
253
504
        repository format that that uses via bzrdir.create_branch and
254
505
        create_repository. If a shared repository is available that is used
255
506
        preferentially. Whatever repository is used, its tree creation policy
257
508
 
258
509
        The created Branch object is returned.
259
510
        If a working tree cannot be made due to base not being a file:// url,
260
 
        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
261
512
        data is created on disk and NotLocalUrl is raised.
262
513
 
263
514
        :param base: The URL to create the branch at.
264
515
        :param force_new_repo: If True a new repository is always created.
265
 
        :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
266
517
                               prevent such creation respectively.
267
 
        :param format: Override for the for the bzrdir format to create
 
518
        :param format: Override for the bzrdir format to create.
 
519
        :param possible_transports: An optional reusable transports list.
268
520
        """
269
521
        if force_new_tree:
270
522
            # check for non local urls
271
 
            t = get_transport(safe_unicode(base))
272
 
            if not isinstance(t, LocalTransport):
 
523
            t = get_transport(base, possible_transports)
 
524
            if not isinstance(t, local.LocalTransport):
273
525
                raise errors.NotLocalUrl(base)
274
 
        if format is None:
275
 
            bzrdir = BzrDir.create(base)
276
 
        else:
277
 
            bzrdir = format.initialize(base)
 
526
        bzrdir = BzrDir.create(base, format, possible_transports)
278
527
        repo = bzrdir._find_or_create_repository(force_new_repo)
279
528
        result = bzrdir.create_branch()
280
 
        if force_new_tree or (repo.make_working_trees() and 
 
529
        if force_new_tree or (repo.make_working_trees() and
281
530
                              force_new_tree is None):
282
531
            try:
283
532
                bzrdir.create_workingtree()
284
533
            except errors.NotLocalUrl:
285
534
                pass
286
535
        return result
287
 
        
288
 
    @staticmethod
289
 
    def create_repository(base, shared=False):
290
 
        """Create a new BzrDir and Repository at the url 'base'.
291
 
 
292
 
        This will use the current default BzrDirFormat, and use whatever 
293
 
        repository format that that uses for bzrdirformat.create_repository.
294
 
 
295
 
        ;param shared: Create a shared repository rather than a standalone
296
 
                       repository.
297
 
        The Repository object is returned.
298
 
 
299
 
        This must be overridden as an instance method in child classes, where
300
 
        it should take no parameters and construct whatever repository format
301
 
        that child class desires.
302
 
        """
303
 
        bzrdir = BzrDir.create(base)
304
 
        return bzrdir.create_repository(shared)
305
 
 
306
 
    @staticmethod
307
 
    def create_standalone_workingtree(base):
 
536
 
 
537
    @staticmethod
 
538
    def create_standalone_workingtree(base, format=None):
308
539
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
309
540
 
310
541
        'base' must be a local path or a file:// url.
311
542
 
312
 
        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
313
545
        repository format that that uses for bzrdirformat.create_workingtree,
314
546
        create_branch and create_repository.
315
547
 
316
 
        The WorkingTree object is returned.
 
548
        :param format: Override for the bzrdir format to create.
 
549
        :return: The WorkingTree object.
317
550
        """
318
 
        t = get_transport(safe_unicode(base))
319
 
        if not isinstance(t, LocalTransport):
 
551
        t = get_transport(base)
 
552
        if not isinstance(t, local.LocalTransport):
320
553
            raise errors.NotLocalUrl(base)
321
 
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
322
 
                                               force_new_repo=True).bzrdir
 
554
        bzrdir = BzrDir.create_branch_and_repo(base,
 
555
                                               force_new_repo=True,
 
556
                                               format=format).bzrdir
323
557
        return bzrdir.create_workingtree()
324
558
 
325
 
    def create_workingtree(self, revision_id=None):
 
559
    def create_workingtree(self, revision_id=None, from_branch=None,
 
560
        accelerator_tree=None, hardlink=False):
326
561
        """Create a working tree at this BzrDir.
327
 
        
328
 
        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.
329
569
        """
330
570
        raise NotImplementedError(self.create_workingtree)
331
571
 
 
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):
 
595
        """Permanently disable the bzrdir.
 
596
 
 
597
        This is done by renaming it to give the user some ability to recover
 
598
        if there was a problem.
 
599
 
 
600
        This will have horrible consequences if anyone has anything locked or
 
601
        in use.
 
602
        :param limit: number of times to retry
 
603
        """
 
604
        i  = 0
 
605
        while True:
 
606
            try:
 
607
                to_path = '.bzr.retired.%d' % i
 
608
                self.root_transport.rename('.bzr', to_path)
 
609
                note("renamed %s to %s"
 
610
                    % (self.root_transport.abspath('.bzr'), to_path))
 
611
                return
 
612
            except (errors.TransportError, IOError, errors.PathError):
 
613
                i += 1
 
614
                if i > limit:
 
615
                    raise
 
616
                else:
 
617
                    pass
 
618
 
 
619
    def destroy_workingtree(self):
 
620
        """Destroy the working tree at this BzrDir.
 
621
 
 
622
        Formats that do not support this may raise UnsupportedOperation.
 
623
        """
 
624
        raise NotImplementedError(self.destroy_workingtree)
 
625
 
 
626
    def destroy_workingtree_metadata(self):
 
627
        """Destroy the control files for the working tree at this BzrDir.
 
628
 
 
629
        The contents of working tree files are not affected.
 
630
        Formats that do not support this may raise UnsupportedOperation.
 
631
        """
 
632
        raise NotImplementedError(self.destroy_workingtree_metadata)
 
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
 
332
663
    def find_repository(self):
333
 
        """Find the repository that should be used for a_bzrdir.
 
664
        """Find the repository that should be used.
334
665
 
335
666
        This does not require a branch as we use it to find the repo for
336
667
        new branches as well as to hook existing branches up to their
337
668
        repository.
338
669
        """
339
 
        try:
340
 
            return self.open_repository()
341
 
        except errors.NoRepositoryPresent:
342
 
            pass
343
 
        next_transport = self.root_transport.clone('..')
344
 
        while True:
345
 
            # find the next containing bzrdir
346
 
            try:
347
 
                found_bzrdir = BzrDir.open_containing_from_transport(
348
 
                    next_transport)[0]
349
 
            except errors.NotBranchError:
350
 
                # none found
351
 
                raise errors.NoRepositoryPresent(self)
 
670
        def usable_repository(found_bzrdir):
352
671
            # does it have a repository ?
353
672
            try:
354
673
                repository = found_bzrdir.open_repository()
355
674
            except errors.NoRepositoryPresent:
356
 
                next_transport = found_bzrdir.root_transport.clone('..')
357
 
                if (found_bzrdir.root_transport.base == next_transport.base):
358
 
                    # top of the file system
359
 
                    break
360
 
                else:
361
 
                    continue
362
 
            if ((found_bzrdir.root_transport.base == 
363
 
                 self.root_transport.base) or repository.is_shared()):
364
 
                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
365
680
            else:
366
 
                raise errors.NoRepositoryPresent(self)
367
 
        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
 
687
 
 
688
    def get_branch_reference(self):
 
689
        """Return the referenced URL for the branch in this bzrdir.
 
690
 
 
691
        :raises NotBranchError: If there is no Branch.
 
692
        :return: The URL the branch in this bzrdir references if it is a
 
693
            reference branch, or None for regular branches.
 
694
        """
 
695
        return None
368
696
 
369
697
    def get_branch_transport(self, branch_format):
370
698
        """Get the transport for use by branch format in this BzrDir.
373
701
        IncompatibleFormat if the branch format they are given has
374
702
        a format string, and vice versa.
375
703
 
376
 
        If branch_format is None, the transport is returned with no 
377
 
        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
378
706
        guaranteed to point to an existing directory ready for use.
379
707
        """
380
708
        raise NotImplementedError(self.get_branch_transport)
381
 
        
 
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
 
382
754
    def get_repository_transport(self, repository_format):
383
755
        """Get the transport for use by repository format in this BzrDir.
384
756
 
386
758
        IncompatibleFormat if the repository format they are given has
387
759
        a format string, and vice versa.
388
760
 
389
 
        If repository_format is None, the transport is returned with no 
390
 
        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
391
763
        guaranteed to point to an existing directory ready for use.
392
764
        """
393
765
        raise NotImplementedError(self.get_repository_transport)
394
 
        
 
766
 
395
767
    def get_workingtree_transport(self, tree_format):
396
768
        """Get the transport for use by workingtree format in this BzrDir.
397
769
 
398
770
        Note that bzr dirs that do not support format strings will raise
399
 
        IncompatibleFormat if the workingtree format they are given has
400
 
        a format string, and vice versa.
 
771
        IncompatibleFormat if the workingtree format they are given has a
 
772
        format string, and vice versa.
401
773
 
402
 
        If workingtree_format is None, the transport is returned with no 
403
 
        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
404
776
        guaranteed to point to an existing directory ready for use.
405
777
        """
406
778
        raise NotImplementedError(self.get_workingtree_transport)
407
 
        
 
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
 
408
788
    def __init__(self, _transport, _format):
409
789
        """Initialize a Bzr control dir object.
410
 
        
 
790
 
411
791
        Only really common logic should reside here, concrete classes should be
412
792
        made with varying behaviours.
413
793
 
417
797
        self._format = _format
418
798
        self.transport = _transport.clone('.bzr')
419
799
        self.root_transport = _transport
 
800
        self._mode_check_done = False
420
801
 
421
802
    def is_control_filename(self, filename):
422
803
        """True if filename is the name of a path which is reserved for bzrdir's.
423
 
        
 
804
 
424
805
        :param filename: A filename within the root transport of this bzrdir.
425
806
 
426
807
        This is true IF and ONLY IF the filename is part of the namespace reserved
429
810
        this in the future - for instance to make bzr talk with svn working
430
811
        trees.
431
812
        """
432
 
        # this might be better on the BzrDirFormat class because it refers to 
433
 
        # all the possible bzrdir disk formats. 
434
 
        # This method is tested via the workingtree is_control_filename tests- 
435
 
        # it was extracted from WorkingTree.is_control_filename. If the methods
436
 
        # 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
437
818
        # add new tests for it to the appropriate place.
438
819
        return filename == '.bzr' or filename.startswith('.bzr/')
439
820
 
440
821
    def needs_format_conversion(self, format=None):
441
822
        """Return true if this bzrdir needs convert_format run on it.
442
 
        
443
 
        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
444
825
        branch and working tree are not, this should return True.
445
826
 
446
827
        :param format: Optional parameter indicating a specific desired
452
833
    def open_unsupported(base):
453
834
        """Open a branch which is not supported."""
454
835
        return BzrDir.open(base, _unsupported=True)
455
 
        
456
 
    @staticmethod
457
 
    def open(base, _unsupported=False):
458
 
        """Open an existing bzrdir, rooted at 'base' (url)
459
 
        
460
 
        _unsupported is a private parameter to the BzrDir class.
461
 
        """
462
 
        t = get_transport(base)
463
 
        mutter("trying to open %r with transport %r", base, t)
464
 
        format = BzrDirFormat.find_format(t)
 
836
 
 
837
    @staticmethod
 
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.
 
842
        """
 
843
        t = get_transport(base, possible_transports=possible_transports)
 
844
        return BzrDir.open_from_transport(t, _unsupported=_unsupported)
 
845
 
 
846
    @staticmethod
 
847
    def open_from_transport(transport, _unsupported=False,
 
848
                            _server_formats=True):
 
849
        """Open a bzrdir within a particular directory.
 
850
 
 
851
        :param transport: Transport containing the bzrdir.
 
852
        :param _unsupported: private.
 
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.
 
858
        base = transport.base
 
859
        def find_format(transport):
 
860
            return transport, BzrDirFormat.find_format(
 
861
                transport, _server_formats=_server_formats)
 
862
 
 
863
        def redirected(transport, e, redirection_notice):
 
864
            redirected_transport = transport._redirected_to(e.source, e.target)
 
865
            if redirected_transport is None:
 
866
                raise errors.NotBranchError(base)
 
867
            note('%s is%s redirected to %s',
 
868
                 transport.base, e.permanently, redirected_transport.base)
 
869
            return redirected_transport
 
870
 
 
871
        try:
 
872
            transport, format = do_catching_redirections(find_format,
 
873
                                                         transport,
 
874
                                                         redirected)
 
875
        except errors.TooManyRedirections:
 
876
            raise errors.NotBranchError(base)
 
877
 
465
878
        BzrDir._check_supported(format, _unsupported)
466
 
        return format.open(t, _found=True)
 
879
        return format.open(transport, _found=True)
467
880
 
468
 
    def open_branch(self, unsupported=False):
 
881
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
469
882
        """Open the branch object at this BzrDir if one is present.
470
883
 
471
884
        If unsupported is True, then no longer supported branch formats can
472
885
        still be opened.
473
 
        
 
886
 
474
887
        TODO: static convenience version of this?
475
888
        """
476
889
        raise NotImplementedError(self.open_branch)
477
890
 
478
891
    @staticmethod
479
 
    def open_containing(url):
 
892
    def open_containing(url, possible_transports=None):
480
893
        """Open an existing branch which contains url.
481
 
        
 
894
 
482
895
        :param url: url to search from.
483
896
        See open_containing_from_transport for more detail.
484
897
        """
485
 
        return BzrDir.open_containing_from_transport(get_transport(url))
486
 
    
 
898
        transport = get_transport(url, possible_transports)
 
899
        return BzrDir.open_containing_from_transport(transport)
 
900
 
487
901
    @staticmethod
488
902
    def open_containing_from_transport(a_transport):
489
 
        """Open an existing branch which contains a_transport.base
 
903
        """Open an existing branch which contains a_transport.base.
490
904
 
491
905
        This probes for a branch at a_transport, and searches upwards from there.
492
906
 
493
907
        Basically we keep looking up until we find the control directory or
494
908
        run into the root.  If there isn't one, raises NotBranchError.
495
 
        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
496
910
        format, UnknownFormatError or UnsupportedFormatError are raised.
497
911
        If there is one, it is returned, along with the unused portion of url.
498
912
 
499
 
        :return: The BzrDir that contains the path, and a Unicode path 
 
913
        :return: The BzrDir that contains the path, and a Unicode path
500
914
                for the rest of the URL.
501
915
        """
502
916
        # this gets the normalised url back. I.e. '.' -> the full path.
503
917
        url = a_transport.base
504
918
        while True:
505
919
            try:
506
 
                format = BzrDirFormat.find_format(a_transport)
507
 
                BzrDir._check_supported(format, False)
508
 
                return format.open(a_transport), urlutils.unescape(a_transport.relpath(url))
 
920
                result = BzrDir.open_from_transport(a_transport)
 
921
                return result, urlutils.unescape(a_transport.relpath(url))
509
922
            except errors.NotBranchError, e:
510
 
                ## mutter('not a branch in: %r %s', a_transport.base, e)
511
923
                pass
512
 
            new_t = a_transport.clone('..')
 
924
            try:
 
925
                new_t = a_transport.clone('..')
 
926
            except errors.InvalidURLJoin:
 
927
                # reached the root, whatever that may be
 
928
                raise errors.NotBranchError(path=url)
513
929
            if new_t.base == a_transport.base:
514
930
                # reached the root, whatever that may be
515
931
                raise errors.NotBranchError(path=url)
516
932
            a_transport = new_t
517
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
 
 
962
    @classmethod
 
963
    def open_containing_tree_or_branch(klass, location):
 
964
        """Return the branch and working tree contained by a location.
 
965
 
 
966
        Returns (tree, branch, relpath).
 
967
        If there is no tree at containing the location, tree will be None.
 
968
        If there is no branch containing the location, an exception will be
 
969
        raised
 
970
        relpath is the portion of the path that is contained by the branch.
 
971
        """
 
972
        bzrdir, relpath = klass.open_containing(location)
 
973
        tree, branch = bzrdir._get_tree_branch()
 
974
        return tree, branch, relpath
 
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
 
518
1001
    def open_repository(self, _unsupported=False):
519
1002
        """Open the repository object at this BzrDir if one is present.
520
1003
 
521
 
        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
522
1005
        open facility. Most client code should use open_branch().repository to
523
1006
        get at a repository.
524
1007
 
525
 
        _unsupported is a private parameter, not part of the api.
 
1008
        :param _unsupported: a private parameter, not part of the api.
526
1009
        TODO: static convenience version of this?
527
1010
        """
528
1011
        raise NotImplementedError(self.open_repository)
529
1012
 
530
 
    def open_workingtree(self, _unsupported=False):
 
1013
    def open_workingtree(self, _unsupported=False,
 
1014
                         recommend_upgrade=True, from_branch=None):
531
1015
        """Open the workingtree object at this BzrDir if one is present.
532
 
        
533
 
        TODO: static convenience version of this?
 
1016
 
 
1017
        :param recommend_upgrade: Optional keyword parameter, when True (the
 
1018
            default), emit through the ui module a recommendation that the user
 
1019
            upgrade the working tree when the workingtree being opened is old
 
1020
            (but still fully supported).
 
1021
        :param from_branch: override bzrdir branch (for lightweight checkouts)
534
1022
        """
535
1023
        raise NotImplementedError(self.open_workingtree)
536
1024
 
537
1025
    def has_branch(self):
538
1026
        """Tell if this bzrdir contains a branch.
539
 
        
 
1027
 
540
1028
        Note: if you're going to open the branch, you should just go ahead
541
 
        and try, and not ask permission first.  (This method just opens the 
542
 
        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.)
543
1031
        """
544
1032
        try:
545
1033
            self.open_branch()
552
1040
 
553
1041
        This will still raise an exception if the bzrdir has a workingtree that
554
1042
        is remote & inaccessible.
555
 
        
 
1043
 
556
1044
        Note: if you're going to open the working tree, you should just go ahead
557
 
        and try, and not ask permission first.  (This method just opens the 
558
 
        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.)
559
1047
        """
560
1048
        try:
561
 
            self.open_workingtree()
 
1049
            self.open_workingtree(recommend_upgrade=False)
562
1050
            return True
563
1051
        except errors.NoWorkingTree:
564
1052
            return False
565
1053
 
566
 
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
 
1054
    def _cloning_metadir(self):
 
1055
        """Produce a metadir suitable for cloning with.
 
1056
 
 
1057
        :returns: (destination_bzrdir_format, source_repository)
 
1058
        """
 
1059
        result_format = self._format.__class__()
 
1060
        try:
 
1061
            try:
 
1062
                branch = self.open_branch(ignore_fallbacks=True)
 
1063
                source_repository = branch.repository
 
1064
                result_format._branch_format = branch._format
 
1065
            except errors.NotBranchError:
 
1066
                source_branch = None
 
1067
                source_repository = self.open_repository()
 
1068
        except errors.NoRepositoryPresent:
 
1069
            source_repository = None
 
1070
        else:
 
1071
            # XXX TODO: This isinstance is here because we have not implemented
 
1072
            # the fix recommended in bug # 103195 - to delegate this choice the
 
1073
            # repository itself.
 
1074
            repo_format = source_repository._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
 
1079
        try:
 
1080
            # TODO: Couldn't we just probe for the format in these cases,
 
1081
            # rather than opening the whole tree?  It would be a little
 
1082
            # faster. mbp 20070401
 
1083
            tree = self.open_workingtree(recommend_upgrade=False)
 
1084
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
1085
            result_format.workingtree_format = None
 
1086
        else:
 
1087
            result_format.workingtree_format = tree._format.__class__()
 
1088
        return result_format, source_repository
 
1089
 
 
1090
    def cloning_metadir(self, require_stacking=False):
 
1091
        """Produce a metadir suitable for cloning or sprouting with.
 
1092
 
 
1093
        These operations may produce workingtrees (yes, even though they're
 
1094
        "cloning" something that doesn't have a tree), so a viable workingtree
 
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.
 
1102
        """
 
1103
        format, repository = self._cloning_metadir()
 
1104
        if format._workingtree_format is None:
 
1105
            # No tree in self.
 
1106
            if repository is None:
 
1107
                # No repository either
 
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).
 
1111
            tree_format = repository._format._matchingbzrdir.workingtree_format
 
1112
            format.workingtree_format = tree_format.__class__()
 
1113
        if require_stacking:
 
1114
            format.require_stacking()
 
1115
        return format
 
1116
 
 
1117
    def checkout_metadir(self):
 
1118
        return self.cloning_metadir()
 
1119
 
 
1120
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
1121
               recurse='down', possible_transports=None,
 
1122
               accelerator_tree=None, hardlink=False, stacked=False,
 
1123
               source_branch=None, create_tree_if_local=True):
567
1124
        """Create a copy of this bzrdir prepared for use as a new line of
568
1125
        development.
569
1126
 
570
 
        If urls last component does not exist, it will be created.
 
1127
        If url's last component does not exist, it will be created.
571
1128
 
572
1129
        Attributes related to the identity of the source branch like
573
1130
        branch nickname will be cleaned, a working tree is created
576
1133
 
577
1134
        if revision_id is not None, then the clone operation may tune
578
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.
579
1146
        """
580
 
        self._make_tail(url)
581
 
        result = self._format.initialize(url)
582
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
583
 
        try:
584
 
            source_branch = self.open_branch()
 
1147
        target_transport = get_transport(url, possible_transports)
 
1148
        target_transport.ensure_base()
 
1149
        cloning_format = self.cloning_metadir(stacked)
 
1150
        # Create/update the result branch
 
1151
        result = cloning_format.initialize_on_transport(target_transport)
 
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
585
1158
            source_repository = source_branch.repository
 
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:
 
1183
                result_repo.fetch(source_repository, 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()
 
1192
        else:
 
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)
 
1203
            wt.lock_write()
 
1204
            try:
 
1205
                if wt.path2id('') is None:
 
1206
                    try:
 
1207
                        wt.set_root_id(self.open_workingtree.get_root_id())
 
1208
                    except errors.NoWorkingTree:
 
1209
                        pass
 
1210
            finally:
 
1211
                wt.unlock()
 
1212
        else:
 
1213
            wt = None
 
1214
        if recurse == 'down':
 
1215
            if wt is not None:
 
1216
                basis = wt.basis_tree()
 
1217
                basis.lock_read()
 
1218
                subtrees = basis.iter_references()
 
1219
            elif result_branch is not None:
 
1220
                basis = result_branch.basis_tree()
 
1221
                basis.lock_read()
 
1222
                subtrees = basis.iter_references()
 
1223
            elif source_branch is not None:
 
1224
                basis = source_branch.basis_tree()
 
1225
                basis.lock_read()
 
1226
                subtrees = basis.iter_references()
 
1227
            else:
 
1228
                subtrees = []
 
1229
                basis = None
 
1230
            try:
 
1231
                for path, file_id in subtrees:
 
1232
                    target = urlutils.join(url, urlutils.escape(path))
 
1233
                    sublocation = source_branch.reference_parent(file_id, path)
 
1234
                    sublocation.bzrdir.sprout(target,
 
1235
                        basis.get_reference_revision(file_id, path),
 
1236
                        force_new_repo=force_new_repo, recurse=recurse,
 
1237
                        stacked=stacked)
 
1238
            finally:
 
1239
                if basis is not None:
 
1240
                    basis.unlock()
 
1241
        return result
 
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()
586
1251
        except errors.NotBranchError:
587
 
            source_branch = None
588
 
            try:
589
 
                source_repository = self.open_repository()
590
 
            except errors.NoRepositoryPresent:
591
 
                # copy the entire basis one if there is one
592
 
                # but there is no repository.
593
 
                source_repository = basis_repo
594
 
        if force_new_repo:
595
 
            result_repo = None
596
 
        else:
597
 
            try:
598
 
                result_repo = result.find_repository()
599
 
            except errors.NoRepositoryPresent:
600
 
                result_repo = None
601
 
        if source_repository is None and result_repo is not None:
602
 
            pass
603
 
        elif source_repository is None and result_repo is None:
604
 
            # no repo available, make a new one
605
 
            result.create_repository()
606
 
        elif source_repository is not None and result_repo is None:
607
 
            # have source, and want to make a new target repo
608
 
            # we don't clone the repo because that preserves attributes
609
 
            # like is_shared(), and we have not yet implemented a 
610
 
            # repository sprout().
611
 
            result_repo = result.create_repository()
612
 
        if result_repo is not None:
613
 
            # fetch needed content into target.
614
 
            if basis_repo:
615
 
                # XXX FIXME RBC 20060214 need tests for this when the basis
616
 
                # is incomplete
617
 
                result_repo.fetch(basis_repo, revision_id=revision_id)
618
 
            result_repo.fetch(source_repository, revision_id=revision_id)
619
 
        if source_branch is not None:
620
 
            source_branch.sprout(result, revision_id=revision_id)
621
 
        else:
622
 
            result.create_branch()
623
 
        # TODO: jam 20060426 we probably need a test in here in the
624
 
        #       case that the newly sprouted branch is a remote one
625
 
        if result_repo is None or result_repo.make_working_trees():
626
 
            result.create_workingtree()
627
 
        return result
 
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()
628
1316
 
629
1317
 
630
1318
class BzrDirPreSplitOut(BzrDir):
633
1321
    def __init__(self, _transport, _format):
634
1322
        """See BzrDir.__init__."""
635
1323
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
636
 
        assert self._format._lock_class == TransportLock
637
 
        assert self._format._lock_file_name == 'branch-lock'
638
 
        self._control_files = LockableFiles(self.get_branch_transport(None),
 
1324
        self._control_files = lockable_files.LockableFiles(
 
1325
                                            self.get_branch_transport(None),
639
1326
                                            self._format._lock_file_name,
640
1327
                                            self._format._lock_class)
641
1328
 
643
1330
        """Pre-splitout bzrdirs do not suffer from stale locks."""
644
1331
        raise NotImplementedError(self.break_lock)
645
1332
 
646
 
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
647
 
        """See BzrDir.clone()."""
648
 
        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
        """
649
1348
        self._make_tail(url)
650
1349
        result = self._format._initialize_for_clone(url)
651
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
652
 
        self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
 
1350
        self.open_repository().clone(result, revision_id=revision_id)
653
1351
        from_branch = self.open_branch()
654
1352
        from_branch.clone(result, revision_id=revision_id)
655
1353
        try:
656
 
            self.open_workingtree().clone(result, basis=basis_tree)
 
1354
            tree = self.open_workingtree()
657
1355
        except errors.NotLocalUrl:
658
1356
            # make a new one, this format always has to have one.
659
 
            try:
660
 
                WorkingTreeFormat2().initialize(result)
661
 
            except errors.NotLocalUrl:
662
 
                # but we cannot do it for remote trees.
663
 
                to_branch = result.open_branch()
664
 
                WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
 
1357
            result._init_workingtree()
 
1358
        else:
 
1359
            tree.clone(result)
665
1360
        return result
666
1361
 
667
1362
    def create_branch(self):
668
1363
        """See BzrDir.create_branch."""
669
 
        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)
670
1369
 
671
1370
    def create_repository(self, shared=False):
672
1371
        """See BzrDir.create_repository."""
674
1373
            raise errors.IncompatibleFormat('shared repository', self._format)
675
1374
        return self.open_repository()
676
1375
 
677
 
    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):
678
1382
        """See BzrDir.create_workingtree."""
 
1383
        # The workingtree is sometimes created when the bzrdir is created,
 
1384
        # but not when cloning.
 
1385
 
679
1386
        # this looks buggy but is not -really-
 
1387
        # because this format creates the workingtree when the bzrdir is
 
1388
        # created
680
1389
        # clone and sprout will have set the revision_id
681
1390
        # and that will have set it for us, its only
682
1391
        # specific uses of create_workingtree in isolation
683
1392
        # that can do wonky stuff here, and that only
684
 
        # happens for creating checkouts, which cannot be 
 
1393
        # happens for creating checkouts, which cannot be
685
1394
        # done on this format anyway. So - acceptable wart.
686
 
        result = self.open_workingtree()
 
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()
687
1402
        if revision_id is not None:
688
 
            result.set_last_revision(revision_id)
 
1403
            if revision_id == _mod_revision.NULL_REVISION:
 
1404
                result.set_parent_ids([])
 
1405
            else:
 
1406
                result.set_parent_ids([revision_id])
689
1407
        return result
690
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
 
 
1419
    def destroy_workingtree(self):
 
1420
        """See BzrDir.destroy_workingtree."""
 
1421
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
 
1422
 
 
1423
    def destroy_workingtree_metadata(self):
 
1424
        """See BzrDir.destroy_workingtree_metadata."""
 
1425
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
 
1426
                                          self)
 
1427
 
691
1428
    def get_branch_transport(self, branch_format):
692
1429
        """See BzrDir.get_branch_transport()."""
693
1430
        if branch_format is None:
723
1460
        # if the format is not the same as the system default,
724
1461
        # an upgrade is needed.
725
1462
        if format is None:
 
1463
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
1464
                % 'needs_format_conversion(format=None)')
726
1465
            format = BzrDirFormat.get_default_format()
727
1466
        return not isinstance(self._format, format.__class__)
728
1467
 
729
 
    def open_branch(self, unsupported=False):
 
1468
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
730
1469
        """See BzrDir.open_branch."""
731
1470
        from bzrlib.branch import BzrBranchFormat4
732
1471
        format = BzrBranchFormat4()
733
1472
        self._check_supported(format, unsupported)
734
1473
        return format.open(self, _found=True)
735
1474
 
736
 
    def sprout(self, url, revision_id=None, basis=None):
 
1475
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
1476
               possible_transports=None, accelerator_tree=None,
 
1477
               hardlink=False, stacked=False, create_tree_if_local=True,
 
1478
               source_branch=None):
737
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)
738
1492
        from bzrlib.workingtree import WorkingTreeFormat2
739
1493
        self._make_tail(url)
740
1494
        result = self._format._initialize_for_clone(url)
741
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
742
1495
        try:
743
 
            self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
 
1496
            self.open_repository().clone(result, revision_id=revision_id)
744
1497
        except errors.NoRepositoryPresent:
745
1498
            pass
746
1499
        try:
747
1500
            self.open_branch().sprout(result, revision_id=revision_id)
748
1501
        except errors.NotBranchError:
749
1502
            pass
 
1503
 
750
1504
        # we always want a working tree
751
 
        WorkingTreeFormat2().initialize(result)
 
1505
        WorkingTreeFormat2().initialize(result,
 
1506
                                        accelerator_tree=accelerator_tree,
 
1507
                                        hardlink=hardlink)
752
1508
        return result
753
1509
 
754
1510
 
755
1511
class BzrDir4(BzrDirPreSplitOut):
756
1512
    """A .bzr version 4 control object.
757
 
    
 
1513
 
758
1514
    This is a deprecated format and may be removed after sept 2006.
759
1515
    """
760
1516
 
764
1520
 
765
1521
    def needs_format_conversion(self, format=None):
766
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)')
767
1526
        return True
768
1527
 
769
1528
    def open_repository(self):
770
1529
        """See BzrDir.open_repository."""
771
 
        from bzrlib.repository import RepositoryFormat4
 
1530
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
772
1531
        return RepositoryFormat4().open(self, _found=True)
773
1532
 
774
1533
 
780
1539
 
781
1540
    def open_repository(self):
782
1541
        """See BzrDir.open_repository."""
783
 
        from bzrlib.repository import RepositoryFormat5
 
1542
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
784
1543
        return RepositoryFormat5().open(self, _found=True)
785
1544
 
786
 
    def open_workingtree(self, _unsupported=False):
 
1545
    def open_workingtree(self, _unsupported=False,
 
1546
            recommend_upgrade=True):
787
1547
        """See BzrDir.create_workingtree."""
788
1548
        from bzrlib.workingtree import WorkingTreeFormat2
789
 
        return WorkingTreeFormat2().open(self, _found=True)
 
1549
        wt_format = WorkingTreeFormat2()
 
1550
        # we don't warn here about upgrades; that ought to be handled for the
 
1551
        # bzrdir as a whole
 
1552
        return wt_format.open(self, _found=True)
790
1553
 
791
1554
 
792
1555
class BzrDir6(BzrDirPreSplitOut):
797
1560
 
798
1561
    def open_repository(self):
799
1562
        """See BzrDir.open_repository."""
800
 
        from bzrlib.repository import RepositoryFormat6
 
1563
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
801
1564
        return RepositoryFormat6().open(self, _found=True)
802
1565
 
803
 
    def open_workingtree(self, _unsupported=False):
 
1566
    def open_workingtree(self, _unsupported=False,
 
1567
        recommend_upgrade=True):
804
1568
        """See BzrDir.create_workingtree."""
 
1569
        # we don't warn here about upgrades; that ought to be handled for the
 
1570
        # bzrdir as a whole
805
1571
        from bzrlib.workingtree import WorkingTreeFormat2
806
1572
        return WorkingTreeFormat2().open(self, _found=True)
807
1573
 
808
1574
 
809
1575
class BzrDirMeta1(BzrDir):
810
1576
    """A .bzr meta version 1 control object.
811
 
    
812
 
    This is the first control object where the 
 
1577
 
 
1578
    This is the first control object where the
813
1579
    individual aspects are really split out: there are separate repository,
814
1580
    workingtree and branch subdirectories and any subset of the three can be
815
1581
    present within a BzrDir.
821
1587
 
822
1588
    def create_branch(self):
823
1589
        """See BzrDir.create_branch."""
824
 
        from bzrlib.branch import BranchFormat
825
 
        return BranchFormat.get_default_format().initialize(self)
 
1590
        return self._format.get_branch_format().initialize(self)
 
1591
 
 
1592
    def destroy_branch(self):
 
1593
        """See BzrDir.create_branch."""
 
1594
        self.transport.delete_tree('branch')
826
1595
 
827
1596
    def create_repository(self, shared=False):
828
1597
        """See BzrDir.create_repository."""
829
1598
        return self._format.repository_format.initialize(self, shared)
830
1599
 
831
 
    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):
832
1606
        """See BzrDir.create_workingtree."""
833
 
        from bzrlib.workingtree import WorkingTreeFormat
834
 
        return WorkingTreeFormat.get_default_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)
 
1610
 
 
1611
    def destroy_workingtree(self):
 
1612
        """See BzrDir.destroy_workingtree."""
 
1613
        wt = self.open_workingtree(recommend_upgrade=False)
 
1614
        repository = wt.branch.repository
 
1615
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
 
1616
        wt.revert(old_tree=empty)
 
1617
        self.destroy_workingtree_metadata()
 
1618
 
 
1619
    def destroy_workingtree_metadata(self):
 
1620
        self.transport.delete_tree('checkout')
 
1621
 
 
1622
    def find_branch_format(self):
 
1623
        """Find the branch 'format' for this bzrdir.
 
1624
 
 
1625
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
1626
        """
 
1627
        from bzrlib.branch import BranchFormat
 
1628
        return BranchFormat.find_format(self)
835
1629
 
836
1630
    def _get_mkdir_mode(self):
837
1631
        """Figure out the mode to use when creating a bzrdir subdir."""
838
 
        temp_control = LockableFiles(self.transport, '', TransportLock)
 
1632
        temp_control = lockable_files.LockableFiles(self.transport, '',
 
1633
                                     lockable_files.TransportLock)
839
1634
        return temp_control._dir_mode
840
1635
 
 
1636
    def get_branch_reference(self):
 
1637
        """See BzrDir.get_branch_reference()."""
 
1638
        from bzrlib.branch import BranchFormat
 
1639
        format = BranchFormat.find_format(self)
 
1640
        return format.get_reference(self)
 
1641
 
841
1642
    def get_branch_transport(self, branch_format):
842
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
843
1646
        if branch_format is None:
844
1647
            return self.transport.clone('branch')
845
1648
        try:
883
1686
    def needs_format_conversion(self, format=None):
884
1687
        """See BzrDir.needs_format_conversion()."""
885
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:
886
1692
            format = BzrDirFormat.get_default_format()
887
1693
        if not isinstance(self._format, format.__class__):
888
1694
            # it is not a meta dir format, conversion is needed.
895
1701
                return True
896
1702
        except errors.NoRepositoryPresent:
897
1703
            pass
898
 
        # currently there are no other possible conversions for meta1 formats.
 
1704
        try:
 
1705
            if not isinstance(self.open_branch()._format,
 
1706
                              format.get_branch_format().__class__):
 
1707
                # the branch needs an upgrade.
 
1708
                return True
 
1709
        except errors.NotBranchError:
 
1710
            pass
 
1711
        try:
 
1712
            my_wt = self.open_workingtree(recommend_upgrade=False)
 
1713
            if not isinstance(my_wt._format,
 
1714
                              format.workingtree_format.__class__):
 
1715
                # the workingtree needs an upgrade.
 
1716
                return True
 
1717
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
1718
            pass
899
1719
        return False
900
1720
 
901
 
    def open_branch(self, unsupported=False):
 
1721
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
902
1722
        """See BzrDir.open_branch."""
903
 
        from bzrlib.branch import BranchFormat
904
 
        format = BranchFormat.find_format(self)
 
1723
        format = self.find_branch_format()
905
1724
        self._check_supported(format, unsupported)
906
 
        return format.open(self, _found=True)
 
1725
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
907
1726
 
908
1727
    def open_repository(self, unsupported=False):
909
1728
        """See BzrDir.open_repository."""
912
1731
        self._check_supported(format, unsupported)
913
1732
        return format.open(self, _found=True)
914
1733
 
915
 
    def open_workingtree(self, unsupported=False):
 
1734
    def open_workingtree(self, unsupported=False,
 
1735
            recommend_upgrade=True):
916
1736
        """See BzrDir.open_workingtree."""
917
1737
        from bzrlib.workingtree import WorkingTreeFormat
918
1738
        format = WorkingTreeFormat.find_format(self)
919
 
        self._check_supported(format, unsupported)
 
1739
        self._check_supported(format, unsupported,
 
1740
            recommend_upgrade,
 
1741
            basedir=self.root_transport.base)
920
1742
        return format.open(self, _found=True)
921
1743
 
 
1744
    def _get_config(self):
 
1745
        return config.TransportConfig(self.transport, 'control.conf')
 
1746
 
922
1747
 
923
1748
class BzrDirFormat(object):
924
1749
    """An encapsulation of the initialization and open routines for a format.
928
1753
     * a format string,
929
1754
     * an open routine.
930
1755
 
931
 
    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
932
1757
    during bzrdir opening. These should be subclasses of BzrDirFormat
933
1758
    for consistency.
934
1759
 
935
1760
    Once a format is deprecated, just deprecate the initialize and open
936
 
    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
937
1762
    object will be created every system load.
938
1763
    """
939
1764
 
945
1770
 
946
1771
    _control_formats = []
947
1772
    """The registered control formats - .bzr, ....
948
 
    
 
1773
 
 
1774
    This is a list of BzrDirFormat objects.
 
1775
    """
 
1776
 
 
1777
    _control_server_formats = []
 
1778
    """The registered control server formats, e.g. RemoteBzrDirs.
 
1779
 
949
1780
    This is a list of BzrDirFormat objects.
950
1781
    """
951
1782
 
955
1786
    # TransportLock or LockDir
956
1787
 
957
1788
    @classmethod
958
 
    def find_format(klass, transport):
 
1789
    def find_format(klass, transport, _server_formats=True):
959
1790
        """Return the format present at transport."""
960
 
        for format in klass._control_formats:
 
1791
        if _server_formats:
 
1792
            formats = klass._control_server_formats + klass._control_formats
 
1793
        else:
 
1794
            formats = klass._control_formats
 
1795
        for format in formats:
961
1796
            try:
962
1797
                return format.probe_transport(transport)
963
1798
            except errors.NotBranchError:
967
1802
 
968
1803
    @classmethod
969
1804
    def probe_transport(klass, transport):
970
 
        """Return the .bzrdir style transport present at URL."""
 
1805
        """Return the .bzrdir style format present in a directory."""
971
1806
        try:
972
1807
            format_string = transport.get(".bzr/branch-format").read()
973
1808
        except errors.NoSuchFile:
976
1811
        try:
977
1812
            return klass._formats[format_string]
978
1813
        except KeyError:
979
 
            raise errors.UnknownFormatError(format=format_string)
 
1814
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
980
1815
 
981
1816
    @classmethod
982
1817
    def get_default_format(klass):
1000
1835
        current default format. In the case of plugins we can/should provide
1001
1836
        some means for them to extend the range of returnable converters.
1002
1837
 
1003
 
        :param format: Optional format to override the default format of the 
 
1838
        :param format: Optional format to override the default format of the
1004
1839
                       library.
1005
1840
        """
1006
1841
        raise NotImplementedError(self.get_converter)
1007
1842
 
1008
 
    def initialize(self, url):
 
1843
    def initialize(self, url, possible_transports=None):
1009
1844
        """Create a bzr control dir at this url and return an opened copy.
1010
 
        
 
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
 
1011
1850
        Subclasses should typically override initialize_on_transport
1012
1851
        instead of this method.
1013
1852
        """
1014
 
        return self.initialize_on_transport(get_transport(url))
 
1853
        return self.initialize_on_transport(get_transport(url,
 
1854
                                                          possible_transports))
1015
1855
 
1016
1856
    def initialize_on_transport(self, transport):
1017
1857
        """Initialize a new bzrdir in the base directory of a Transport."""
1018
 
        # 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
1019
1978
        # mode from the root directory
1020
 
        temp_control = LockableFiles(transport, '', TransportLock)
 
1979
        temp_control = lockable_files.LockableFiles(transport,
 
1980
                            '', lockable_files.TransportLock)
1021
1981
        temp_control._transport.mkdir('.bzr',
1022
1982
                                      # FIXME: RBC 20060121 don't peek under
1023
1983
                                      # the covers
1024
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'))
1025
1987
        file_mode = temp_control._file_mode
1026
1988
        del temp_control
1027
 
        mutter('created control directory in ' + transport.base)
1028
 
        control = transport.clone('.bzr')
1029
 
        utf8_files = [('README', 
1030
 
                       "This is a Bazaar-NG control directory.\n"
1031
 
                       "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"),
1032
1994
                      ('branch-format', self.get_format_string()),
1033
1995
                      ]
1034
1996
        # NB: no need to escape relative paths that are url safe.
1035
 
        control_files = LockableFiles(control, self._lock_file_name, 
1036
 
                                      self._lock_class)
 
1997
        control_files = lockable_files.LockableFiles(bzrdir_transport,
 
1998
            self._lock_file_name, self._lock_class)
1037
1999
        control_files.create_lock()
1038
2000
        control_files.lock_write()
1039
2001
        try:
1040
 
            for file, content in utf8_files:
1041
 
                control_files.put_utf8(file, content)
 
2002
            for (filename, content) in utf8_files:
 
2003
                bzrdir_transport.put_bytes(filename, content,
 
2004
                    mode=file_mode)
1042
2005
        finally:
1043
2006
            control_files.unlock()
1044
2007
        return self.open(transport, _found=True)
1047
2010
        """Is this format supported?
1048
2011
 
1049
2012
        Supported formats must be initializable and openable.
1050
 
        Unsupported formats may not support initialization or committing or 
 
2013
        Unsupported formats may not support initialization or committing or
1051
2014
        some other features depending on the reason for not being supported.
1052
2015
        """
1053
2016
        return True
1054
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
 
 
2028
    def same_model(self, target_format):
 
2029
        return (self.repository_format.rich_root_data ==
 
2030
            target_format.rich_root_data)
 
2031
 
1055
2032
    @classmethod
1056
2033
    def known_formats(klass):
1057
2034
        """Return all the known formats.
1058
 
        
 
2035
 
1059
2036
        Concrete formats should override _known_formats.
1060
2037
        """
1061
 
        # There is double indirection here to make sure that control 
1062
 
        # 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
1063
2040
        # once. This can otherwise be quite expensive for remote connections.
1064
2041
        result = set()
1065
2042
        for format in klass._control_formats:
1066
2043
            result.update(format._known_formats())
1067
2044
        return result
1068
 
    
 
2045
 
1069
2046
    @classmethod
1070
2047
    def _known_formats(klass):
1071
2048
        """Return the known format instances for this control format."""
1073
2050
 
1074
2051
    def open(self, transport, _found=False):
1075
2052
        """Return an instance of this format for the dir transport points at.
1076
 
        
 
2053
 
1077
2054
        _found is a private parameter, do not use it.
1078
2055
        """
1079
2056
        if not _found:
1080
 
            assert isinstance(BzrDirFormat.find_format(transport),
1081
 
                              self.__class__)
 
2057
            found_format = BzrDirFormat.find_format(transport)
 
2058
            if not isinstance(found_format, self.__class__):
 
2059
                raise AssertionError("%s was asked to open %s, but it seems to need "
 
2060
                        "format %s"
 
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)
1082
2065
        return self._open(transport)
1083
2066
 
1084
2067
    def _open(self, transport):
1092
2075
    @classmethod
1093
2076
    def register_format(klass, format):
1094
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__)
1095
2080
 
1096
2081
    @classmethod
1097
2082
    def register_control_format(klass, format):
1098
 
        """Register a format that does not use '.bzrdir' for its control dir.
 
2083
        """Register a format that does not use '.bzr' for its control dir.
1099
2084
 
1100
2085
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1101
 
        which BzrDirFormat can inherit from, and renamed to register_format 
 
2086
        which BzrDirFormat can inherit from, and renamed to register_format
1102
2087
        there. It has been done without that for now for simplicity of
1103
2088
        implementation.
1104
2089
        """
1105
2090
        klass._control_formats.append(format)
1106
2091
 
1107
2092
    @classmethod
1108
 
    def set_default_format(klass, format):
 
2093
    def register_control_server_format(klass, format):
 
2094
        """Register a control format for client-server environments.
 
2095
 
 
2096
        These formats will be tried before ones registered with
 
2097
        register_control_format.  This gives implementations that decide to the
 
2098
        chance to grab it before anything looks at the contents of the format
 
2099
        file.
 
2100
        """
 
2101
        klass._control_server_formats.append(format)
 
2102
 
 
2103
    @classmethod
 
2104
    def _set_default_format(klass, format):
 
2105
        """Set default format (for testing behavior of defaults only)"""
1109
2106
        klass._default_format = format
1110
2107
 
1111
2108
    def __str__(self):
1112
 
        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
        """
1113
2123
 
1114
2124
    @classmethod
1115
2125
    def unregister_format(klass, format):
1116
 
        assert klass._formats[format.get_format_string()] is format
1117
2126
        del klass._formats[format.get_format_string()]
1118
2127
 
1119
2128
    @classmethod
1121
2130
        klass._control_formats.remove(format)
1122
2131
 
1123
2132
 
1124
 
# register BzrDirFormat as a control format
1125
 
BzrDirFormat.register_control_format(BzrDirFormat)
1126
 
 
1127
 
 
1128
2133
class BzrDirFormat4(BzrDirFormat):
1129
2134
    """Bzr dir format 4.
1130
2135
 
1138
2143
    removed in format 5; write support for this format has been removed.
1139
2144
    """
1140
2145
 
1141
 
    _lock_class = TransportLock
 
2146
    _lock_class = lockable_files.TransportLock
1142
2147
 
1143
2148
    def get_format_string(self):
1144
2149
        """See BzrDirFormat.get_format_string()."""
1152
2157
        """See BzrDirFormat.get_converter()."""
1153
2158
        # there is one and only one upgrade path here.
1154
2159
        return ConvertBzrDir4To5()
1155
 
        
 
2160
 
1156
2161
    def initialize_on_transport(self, transport):
1157
2162
        """Format 4 branches cannot be created."""
1158
2163
        raise errors.UninitializableFormat(self)
1161
2166
        """Format 4 is not supported.
1162
2167
 
1163
2168
        It is not supported because the model changed from 4 to 5 and the
1164
 
        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
1165
2170
        feasible.
1166
2171
        """
1167
2172
        return False
1168
2173
 
 
2174
    def network_name(self):
 
2175
        return self.get_format_string()
 
2176
 
1169
2177
    def _open(self, transport):
1170
2178
        """See BzrDirFormat._open."""
1171
2179
        return BzrDir4(transport, self)
1172
2180
 
1173
2181
    def __return_repository_format(self):
1174
2182
        """Circular import protection."""
1175
 
        from bzrlib.repository import RepositoryFormat4
1176
 
        return RepositoryFormat4(self)
 
2183
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
2184
        return RepositoryFormat4()
1177
2185
    repository_format = property(__return_repository_format)
1178
2186
 
1179
2187
 
1180
 
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):
1181
2214
    """Bzr control format 5.
1182
2215
 
1183
2216
    This format is a combined format for working tree, branch and repository.
1184
2217
    It has:
1185
 
     - Format 2 working trees [always] 
1186
 
     - Format 4 branches [always] 
 
2218
     - Format 2 working trees [always]
 
2219
     - Format 4 branches [always]
1187
2220
     - Format 5 repositories [always]
1188
2221
       Unhashed stores in the repository.
1189
2222
    """
1190
2223
 
1191
 
    _lock_class = TransportLock
 
2224
    _lock_class = lockable_files.TransportLock
1192
2225
 
1193
2226
    def get_format_string(self):
1194
2227
        """See BzrDirFormat.get_format_string()."""
1195
2228
        return "Bazaar-NG branch, format 5\n"
1196
2229
 
 
2230
    def get_branch_format(self):
 
2231
        from bzrlib import branch
 
2232
        return branch.BzrBranchFormat4()
 
2233
 
1197
2234
    def get_format_description(self):
1198
2235
        """See BzrDirFormat.get_format_description()."""
1199
2236
        return "All-in-one format 5"
1205
2242
 
1206
2243
    def _initialize_for_clone(self, url):
1207
2244
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1208
 
        
 
2245
 
1209
2246
    def initialize_on_transport(self, transport, _cloning=False):
1210
2247
        """Format 5 dirs always have working tree, branch and repository.
1211
 
        
 
2248
 
1212
2249
        Except when they are being cloned.
1213
2250
        """
1214
2251
        from bzrlib.branch import BzrBranchFormat4
1215
 
        from bzrlib.repository import RepositoryFormat5
1216
 
        from bzrlib.workingtree import WorkingTreeFormat2
 
2252
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1217
2253
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1218
2254
        RepositoryFormat5().initialize(result, _internal=True)
1219
2255
        if not _cloning:
1220
 
            BzrBranchFormat4().initialize(result)
1221
 
            WorkingTreeFormat2().initialize(result)
 
2256
            branch = BzrBranchFormat4().initialize(result)
 
2257
            result._init_workingtree()
1222
2258
        return result
1223
2259
 
 
2260
    def network_name(self):
 
2261
        return self.get_format_string()
 
2262
 
1224
2263
    def _open(self, transport):
1225
2264
        """See BzrDirFormat._open."""
1226
2265
        return BzrDir5(transport, self)
1227
2266
 
1228
2267
    def __return_repository_format(self):
1229
2268
        """Circular import protection."""
1230
 
        from bzrlib.repository import RepositoryFormat5
1231
 
        return RepositoryFormat5(self)
 
2269
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
2270
        return RepositoryFormat5()
1232
2271
    repository_format = property(__return_repository_format)
1233
2272
 
1234
2273
 
1235
 
class BzrDirFormat6(BzrDirFormat):
 
2274
class BzrDirFormat6(BzrDirFormatAllInOne):
1236
2275
    """Bzr control format 6.
1237
2276
 
1238
2277
    This format is a combined format for working tree, branch and repository.
1239
2278
    It has:
1240
 
     - Format 2 working trees [always] 
1241
 
     - Format 4 branches [always] 
 
2279
     - Format 2 working trees [always]
 
2280
     - Format 4 branches [always]
1242
2281
     - Format 6 repositories [always]
1243
2282
    """
1244
2283
 
1245
 
    _lock_class = TransportLock
 
2284
    _lock_class = lockable_files.TransportLock
1246
2285
 
1247
2286
    def get_format_string(self):
1248
2287
        """See BzrDirFormat.get_format_string()."""
1252
2291
        """See BzrDirFormat.get_format_description()."""
1253
2292
        return "All-in-one format 6"
1254
2293
 
 
2294
    def get_branch_format(self):
 
2295
        from bzrlib import branch
 
2296
        return branch.BzrBranchFormat4()
 
2297
 
1255
2298
    def get_converter(self, format=None):
1256
2299
        """See BzrDirFormat.get_converter()."""
1257
2300
        # there is one and only one upgrade path here.
1258
2301
        return ConvertBzrDir6ToMeta()
1259
 
        
 
2302
 
1260
2303
    def _initialize_for_clone(self, url):
1261
2304
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1262
2305
 
1263
2306
    def initialize_on_transport(self, transport, _cloning=False):
1264
2307
        """Format 6 dirs always have working tree, branch and repository.
1265
 
        
 
2308
 
1266
2309
        Except when they are being cloned.
1267
2310
        """
1268
2311
        from bzrlib.branch import BzrBranchFormat4
1269
 
        from bzrlib.repository import RepositoryFormat6
1270
 
        from bzrlib.workingtree import WorkingTreeFormat2
 
2312
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1271
2313
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1272
2314
        RepositoryFormat6().initialize(result, _internal=True)
1273
2315
        if not _cloning:
1274
 
            BzrBranchFormat4().initialize(result)
1275
 
            try:
1276
 
                WorkingTreeFormat2().initialize(result)
1277
 
            except errors.NotLocalUrl:
1278
 
                # emulate pre-check behaviour for working tree and silently 
1279
 
                # fail.
1280
 
                pass
 
2316
            branch = BzrBranchFormat4().initialize(result)
 
2317
            result._init_workingtree()
1281
2318
        return result
1282
2319
 
 
2320
    def network_name(self):
 
2321
        return self.get_format_string()
 
2322
 
1283
2323
    def _open(self, transport):
1284
2324
        """See BzrDirFormat._open."""
1285
2325
        return BzrDir6(transport, self)
1286
2326
 
1287
2327
    def __return_repository_format(self):
1288
2328
        """Circular import protection."""
1289
 
        from bzrlib.repository import RepositoryFormat6
1290
 
        return RepositoryFormat6(self)
 
2329
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
2330
        return RepositoryFormat6()
1291
2331
    repository_format = property(__return_repository_format)
1292
2332
 
1293
2333
 
1302
2342
     - Format 7 repositories [optional]
1303
2343
    """
1304
2344
 
1305
 
    _lock_class = LockDir
 
2345
    _lock_class = lockdir.LockDir
 
2346
 
 
2347
    def __init__(self):
 
2348
        self._workingtree_format = None
 
2349
        self._branch_format = None
 
2350
        self._repository_format = None
 
2351
 
 
2352
    def __eq__(self, other):
 
2353
        if other.__class__ is not self.__class__:
 
2354
            return False
 
2355
        if other.repository_format != self.repository_format:
 
2356
            return False
 
2357
        if other.workingtree_format != self.workingtree_format:
 
2358
            return False
 
2359
        return True
 
2360
 
 
2361
    def __ne__(self, other):
 
2362
        return not self == other
 
2363
 
 
2364
    def get_branch_format(self):
 
2365
        if self._branch_format is None:
 
2366
            from bzrlib.branch import BranchFormat
 
2367
            self._branch_format = BranchFormat.get_default_format()
 
2368
        return self._branch_format
 
2369
 
 
2370
    def set_branch_format(self, format):
 
2371
        self._branch_format = format
 
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())
1306
2464
 
1307
2465
    def get_converter(self, format=None):
1308
2466
        """See BzrDirFormat.get_converter()."""
1321
2479
        """See BzrDirFormat.get_format_description()."""
1322
2480
        return "Meta directory format 1"
1323
2481
 
 
2482
    def network_name(self):
 
2483
        return self.get_format_string()
 
2484
 
1324
2485
    def _open(self, transport):
1325
2486
        """See BzrDirFormat._open."""
1326
 
        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)
1327
2493
 
1328
2494
    def __return_repository_format(self):
1329
2495
        """Circular import protection."""
1330
 
        if getattr(self, '_repository_format', None):
 
2496
        if self._repository_format:
1331
2497
            return self._repository_format
1332
2498
        from bzrlib.repository import RepositoryFormat
1333
2499
        return RepositoryFormat.get_default_format()
1334
2500
 
1335
 
    def __set_repository_format(self, value):
1336
 
        """Allow changint the repository format for metadir formats."""
 
2501
    def _set_repository_format(self, value):
 
2502
        """Allow changing the repository format for metadir formats."""
1337
2503
        self._repository_format = value
1338
2504
 
1339
 
    repository_format = property(__return_repository_format, __set_repository_format)
1340
 
 
1341
 
 
 
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
 
2525
 
 
2526
    def __get_workingtree_format(self):
 
2527
        if self._workingtree_format is None:
 
2528
            from bzrlib.workingtree import WorkingTreeFormat
 
2529
            self._workingtree_format = WorkingTreeFormat.get_default_format()
 
2530
        return self._workingtree_format
 
2531
 
 
2532
    def __set_workingtree_format(self, wt_format):
 
2533
        self._workingtree_format = wt_format
 
2534
 
 
2535
    workingtree_format = property(__get_workingtree_format,
 
2536
                                  __set_workingtree_format)
 
2537
 
 
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
 
 
2548
# Register bzr control format
 
2549
BzrDirFormat.register_control_format(BzrDirFormat)
 
2550
 
 
2551
# Register bzr formats
1342
2552
BzrDirFormat.register_format(BzrDirFormat4())
1343
2553
BzrDirFormat.register_format(BzrDirFormat5())
1344
2554
BzrDirFormat.register_format(BzrDirFormat6())
1345
2555
__default_format = BzrDirMetaFormat1()
1346
2556
BzrDirFormat.register_format(__default_format)
1347
 
BzrDirFormat.set_default_format(__default_format)
1348
 
 
1349
 
 
1350
 
class BzrDirTestProviderAdapter(object):
1351
 
    """A tool to generate a suite testing multiple bzrdir formats at once.
1352
 
 
1353
 
    This is done by copying the test once for each transport and injecting
1354
 
    the transport_server, transport_readonly_server, and bzrdir_format
1355
 
    classes into each copy. Each copy is also given a new id() to make it
1356
 
    easy to identify.
1357
 
    """
1358
 
 
1359
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1360
 
        self._transport_server = transport_server
1361
 
        self._transport_readonly_server = transport_readonly_server
1362
 
        self._formats = formats
1363
 
    
1364
 
    def adapt(self, test):
1365
 
        result = TestSuite()
1366
 
        for format in self._formats:
1367
 
            new_test = deepcopy(test)
1368
 
            new_test.transport_server = self._transport_server
1369
 
            new_test.transport_readonly_server = self._transport_readonly_server
1370
 
            new_test.bzrdir_format = format
1371
 
            def make_new_test_id():
1372
 
                new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1373
 
                return lambda: new_id
1374
 
            new_test.id = make_new_test_id()
1375
 
            result.addTest(new_test)
1376
 
        return result
 
2557
BzrDirFormat._default_format = __default_format
1377
2558
 
1378
2559
 
1379
2560
class Converter(object):
1401
2582
        self.absent_revisions = set()
1402
2583
        self.text_count = 0
1403
2584
        self.revisions = {}
1404
 
        
 
2585
 
1405
2586
    def convert(self, to_convert, pb):
1406
2587
        """See Converter.convert()."""
1407
2588
        self.bzrdir = to_convert
1408
2589
        self.pb = pb
1409
2590
        self.pb.note('starting upgrade from format 4 to 5')
1410
 
        if isinstance(self.bzrdir.transport, LocalTransport):
 
2591
        if isinstance(self.bzrdir.transport, local.LocalTransport):
1411
2592
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1412
2593
        self._convert_to_weaves()
1413
2594
        return BzrDir.open(self.bzrdir.root_transport.base)
1452
2633
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
1453
2634
        self.pb.note('  %6d texts', self.text_count)
1454
2635
        self._cleanup_spare_files_after_format4()
1455
 
        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())
1456
2640
 
1457
2641
    def _cleanup_spare_files_after_format4(self):
1458
2642
        # FIXME working tree upgrade foo.
1466
2650
        self.bzrdir.transport.delete_tree('text-store')
1467
2651
 
1468
2652
    def _convert_working_inv(self):
1469
 
        inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1470
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1471
 
        # FIXME inventory is a working tree change.
1472
 
        self.branch.control_files.put('inventory', new_inv_xml)
 
2653
        inv = xml4.serializer_v4.read_inventory(
 
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())
1473
2658
 
1474
2659
    def _write_all_weaves(self):
1475
2660
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1495
2680
        self.bzrdir.transport.mkdir('revision-store')
1496
2681
        revision_transport = self.bzrdir.transport.clone('revision-store')
1497
2682
        # TODO permissions
1498
 
        _revision_store = TextRevisionStore(TextStore(revision_transport,
1499
 
                                                      prefixed=False,
1500
 
                                                      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)
1501
2688
        try:
1502
 
            transaction = bzrlib.transactions.WriteTransaction()
1503
2689
            for i, rev_id in enumerate(self.converted_revs):
1504
2690
                self.pb.update('write revision', i, len(self.converted_revs))
1505
 
                _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))
1506
2695
        finally:
1507
2696
            self.pb.clear()
1508
 
            
 
2697
 
1509
2698
    def _load_one_rev(self, rev_id):
1510
2699
        """Load a revision object into memory.
1511
2700
 
1521
2710
                         rev_id)
1522
2711
            self.absent_revisions.add(rev_id)
1523
2712
        else:
1524
 
            rev = self.branch.repository._revision_store.get_revision(rev_id,
1525
 
                self.branch.repository.get_transaction())
 
2713
            rev = self.branch.repository.get_revision(rev_id)
1526
2714
            for parent_id in rev.parent_ids:
1527
2715
                self.known_revisions.add(parent_id)
1528
2716
                self.to_read.append(parent_id)
1529
2717
            self.revisions[rev_id] = rev
1530
2718
 
1531
2719
    def _load_old_inventory(self, rev_id):
1532
 
        assert rev_id not in self.converted_revs
1533
2720
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1534
 
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
 
2721
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
 
2722
        inv.revision_id = rev_id
1535
2723
        rev = self.revisions[rev_id]
1536
 
        if rev.inventory_sha1:
1537
 
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1538
 
                'inventory sha mismatch for {%s}' % rev_id
1539
2724
        return inv
1540
2725
 
1541
2726
    def _load_updated_inventory(self, rev_id):
1542
 
        assert rev_id in self.converted_revs
1543
2727
        inv_xml = self.inv_weave.get_text(rev_id)
1544
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
2728
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
1545
2729
        return inv
1546
2730
 
1547
2731
    def _convert_one_rev(self, rev_id):
1551
2735
        present_parents = [p for p in rev.parent_ids
1552
2736
                           if p not in self.absent_revisions]
1553
2737
        self._convert_revision_contents(rev, inv, present_parents)
1554
 
        self._store_new_weave(rev, inv, present_parents)
 
2738
        self._store_new_inv(rev, inv, present_parents)
1555
2739
        self.converted_revs.add(rev_id)
1556
2740
 
1557
 
    def _store_new_weave(self, rev, inv, present_parents):
1558
 
        # the XML is now updated with text versions
1559
 
        if __debug__:
1560
 
            entries = inv.iter_entries()
1561
 
            entries.next()
1562
 
            for path, ie in entries:
1563
 
                assert hasattr(ie, 'revision'), \
1564
 
                    'no revision on {%s} in {%s}' % \
1565
 
                    (file_id, rev.revision_id)
1566
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
2741
    def _store_new_inv(self, rev, inv, present_parents):
 
2742
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1567
2743
        new_inv_sha1 = sha_string(new_inv_xml)
1568
 
        self.inv_weave.add_lines(rev.revision_id, 
 
2744
        self.inv_weave.add_lines(rev.revision_id,
1569
2745
                                 present_parents,
1570
2746
                                 new_inv_xml.splitlines(True))
1571
2747
        rev.inventory_sha1 = new_inv_sha1
1596
2772
            w = Weave(file_id)
1597
2773
            self.text_weaves[file_id] = w
1598
2774
        text_changed = False
1599
 
        previous_entries = ie.find_previous_heads(parent_invs,
1600
 
                                                  None,
1601
 
                                                  None,
1602
 
                                                  entry_vf=w)
1603
 
        for old_revision in previous_entries:
1604
 
                # if this fails, its a ghost ?
1605
 
                assert old_revision in self.converted_revs 
 
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)
1606
2781
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1607
2782
        del ie.text_id
1608
 
        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)
1609
2789
 
1610
2790
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1611
2791
        # TODO: convert this logic, which is ~= snapshot to
1612
2792
        # a call to:. This needs the path figured out. rather than a work_tree
1613
2793
        # a v4 revision_tree can be given, or something that looks enough like
1614
2794
        # one to give the file content to the entry if it needs it.
1615
 
        # 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
1616
2796
        # save against.
1617
2797
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1618
2798
        if len(previous_revisions) == 1:
1621
2801
                ie.revision = previous_ie.revision
1622
2802
                return
1623
2803
        if ie.has_text():
1624
 
            text = self.branch.repository.text_store.get(ie.text_id)
 
2804
            text = self.branch.repository._text_store.get(ie.text_id)
1625
2805
            file_lines = text.readlines()
1626
 
            assert sha_strings(file_lines) == ie.text_sha1
1627
 
            assert sum(map(len, file_lines)) == ie.text_size
1628
2806
            w.add_lines(rev_id, previous_revisions, file_lines)
1629
2807
            self.text_count += 1
1630
2808
        else:
1677
2855
                if (filename.endswith(".weave") or
1678
2856
                    filename.endswith(".gz") or
1679
2857
                    filename.endswith(".sig")):
1680
 
                    file_id = os.path.splitext(filename)[0]
 
2858
                    file_id, suffix = os.path.splitext(filename)
1681
2859
                else:
1682
2860
                    file_id = filename
1683
 
                prefix_dir = store.hash_prefix(file_id)
 
2861
                    suffix = ''
 
2862
                new_name = store._mapper.map((file_id,)) + suffix
1684
2863
                # FIXME keep track of the dirs made RBC 20060121
1685
2864
                try:
1686
 
                    store_transport.move(filename, prefix_dir + '/' + filename)
 
2865
                    store_transport.move(filename, new_name)
1687
2866
                except errors.NoSuchFile: # catches missing dirs strangely enough
1688
 
                    store_transport.mkdir(prefix_dir)
1689
 
                    store_transport.move(filename, prefix_dir + '/' + filename)
1690
 
        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())
1691
2873
 
1692
2874
 
1693
2875
class ConvertBzrDir6ToMeta(Converter):
1695
2877
 
1696
2878
    def convert(self, to_convert, pb):
1697
2879
        """See Converter.convert()."""
 
2880
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
 
2881
        from bzrlib.branch import BzrBranchFormat5
1698
2882
        self.bzrdir = to_convert
1699
2883
        self.pb = pb
1700
2884
        self.count = 0
1701
2885
        self.total = 20 # the steps we know about
1702
2886
        self.garbage_inventories = []
 
2887
        self.dir_mode = self.bzrdir._get_dir_mode()
 
2888
        self.file_mode = self.bzrdir._get_file_mode()
1703
2889
 
1704
2890
        self.pb.note('starting upgrade from format 6 to metadir')
1705
 
        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)
1706
2895
        # its faster to move specific files around than to open and use the apis...
1707
2896
        # first off, nuke ancestry.weave, it was never used.
1708
2897
        try:
1718
2907
            if name.startswith('basis-inventory.'):
1719
2908
                self.garbage_inventories.append(name)
1720
2909
        # create new directories for repository, working tree and branch
1721
 
        self.dir_mode = self.bzrdir._control_files._dir_mode
1722
 
        self.file_mode = self.bzrdir._control_files._file_mode
1723
2910
        repository_names = [('inventory.weave', True),
1724
2911
                            ('revision-store', True),
1725
2912
                            ('weaves', True)]
1727
2914
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1728
2915
        self.make_lock('repository')
1729
2916
        # we hard code the formats here because we are converting into
1730
 
        # 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
1731
2918
        # future format within each component.
1732
 
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
 
2919
        self.put_format('repository', RepositoryFormat7())
1733
2920
        for entry in repository_names:
1734
2921
            self.move_entry('repository', entry)
1735
2922
 
1736
2923
        self.step('Upgrading branch      ')
1737
2924
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1738
2925
        self.make_lock('branch')
1739
 
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
 
2926
        self.put_format('branch', BzrBranchFormat5())
1740
2927
        branch_files = [('revision-history', True),
1741
2928
                        ('branch-name', True),
1742
2929
                        ('parent', False)]
1743
2930
        for entry in branch_files:
1744
2931
            self.move_entry('branch', entry)
1745
2932
 
1746
 
        self.step('Upgrading working tree')
1747
 
        self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1748
 
        self.make_lock('checkout')
1749
 
        self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1750
 
        self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1751
2933
        checkout_files = [('pending-merges', True),
1752
2934
                          ('inventory', True),
1753
2935
                          ('stat-cache', False)]
1754
 
        for entry in checkout_files:
1755
 
            self.move_entry('checkout', entry)
1756
 
        if last_revision is not None:
1757
 
            self.bzrdir._control_files.put_utf8('checkout/last-revision',
1758
 
                                                last_revision)
1759
 
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
 
2936
        # If a mandatory checkout file is not present, the branch does not have
 
2937
        # a functional checkout. Do not create a checkout in the converted
 
2938
        # branch.
 
2939
        for name, mandatory in checkout_files:
 
2940
            if mandatory and name not in bzrcontents:
 
2941
                has_checkout = False
 
2942
                break
 
2943
        else:
 
2944
            has_checkout = True
 
2945
        if not has_checkout:
 
2946
            self.pb.note('No working tree.')
 
2947
            # If some checkout files are there, we may as well get rid of them.
 
2948
            for name, mandatory in checkout_files:
 
2949
                if name in bzrcontents:
 
2950
                    self.bzrdir.transport.delete(name)
 
2951
        else:
 
2952
            from bzrlib.workingtree import WorkingTreeFormat3
 
2953
            self.step('Upgrading working tree')
 
2954
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
 
2955
            self.make_lock('checkout')
 
2956
            self.put_format(
 
2957
                'checkout', WorkingTreeFormat3())
 
2958
            self.bzrdir.transport.delete_multi(
 
2959
                self.garbage_inventories, self.pb)
 
2960
            for entry in checkout_files:
 
2961
                self.move_entry('checkout', entry)
 
2962
            if last_revision is not None:
 
2963
                self.bzrdir.transport.put_bytes(
 
2964
                    'checkout/last-revision', last_revision)
 
2965
        self.bzrdir.transport.put_bytes(
 
2966
            'branch-format',
 
2967
            BzrDirMetaFormat1().get_format_string(),
 
2968
            mode=self.file_mode)
1760
2969
        return BzrDir.open(self.bzrdir.root_transport.base)
1761
2970
 
1762
2971
    def make_lock(self, name):
1763
2972
        """Make a lock for the new control dir name."""
1764
2973
        self.step('Make %s lock' % name)
1765
 
        ld = LockDir(self.bzrdir.transport, 
1766
 
                     '%s/lock' % name,
1767
 
                     file_modebits=self.file_mode,
1768
 
                     dir_modebits=self.dir_mode)
 
2974
        ld = lockdir.LockDir(self.bzrdir.transport,
 
2975
                             '%s/lock' % name,
 
2976
                             file_modebits=self.file_mode,
 
2977
                             dir_modebits=self.dir_mode)
1769
2978
        ld.create()
1770
2979
 
1771
2980
    def move_entry(self, new_dir, entry):
1780
2989
                raise
1781
2990
 
1782
2991
    def put_format(self, dirname, format):
1783
 
        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)
1784
2995
 
1785
2996
 
1786
2997
class ConvertMetaToMeta(Converter):
1810
3021
                self.pb.note('starting repository conversion')
1811
3022
                converter = CopyConverter(self.target_format.repository_format)
1812
3023
                converter.convert(repo, pb)
 
3024
        try:
 
3025
            branch = self.bzrdir.open_branch()
 
3026
        except errors.NotBranchError:
 
3027
            pass
 
3028
        else:
 
3029
            # TODO: conversions of Branch and Tree should be done by
 
3030
            # InterXFormat lookups/some sort of registry.
 
3031
            # Avoid circular imports
 
3032
            from bzrlib import branch as _mod_branch
 
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)
 
3051
                branch_converter.convert(branch)
 
3052
                branch = self.bzrdir.open_branch()
 
3053
                old = branch._format.__class__
 
3054
        try:
 
3055
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
 
3056
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
3057
            pass
 
3058
        else:
 
3059
            # TODO: conversions of Branch and Tree should be done by
 
3060
            # InterXFormat lookups
 
3061
            if (isinstance(tree, workingtree.WorkingTree3) and
 
3062
                not isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
3063
                isinstance(self.target_format.workingtree_format,
 
3064
                    workingtree_4.DirStateWorkingTreeFormat)):
 
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)
1813
3076
        return to_convert
 
3077
 
 
3078
 
 
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.
 
3081
# we can make it a lazy object if the control formats is turned into something
 
3082
# like a registry.
 
3083
class RemoteBzrDirFormat(BzrDirMetaFormat1):
 
3084
    """Format representing bzrdirs accessed via a smart server"""
 
3085
 
 
3086
    def __init__(self):
 
3087
        BzrDirMetaFormat1.__init__(self)
 
3088
        self._network_name = None
 
3089
 
 
3090
    def get_format_description(self):
 
3091
        return 'bzr remote bzrdir'
 
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
 
 
3102
    @classmethod
 
3103
    def probe_transport(klass, transport):
 
3104
        """Return a RemoteBzrDirFormat object if it looks possible."""
 
3105
        try:
 
3106
            medium = transport.get_smart_medium()
 
3107
        except (NotImplementedError, AttributeError,
 
3108
                errors.TransportNotPossible, errors.NoSmartMedium,
 
3109
                errors.SmartProtocolError):
 
3110
            # no smart server, so not a branch for this format type.
 
3111
            raise errors.NotBranchError(path=transport.base)
 
3112
        else:
 
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)
 
3124
            return klass()
 
3125
 
 
3126
    def initialize_on_transport(self, transport):
 
3127
        try:
 
3128
            # hand off the request to the smart server
 
3129
            client_medium = transport.get_smart_medium()
 
3130
        except errors.NoSmartMedium:
 
3131
            # TODO: lookup the local format from a server hint.
 
3132
            local_dir_format = BzrDirMetaFormat1()
 
3133
            return local_dir_format.initialize_on_transport(transport)
 
3134
        client = _SmartClient(client_medium)
 
3135
        path = client.remote_path_from_transport(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
 
3292
 
 
3293
    def _open(self, transport):
 
3294
        return remote.RemoteBzrDir(transport, self)
 
3295
 
 
3296
    def __eq__(self, other):
 
3297
        if not isinstance(other, RemoteBzrDirFormat):
 
3298
            return False
 
3299
        return self.get_format_description() == other.get_format_description()
 
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
 
 
3330
 
 
3331
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
 
3332
 
 
3333
 
 
3334
class BzrDirFormatInfo(object):
 
3335
 
 
3336
    def __init__(self, native, deprecated, hidden, experimental):
 
3337
        self.deprecated = deprecated
 
3338
        self.native = native
 
3339
        self.hidden = hidden
 
3340
        self.experimental = experimental
 
3341
 
 
3342
 
 
3343
class BzrDirFormatRegistry(registry.Registry):
 
3344
    """Registry of user-selectable BzrDir subformats.
 
3345
 
 
3346
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
 
3347
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
 
3348
    """
 
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
 
 
3360
    def register_metadir(self, key,
 
3361
             repository_format, help, native=True, deprecated=False,
 
3362
             branch_format=None,
 
3363
             tree_format=None,
 
3364
             hidden=False,
 
3365
             experimental=False,
 
3366
             alias=False):
 
3367
        """Register a metadir subformat.
 
3368
 
 
3369
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
 
3370
        by the Repository/Branch/WorkingTreeformats.
 
3371
 
 
3372
        :param repository_format: The fully-qualified repository format class
 
3373
            name as a string.
 
3374
        :param branch_format: Fully-qualified branch format class name as
 
3375
            a string.
 
3376
        :param tree_format: Fully-qualified tree format class name as
 
3377
            a string.
 
3378
        """
 
3379
        # This should be expanded to support setting WorkingTree and Branch
 
3380
        # formats, once BzrDirMetaFormat1 supports that.
 
3381
        def _load(full_name):
 
3382
            mod_name, factory_name = full_name.rsplit('.', 1)
 
3383
            try:
 
3384
                mod = __import__(mod_name, globals(), locals(),
 
3385
                        [factory_name])
 
3386
            except ImportError, e:
 
3387
                raise ImportError('failed to load %s: %s' % (full_name, e))
 
3388
            try:
 
3389
                factory = getattr(mod, factory_name)
 
3390
            except AttributeError:
 
3391
                raise AttributeError('no factory %s in module %r'
 
3392
                    % (full_name, mod))
 
3393
            return factory()
 
3394
 
 
3395
        def helper():
 
3396
            bd = BzrDirMetaFormat1()
 
3397
            if branch_format is not None:
 
3398
                bd.set_branch_format(_load(branch_format))
 
3399
            if tree_format is not None:
 
3400
                bd.workingtree_format = _load(tree_format)
 
3401
            if repository_format is not None:
 
3402
                bd.repository_format = _load(repository_format)
 
3403
            return bd
 
3404
        self.register(key, helper, help, native, deprecated, hidden,
 
3405
            experimental, alias)
 
3406
 
 
3407
    def register(self, key, factory, help, native=True, deprecated=False,
 
3408
                 hidden=False, experimental=False, alias=False):
 
3409
        """Register a BzrDirFormat factory.
 
3410
 
 
3411
        The factory must be a callable that takes one parameter: the key.
 
3412
        It must produce an instance of the BzrDirFormat when called.
 
3413
 
 
3414
        This function mainly exists to prevent the info object from being
 
3415
        supplied directly.
 
3416
        """
 
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)
 
3422
 
 
3423
    def register_lazy(self, key, module_name, member_name, help, native=True,
 
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)
 
3430
 
 
3431
    def set_default(self, key):
 
3432
        """Set the 'default' key to be a clone of the supplied key.
 
3433
 
 
3434
        This method must be called once and only once.
 
3435
        """
 
3436
        registry.Registry.register(self, 'default', self.get(key),
 
3437
            self.get_help(key), info=self.get_info(key))
 
3438
        self._aliases.add('default')
 
3439
 
 
3440
    def set_default_repository(self, key):
 
3441
        """Set the FormatRegistry default and Repository default.
 
3442
 
 
3443
        This is a transitional method while Repository.set_default_format
 
3444
        is deprecated.
 
3445
        """
 
3446
        if 'default' in self:
 
3447
            self.remove('default')
 
3448
        self.set_default(key)
 
3449
        format = self.get('default')()
 
3450
 
 
3451
    def make_bzrdir(self, key):
 
3452
        return self.get(key)()
 
3453
 
 
3454
    def help_topic(self, topic):
 
3455
        output = ""
 
3456
        default_realkey = None
 
3457
        default_help = self.get_help('default')
 
3458
        help_pairs = []
 
3459
        for key in self._registration_order:
 
3460
            if key == 'default':
 
3461
                continue
 
3462
            help = self.get_help(key)
 
3463
            if help == default_help:
 
3464
                default_realkey = key
 
3465
            else:
 
3466
                help_pairs.append((key, help))
 
3467
 
 
3468
        def wrapped(key, help, info):
 
3469
            if info.native:
 
3470
                help = '(native) ' + help
 
3471
            return ':%s:\n%s\n\n' % (key,
 
3472
                textwrap.fill(help, initial_indent='    ',
 
3473
                    subsequent_indent='    ',
 
3474
                    break_long_words=False))
 
3475
        if default_realkey is not None:
 
3476
            output += wrapped(default_realkey, '(default) %s' % default_help,
 
3477
                              self.get_info('default'))
 
3478
        deprecated_pairs = []
 
3479
        experimental_pairs = []
 
3480
        for key, help in help_pairs:
 
3481
            info = self.get_info(key)
 
3482
            if info.hidden:
 
3483
                continue
 
3484
            elif info.deprecated:
 
3485
                deprecated_pairs.append((key, help))
 
3486
            elif info.experimental:
 
3487
                experimental_pairs.append((key, help))
 
3488
            else:
 
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"
 
3500
        if len(deprecated_pairs) > 0:
 
3501
            other_output += "\nDeprecated formats are shown below.\n\n"
 
3502
            for key, help in deprecated_pairs:
 
3503
                info = self.get_info(key)
 
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.
 
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.
 
3681
format_registry.register('weave', BzrDirFormat6,
 
3682
    'Pre-0.8 format.  Slower than knit and does not'
 
3683
    ' support checkouts or shared repositories.',
 
3684
    deprecated=True)
 
3685
format_registry.register_metadir('metaweave',
 
3686
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
 
3687
    'Transitional format in 0.8.  Slower than knit.',
 
3688
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
3689
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
 
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)
 
3697
format_registry.register_metadir('dirstate',
 
3698
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
3699
    help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
 
3700
        'above when accessed over the network.',
 
3701
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
3702
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
 
3703
    # directly from workingtree_4 triggers a circular import.
 
3704
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3705
    deprecated=True)
 
3706
format_registry.register_metadir('dirstate-tags',
 
3707
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
3708
    help='New in 0.15: Fast local operations and improved scaling for '
 
3709
        'network operations. Additionally adds support for tags.'
 
3710
        ' Incompatible with bzr < 0.15.',
 
3711
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
3712
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
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)
 
3721
format_registry.register_metadir('dirstate-with-subtree',
 
3722
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
3723
    help='New in 0.15: Fast local operations and improved scaling for '
 
3724
        'network operations. Additionally adds support for versioning nested '
 
3725
        'bzr branches. Incompatible with bzr < 0.15.',
 
3726
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
3727
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
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')