/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

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