← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-12 12:36:57 UTC
  • mfrom: (1732.3.4 bzr.revnoX)
  • Revision ID: pqm@pqm.ubuntu.com-20060712123657-365eeb32b69308bf
(matthieu) revno:x:url revision spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
 
# TODO: Move old formats into a plugin to make this file smaller.
 
23
# TODO: remove unittest dependency; put that stuff inside the test suite
29
24
 
 
25
from copy import deepcopy
 
26
from cStringIO import StringIO
30
27
import os
31
 
import sys
32
 
import warnings
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
28
from stat import S_ISDIR
 
29
from unittest import TestSuite
37
30
 
38
31
import bzrlib
39
 
from bzrlib import (
40
 
    branch,
41
 
    config,
42
 
    controldir,
43
 
    errors,
44
 
    graph,
45
 
    lockable_files,
46
 
    lockdir,
47
 
    osutils,
48
 
    pyutils,
49
 
    remote,
50
 
    repository,
51
 
    revision as _mod_revision,
52
 
    ui,
53
 
    urlutils,
54
 
    versionedfile,
55
 
    win32utils,
56
 
    workingtree,
57
 
    workingtree_4,
58
 
    xml4,
59
 
    xml5,
60
 
    )
 
32
import bzrlib.errors as errors
 
33
from bzrlib.lockable_files import LockableFiles, TransportLock
 
34
from bzrlib.lockdir import LockDir
61
35
from bzrlib.osutils import (
62
 
    sha_string,
63
 
    )
64
 
from bzrlib.push import (
65
 
    PushResult,
66
 
    )
67
 
from bzrlib.repofmt import pack_repo
68
 
from bzrlib.smart.client import _SmartClient
 
36
                            abspath,
 
37
                            pathjoin,
 
38
                            safe_unicode,
 
39
                            sha_strings,
 
40
                            sha_string,
 
41
                            )
 
42
from bzrlib.store.revision.text import TextRevisionStore
 
43
from bzrlib.store.text import TextStore
69
44
from bzrlib.store.versioned import WeaveStore
 
45
from bzrlib.trace import mutter
70
46
from bzrlib.transactions import WriteTransaction
71
 
from bzrlib.transport import (
72
 
    do_catching_redirections,
73
 
    get_transport,
74
 
    local,
75
 
    )
 
47
from bzrlib.transport import get_transport
 
48
from bzrlib.transport.local import LocalTransport
 
49
import bzrlib.urlutils as urlutils
76
50
from bzrlib.weave import Weave
77
 
""")
78
 
 
79
 
from bzrlib.trace import (
80
 
    mutter,
81
 
    note,
82
 
    warning,
83
 
    )
84
 
 
85
 
from bzrlib import (
86
 
    hooks,
87
 
    registry,
88
 
    symbol_versioning,
89
 
    )
90
 
from bzrlib.symbol_versioning import (
91
 
    deprecated_in,
92
 
    deprecated_method,
93
 
    )
94
 
 
95
 
 
96
 
class BzrDir(controldir.ControlDir):
 
51
from bzrlib.xml4 import serializer_v4
 
52
import bzrlib.xml5
 
53
 
 
54
 
 
55
class BzrDir(object):
97
56
    """A .bzr control diretory.
98
 
 
 
57
    
99
58
    BzrDir instances let you create or open any of the things that can be
100
59
    found within .bzr - checkouts, branches and repositories.
101
 
 
102
 
    :ivar transport:
 
60
    
 
61
    transport
103
62
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
104
 
    :ivar root_transport:
105
 
        a transport connected to the directory this bzr was opened from
106
 
        (i.e. the parent directory holding the .bzr directory).
107
 
 
108
 
    Everything in the bzrdir should have the same file permissions.
109
 
 
110
 
    :cvar hooks: An instance of BzrDirHooks.
 
63
    root_transport
 
64
        a transport connected to the directory this bzr was opened from.
111
65
    """
112
66
 
113
67
    def break_lock(self):
116
70
        If there is a tree, the tree is opened and break_lock() called.
117
71
        Otherwise, branch is tried, and finally repository.
118
72
        """
119
 
        # XXX: This seems more like a UI function than something that really
120
 
        # belongs in this class.
121
73
        try:
122
74
            thing_to_unlock = self.open_workingtree()
123
75
        except (errors.NotLocalUrl, errors.NoWorkingTree):
130
82
                    return
131
83
        thing_to_unlock.break_lock()
132
84
 
133
 
    def check_conversion_target(self, target_format):
134
 
        """Check that a bzrdir as a whole can be converted to a new format."""
135
 
        # The only current restriction is that the repository content can be 
136
 
        # fetched compatibly with the target.
137
 
        target_repo_format = target_format.repository_format
138
 
        try:
139
 
            self.open_repository()._format.check_conversion_target(
140
 
                target_repo_format)
141
 
        except errors.NoRepositoryPresent:
142
 
            # No repo, no problem.
143
 
            pass
 
85
    def can_convert_format(self):
 
86
        """Return true if this bzrdir is one whose format we can convert from."""
 
87
        return True
144
88
 
145
89
    @staticmethod
146
 
    def _check_supported(format, allow_unsupported,
147
 
        recommend_upgrade=True,
148
 
        basedir=None):
149
 
        """Give an error or warning on old formats.
150
 
 
151
 
        :param format: may be any kind of format - workingtree, branch,
152
 
        or repository.
153
 
 
154
 
        :param allow_unsupported: If true, allow opening
155
 
        formats that are strongly deprecated, and which may
156
 
        have limited functionality.
157
 
 
158
 
        :param recommend_upgrade: If true (default), warn
159
 
        the user through the ui object that they may wish
160
 
        to upgrade the object.
 
90
    def _check_supported(format, allow_unsupported):
 
91
        """Check whether format is a supported format.
 
92
 
 
93
        If allow_unsupported is True, this is a no-op.
161
94
        """
162
 
        # TODO: perhaps move this into a base Format class; it's not BzrDir
163
 
        # specific. mbp 20070323
164
95
        if not allow_unsupported and not format.is_supported():
165
96
            # see open_downlevel to open legacy branches.
166
97
            raise errors.UnsupportedFormatError(format=format)
167
 
        if recommend_upgrade \
168
 
            and getattr(format, 'upgrade_recommended', False):
169
 
            ui.ui_factory.recommend_upgrade(
170
 
                format.get_format_description(),
171
 
                basedir)
172
 
 
173
 
    def clone_on_transport(self, transport, revision_id=None,
174
 
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
175
 
        create_prefix=False, use_existing_dir=True, no_tree=False):
176
 
        """Clone this bzrdir and its contents to transport verbatim.
177
 
 
178
 
        :param transport: The transport for the location to produce the clone
179
 
            at.  If the target directory does not exist, it will be created.
180
 
        :param revision_id: The tip revision-id to use for any branch or
181
 
            working tree.  If not None, then the clone operation may tune
 
98
 
 
99
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
 
100
        """Clone this bzrdir and its contents to url verbatim.
 
101
 
 
102
        If urls last component does not exist, it will be created.
 
103
 
 
104
        if revision_id is not None, then the clone operation may tune
182
105
            itself to download less data.
183
 
        :param force_new_repo: Do not use a shared repository for the target,
 
106
        :param force_new_repo: Do not use a shared repository for the target 
184
107
                               even if one is available.
185
 
        :param preserve_stacking: When cloning a stacked branch, stack the
186
 
            new branch on top of the other branch's stacked-on branch.
187
 
        :param create_prefix: Create any missing directories leading up to
188
 
            to_transport.
189
 
        :param use_existing_dir: Use an existing directory if one exists.
190
108
        """
191
 
        # Overview: put together a broad description of what we want to end up
192
 
        # with; then make as few api calls as possible to do it.
193
 
 
194
 
        # We may want to create a repo/branch/tree, if we do so what format
195
 
        # would we want for each:
196
 
        require_stacking = (stacked_on is not None)
197
 
        format = self.cloning_metadir(require_stacking)
198
 
 
199
 
        # Figure out what objects we want:
 
109
        self._make_tail(url)
 
110
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
111
        result = self._format.initialize(url)
200
112
        try:
201
113
            local_repo = self.find_repository()
202
114
        except errors.NoRepositoryPresent:
203
115
            local_repo = None
204
 
        try:
205
 
            local_branch = self.open_branch()
206
 
        except errors.NotBranchError:
207
 
            local_branch = None
208
 
        else:
209
 
            # enable fallbacks when branch is not a branch reference
210
 
            if local_branch.repository.has_same_location(local_repo):
211
 
                local_repo = local_branch.repository
212
 
            if preserve_stacking:
213
 
                try:
214
 
                    stacked_on = local_branch.get_stacked_on_url()
215
 
                except (errors.UnstackableBranchFormat,
216
 
                        errors.UnstackableRepositoryFormat,
217
 
                        errors.NotStacked):
218
 
                    pass
219
 
        # Bug: We create a metadir without knowing if it can support stacking,
220
 
        # we should look up the policy needs first, or just use it as a hint,
221
 
        # or something.
222
116
        if local_repo:
223
 
            make_working_trees = local_repo.make_working_trees() and not no_tree
224
 
            want_shared = local_repo.is_shared()
225
 
            repo_format_name = format.repository_format.network_name()
226
 
        else:
227
 
            make_working_trees = False
228
 
            want_shared = False
229
 
            repo_format_name = None
230
 
 
231
 
        result_repo, result, require_stacking, repository_policy = \
232
 
            format.initialize_on_transport_ex(transport,
233
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
234
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
235
 
            stack_on_pwd=self.root_transport.base,
236
 
            repo_format_name=repo_format_name,
237
 
            make_working_trees=make_working_trees, shared_repo=want_shared)
238
 
        if repo_format_name:
239
 
            try:
240
 
                # If the result repository is in the same place as the
241
 
                # resulting bzr dir, it will have no content, further if the
242
 
                # result is not stacked then we know all content should be
243
 
                # copied, and finally if we are copying up to a specific
244
 
                # revision_id then we can use the pending-ancestry-result which
245
 
                # does not require traversing all of history to describe it.
246
 
                if (result_repo.user_url == result.user_url
247
 
                    and not require_stacking and
248
 
                    revision_id is not None):
249
 
                    fetch_spec = graph.PendingAncestryResult(
250
 
                        [revision_id], local_repo)
251
 
                    result_repo.fetch(local_repo, fetch_spec=fetch_spec)
252
 
                else:
 
117
            # may need to copy content in
 
118
            if force_new_repo:
 
119
                result_repo = local_repo.clone(
 
120
                    result,
 
121
                    revision_id=revision_id,
 
122
                    basis=basis_repo)
 
123
                result_repo.set_make_working_trees(local_repo.make_working_trees())
 
124
            else:
 
125
                try:
 
126
                    result_repo = result.find_repository()
 
127
                    # fetch content this dir needs.
 
128
                    if basis_repo:
 
129
                        # XXX FIXME RBC 20060214 need tests for this when the basis
 
130
                        # is incomplete
 
131
                        result_repo.fetch(basis_repo, revision_id=revision_id)
253
132
                    result_repo.fetch(local_repo, revision_id=revision_id)
254
 
            finally:
255
 
                result_repo.unlock()
256
 
        else:
257
 
            if result_repo is not None:
258
 
                raise AssertionError('result_repo not None(%r)' % result_repo)
 
133
                except errors.NoRepositoryPresent:
 
134
                    # needed to make one anyway.
 
135
                    result_repo = local_repo.clone(
 
136
                        result,
 
137
                        revision_id=revision_id,
 
138
                        basis=basis_repo)
 
139
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
259
140
        # 1 if there is a branch present
260
141
        #   make sure its content is available in the target repository
261
142
        #   clone it.
262
 
        if local_branch is not None:
263
 
            result_branch = local_branch.clone(result, revision_id=revision_id,
264
 
                repository_policy=repository_policy)
265
 
        try:
266
 
            # Cheaper to check if the target is not local, than to try making
267
 
            # the tree and fail.
268
 
            result.root_transport.local_abspath('.')
269
 
            if result_repo is None or result_repo.make_working_trees():
270
 
                self.open_workingtree().clone(result)
 
143
        try:
 
144
            self.open_branch().clone(result, revision_id=revision_id)
 
145
        except errors.NotBranchError:
 
146
            pass
 
147
        try:
 
148
            self.open_workingtree().clone(result, basis=basis_tree)
271
149
        except (errors.NoWorkingTree, errors.NotLocalUrl):
272
150
            pass
273
151
        return result
274
152
 
 
153
    def _get_basis_components(self, basis):
 
154
        """Retrieve the basis components that are available at basis."""
 
155
        if basis is None:
 
156
            return None, None, None
 
157
        try:
 
158
            basis_tree = basis.open_workingtree()
 
159
            basis_branch = basis_tree.branch
 
160
            basis_repo = basis_branch.repository
 
161
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
162
            basis_tree = None
 
163
            try:
 
164
                basis_branch = basis.open_branch()
 
165
                basis_repo = basis_branch.repository
 
166
            except errors.NotBranchError:
 
167
                basis_branch = None
 
168
                try:
 
169
                    basis_repo = basis.open_repository()
 
170
                except errors.NoRepositoryPresent:
 
171
                    basis_repo = None
 
172
        return basis_repo, basis_branch, basis_tree
 
173
 
275
174
    # TODO: This should be given a Transport, and should chdir up; otherwise
276
175
    # this will open a new connection.
277
176
    def _make_tail(self, url):
278
 
        t = get_transport(url)
279
 
        t.ensure_base()
280
 
 
281
 
    @staticmethod
282
 
    def find_bzrdirs(transport, evaluate=None, list_current=None):
283
 
        """Find bzrdirs recursively from current location.
284
 
 
285
 
        This is intended primarily as a building block for more sophisticated
286
 
        functionality, like finding trees under a directory, or finding
287
 
        branches that use a given repository.
288
 
        :param evaluate: An optional callable that yields recurse, value,
289
 
            where recurse controls whether this bzrdir is recursed into
290
 
            and value is the value to yield.  By default, all bzrdirs
291
 
            are recursed into, and the return value is the bzrdir.
292
 
        :param list_current: if supplied, use this function to list the current
293
 
            directory, instead of Transport.list_dir
294
 
        :return: a generator of found bzrdirs, or whatever evaluate returns.
295
 
        """
296
 
        if list_current is None:
297
 
            def list_current(transport):
298
 
                return transport.list_dir('')
299
 
        if evaluate is None:
300
 
            def evaluate(bzrdir):
301
 
                return True, bzrdir
302
 
 
303
 
        pending = [transport]
304
 
        while len(pending) > 0:
305
 
            current_transport = pending.pop()
306
 
            recurse = True
307
 
            try:
308
 
                bzrdir = BzrDir.open_from_transport(current_transport)
309
 
            except (errors.NotBranchError, errors.PermissionDenied):
310
 
                pass
311
 
            else:
312
 
                recurse, value = evaluate(bzrdir)
313
 
                yield value
314
 
            try:
315
 
                subdirs = list_current(current_transport)
316
 
            except (errors.NoSuchFile, errors.PermissionDenied):
317
 
                continue
318
 
            if recurse:
319
 
                for subdir in sorted(subdirs, reverse=True):
320
 
                    pending.append(current_transport.clone(subdir))
321
 
 
322
 
    @staticmethod
323
 
    def find_branches(transport):
324
 
        """Find all branches under a transport.
325
 
 
326
 
        This will find all branches below the transport, including branches
327
 
        inside other branches.  Where possible, it will use
328
 
        Repository.find_branches.
329
 
 
330
 
        To list all the branches that use a particular Repository, see
331
 
        Repository.find_branches
332
 
        """
333
 
        def evaluate(bzrdir):
334
 
            try:
335
 
                repository = bzrdir.open_repository()
336
 
            except errors.NoRepositoryPresent:
337
 
                pass
338
 
            else:
339
 
                return False, ([], repository)
340
 
            return True, (bzrdir.list_branches(), None)
341
 
        ret = []
342
 
        for branches, repo in BzrDir.find_bzrdirs(transport,
343
 
                                                  evaluate=evaluate):
344
 
            if repo is not None:
345
 
                ret.extend(repo.find_branches())
346
 
            if branches is not None:
347
 
                ret.extend(branches)
348
 
        return ret
349
 
 
350
 
    @staticmethod
351
 
    def create_branch_and_repo(base, force_new_repo=False, format=None):
 
177
        head, tail = urlutils.split(url)
 
178
        if tail and tail != '.':
 
179
            t = bzrlib.transport.get_transport(head)
 
180
            try:
 
181
                t.mkdir(tail)
 
182
            except errors.FileExists:
 
183
                pass
 
184
 
 
185
    # TODO: Should take a Transport
 
186
    @classmethod
 
187
    def create(cls, base):
 
188
        """Create a new BzrDir at the url 'base'.
 
189
        
 
190
        This will call the current default formats initialize with base
 
191
        as the only parameter.
 
192
 
 
193
        If you need a specific format, consider creating an instance
 
194
        of that and calling initialize().
 
195
        """
 
196
        if cls is not BzrDir:
 
197
            raise AssertionError("BzrDir.create always creates the default format, "
 
198
                    "not one of %r" % cls)
 
199
        head, tail = urlutils.split(base)
 
200
        if tail and tail != '.':
 
201
            t = bzrlib.transport.get_transport(head)
 
202
            try:
 
203
                t.mkdir(tail)
 
204
            except errors.FileExists:
 
205
                pass
 
206
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
 
207
 
 
208
    def create_branch(self):
 
209
        """Create a branch in this BzrDir.
 
210
 
 
211
        The bzrdirs format will control what branch format is created.
 
212
        For more control see BranchFormatXX.create(a_bzrdir).
 
213
        """
 
214
        raise NotImplementedError(self.create_branch)
 
215
 
 
216
    @staticmethod
 
217
    def create_branch_and_repo(base, force_new_repo=False):
352
218
        """Create a new BzrDir, Branch and Repository at the url 'base'.
353
219
 
354
 
        This will use the current default BzrDirFormat unless one is
355
 
        specified, and use whatever
 
220
        This will use the current default BzrDirFormat, and use whatever 
356
221
        repository format that that uses via bzrdir.create_branch and
357
222
        create_repository. If a shared repository is available that is used
358
223
        preferentially.
361
226
 
362
227
        :param base: The URL to create the branch at.
363
228
        :param force_new_repo: If True a new repository is always created.
364
 
        :param format: If supplied, the format of branch to create.  If not
365
 
            supplied, the default is used.
366
229
        """
367
 
        bzrdir = BzrDir.create(base, format)
 
230
        bzrdir = BzrDir.create(base)
368
231
        bzrdir._find_or_create_repository(force_new_repo)
369
232
        return bzrdir.create_branch()
370
233
 
371
 
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
372
 
                                    stack_on_pwd=None, require_stacking=False):
373
 
        """Return an object representing a policy to use.
374
 
 
375
 
        This controls whether a new repository is created, and the format of
376
 
        that repository, or some existing shared repository used instead.
377
 
 
378
 
        If stack_on is supplied, will not seek a containing shared repo.
379
 
 
380
 
        :param force_new_repo: If True, require a new repository to be created.
381
 
        :param stack_on: If supplied, the location to stack on.  If not
382
 
            supplied, a default_stack_on location may be used.
383
 
        :param stack_on_pwd: If stack_on is relative, the location it is
384
 
            relative to.
385
 
        """
386
 
        def repository_policy(found_bzrdir):
387
 
            stack_on = None
388
 
            stack_on_pwd = None
389
 
            config = found_bzrdir.get_config()
390
 
            stop = False
391
 
            stack_on = config.get_default_stack_on()
392
 
            if stack_on is not None:
393
 
                stack_on_pwd = found_bzrdir.user_url
394
 
                stop = True
395
 
            # does it have a repository ?
396
 
            try:
397
 
                repository = found_bzrdir.open_repository()
398
 
            except errors.NoRepositoryPresent:
399
 
                repository = None
400
 
            else:
401
 
                if (found_bzrdir.user_url != self.user_url 
402
 
                    and not repository.is_shared()):
403
 
                    # Don't look higher, can't use a higher shared repo.
404
 
                    repository = None
405
 
                    stop = True
406
 
                else:
407
 
                    stop = True
408
 
            if not stop:
409
 
                return None, False
410
 
            if repository:
411
 
                return UseExistingRepository(repository, stack_on,
412
 
                    stack_on_pwd, require_stacking=require_stacking), True
413
 
            else:
414
 
                return CreateRepository(self, stack_on, stack_on_pwd,
415
 
                    require_stacking=require_stacking), True
416
 
 
417
 
        if not force_new_repo:
418
 
            if stack_on is None:
419
 
                policy = self._find_containing(repository_policy)
420
 
                if policy is not None:
421
 
                    return policy
422
 
            else:
423
 
                try:
424
 
                    return UseExistingRepository(self.open_repository(),
425
 
                        stack_on, stack_on_pwd,
426
 
                        require_stacking=require_stacking)
427
 
                except errors.NoRepositoryPresent:
428
 
                    pass
429
 
        return CreateRepository(self, stack_on, stack_on_pwd,
430
 
                                require_stacking=require_stacking)
431
 
 
432
234
    def _find_or_create_repository(self, force_new_repo):
433
235
        """Create a new repository if needed, returning the repository."""
434
 
        policy = self.determine_repository_policy(force_new_repo)
435
 
        return policy.acquire_repository()[0]
436
 
 
 
236
        if force_new_repo:
 
237
            return self.create_repository()
 
238
        try:
 
239
            return self.find_repository()
 
240
        except errors.NoRepositoryPresent:
 
241
            return self.create_repository()
 
242
        
437
243
    @staticmethod
438
244
    def create_branch_convenience(base, force_new_repo=False,
439
 
                                  force_new_tree=None, format=None,
440
 
                                  possible_transports=None):
 
245
                                  force_new_tree=None, format=None):
441
246
        """Create a new BzrDir, Branch and Repository at the url 'base'.
442
247
 
443
248
        This is a convenience function - it will use an existing repository
444
249
        if possible, can be told explicitly whether to create a working tree or
445
250
        not.
446
251
 
447
 
        This will use the current default BzrDirFormat unless one is
448
 
        specified, and use whatever
 
252
        This will use the current default BzrDirFormat, and use whatever 
449
253
        repository format that that uses via bzrdir.create_branch and
450
254
        create_repository. If a shared repository is available that is used
451
255
        preferentially. Whatever repository is used, its tree creation policy
453
257
 
454
258
        The created Branch object is returned.
455
259
        If a working tree cannot be made due to base not being a file:// url,
456
 
        no error is raised unless force_new_tree is True, in which case no
 
260
        no error is raised unless force_new_tree is True, in which case no 
457
261
        data is created on disk and NotLocalUrl is raised.
458
262
 
459
263
        :param base: The URL to create the branch at.
460
264
        :param force_new_repo: If True a new repository is always created.
461
 
        :param force_new_tree: If True or False force creation of a tree or
 
265
        :param force_new_tree: If True or False force creation of a tree or 
462
266
                               prevent such creation respectively.
463
 
        :param format: Override for the bzrdir format to create.
464
 
        :param possible_transports: An optional reusable transports list.
 
267
        :param format: Override for the for the bzrdir format to create
465
268
        """
466
269
        if force_new_tree:
467
270
            # check for non local urls
468
 
            t = get_transport(base, possible_transports)
469
 
            if not isinstance(t, local.LocalTransport):
 
271
            t = get_transport(safe_unicode(base))
 
272
            if not isinstance(t, LocalTransport):
470
273
                raise errors.NotLocalUrl(base)
471
 
        bzrdir = BzrDir.create(base, format, possible_transports)
 
274
        if format is None:
 
275
            bzrdir = BzrDir.create(base)
 
276
        else:
 
277
            bzrdir = format.initialize(base)
472
278
        repo = bzrdir._find_or_create_repository(force_new_repo)
473
279
        result = bzrdir.create_branch()
474
 
        if force_new_tree or (repo.make_working_trees() and
 
280
        if force_new_tree or (repo.make_working_trees() and 
475
281
                              force_new_tree is None):
476
282
            try:
477
283
                bzrdir.create_workingtree()
478
284
            except errors.NotLocalUrl:
479
285
                pass
480
286
        return result
481
 
 
482
 
    @staticmethod
483
 
    def create_standalone_workingtree(base, format=None):
 
287
        
 
288
    @staticmethod
 
289
    def create_repository(base, shared=False):
 
290
        """Create a new BzrDir and Repository at the url 'base'.
 
291
 
 
292
        This will use the current default BzrDirFormat, and use whatever 
 
293
        repository format that that uses for bzrdirformat.create_repository.
 
294
 
 
295
        ;param shared: Create a shared repository rather than a standalone
 
296
                       repository.
 
297
        The Repository object is returned.
 
298
 
 
299
        This must be overridden as an instance method in child classes, where
 
300
        it should take no parameters and construct whatever repository format
 
301
        that child class desires.
 
302
        """
 
303
        bzrdir = BzrDir.create(base)
 
304
        return bzrdir.create_repository(shared)
 
305
 
 
306
    @staticmethod
 
307
    def create_standalone_workingtree(base):
484
308
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
485
309
 
486
310
        'base' must be a local path or a file:// url.
487
311
 
488
 
        This will use the current default BzrDirFormat unless one is
489
 
        specified, and use whatever
 
312
        This will use the current default BzrDirFormat, and use whatever 
490
313
        repository format that that uses for bzrdirformat.create_workingtree,
491
314
        create_branch and create_repository.
492
315
 
493
 
        :param format: Override for the bzrdir format to create.
494
 
        :return: The WorkingTree object.
 
316
        The WorkingTree object is returned.
495
317
        """
496
 
        t = get_transport(base)
497
 
        if not isinstance(t, local.LocalTransport):
 
318
        t = get_transport(safe_unicode(base))
 
319
        if not isinstance(t, LocalTransport):
498
320
            raise errors.NotLocalUrl(base)
499
 
        bzrdir = BzrDir.create_branch_and_repo(base,
500
 
                                               force_new_repo=True,
501
 
                                               format=format).bzrdir
 
321
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
 
322
                                               force_new_repo=True).bzrdir
502
323
        return bzrdir.create_workingtree()
503
324
 
504
 
    @deprecated_method(deprecated_in((2, 3, 0)))
505
 
    def generate_backup_name(self, base):
506
 
        return self._available_backup_name(base)
507
 
 
508
 
    def _available_backup_name(self, base):
509
 
        """Find a non-existing backup file name based on base.
510
 
 
511
 
        See bzrlib.osutils.available_backup_name about race conditions.
512
 
        """
513
 
        return osutils.available_backup_name(base, self.root_transport.has)
514
 
 
515
 
    def backup_bzrdir(self):
516
 
        """Backup this bzr control directory.
517
 
 
518
 
        :return: Tuple with old path name and new path name
519
 
        """
520
 
 
521
 
        pb = ui.ui_factory.nested_progress_bar()
 
325
    def create_workingtree(self, revision_id=None):
 
326
        """Create a working tree at this BzrDir.
 
327
        
 
328
        revision_id: create it as of this revision id.
 
329
        """
 
330
        raise NotImplementedError(self.create_workingtree)
 
331
 
 
332
    def find_repository(self):
 
333
        """Find the repository that should be used for a_bzrdir.
 
334
 
 
335
        This does not require a branch as we use it to find the repo for
 
336
        new branches as well as to hook existing branches up to their
 
337
        repository.
 
338
        """
522
339
        try:
523
 
            old_path = self.root_transport.abspath('.bzr')
524
 
            backup_dir = self._available_backup_name('backup.bzr')
525
 
            new_path = self.root_transport.abspath(backup_dir)
526
 
            ui.ui_factory.note('making backup of %s\n  to %s'
527
 
                               % (old_path, new_path,))
528
 
            self.root_transport.copy_tree('.bzr', backup_dir)
529
 
            return (old_path, new_path)
530
 
        finally:
531
 
            pb.finished()
532
 
 
533
 
    def retire_bzrdir(self, limit=10000):
534
 
        """Permanently disable the bzrdir.
535
 
 
536
 
        This is done by renaming it to give the user some ability to recover
537
 
        if there was a problem.
538
 
 
539
 
        This will have horrible consequences if anyone has anything locked or
540
 
        in use.
541
 
        :param limit: number of times to retry
542
 
        """
543
 
        i  = 0
544
 
        while True:
545
 
            try:
546
 
                to_path = '.bzr.retired.%d' % i
547
 
                self.root_transport.rename('.bzr', to_path)
548
 
                note("renamed %s to %s"
549
 
                    % (self.root_transport.abspath('.bzr'), to_path))
550
 
                return
551
 
            except (errors.TransportError, IOError, errors.PathError):
552
 
                i += 1
553
 
                if i > limit:
554
 
                    raise
555
 
                else:
556
 
                    pass
557
 
 
558
 
    def _find_containing(self, evaluate):
559
 
        """Find something in a containing control directory.
560
 
 
561
 
        This method will scan containing control dirs, until it finds what
562
 
        it is looking for, decides that it will never find it, or runs out
563
 
        of containing control directories to check.
564
 
 
565
 
        It is used to implement find_repository and
566
 
        determine_repository_policy.
567
 
 
568
 
        :param evaluate: A function returning (value, stop).  If stop is True,
569
 
            the value will be returned.
570
 
        """
571
 
        found_bzrdir = self
572
 
        while True:
573
 
            result, stop = evaluate(found_bzrdir)
574
 
            if stop:
575
 
                return result
576
 
            next_transport = found_bzrdir.root_transport.clone('..')
577
 
            if (found_bzrdir.user_url == next_transport.base):
578
 
                # top of the file system
579
 
                return None
 
340
            return self.open_repository()
 
341
        except errors.NoRepositoryPresent:
 
342
            pass
 
343
        next_transport = self.root_transport.clone('..')
 
344
        while True:
580
345
            # find the next containing bzrdir
581
346
            try:
582
347
                found_bzrdir = BzrDir.open_containing_from_transport(
583
348
                    next_transport)[0]
584
349
            except errors.NotBranchError:
585
 
                return None
586
 
 
587
 
    def find_repository(self):
588
 
        """Find the repository that should be used.
589
 
 
590
 
        This does not require a branch as we use it to find the repo for
591
 
        new branches as well as to hook existing branches up to their
592
 
        repository.
593
 
        """
594
 
        def usable_repository(found_bzrdir):
 
350
                # none found
 
351
                raise errors.NoRepositoryPresent(self)
595
352
            # does it have a repository ?
596
353
            try:
597
354
                repository = found_bzrdir.open_repository()
598
355
            except errors.NoRepositoryPresent:
599
 
                return None, False
600
 
            if found_bzrdir.user_url == self.user_url:
601
 
                return repository, True
602
 
            elif repository.is_shared():
603
 
                return repository, True
604
 
            else:
605
 
                return None, True
606
 
 
607
 
        found_repo = self._find_containing(usable_repository)
608
 
        if found_repo is None:
609
 
            raise errors.NoRepositoryPresent(self)
610
 
        return found_repo
611
 
 
612
 
    def _find_creation_modes(self):
613
 
        """Determine the appropriate modes for files and directories.
614
 
 
615
 
        They're always set to be consistent with the base directory,
616
 
        assuming that this transport allows setting modes.
617
 
        """
618
 
        # TODO: Do we need or want an option (maybe a config setting) to turn
619
 
        # this off or override it for particular locations? -- mbp 20080512
620
 
        if self._mode_check_done:
621
 
            return
622
 
        self._mode_check_done = True
623
 
        try:
624
 
            st = self.transport.stat('.')
625
 
        except errors.TransportNotPossible:
626
 
            self._dir_mode = None
627
 
            self._file_mode = None
628
 
        else:
629
 
            # Check the directory mode, but also make sure the created
630
 
            # directories and files are read-write for this user. This is
631
 
            # mostly a workaround for filesystems which lie about being able to
632
 
            # write to a directory (cygwin & win32)
633
 
            if (st.st_mode & 07777 == 00000):
634
 
                # FTP allows stat but does not return dir/file modes
635
 
                self._dir_mode = None
636
 
                self._file_mode = None
637
 
            else:
638
 
                self._dir_mode = (st.st_mode & 07777) | 00700
639
 
                # Remove the sticky and execute bits for files
640
 
                self._file_mode = self._dir_mode & ~07111
641
 
 
642
 
    def _get_file_mode(self):
643
 
        """Return Unix mode for newly created files, or None.
644
 
        """
645
 
        if not self._mode_check_done:
646
 
            self._find_creation_modes()
647
 
        return self._file_mode
648
 
 
649
 
    def _get_dir_mode(self):
650
 
        """Return Unix mode for newly created directories, or None.
651
 
        """
652
 
        if not self._mode_check_done:
653
 
            self._find_creation_modes()
654
 
        return self._dir_mode
655
 
 
656
 
    def get_config(self):
657
 
        """Get configuration for this BzrDir."""
658
 
        return config.BzrDirConfig(self)
659
 
 
660
 
    def _get_config(self):
661
 
        """By default, no configuration is available."""
662
 
        return None
663
 
 
 
356
                next_transport = found_bzrdir.root_transport.clone('..')
 
357
                if (found_bzrdir.root_transport.base == next_transport.base):
 
358
                    # top of the file system
 
359
                    break
 
360
                else:
 
361
                    continue
 
362
            if ((found_bzrdir.root_transport.base == 
 
363
                 self.root_transport.base) or repository.is_shared()):
 
364
                return repository
 
365
            else:
 
366
                raise errors.NoRepositoryPresent(self)
 
367
        raise errors.NoRepositoryPresent(self)
 
368
 
 
369
    def get_branch_transport(self, branch_format):
 
370
        """Get the transport for use by branch format in this BzrDir.
 
371
 
 
372
        Note that bzr dirs that do not support format strings will raise
 
373
        IncompatibleFormat if the branch format they are given has
 
374
        a format string, and vice versa.
 
375
 
 
376
        If branch_format is None, the transport is returned with no 
 
377
        checking. if it is not None, then the returned transport is
 
378
        guaranteed to point to an existing directory ready for use.
 
379
        """
 
380
        raise NotImplementedError(self.get_branch_transport)
 
381
        
 
382
    def get_repository_transport(self, repository_format):
 
383
        """Get the transport for use by repository format in this BzrDir.
 
384
 
 
385
        Note that bzr dirs that do not support format strings will raise
 
386
        IncompatibleFormat if the repository format they are given has
 
387
        a format string, and vice versa.
 
388
 
 
389
        If repository_format is None, the transport is returned with no 
 
390
        checking. if it is not None, then the returned transport is
 
391
        guaranteed to point to an existing directory ready for use.
 
392
        """
 
393
        raise NotImplementedError(self.get_repository_transport)
 
394
        
 
395
    def get_workingtree_transport(self, tree_format):
 
396
        """Get the transport for use by workingtree format in this BzrDir.
 
397
 
 
398
        Note that bzr dirs that do not support format strings will raise
 
399
        IncompatibleFormat if the workingtree format they are given has
 
400
        a format string, and vice versa.
 
401
 
 
402
        If workingtree_format is None, the transport is returned with no 
 
403
        checking. if it is not None, then the returned transport is
 
404
        guaranteed to point to an existing directory ready for use.
 
405
        """
 
406
        raise NotImplementedError(self.get_workingtree_transport)
 
407
        
664
408
    def __init__(self, _transport, _format):
665
409
        """Initialize a Bzr control dir object.
666
 
 
 
410
        
667
411
        Only really common logic should reside here, concrete classes should be
668
412
        made with varying behaviours.
669
413
 
671
415
        :param _transport: the transport this dir is based at.
672
416
        """
673
417
        self._format = _format
674
 
        # these are also under the more standard names of 
675
 
        # control_transport and user_transport
676
418
        self.transport = _transport.clone('.bzr')
677
419
        self.root_transport = _transport
678
 
        self._mode_check_done = False
679
 
 
680
 
    @property 
681
 
    def user_transport(self):
682
 
        return self.root_transport
683
 
 
684
 
    @property
685
 
    def control_transport(self):
686
 
        return self.transport
687
420
 
688
421
    def is_control_filename(self, filename):
689
422
        """True if filename is the name of a path which is reserved for bzrdir's.
690
 
 
 
423
        
691
424
        :param filename: A filename within the root transport of this bzrdir.
692
425
 
693
426
        This is true IF and ONLY IF the filename is part of the namespace reserved
694
427
        for bzr control dirs. Currently this is the '.bzr' directory in the root
695
 
        of the root_transport. 
 
428
        of the root_transport. it is expected that plugins will need to extend
 
429
        this in the future - for instance to make bzr talk with svn working
 
430
        trees.
696
431
        """
697
 
        # this might be better on the BzrDirFormat class because it refers to
698
 
        # all the possible bzrdir disk formats.
699
 
        # This method is tested via the workingtree is_control_filename tests-
700
 
        # it was extracted from WorkingTree.is_control_filename. If the method's
701
 
        # contract is extended beyond the current trivial implementation, please
 
432
        # this might be better on the BzrDirFormat class because it refers to 
 
433
        # all the possible bzrdir disk formats. 
 
434
        # This method is tested via the workingtree is_control_filename tests- 
 
435
        # it was extracted from WorkingTree.is_control_filename. If the methods
 
436
        # contract is extended beyond the current trivial  implementation please
702
437
        # add new tests for it to the appropriate place.
703
438
        return filename == '.bzr' or filename.startswith('.bzr/')
704
439
 
 
440
    def needs_format_conversion(self, format=None):
 
441
        """Return true if this bzrdir needs convert_format run on it.
 
442
        
 
443
        For instance, if the repository format is out of date but the 
 
444
        branch and working tree are not, this should return True.
 
445
 
 
446
        :param format: Optional parameter indicating a specific desired
 
447
                       format we plan to arrive at.
 
448
        """
 
449
        raise NotImplementedError(self.needs_format_conversion)
 
450
 
705
451
    @staticmethod
706
452
    def open_unsupported(base):
707
453
        """Open a branch which is not supported."""
708
454
        return BzrDir.open(base, _unsupported=True)
709
 
 
710
 
    @staticmethod
711
 
    def open(base, _unsupported=False, possible_transports=None):
712
 
        """Open an existing bzrdir, rooted at 'base' (url).
713
 
 
714
 
        :param _unsupported: a private parameter to the BzrDir class.
715
 
        """
716
 
        t = get_transport(base, possible_transports=possible_transports)
717
 
        return BzrDir.open_from_transport(t, _unsupported=_unsupported)
718
 
 
719
 
    @staticmethod
720
 
    def open_from_transport(transport, _unsupported=False,
721
 
                            _server_formats=True):
722
 
        """Open a bzrdir within a particular directory.
723
 
 
724
 
        :param transport: Transport containing the bzrdir.
725
 
        :param _unsupported: private.
726
 
        """
727
 
        for hook in BzrDir.hooks['pre_open']:
728
 
            hook(transport)
729
 
        # Keep initial base since 'transport' may be modified while following
730
 
        # the redirections.
731
 
        base = transport.base
732
 
        def find_format(transport):
733
 
            return transport, controldir.ControlDirFormat.find_format(
734
 
                transport, _server_formats=_server_formats)
735
 
 
736
 
        def redirected(transport, e, redirection_notice):
737
 
            redirected_transport = transport._redirected_to(e.source, e.target)
738
 
            if redirected_transport is None:
739
 
                raise errors.NotBranchError(base)
740
 
            note('%s is%s redirected to %s',
741
 
                 transport.base, e.permanently, redirected_transport.base)
742
 
            return redirected_transport
743
 
 
744
 
        try:
745
 
            transport, format = do_catching_redirections(find_format,
746
 
                                                         transport,
747
 
                                                         redirected)
748
 
        except errors.TooManyRedirections:
749
 
            raise errors.NotBranchError(base)
750
 
 
 
455
        
 
456
    @staticmethod
 
457
    def open(base, _unsupported=False):
 
458
        """Open an existing bzrdir, rooted at 'base' (url)
 
459
        
 
460
        _unsupported is a private parameter to the BzrDir class.
 
461
        """
 
462
        t = get_transport(base)
 
463
        mutter("trying to open %r with transport %r", base, t)
 
464
        format = BzrDirFormat.find_format(t)
751
465
        BzrDir._check_supported(format, _unsupported)
752
 
        return format.open(transport, _found=True)
 
466
        return format.open(t, _found=True)
 
467
 
 
468
    def open_branch(self, unsupported=False):
 
469
        """Open the branch object at this BzrDir if one is present.
 
470
 
 
471
        If unsupported is True, then no longer supported branch formats can
 
472
        still be opened.
 
473
        
 
474
        TODO: static convenience version of this?
 
475
        """
 
476
        raise NotImplementedError(self.open_branch)
753
477
 
754
478
    @staticmethod
755
 
    def open_containing(url, possible_transports=None):
 
479
    def open_containing(url):
756
480
        """Open an existing branch which contains url.
757
 
 
 
481
        
758
482
        :param url: url to search from.
759
483
        See open_containing_from_transport for more detail.
760
484
        """
761
 
        transport = get_transport(url, possible_transports)
762
 
        return BzrDir.open_containing_from_transport(transport)
763
 
 
 
485
        return BzrDir.open_containing_from_transport(get_transport(url))
 
486
    
764
487
    @staticmethod
765
488
    def open_containing_from_transport(a_transport):
766
 
        """Open an existing branch which contains a_transport.base.
 
489
        """Open an existing branch which contains a_transport.base
767
490
 
768
491
        This probes for a branch at a_transport, and searches upwards from there.
769
492
 
770
493
        Basically we keep looking up until we find the control directory or
771
494
        run into the root.  If there isn't one, raises NotBranchError.
772
 
        If there is one and it is either an unrecognised format or an unsupported
 
495
        If there is one and it is either an unrecognised format or an unsupported 
773
496
        format, UnknownFormatError or UnsupportedFormatError are raised.
774
497
        If there is one, it is returned, along with the unused portion of url.
775
498
 
776
 
        :return: The BzrDir that contains the path, and a Unicode path
 
499
        :return: The BzrDir that contains the path, and a Unicode path 
777
500
                for the rest of the URL.
778
501
        """
779
502
        # this gets the normalised url back. I.e. '.' -> the full path.
780
503
        url = a_transport.base
781
504
        while True:
782
505
            try:
783
 
                result = BzrDir.open_from_transport(a_transport)
784
 
                return result, urlutils.unescape(a_transport.relpath(url))
 
506
                format = BzrDirFormat.find_format(a_transport)
 
507
                BzrDir._check_supported(format, False)
 
508
                return format.open(a_transport), urlutils.unescape(a_transport.relpath(url))
785
509
            except errors.NotBranchError, e:
 
510
                ## mutter('not a branch in: %r %s', a_transport.base, e)
786
511
                pass
787
 
            try:
788
 
                new_t = a_transport.clone('..')
789
 
            except errors.InvalidURLJoin:
790
 
                # reached the root, whatever that may be
791
 
                raise errors.NotBranchError(path=url)
 
512
            new_t = a_transport.clone('..')
792
513
            if new_t.base == a_transport.base:
793
514
                # reached the root, whatever that may be
794
515
                raise errors.NotBranchError(path=url)
795
516
            a_transport = new_t
796
517
 
797
 
    @classmethod
798
 
    def open_tree_or_branch(klass, location):
799
 
        """Return the branch and working tree at a location.
800
 
 
801
 
        If there is no tree at the location, tree will be None.
802
 
        If there is no branch at the location, an exception will be
803
 
        raised
804
 
        :return: (tree, branch)
805
 
        """
806
 
        bzrdir = klass.open(location)
807
 
        return bzrdir._get_tree_branch()
808
 
 
809
 
    @classmethod
810
 
    def open_containing_tree_or_branch(klass, location):
811
 
        """Return the branch and working tree contained by a location.
812
 
 
813
 
        Returns (tree, branch, relpath).
814
 
        If there is no tree at containing the location, tree will be None.
815
 
        If there is no branch containing the location, an exception will be
816
 
        raised
817
 
        relpath is the portion of the path that is contained by the branch.
818
 
        """
819
 
        bzrdir, relpath = klass.open_containing(location)
820
 
        tree, branch = bzrdir._get_tree_branch()
821
 
        return tree, branch, relpath
822
 
 
823
 
    @classmethod
824
 
    def open_containing_tree_branch_or_repository(klass, location):
825
 
        """Return the working tree, branch and repo contained by a location.
826
 
 
827
 
        Returns (tree, branch, repository, relpath).
828
 
        If there is no tree containing the location, tree will be None.
829
 
        If there is no branch containing the location, branch will be None.
830
 
        If there is no repository containing the location, repository will be
831
 
        None.
832
 
        relpath is the portion of the path that is contained by the innermost
833
 
        BzrDir.
834
 
 
835
 
        If no tree, branch or repository is found, a NotBranchError is raised.
836
 
        """
837
 
        bzrdir, relpath = klass.open_containing(location)
838
 
        try:
839
 
            tree, branch = bzrdir._get_tree_branch()
840
 
        except errors.NotBranchError:
841
 
            try:
842
 
                repo = bzrdir.find_repository()
843
 
                return None, None, repo, relpath
844
 
            except (errors.NoRepositoryPresent):
845
 
                raise errors.NotBranchError(location)
846
 
        return tree, branch, branch.repository, relpath
847
 
 
848
 
    def _cloning_metadir(self):
849
 
        """Produce a metadir suitable for cloning with.
850
 
 
851
 
        :returns: (destination_bzrdir_format, source_repository)
852
 
        """
853
 
        result_format = self._format.__class__()
854
 
        try:
855
 
            try:
856
 
                branch = self.open_branch(ignore_fallbacks=True)
857
 
                source_repository = branch.repository
858
 
                result_format._branch_format = branch._format
859
 
            except errors.NotBranchError:
860
 
                source_branch = None
 
518
    def open_repository(self, _unsupported=False):
 
519
        """Open the repository object at this BzrDir if one is present.
 
520
 
 
521
        This will not follow the Branch object pointer - its strictly a direct
 
522
        open facility. Most client code should use open_branch().repository to
 
523
        get at a repository.
 
524
 
 
525
        _unsupported is a private parameter, not part of the api.
 
526
        TODO: static convenience version of this?
 
527
        """
 
528
        raise NotImplementedError(self.open_repository)
 
529
 
 
530
    def open_workingtree(self, _unsupported=False):
 
531
        """Open the workingtree object at this BzrDir if one is present.
 
532
        
 
533
        TODO: static convenience version of this?
 
534
        """
 
535
        raise NotImplementedError(self.open_workingtree)
 
536
 
 
537
    def has_branch(self):
 
538
        """Tell if this bzrdir contains a branch.
 
539
        
 
540
        Note: if you're going to open the branch, you should just go ahead
 
541
        and try, and not ask permission first.  (This method just opens the 
 
542
        branch and discards it, and that's somewhat expensive.) 
 
543
        """
 
544
        try:
 
545
            self.open_branch()
 
546
            return True
 
547
        except errors.NotBranchError:
 
548
            return False
 
549
 
 
550
    def has_workingtree(self):
 
551
        """Tell if this bzrdir contains a working tree.
 
552
 
 
553
        This will still raise an exception if the bzrdir has a workingtree that
 
554
        is remote & inaccessible.
 
555
        
 
556
        Note: if you're going to open the working tree, you should just go ahead
 
557
        and try, and not ask permission first.  (This method just opens the 
 
558
        workingtree and discards it, and that's somewhat expensive.) 
 
559
        """
 
560
        try:
 
561
            self.open_workingtree()
 
562
            return True
 
563
        except errors.NoWorkingTree:
 
564
            return False
 
565
 
 
566
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
 
567
        """Create a copy of this bzrdir prepared for use as a new line of
 
568
        development.
 
569
 
 
570
        If urls last component does not exist, it will be created.
 
571
 
 
572
        Attributes related to the identity of the source branch like
 
573
        branch nickname will be cleaned, a working tree is created
 
574
        whether one existed before or not; and a local branch is always
 
575
        created.
 
576
 
 
577
        if revision_id is not None, then the clone operation may tune
 
578
            itself to download less data.
 
579
        """
 
580
        self._make_tail(url)
 
581
        result = self._format.initialize(url)
 
582
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
583
        try:
 
584
            source_branch = self.open_branch()
 
585
            source_repository = source_branch.repository
 
586
        except errors.NotBranchError:
 
587
            source_branch = None
 
588
            try:
861
589
                source_repository = self.open_repository()
862
 
        except errors.NoRepositoryPresent:
863
 
            source_repository = None
864
 
        else:
865
 
            # XXX TODO: This isinstance is here because we have not implemented
866
 
            # the fix recommended in bug # 103195 - to delegate this choice the
867
 
            # repository itself.
868
 
            repo_format = source_repository._format
869
 
            if isinstance(repo_format, remote.RemoteRepositoryFormat):
870
 
                source_repository._ensure_real()
871
 
                repo_format = source_repository._real_repository._format
872
 
            result_format.repository_format = repo_format
873
 
        try:
874
 
            # TODO: Couldn't we just probe for the format in these cases,
875
 
            # rather than opening the whole tree?  It would be a little
876
 
            # faster. mbp 20070401
877
 
            tree = self.open_workingtree(recommend_upgrade=False)
878
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
879
 
            result_format.workingtree_format = None
880
 
        else:
881
 
            result_format.workingtree_format = tree._format.__class__()
882
 
        return result_format, source_repository
883
 
 
884
 
    def cloning_metadir(self, require_stacking=False):
885
 
        """Produce a metadir suitable for cloning or sprouting with.
886
 
 
887
 
        These operations may produce workingtrees (yes, even though they're
888
 
        "cloning" something that doesn't have a tree), so a viable workingtree
889
 
        format must be selected.
890
 
 
891
 
        :require_stacking: If True, non-stackable formats will be upgraded
892
 
            to similar stackable formats.
893
 
        :returns: a BzrDirFormat with all component formats either set
894
 
            appropriately or set to None if that component should not be
895
 
            created.
896
 
        """
897
 
        format, repository = self._cloning_metadir()
898
 
        if format._workingtree_format is None:
899
 
            # No tree in self.
900
 
            if repository is None:
901
 
                # No repository either
902
 
                return format
903
 
            # We have a repository, so set a working tree? (Why? This seems to
904
 
            # contradict the stated return value in the docstring).
905
 
            tree_format = repository._format._matchingbzrdir.workingtree_format
906
 
            format.workingtree_format = tree_format.__class__()
907
 
        if require_stacking:
908
 
            format.require_stacking()
909
 
        return format
910
 
 
911
 
    @classmethod
912
 
    def create(cls, base, format=None, possible_transports=None):
913
 
        """Create a new BzrDir at the url 'base'.
914
 
 
915
 
        :param format: If supplied, the format of branch to create.  If not
916
 
            supplied, the default is used.
917
 
        :param possible_transports: If supplied, a list of transports that
918
 
            can be reused to share a remote connection.
919
 
        """
920
 
        if cls is not BzrDir:
921
 
            raise AssertionError("BzrDir.create always creates the"
922
 
                "default format, not one of %r" % cls)
923
 
        t = get_transport(base, possible_transports)
924
 
        t.ensure_base()
925
 
        if format is None:
926
 
            format = controldir.ControlDirFormat.get_default_format()
927
 
        return format.initialize_on_transport(t)
928
 
 
929
 
 
930
 
 
931
 
class BzrDirHooks(hooks.Hooks):
932
 
    """Hooks for BzrDir operations."""
933
 
 
934
 
    def __init__(self):
935
 
        """Create the default hooks."""
936
 
        hooks.Hooks.__init__(self)
937
 
        self.create_hook(hooks.HookPoint('pre_open',
938
 
            "Invoked before attempting to open a BzrDir with the transport "
939
 
            "that the open will use.", (1, 14), None))
940
 
        self.create_hook(hooks.HookPoint('post_repo_init',
941
 
            "Invoked after a repository has been initialized. "
942
 
            "post_repo_init is called with a "
943
 
            "bzrlib.bzrdir.RepoInitHookParams.",
944
 
            (2, 2), None))
945
 
 
946
 
# install the default hooks
947
 
BzrDir.hooks = BzrDirHooks()
948
 
 
949
 
 
950
 
class RepoInitHookParams(object):
951
 
    """Object holding parameters passed to *_repo_init hooks.
952
 
 
953
 
    There are 4 fields that hooks may wish to access:
954
 
 
955
 
    :ivar repository: Repository created
956
 
    :ivar format: Repository format
957
 
    :ivar bzrdir: The bzrdir for the repository
958
 
    :ivar shared: The repository is shared
959
 
    """
960
 
 
961
 
    def __init__(self, repository, format, a_bzrdir, shared):
962
 
        """Create a group of RepoInitHook parameters.
963
 
 
964
 
        :param repository: Repository created
965
 
        :param format: Repository format
966
 
        :param bzrdir: The bzrdir for the repository
967
 
        :param shared: The repository is shared
968
 
        """
969
 
        self.repository = repository
970
 
        self.format = format
971
 
        self.bzrdir = a_bzrdir
972
 
        self.shared = shared
973
 
 
974
 
    def __eq__(self, other):
975
 
        return self.__dict__ == other.__dict__
976
 
 
977
 
    def __repr__(self):
978
 
        if self.repository:
979
 
            return "<%s for %s>" % (self.__class__.__name__,
980
 
                self.repository)
981
 
        else:
982
 
            return "<%s for %s>" % (self.__class__.__name__,
983
 
                self.bzrdir)
 
590
            except errors.NoRepositoryPresent:
 
591
                # copy the entire basis one if there is one
 
592
                # but there is no repository.
 
593
                source_repository = basis_repo
 
594
        if force_new_repo:
 
595
            result_repo = None
 
596
        else:
 
597
            try:
 
598
                result_repo = result.find_repository()
 
599
            except errors.NoRepositoryPresent:
 
600
                result_repo = None
 
601
        if source_repository is None and result_repo is not None:
 
602
            pass
 
603
        elif source_repository is None and result_repo is None:
 
604
            # no repo available, make a new one
 
605
            result.create_repository()
 
606
        elif source_repository is not None and result_repo is None:
 
607
            # have source, and want to make a new target repo
 
608
            # we don't clone the repo because that preserves attributes
 
609
            # like is_shared(), and we have not yet implemented a 
 
610
            # repository sprout().
 
611
            result_repo = result.create_repository()
 
612
        if result_repo is not None:
 
613
            # fetch needed content into target.
 
614
            if basis_repo:
 
615
                # XXX FIXME RBC 20060214 need tests for this when the basis
 
616
                # is incomplete
 
617
                result_repo.fetch(basis_repo, revision_id=revision_id)
 
618
            result_repo.fetch(source_repository, revision_id=revision_id)
 
619
        if source_branch is not None:
 
620
            source_branch.sprout(result, revision_id=revision_id)
 
621
        else:
 
622
            result.create_branch()
 
623
        # TODO: jam 20060426 we probably need a test in here in the
 
624
        #       case that the newly sprouted branch is a remote one
 
625
        if result_repo is None or result_repo.make_working_trees():
 
626
            result.create_workingtree()
 
627
        return result
984
628
 
985
629
 
986
630
class BzrDirPreSplitOut(BzrDir):
989
633
    def __init__(self, _transport, _format):
990
634
        """See BzrDir.__init__."""
991
635
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
992
 
        self._control_files = lockable_files.LockableFiles(
993
 
                                            self.get_branch_transport(None),
 
636
        assert self._format._lock_class == TransportLock
 
637
        assert self._format._lock_file_name == 'branch-lock'
 
638
        self._control_files = LockableFiles(self.get_branch_transport(None),
994
639
                                            self._format._lock_file_name,
995
640
                                            self._format._lock_class)
996
641
 
998
643
        """Pre-splitout bzrdirs do not suffer from stale locks."""
999
644
        raise NotImplementedError(self.break_lock)
1000
645
 
1001
 
    def cloning_metadir(self, require_stacking=False):
1002
 
        """Produce a metadir suitable for cloning with."""
1003
 
        if require_stacking:
1004
 
            return controldir.format_registry.make_bzrdir('1.6')
1005
 
        return self._format.__class__()
1006
 
 
1007
 
    def clone(self, url, revision_id=None, force_new_repo=False,
1008
 
              preserve_stacking=False):
1009
 
        """See BzrDir.clone().
1010
 
 
1011
 
        force_new_repo has no effect, since this family of formats always
1012
 
        require a new repository.
1013
 
        preserve_stacking has no effect, since no source branch using this
1014
 
        family of formats can be stacked, so there is no stacking to preserve.
1015
 
        """
 
646
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
 
647
        """See BzrDir.clone()."""
 
648
        from bzrlib.workingtree import WorkingTreeFormat2
1016
649
        self._make_tail(url)
1017
650
        result = self._format._initialize_for_clone(url)
1018
 
        self.open_repository().clone(result, revision_id=revision_id)
 
651
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
652
        self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
1019
653
        from_branch = self.open_branch()
1020
654
        from_branch.clone(result, revision_id=revision_id)
1021
655
        try:
1022
 
            tree = self.open_workingtree()
 
656
            self.open_workingtree().clone(result, basis=basis_tree)
1023
657
        except errors.NotLocalUrl:
1024
658
            # make a new one, this format always has to have one.
1025
 
            result._init_workingtree()
1026
 
        else:
1027
 
            tree.clone(result)
 
659
            try:
 
660
                WorkingTreeFormat2().initialize(result)
 
661
            except errors.NotLocalUrl:
 
662
                # but we cannot do it for remote trees.
 
663
                to_branch = result.open_branch()
 
664
                WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
1028
665
        return result
1029
666
 
1030
 
    def create_branch(self, name=None):
 
667
    def create_branch(self):
1031
668
        """See BzrDir.create_branch."""
1032
 
        return self._format.get_branch_format().initialize(self, name=name)
1033
 
 
1034
 
    def destroy_branch(self, name=None):
1035
 
        """See BzrDir.destroy_branch."""
1036
 
        raise errors.UnsupportedOperation(self.destroy_branch, self)
 
669
        return self.open_branch()
1037
670
 
1038
671
    def create_repository(self, shared=False):
1039
672
        """See BzrDir.create_repository."""
1041
674
            raise errors.IncompatibleFormat('shared repository', self._format)
1042
675
        return self.open_repository()
1043
676
 
1044
 
    def destroy_repository(self):
1045
 
        """See BzrDir.destroy_repository."""
1046
 
        raise errors.UnsupportedOperation(self.destroy_repository, self)
1047
 
 
1048
 
    def create_workingtree(self, revision_id=None, from_branch=None,
1049
 
                           accelerator_tree=None, hardlink=False):
 
677
    def create_workingtree(self, revision_id=None):
1050
678
        """See BzrDir.create_workingtree."""
1051
 
        # The workingtree is sometimes created when the bzrdir is created,
1052
 
        # but not when cloning.
1053
 
 
1054
679
        # this looks buggy but is not -really-
1055
 
        # because this format creates the workingtree when the bzrdir is
1056
 
        # created
1057
680
        # clone and sprout will have set the revision_id
1058
681
        # and that will have set it for us, its only
1059
682
        # specific uses of create_workingtree in isolation
1060
683
        # that can do wonky stuff here, and that only
1061
 
        # happens for creating checkouts, which cannot be
 
684
        # happens for creating checkouts, which cannot be 
1062
685
        # done on this format anyway. So - acceptable wart.
1063
 
        if hardlink:
1064
 
            warning("can't support hardlinked working trees in %r"
1065
 
                % (self,))
1066
 
        try:
1067
 
            result = self.open_workingtree(recommend_upgrade=False)
1068
 
        except errors.NoSuchFile:
1069
 
            result = self._init_workingtree()
 
686
        result = self.open_workingtree()
1070
687
        if revision_id is not None:
1071
 
            if revision_id == _mod_revision.NULL_REVISION:
1072
 
                result.set_parent_ids([])
1073
 
            else:
1074
 
                result.set_parent_ids([revision_id])
 
688
            result.set_last_revision(revision_id)
1075
689
        return result
1076
690
 
1077
 
    def _init_workingtree(self):
1078
 
        from bzrlib.workingtree import WorkingTreeFormat2
1079
 
        try:
1080
 
            return WorkingTreeFormat2().initialize(self)
1081
 
        except errors.NotLocalUrl:
1082
 
            # Even though we can't access the working tree, we need to
1083
 
            # create its control files.
1084
 
            return WorkingTreeFormat2()._stub_initialize_on_transport(
1085
 
                self.transport, self._control_files._file_mode)
1086
 
 
1087
 
    def destroy_workingtree(self):
1088
 
        """See BzrDir.destroy_workingtree."""
1089
 
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1090
 
 
1091
 
    def destroy_workingtree_metadata(self):
1092
 
        """See BzrDir.destroy_workingtree_metadata."""
1093
 
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1094
 
                                          self)
1095
 
 
1096
 
    def get_branch_transport(self, branch_format, name=None):
 
691
    def get_branch_transport(self, branch_format):
1097
692
        """See BzrDir.get_branch_transport()."""
1098
 
        if name is not None:
1099
 
            raise errors.NoColocatedBranchSupport(self)
1100
693
        if branch_format is None:
1101
694
            return self.transport
1102
695
        try:
1130
723
        # if the format is not the same as the system default,
1131
724
        # an upgrade is needed.
1132
725
        if format is None:
1133
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1134
 
                % 'needs_format_conversion(format=None)')
1135
726
            format = BzrDirFormat.get_default_format()
1136
727
        return not isinstance(self._format, format.__class__)
1137
728
 
1138
 
    def open_branch(self, name=None, unsupported=False,
1139
 
                    ignore_fallbacks=False):
 
729
    def open_branch(self, unsupported=False):
1140
730
        """See BzrDir.open_branch."""
1141
731
        from bzrlib.branch import BzrBranchFormat4
1142
732
        format = BzrBranchFormat4()
1143
733
        self._check_supported(format, unsupported)
1144
 
        return format.open(self, name, _found=True)
 
734
        return format.open(self, _found=True)
1145
735
 
1146
 
    def sprout(self, url, revision_id=None, force_new_repo=False,
1147
 
               possible_transports=None, accelerator_tree=None,
1148
 
               hardlink=False, stacked=False, create_tree_if_local=True,
1149
 
               source_branch=None):
 
736
    def sprout(self, url, revision_id=None, basis=None):
1150
737
        """See BzrDir.sprout()."""
1151
 
        if source_branch is not None:
1152
 
            my_branch = self.open_branch()
1153
 
            if source_branch.base != my_branch.base:
1154
 
                raise AssertionError(
1155
 
                    "source branch %r is not within %r with branch %r" %
1156
 
                    (source_branch, self, my_branch))
1157
 
        if stacked:
1158
 
            raise errors.UnstackableBranchFormat(
1159
 
                self._format, self.root_transport.base)
1160
 
        if not create_tree_if_local:
1161
 
            raise errors.MustHaveWorkingTree(
1162
 
                self._format, self.root_transport.base)
1163
738
        from bzrlib.workingtree import WorkingTreeFormat2
1164
739
        self._make_tail(url)
1165
740
        result = self._format._initialize_for_clone(url)
 
741
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
1166
742
        try:
1167
 
            self.open_repository().clone(result, revision_id=revision_id)
 
743
            self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
1168
744
        except errors.NoRepositoryPresent:
1169
745
            pass
1170
746
        try:
1171
747
            self.open_branch().sprout(result, revision_id=revision_id)
1172
748
        except errors.NotBranchError:
1173
749
            pass
1174
 
 
1175
750
        # we always want a working tree
1176
 
        WorkingTreeFormat2().initialize(result,
1177
 
                                        accelerator_tree=accelerator_tree,
1178
 
                                        hardlink=hardlink)
 
751
        WorkingTreeFormat2().initialize(result)
1179
752
        return result
1180
753
 
1181
754
 
1182
755
class BzrDir4(BzrDirPreSplitOut):
1183
756
    """A .bzr version 4 control object.
1184
 
 
 
757
    
1185
758
    This is a deprecated format and may be removed after sept 2006.
1186
759
    """
1187
760
 
1191
764
 
1192
765
    def needs_format_conversion(self, format=None):
1193
766
        """Format 4 dirs are always in need of conversion."""
1194
 
        if format is None:
1195
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1196
 
                % 'needs_format_conversion(format=None)')
1197
767
        return True
1198
768
 
1199
769
    def open_repository(self):
1200
770
        """See BzrDir.open_repository."""
1201
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
771
        from bzrlib.repository import RepositoryFormat4
1202
772
        return RepositoryFormat4().open(self, _found=True)
1203
773
 
1204
774
 
1208
778
    This is a deprecated format and may be removed after sept 2006.
1209
779
    """
1210
780
 
1211
 
    def has_workingtree(self):
1212
 
        """See BzrDir.has_workingtree."""
1213
 
        return True
1214
 
    
1215
781
    def open_repository(self):
1216
782
        """See BzrDir.open_repository."""
1217
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
783
        from bzrlib.repository import RepositoryFormat5
1218
784
        return RepositoryFormat5().open(self, _found=True)
1219
785
 
1220
 
    def open_workingtree(self, _unsupported=False,
1221
 
            recommend_upgrade=True):
 
786
    def open_workingtree(self, _unsupported=False):
1222
787
        """See BzrDir.create_workingtree."""
1223
788
        from bzrlib.workingtree import WorkingTreeFormat2
1224
 
        wt_format = WorkingTreeFormat2()
1225
 
        # we don't warn here about upgrades; that ought to be handled for the
1226
 
        # bzrdir as a whole
1227
 
        return wt_format.open(self, _found=True)
 
789
        return WorkingTreeFormat2().open(self, _found=True)
1228
790
 
1229
791
 
1230
792
class BzrDir6(BzrDirPreSplitOut):
1233
795
    This is a deprecated format and may be removed after sept 2006.
1234
796
    """
1235
797
 
1236
 
    def has_workingtree(self):
1237
 
        """See BzrDir.has_workingtree."""
1238
 
        return True
1239
 
    
1240
798
    def open_repository(self):
1241
799
        """See BzrDir.open_repository."""
1242
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
800
        from bzrlib.repository import RepositoryFormat6
1243
801
        return RepositoryFormat6().open(self, _found=True)
1244
802
 
1245
 
    def open_workingtree(self, _unsupported=False,
1246
 
        recommend_upgrade=True):
 
803
    def open_workingtree(self, _unsupported=False):
1247
804
        """See BzrDir.create_workingtree."""
1248
 
        # we don't warn here about upgrades; that ought to be handled for the
1249
 
        # bzrdir as a whole
1250
805
        from bzrlib.workingtree import WorkingTreeFormat2
1251
806
        return WorkingTreeFormat2().open(self, _found=True)
1252
807
 
1253
808
 
1254
809
class BzrDirMeta1(BzrDir):
1255
810
    """A .bzr meta version 1 control object.
1256
 
 
1257
 
    This is the first control object where the
 
811
    
 
812
    This is the first control object where the 
1258
813
    individual aspects are really split out: there are separate repository,
1259
814
    workingtree and branch subdirectories and any subset of the three can be
1260
815
    present within a BzrDir.
1264
819
        """See BzrDir.can_convert_format()."""
1265
820
        return True
1266
821
 
1267
 
    def create_branch(self, name=None):
1268
 
        """See BzrDir.create_branch."""
1269
 
        return self._format.get_branch_format().initialize(self, name=name)
1270
 
 
1271
 
    def destroy_branch(self, name=None):
1272
 
        """See BzrDir.create_branch."""
1273
 
        if name is not None:
1274
 
            raise errors.NoColocatedBranchSupport(self)
1275
 
        self.transport.delete_tree('branch')
 
822
    def create_branch(self):
 
823
        """See BzrDir.create_branch."""
 
824
        from bzrlib.branch import BranchFormat
 
825
        return BranchFormat.get_default_format().initialize(self)
1276
826
 
1277
827
    def create_repository(self, shared=False):
1278
828
        """See BzrDir.create_repository."""
1279
829
        return self._format.repository_format.initialize(self, shared)
1280
830
 
1281
 
    def destroy_repository(self):
1282
 
        """See BzrDir.destroy_repository."""
1283
 
        self.transport.delete_tree('repository')
1284
 
 
1285
 
    def create_workingtree(self, revision_id=None, from_branch=None,
1286
 
                           accelerator_tree=None, hardlink=False):
 
831
    def create_workingtree(self, revision_id=None):
1287
832
        """See BzrDir.create_workingtree."""
1288
 
        return self._format.workingtree_format.initialize(
1289
 
            self, revision_id, from_branch=from_branch,
1290
 
            accelerator_tree=accelerator_tree, hardlink=hardlink)
1291
 
 
1292
 
    def destroy_workingtree(self):
1293
 
        """See BzrDir.destroy_workingtree."""
1294
 
        wt = self.open_workingtree(recommend_upgrade=False)
1295
 
        repository = wt.branch.repository
1296
 
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1297
 
        # We ignore the conflicts returned by wt.revert since we're about to
1298
 
        # delete the wt metadata anyway, all that should be left here are
1299
 
        # detritus. But see bug #634470 about subtree .bzr dirs.
1300
 
        conflicts = wt.revert(old_tree=empty)
1301
 
        self.destroy_workingtree_metadata()
1302
 
 
1303
 
    def destroy_workingtree_metadata(self):
1304
 
        self.transport.delete_tree('checkout')
1305
 
 
1306
 
    def find_branch_format(self, name=None):
1307
 
        """Find the branch 'format' for this bzrdir.
1308
 
 
1309
 
        This might be a synthetic object for e.g. RemoteBranch and SVN.
1310
 
        """
1311
 
        from bzrlib.branch import BranchFormat
1312
 
        return BranchFormat.find_format(self, name=name)
 
833
        from bzrlib.workingtree import WorkingTreeFormat
 
834
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
1313
835
 
1314
836
    def _get_mkdir_mode(self):
1315
837
        """Figure out the mode to use when creating a bzrdir subdir."""
1316
 
        temp_control = lockable_files.LockableFiles(self.transport, '',
1317
 
                                     lockable_files.TransportLock)
 
838
        temp_control = LockableFiles(self.transport, '', TransportLock)
1318
839
        return temp_control._dir_mode
1319
840
 
1320
 
    def get_branch_reference(self, name=None):
1321
 
        """See BzrDir.get_branch_reference()."""
1322
 
        from bzrlib.branch import BranchFormat
1323
 
        format = BranchFormat.find_format(self, name=name)
1324
 
        return format.get_reference(self, name=name)
1325
 
 
1326
 
    def get_branch_transport(self, branch_format, name=None):
 
841
    def get_branch_transport(self, branch_format):
1327
842
        """See BzrDir.get_branch_transport()."""
1328
 
        if name is not None:
1329
 
            raise errors.NoColocatedBranchSupport(self)
1330
 
        # XXX: this shouldn't implicitly create the directory if it's just
1331
 
        # promising to get a transport -- mbp 20090727
1332
843
        if branch_format is None:
1333
844
            return self.transport.clone('branch')
1334
845
        try:
1369
880
            pass
1370
881
        return self.transport.clone('checkout')
1371
882
 
1372
 
    def has_workingtree(self):
1373
 
        """Tell if this bzrdir contains a working tree.
1374
 
 
1375
 
        This will still raise an exception if the bzrdir has a workingtree that
1376
 
        is remote & inaccessible.
1377
 
 
1378
 
        Note: if you're going to open the working tree, you should just go
1379
 
        ahead and try, and not ask permission first.
1380
 
        """
1381
 
        from bzrlib.workingtree import WorkingTreeFormat
1382
 
        try:
1383
 
            WorkingTreeFormat.find_format(self)
1384
 
        except errors.NoWorkingTree:
1385
 
            return False
1386
 
        return True
1387
 
 
1388
883
    def needs_format_conversion(self, format=None):
1389
884
        """See BzrDir.needs_format_conversion()."""
1390
885
        if format is None:
1391
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1392
 
                % 'needs_format_conversion(format=None)')
1393
 
        if format is None:
1394
886
            format = BzrDirFormat.get_default_format()
1395
887
        if not isinstance(self._format, format.__class__):
1396
888
            # it is not a meta dir format, conversion is needed.
1403
895
                return True
1404
896
        except errors.NoRepositoryPresent:
1405
897
            pass
1406
 
        for branch in self.list_branches():
1407
 
            if not isinstance(branch._format,
1408
 
                              format.get_branch_format().__class__):
1409
 
                # the branch needs an upgrade.
1410
 
                return True
1411
 
        try:
1412
 
            my_wt = self.open_workingtree(recommend_upgrade=False)
1413
 
            if not isinstance(my_wt._format,
1414
 
                              format.workingtree_format.__class__):
1415
 
                # the workingtree needs an upgrade.
1416
 
                return True
1417
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
1418
 
            pass
 
898
        # currently there are no other possible conversions for meta1 formats.
1419
899
        return False
1420
900
 
1421
 
    def open_branch(self, name=None, unsupported=False,
1422
 
                    ignore_fallbacks=False):
 
901
    def open_branch(self, unsupported=False):
1423
902
        """See BzrDir.open_branch."""
1424
 
        format = self.find_branch_format(name=name)
 
903
        from bzrlib.branch import BranchFormat
 
904
        format = BranchFormat.find_format(self)
1425
905
        self._check_supported(format, unsupported)
1426
 
        return format.open(self, name=name,
1427
 
            _found=True, ignore_fallbacks=ignore_fallbacks)
 
906
        return format.open(self, _found=True)
1428
907
 
1429
908
    def open_repository(self, unsupported=False):
1430
909
        """See BzrDir.open_repository."""
1433
912
        self._check_supported(format, unsupported)
1434
913
        return format.open(self, _found=True)
1435
914
 
1436
 
    def open_workingtree(self, unsupported=False,
1437
 
            recommend_upgrade=True):
 
915
    def open_workingtree(self, unsupported=False):
1438
916
        """See BzrDir.open_workingtree."""
1439
917
        from bzrlib.workingtree import WorkingTreeFormat
1440
918
        format = WorkingTreeFormat.find_format(self)
1441
 
        self._check_supported(format, unsupported,
1442
 
            recommend_upgrade,
1443
 
            basedir=self.root_transport.base)
 
919
        self._check_supported(format, unsupported)
1444
920
        return format.open(self, _found=True)
1445
921
 
1446
 
    def _get_config(self):
1447
 
        return config.TransportConfig(self.transport, 'control.conf')
1448
 
 
1449
 
 
1450
 
class BzrProber(controldir.Prober):
1451
 
    """Prober for formats that use a .bzr/ control directory."""
1452
 
 
1453
 
    _formats = {}
1454
 
    """The known .bzr formats."""
1455
 
 
1456
 
    @classmethod
1457
 
    def register_bzrdir_format(klass, format):
1458
 
        klass._formats[format.get_format_string()] = format
1459
 
 
1460
 
    @classmethod
1461
 
    def unregister_bzrdir_format(klass, format):
1462
 
        del klass._formats[format.get_format_string()]
1463
 
 
1464
 
    @classmethod
1465
 
    def probe_transport(klass, transport):
1466
 
        """Return the .bzrdir style format present in a directory."""
1467
 
        try:
1468
 
            format_string = transport.get_bytes(".bzr/branch-format")
1469
 
        except errors.NoSuchFile:
1470
 
            raise errors.NotBranchError(path=transport.base)
1471
 
        try:
1472
 
            return klass._formats[format_string]
1473
 
        except KeyError:
1474
 
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1475
 
 
1476
 
 
1477
 
controldir.ControlDirFormat.register_prober(BzrProber)
1478
 
 
1479
 
 
1480
 
class RemoteBzrProber(controldir.Prober):
1481
 
    """Prober for remote servers that provide a Bazaar smart server."""
1482
 
 
1483
 
    @classmethod
1484
 
    def probe_transport(klass, transport):
1485
 
        """Return a RemoteBzrDirFormat object if it looks possible."""
1486
 
        try:
1487
 
            medium = transport.get_smart_medium()
1488
 
        except (NotImplementedError, AttributeError,
1489
 
                errors.TransportNotPossible, errors.NoSmartMedium,
1490
 
                errors.SmartProtocolError):
1491
 
            # no smart server, so not a branch for this format type.
1492
 
            raise errors.NotBranchError(path=transport.base)
1493
 
        else:
1494
 
            # Decline to open it if the server doesn't support our required
1495
 
            # version (3) so that the VFS-based transport will do it.
1496
 
            if medium.should_probe():
1497
 
                try:
1498
 
                    server_version = medium.protocol_version()
1499
 
                except errors.SmartProtocolError:
1500
 
                    # Apparently there's no usable smart server there, even though
1501
 
                    # the medium supports the smart protocol.
1502
 
                    raise errors.NotBranchError(path=transport.base)
1503
 
                if server_version != '2':
1504
 
                    raise errors.NotBranchError(path=transport.base)
1505
 
            return RemoteBzrDirFormat()
1506
 
 
1507
 
 
1508
 
class BzrDirFormat(controldir.ControlDirFormat):
1509
 
    """ControlDirFormat base class for .bzr/ directories.
1510
 
 
1511
 
    Formats are placed in a dict by their format string for reference
 
922
 
 
923
class BzrDirFormat(object):
 
924
    """An encapsulation of the initialization and open routines for a format.
 
925
 
 
926
    Formats provide three things:
 
927
     * An initialization routine,
 
928
     * a format string,
 
929
     * an open routine.
 
930
 
 
931
    Formats are placed in an dict by their format string for reference 
1512
932
    during bzrdir opening. These should be subclasses of BzrDirFormat
1513
933
    for consistency.
1514
934
 
1515
935
    Once a format is deprecated, just deprecate the initialize and open
1516
 
    methods on the format class. Do not deprecate the object, as the
 
936
    methods on the format class. Do not deprecate the object, as the 
1517
937
    object will be created every system load.
1518
938
    """
1519
939
 
 
940
    _default_format = None
 
941
    """The default format used for new .bzr dirs."""
 
942
 
 
943
    _formats = {}
 
944
    """The known formats."""
 
945
 
 
946
    _control_formats = []
 
947
    """The registered control formats - .bzr, ....
 
948
    
 
949
    This is a list of BzrDirFormat objects.
 
950
    """
 
951
 
1520
952
    _lock_file_name = 'branch-lock'
1521
953
 
1522
954
    # _lock_class must be set in subclasses to the lock type, typ.
1523
955
    # TransportLock or LockDir
1524
956
 
 
957
    @classmethod
 
958
    def find_format(klass, transport):
 
959
        """Return the format present at transport."""
 
960
        for format in klass._control_formats:
 
961
            try:
 
962
                return format.probe_transport(transport)
 
963
            except errors.NotBranchError:
 
964
                # this format does not find a control dir here.
 
965
                pass
 
966
        raise errors.NotBranchError(path=transport.base)
 
967
 
 
968
    @classmethod
 
969
    def probe_transport(klass, transport):
 
970
        """Return the .bzrdir style transport present at URL."""
 
971
        try:
 
972
            format_string = transport.get(".bzr/branch-format").read()
 
973
        except errors.NoSuchFile:
 
974
            raise errors.NotBranchError(path=transport.base)
 
975
 
 
976
        try:
 
977
            return klass._formats[format_string]
 
978
        except KeyError:
 
979
            raise errors.UnknownFormatError(format=format_string)
 
980
 
 
981
    @classmethod
 
982
    def get_default_format(klass):
 
983
        """Return the current default format."""
 
984
        return klass._default_format
 
985
 
1525
986
    def get_format_string(self):
1526
987
        """Return the ASCII format string that identifies this format."""
1527
988
        raise NotImplementedError(self.get_format_string)
1528
989
 
 
990
    def get_format_description(self):
 
991
        """Return the short description for this format."""
 
992
        raise NotImplementedError(self.get_format_description)
 
993
 
 
994
    def get_converter(self, format=None):
 
995
        """Return the converter to use to convert bzrdirs needing converts.
 
996
 
 
997
        This returns a bzrlib.bzrdir.Converter object.
 
998
 
 
999
        This should return the best upgrader to step this format towards the
 
1000
        current default format. In the case of plugins we can/should provide
 
1001
        some means for them to extend the range of returnable converters.
 
1002
 
 
1003
        :param format: Optional format to override the default format of the 
 
1004
                       library.
 
1005
        """
 
1006
        raise NotImplementedError(self.get_converter)
 
1007
 
 
1008
    def initialize(self, url):
 
1009
        """Create a bzr control dir at this url and return an opened copy.
 
1010
        
 
1011
        Subclasses should typically override initialize_on_transport
 
1012
        instead of this method.
 
1013
        """
 
1014
        return self.initialize_on_transport(get_transport(url))
 
1015
 
1529
1016
    def initialize_on_transport(self, transport):
1530
1017
        """Initialize a new bzrdir in the base directory of a Transport."""
1531
 
        try:
1532
 
            # can we hand off the request to the smart server rather than using
1533
 
            # vfs calls?
1534
 
            client_medium = transport.get_smart_medium()
1535
 
        except errors.NoSmartMedium:
1536
 
            return self._initialize_on_transport_vfs(transport)
1537
 
        else:
1538
 
            # Current RPC's only know how to create bzr metadir1 instances, so
1539
 
            # we still delegate to vfs methods if the requested format is not a
1540
 
            # metadir1
1541
 
            if type(self) != BzrDirMetaFormat1:
1542
 
                return self._initialize_on_transport_vfs(transport)
1543
 
            remote_format = RemoteBzrDirFormat()
1544
 
            self._supply_sub_formats_to(remote_format)
1545
 
            return remote_format.initialize_on_transport(transport)
1546
 
 
1547
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1548
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
1549
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1550
 
        shared_repo=False, vfs_only=False):
1551
 
        """Create this format on transport.
1552
 
 
1553
 
        The directory to initialize will be created.
1554
 
 
1555
 
        :param force_new_repo: Do not use a shared repository for the target,
1556
 
                               even if one is available.
1557
 
        :param create_prefix: Create any missing directories leading up to
1558
 
            to_transport.
1559
 
        :param use_existing_dir: Use an existing directory if one exists.
1560
 
        :param stacked_on: A url to stack any created branch on, None to follow
1561
 
            any target stacking policy.
1562
 
        :param stack_on_pwd: If stack_on is relative, the location it is
1563
 
            relative to.
1564
 
        :param repo_format_name: If non-None, a repository will be
1565
 
            made-or-found. Should none be found, or if force_new_repo is True
1566
 
            the repo_format_name is used to select the format of repository to
1567
 
            create.
1568
 
        :param make_working_trees: Control the setting of make_working_trees
1569
 
            for a new shared repository when one is made. None to use whatever
1570
 
            default the format has.
1571
 
        :param shared_repo: Control whether made repositories are shared or
1572
 
            not.
1573
 
        :param vfs_only: If True do not attempt to use a smart server
1574
 
        :return: repo, bzrdir, require_stacking, repository_policy. repo is
1575
 
            None if none was created or found, bzrdir is always valid.
1576
 
            require_stacking is the result of examining the stacked_on
1577
 
            parameter and any stacking policy found for the target.
1578
 
        """
1579
 
        if not vfs_only:
1580
 
            # Try to hand off to a smart server 
1581
 
            try:
1582
 
                client_medium = transport.get_smart_medium()
1583
 
            except errors.NoSmartMedium:
1584
 
                pass
1585
 
            else:
1586
 
                # TODO: lookup the local format from a server hint.
1587
 
                remote_dir_format = RemoteBzrDirFormat()
1588
 
                remote_dir_format._network_name = self.network_name()
1589
 
                self._supply_sub_formats_to(remote_dir_format)
1590
 
                return remote_dir_format.initialize_on_transport_ex(transport,
1591
 
                    use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1592
 
                    force_new_repo=force_new_repo, stacked_on=stacked_on,
1593
 
                    stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1594
 
                    make_working_trees=make_working_trees, shared_repo=shared_repo)
1595
 
        # XXX: Refactor the create_prefix/no_create_prefix code into a
1596
 
        #      common helper function
1597
 
        # The destination may not exist - if so make it according to policy.
1598
 
        def make_directory(transport):
1599
 
            transport.mkdir('.')
1600
 
            return transport
1601
 
        def redirected(transport, e, redirection_notice):
1602
 
            note(redirection_notice)
1603
 
            return transport._redirected_to(e.source, e.target)
1604
 
        try:
1605
 
            transport = do_catching_redirections(make_directory, transport,
1606
 
                redirected)
1607
 
        except errors.FileExists:
1608
 
            if not use_existing_dir:
1609
 
                raise
1610
 
        except errors.NoSuchFile:
1611
 
            if not create_prefix:
1612
 
                raise
1613
 
            transport.create_prefix()
1614
 
 
1615
 
        require_stacking = (stacked_on is not None)
1616
 
        # Now the target directory exists, but doesn't have a .bzr
1617
 
        # directory. So we need to create it, along with any work to create
1618
 
        # all of the dependent branches, etc.
1619
 
 
1620
 
        result = self.initialize_on_transport(transport)
1621
 
        if repo_format_name:
1622
 
            try:
1623
 
                # use a custom format
1624
 
                result._format.repository_format = \
1625
 
                    repository.network_format_registry.get(repo_format_name)
1626
 
            except AttributeError:
1627
 
                # The format didn't permit it to be set.
1628
 
                pass
1629
 
            # A repository is desired, either in-place or shared.
1630
 
            repository_policy = result.determine_repository_policy(
1631
 
                force_new_repo, stacked_on, stack_on_pwd,
1632
 
                require_stacking=require_stacking)
1633
 
            result_repo, is_new_repo = repository_policy.acquire_repository(
1634
 
                make_working_trees, shared_repo)
1635
 
            if not require_stacking and repository_policy._require_stacking:
1636
 
                require_stacking = True
1637
 
                result._format.require_stacking()
1638
 
            result_repo.lock_write()
1639
 
        else:
1640
 
            result_repo = None
1641
 
            repository_policy = None
1642
 
        return result_repo, result, require_stacking, repository_policy
1643
 
 
1644
 
    def _initialize_on_transport_vfs(self, transport):
1645
 
        """Initialize a new bzrdir using VFS calls.
1646
 
 
1647
 
        :param transport: The transport to create the .bzr directory in.
1648
 
        :return: A
1649
 
        """
1650
 
        # Since we are creating a .bzr directory, inherit the
 
1018
        # Since we don't have a .bzr directory, inherit the
1651
1019
        # mode from the root directory
1652
 
        temp_control = lockable_files.LockableFiles(transport,
1653
 
                            '', lockable_files.TransportLock)
 
1020
        temp_control = LockableFiles(transport, '', TransportLock)
1654
1021
        temp_control._transport.mkdir('.bzr',
1655
1022
                                      # FIXME: RBC 20060121 don't peek under
1656
1023
                                      # the covers
1657
1024
                                      mode=temp_control._dir_mode)
1658
 
        if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1659
 
            win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1660
1025
        file_mode = temp_control._file_mode
1661
1026
        del temp_control
1662
 
        bzrdir_transport = transport.clone('.bzr')
1663
 
        utf8_files = [('README',
1664
 
                       "This is a Bazaar control directory.\n"
1665
 
                       "Do not change any files in this directory.\n"
1666
 
                       "See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
 
1027
        mutter('created control directory in ' + transport.base)
 
1028
        control = transport.clone('.bzr')
 
1029
        utf8_files = [('README', 
 
1030
                       "This is a Bazaar-NG control directory.\n"
 
1031
                       "Do not change any files in this directory.\n"),
1667
1032
                      ('branch-format', self.get_format_string()),
1668
1033
                      ]
1669
1034
        # NB: no need to escape relative paths that are url safe.
1670
 
        control_files = lockable_files.LockableFiles(bzrdir_transport,
1671
 
            self._lock_file_name, self._lock_class)
 
1035
        control_files = LockableFiles(control, self._lock_file_name, 
 
1036
                                      self._lock_class)
1672
1037
        control_files.create_lock()
1673
1038
        control_files.lock_write()
1674
1039
        try:
1675
 
            for (filename, content) in utf8_files:
1676
 
                bzrdir_transport.put_bytes(filename, content,
1677
 
                    mode=file_mode)
 
1040
            for file, content in utf8_files:
 
1041
                control_files.put_utf8(file, content)
1678
1042
        finally:
1679
1043
            control_files.unlock()
1680
1044
        return self.open(transport, _found=True)
1681
1045
 
 
1046
    def is_supported(self):
 
1047
        """Is this format supported?
 
1048
 
 
1049
        Supported formats must be initializable and openable.
 
1050
        Unsupported formats may not support initialization or committing or 
 
1051
        some other features depending on the reason for not being supported.
 
1052
        """
 
1053
        return True
 
1054
 
 
1055
    @classmethod
 
1056
    def known_formats(klass):
 
1057
        """Return all the known formats.
 
1058
        
 
1059
        Concrete formats should override _known_formats.
 
1060
        """
 
1061
        # There is double indirection here to make sure that control 
 
1062
        # formats used by more than one dir format will only be probed 
 
1063
        # once. This can otherwise be quite expensive for remote connections.
 
1064
        result = set()
 
1065
        for format in klass._control_formats:
 
1066
            result.update(format._known_formats())
 
1067
        return result
 
1068
    
 
1069
    @classmethod
 
1070
    def _known_formats(klass):
 
1071
        """Return the known format instances for this control format."""
 
1072
        return set(klass._formats.values())
 
1073
 
1682
1074
    def open(self, transport, _found=False):
1683
1075
        """Return an instance of this format for the dir transport points at.
1684
 
 
 
1076
        
1685
1077
        _found is a private parameter, do not use it.
1686
1078
        """
1687
1079
        if not _found:
1688
 
            found_format = controldir.ControlDirFormat.find_format(transport)
1689
 
            if not isinstance(found_format, self.__class__):
1690
 
                raise AssertionError("%s was asked to open %s, but it seems to need "
1691
 
                        "format %s"
1692
 
                        % (self, transport, found_format))
1693
 
            # Allow subclasses - use the found format.
1694
 
            self._supply_sub_formats_to(found_format)
1695
 
            return found_format._open(transport)
 
1080
            assert isinstance(BzrDirFormat.find_format(transport),
 
1081
                              self.__class__)
1696
1082
        return self._open(transport)
1697
1083
 
1698
1084
    def _open(self, transport):
1705
1091
 
1706
1092
    @classmethod
1707
1093
    def register_format(klass, format):
1708
 
        BzrProber.register_bzrdir_format(format)
1709
 
        # bzr native formats have a network name of their format string.
1710
 
        controldir.network_format_registry.register(format.get_format_string(), format.__class__)
1711
 
        controldir.ControlDirFormat.register_format(format)
1712
 
 
1713
 
    def _supply_sub_formats_to(self, other_format):
1714
 
        """Give other_format the same values for sub formats as this has.
1715
 
 
1716
 
        This method is expected to be used when parameterising a
1717
 
        RemoteBzrDirFormat instance with the parameters from a
1718
 
        BzrDirMetaFormat1 instance.
1719
 
 
1720
 
        :param other_format: other_format is a format which should be
1721
 
            compatible with whatever sub formats are supported by self.
1722
 
        :return: None.
 
1094
        klass._formats[format.get_format_string()] = format
 
1095
 
 
1096
    @classmethod
 
1097
    def register_control_format(klass, format):
 
1098
        """Register a format that does not use '.bzrdir' for its control dir.
 
1099
 
 
1100
        TODO: This should be pulled up into a 'ControlDirFormat' base class
 
1101
        which BzrDirFormat can inherit from, and renamed to register_format 
 
1102
        there. It has been done without that for now for simplicity of
 
1103
        implementation.
1723
1104
        """
 
1105
        klass._control_formats.append(format)
 
1106
 
 
1107
    @classmethod
 
1108
    def set_default_format(klass, format):
 
1109
        klass._default_format = format
 
1110
 
 
1111
    def __str__(self):
 
1112
        return self.get_format_string()[:-1]
1724
1113
 
1725
1114
    @classmethod
1726
1115
    def unregister_format(klass, format):
1727
 
        BzrProber.unregister_bzrdir_format(format)
1728
 
        controldir.ControlDirFormat.unregister_format(format)
1729
 
        controldir.network_format_registry.remove(format.get_format_string())
 
1116
        assert klass._formats[format.get_format_string()] is format
 
1117
        del klass._formats[format.get_format_string()]
 
1118
 
 
1119
    @classmethod
 
1120
    def unregister_control_format(klass, format):
 
1121
        klass._control_formats.remove(format)
 
1122
 
 
1123
 
 
1124
# register BzrDirFormat as a control format
 
1125
BzrDirFormat.register_control_format(BzrDirFormat)
1730
1126
 
1731
1127
 
1732
1128
class BzrDirFormat4(BzrDirFormat):
1742
1138
    removed in format 5; write support for this format has been removed.
1743
1139
    """
1744
1140
 
1745
 
    _lock_class = lockable_files.TransportLock
 
1141
    _lock_class = TransportLock
1746
1142
 
1747
1143
    def get_format_string(self):
1748
1144
        """See BzrDirFormat.get_format_string()."""
1756
1152
        """See BzrDirFormat.get_converter()."""
1757
1153
        # there is one and only one upgrade path here.
1758
1154
        return ConvertBzrDir4To5()
1759
 
 
 
1155
        
1760
1156
    def initialize_on_transport(self, transport):
1761
1157
        """Format 4 branches cannot be created."""
1762
1158
        raise errors.UninitializableFormat(self)
1765
1161
        """Format 4 is not supported.
1766
1162
 
1767
1163
        It is not supported because the model changed from 4 to 5 and the
1768
 
        conversion logic is expensive - so doing it on the fly was not
 
1164
        conversion logic is expensive - so doing it on the fly was not 
1769
1165
        feasible.
1770
1166
        """
1771
1167
        return False
1772
1168
 
1773
 
    def network_name(self):
1774
 
        return self.get_format_string()
1775
 
 
1776
1169
    def _open(self, transport):
1777
1170
        """See BzrDirFormat._open."""
1778
1171
        return BzrDir4(transport, self)
1779
1172
 
1780
1173
    def __return_repository_format(self):
1781
1174
        """Circular import protection."""
1782
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
1783
 
        return RepositoryFormat4()
 
1175
        from bzrlib.repository import RepositoryFormat4
 
1176
        return RepositoryFormat4(self)
1784
1177
    repository_format = property(__return_repository_format)
1785
1178
 
1786
1179
 
1787
 
class BzrDirFormatAllInOne(BzrDirFormat):
1788
 
    """Common class for formats before meta-dirs."""
1789
 
 
1790
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1791
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
1792
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1793
 
        shared_repo=False):
1794
 
        """See BzrDirFormat.initialize_on_transport_ex."""
1795
 
        require_stacking = (stacked_on is not None)
1796
 
        # Format 5 cannot stack, but we've been asked to - actually init
1797
 
        # a Meta1Dir
1798
 
        if require_stacking:
1799
 
            format = BzrDirMetaFormat1()
1800
 
            return format.initialize_on_transport_ex(transport,
1801
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1802
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
1803
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1804
 
                make_working_trees=make_working_trees, shared_repo=shared_repo)
1805
 
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
1806
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1807
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
1808
 
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1809
 
            make_working_trees=make_working_trees, shared_repo=shared_repo)
1810
 
 
1811
 
 
1812
 
class BzrDirFormat5(BzrDirFormatAllInOne):
 
1180
class BzrDirFormat5(BzrDirFormat):
1813
1181
    """Bzr control format 5.
1814
1182
 
1815
1183
    This format is a combined format for working tree, branch and repository.
1816
1184
    It has:
1817
 
     - Format 2 working trees [always]
1818
 
     - Format 4 branches [always]
 
1185
     - Format 2 working trees [always] 
 
1186
     - Format 4 branches [always] 
1819
1187
     - Format 5 repositories [always]
1820
1188
       Unhashed stores in the repository.
1821
1189
    """
1822
1190
 
1823
 
    _lock_class = lockable_files.TransportLock
 
1191
    _lock_class = TransportLock
1824
1192
 
1825
1193
    def get_format_string(self):
1826
1194
        """See BzrDirFormat.get_format_string()."""
1827
1195
        return "Bazaar-NG branch, format 5\n"
1828
1196
 
1829
 
    def get_branch_format(self):
1830
 
        from bzrlib import branch
1831
 
        return branch.BzrBranchFormat4()
1832
 
 
1833
1197
    def get_format_description(self):
1834
1198
        """See BzrDirFormat.get_format_description()."""
1835
1199
        return "All-in-one format 5"
1841
1205
 
1842
1206
    def _initialize_for_clone(self, url):
1843
1207
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1844
 
 
 
1208
        
1845
1209
    def initialize_on_transport(self, transport, _cloning=False):
1846
1210
        """Format 5 dirs always have working tree, branch and repository.
1847
 
 
 
1211
        
1848
1212
        Except when they are being cloned.
1849
1213
        """
1850
1214
        from bzrlib.branch import BzrBranchFormat4
1851
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1215
        from bzrlib.repository import RepositoryFormat5
 
1216
        from bzrlib.workingtree import WorkingTreeFormat2
1852
1217
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1853
1218
        RepositoryFormat5().initialize(result, _internal=True)
1854
1219
        if not _cloning:
1855
 
            branch = BzrBranchFormat4().initialize(result)
1856
 
            result._init_workingtree()
 
1220
            BzrBranchFormat4().initialize(result)
 
1221
            WorkingTreeFormat2().initialize(result)
1857
1222
        return result
1858
1223
 
1859
 
    def network_name(self):
1860
 
        return self.get_format_string()
1861
 
 
1862
1224
    def _open(self, transport):
1863
1225
        """See BzrDirFormat._open."""
1864
1226
        return BzrDir5(transport, self)
1865
1227
 
1866
1228
    def __return_repository_format(self):
1867
1229
        """Circular import protection."""
1868
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1869
 
        return RepositoryFormat5()
 
1230
        from bzrlib.repository import RepositoryFormat5
 
1231
        return RepositoryFormat5(self)
1870
1232
    repository_format = property(__return_repository_format)
1871
1233
 
1872
1234
 
1873
 
class BzrDirFormat6(BzrDirFormatAllInOne):
 
1235
class BzrDirFormat6(BzrDirFormat):
1874
1236
    """Bzr control format 6.
1875
1237
 
1876
1238
    This format is a combined format for working tree, branch and repository.
1877
1239
    It has:
1878
 
     - Format 2 working trees [always]
1879
 
     - Format 4 branches [always]
 
1240
     - Format 2 working trees [always] 
 
1241
     - Format 4 branches [always] 
1880
1242
     - Format 6 repositories [always]
1881
1243
    """
1882
1244
 
1883
 
    _lock_class = lockable_files.TransportLock
 
1245
    _lock_class = TransportLock
1884
1246
 
1885
1247
    def get_format_string(self):
1886
1248
        """See BzrDirFormat.get_format_string()."""
1890
1252
        """See BzrDirFormat.get_format_description()."""
1891
1253
        return "All-in-one format 6"
1892
1254
 
1893
 
    def get_branch_format(self):
1894
 
        from bzrlib import branch
1895
 
        return branch.BzrBranchFormat4()
1896
 
 
1897
1255
    def get_converter(self, format=None):
1898
1256
        """See BzrDirFormat.get_converter()."""
1899
1257
        # there is one and only one upgrade path here.
1900
1258
        return ConvertBzrDir6ToMeta()
1901
 
 
 
1259
        
1902
1260
    def _initialize_for_clone(self, url):
1903
1261
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1904
1262
 
1905
1263
    def initialize_on_transport(self, transport, _cloning=False):
1906
1264
        """Format 6 dirs always have working tree, branch and repository.
1907
 
 
 
1265
        
1908
1266
        Except when they are being cloned.
1909
1267
        """
1910
1268
        from bzrlib.branch import BzrBranchFormat4
1911
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1269
        from bzrlib.repository import RepositoryFormat6
 
1270
        from bzrlib.workingtree import WorkingTreeFormat2
1912
1271
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1913
1272
        RepositoryFormat6().initialize(result, _internal=True)
1914
1273
        if not _cloning:
1915
 
            branch = BzrBranchFormat4().initialize(result)
1916
 
            result._init_workingtree()
 
1274
            BzrBranchFormat4().initialize(result)
 
1275
            try:
 
1276
                WorkingTreeFormat2().initialize(result)
 
1277
            except errors.NotLocalUrl:
 
1278
                # emulate pre-check behaviour for working tree and silently 
 
1279
                # fail.
 
1280
                pass
1917
1281
        return result
1918
1282
 
1919
 
    def network_name(self):
1920
 
        return self.get_format_string()
1921
 
 
1922
1283
    def _open(self, transport):
1923
1284
        """See BzrDirFormat._open."""
1924
1285
        return BzrDir6(transport, self)
1925
1286
 
1926
1287
    def __return_repository_format(self):
1927
1288
        """Circular import protection."""
1928
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1929
 
        return RepositoryFormat6()
 
1289
        from bzrlib.repository import RepositoryFormat6
 
1290
        return RepositoryFormat6(self)
1930
1291
    repository_format = property(__return_repository_format)
1931
1292
 
1932
1293
 
1941
1302
     - Format 7 repositories [optional]
1942
1303
    """
1943
1304
 
1944
 
    _lock_class = lockdir.LockDir
1945
 
 
1946
 
    def __init__(self):
1947
 
        self._workingtree_format = None
1948
 
        self._branch_format = None
1949
 
        self._repository_format = None
1950
 
 
1951
 
    def __eq__(self, other):
1952
 
        if other.__class__ is not self.__class__:
1953
 
            return False
1954
 
        if other.repository_format != self.repository_format:
1955
 
            return False
1956
 
        if other.workingtree_format != self.workingtree_format:
1957
 
            return False
1958
 
        return True
1959
 
 
1960
 
    def __ne__(self, other):
1961
 
        return not self == other
1962
 
 
1963
 
    def get_branch_format(self):
1964
 
        if self._branch_format is None:
1965
 
            from bzrlib.branch import BranchFormat
1966
 
            self._branch_format = BranchFormat.get_default_format()
1967
 
        return self._branch_format
1968
 
 
1969
 
    def set_branch_format(self, format):
1970
 
        self._branch_format = format
1971
 
 
1972
 
    def require_stacking(self, stack_on=None, possible_transports=None,
1973
 
            _skip_repo=False):
1974
 
        """We have a request to stack, try to ensure the formats support it.
1975
 
 
1976
 
        :param stack_on: If supplied, it is the URL to a branch that we want to
1977
 
            stack on. Check to see if that format supports stacking before
1978
 
            forcing an upgrade.
1979
 
        """
1980
 
        # Stacking is desired. requested by the target, but does the place it
1981
 
        # points at support stacking? If it doesn't then we should
1982
 
        # not implicitly upgrade. We check this here.
1983
 
        new_repo_format = None
1984
 
        new_branch_format = None
1985
 
 
1986
 
        # a bit of state for get_target_branch so that we don't try to open it
1987
 
        # 2 times, for both repo *and* branch
1988
 
        target = [None, False, None] # target_branch, checked, upgrade anyway
1989
 
        def get_target_branch():
1990
 
            if target[1]:
1991
 
                # We've checked, don't check again
1992
 
                return target
1993
 
            if stack_on is None:
1994
 
                # No target format, that means we want to force upgrading
1995
 
                target[:] = [None, True, True]
1996
 
                return target
1997
 
            try:
1998
 
                target_dir = BzrDir.open(stack_on,
1999
 
                    possible_transports=possible_transports)
2000
 
            except errors.NotBranchError:
2001
 
                # Nothing there, don't change formats
2002
 
                target[:] = [None, True, False]
2003
 
                return target
2004
 
            except errors.JailBreak:
2005
 
                # JailBreak, JFDI and upgrade anyway
2006
 
                target[:] = [None, True, True]
2007
 
                return target
2008
 
            try:
2009
 
                target_branch = target_dir.open_branch()
2010
 
            except errors.NotBranchError:
2011
 
                # No branch, don't upgrade formats
2012
 
                target[:] = [None, True, False]
2013
 
                return target
2014
 
            target[:] = [target_branch, True, False]
2015
 
            return target
2016
 
 
2017
 
        if (not _skip_repo and
2018
 
                 not self.repository_format.supports_external_lookups):
2019
 
            # We need to upgrade the Repository.
2020
 
            target_branch, _, do_upgrade = get_target_branch()
2021
 
            if target_branch is None:
2022
 
                # We don't have a target branch, should we upgrade anyway?
2023
 
                if do_upgrade:
2024
 
                    # stack_on is inaccessible, JFDI.
2025
 
                    # TODO: bad monkey, hard-coded formats...
2026
 
                    if self.repository_format.rich_root_data:
2027
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2028
 
                    else:
2029
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5()
2030
 
            else:
2031
 
                # If the target already supports stacking, then we know the
2032
 
                # project is already able to use stacking, so auto-upgrade
2033
 
                # for them
2034
 
                new_repo_format = target_branch.repository._format
2035
 
                if not new_repo_format.supports_external_lookups:
2036
 
                    # target doesn't, source doesn't, so don't auto upgrade
2037
 
                    # repo
2038
 
                    new_repo_format = None
2039
 
            if new_repo_format is not None:
2040
 
                self.repository_format = new_repo_format
2041
 
                note('Source repository format does not support stacking,'
2042
 
                     ' using format:\n  %s',
2043
 
                     new_repo_format.get_format_description())
2044
 
 
2045
 
        if not self.get_branch_format().supports_stacking():
2046
 
            # We just checked the repo, now lets check if we need to
2047
 
            # upgrade the branch format
2048
 
            target_branch, _, do_upgrade = get_target_branch()
2049
 
            if target_branch is None:
2050
 
                if do_upgrade:
2051
 
                    # TODO: bad monkey, hard-coded formats...
2052
 
                    new_branch_format = branch.BzrBranchFormat7()
2053
 
            else:
2054
 
                new_branch_format = target_branch._format
2055
 
                if not new_branch_format.supports_stacking():
2056
 
                    new_branch_format = None
2057
 
            if new_branch_format is not None:
2058
 
                # Does support stacking, use its format.
2059
 
                self.set_branch_format(new_branch_format)
2060
 
                note('Source branch format does not support stacking,'
2061
 
                     ' using format:\n  %s',
2062
 
                     new_branch_format.get_format_description())
 
1305
    _lock_class = LockDir
2063
1306
 
2064
1307
    def get_converter(self, format=None):
2065
1308
        """See BzrDirFormat.get_converter()."""
2078
1321
        """See BzrDirFormat.get_format_description()."""
2079
1322
        return "Meta directory format 1"
2080
1323
 
2081
 
    def network_name(self):
2082
 
        return self.get_format_string()
2083
 
 
2084
1324
    def _open(self, transport):
2085
1325
        """See BzrDirFormat._open."""
2086
 
        # Create a new format instance because otherwise initialisation of new
2087
 
        # metadirs share the global default format object leading to alias
2088
 
        # problems.
2089
 
        format = BzrDirMetaFormat1()
2090
 
        self._supply_sub_formats_to(format)
2091
 
        return BzrDirMeta1(transport, format)
 
1326
        return BzrDirMeta1(transport, self)
2092
1327
 
2093
1328
    def __return_repository_format(self):
2094
1329
        """Circular import protection."""
2095
 
        if self._repository_format:
 
1330
        if getattr(self, '_repository_format', None):
2096
1331
            return self._repository_format
2097
1332
        from bzrlib.repository import RepositoryFormat
2098
1333
        return RepositoryFormat.get_default_format()
2099
1334
 
2100
 
    def _set_repository_format(self, value):
2101
 
        """Allow changing the repository format for metadir formats."""
 
1335
    def __set_repository_format(self, value):
 
1336
        """Allow changint the repository format for metadir formats."""
2102
1337
        self._repository_format = value
2103
1338
 
2104
 
    repository_format = property(__return_repository_format,
2105
 
        _set_repository_format)
2106
 
 
2107
 
    def _supply_sub_formats_to(self, other_format):
2108
 
        """Give other_format the same values for sub formats as this has.
2109
 
 
2110
 
        This method is expected to be used when parameterising a
2111
 
        RemoteBzrDirFormat instance with the parameters from a
2112
 
        BzrDirMetaFormat1 instance.
2113
 
 
2114
 
        :param other_format: other_format is a format which should be
2115
 
            compatible with whatever sub formats are supported by self.
2116
 
        :return: None.
2117
 
        """
2118
 
        if getattr(self, '_repository_format', None) is not None:
2119
 
            other_format.repository_format = self.repository_format
2120
 
        if self._branch_format is not None:
2121
 
            other_format._branch_format = self._branch_format
2122
 
        if self._workingtree_format is not None:
2123
 
            other_format.workingtree_format = self.workingtree_format
2124
 
 
2125
 
    def __get_workingtree_format(self):
2126
 
        if self._workingtree_format is None:
2127
 
            from bzrlib.workingtree import WorkingTreeFormat
2128
 
            self._workingtree_format = WorkingTreeFormat.get_default_format()
2129
 
        return self._workingtree_format
2130
 
 
2131
 
    def __set_workingtree_format(self, wt_format):
2132
 
        self._workingtree_format = wt_format
2133
 
 
2134
 
    workingtree_format = property(__get_workingtree_format,
2135
 
                                  __set_workingtree_format)
2136
 
 
2137
 
 
2138
 
# Register bzr formats
 
1339
    repository_format = property(__return_repository_format, __set_repository_format)
 
1340
 
 
1341
 
2139
1342
BzrDirFormat.register_format(BzrDirFormat4())
2140
1343
BzrDirFormat.register_format(BzrDirFormat5())
2141
1344
BzrDirFormat.register_format(BzrDirFormat6())
2142
1345
__default_format = BzrDirMetaFormat1()
2143
1346
BzrDirFormat.register_format(__default_format)
2144
 
controldir.ControlDirFormat._default_format = __default_format
 
1347
BzrDirFormat.set_default_format(__default_format)
 
1348
 
 
1349
 
 
1350
class BzrDirTestProviderAdapter(object):
 
1351
    """A tool to generate a suite testing multiple bzrdir formats at once.
 
1352
 
 
1353
    This is done by copying the test once for each transport and injecting
 
1354
    the transport_server, transport_readonly_server, and bzrdir_format
 
1355
    classes into each copy. Each copy is also given a new id() to make it
 
1356
    easy to identify.
 
1357
    """
 
1358
 
 
1359
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1360
        self._transport_server = transport_server
 
1361
        self._transport_readonly_server = transport_readonly_server
 
1362
        self._formats = formats
 
1363
    
 
1364
    def adapt(self, test):
 
1365
        result = TestSuite()
 
1366
        for format in self._formats:
 
1367
            new_test = deepcopy(test)
 
1368
            new_test.transport_server = self._transport_server
 
1369
            new_test.transport_readonly_server = self._transport_readonly_server
 
1370
            new_test.bzrdir_format = format
 
1371
            def make_new_test_id():
 
1372
                new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
 
1373
                return lambda: new_id
 
1374
            new_test.id = make_new_test_id()
 
1375
            result.addTest(new_test)
 
1376
        return result
2145
1377
 
2146
1378
 
2147
1379
class Converter(object):
2169
1401
        self.absent_revisions = set()
2170
1402
        self.text_count = 0
2171
1403
        self.revisions = {}
2172
 
 
 
1404
        
2173
1405
    def convert(self, to_convert, pb):
2174
1406
        """See Converter.convert()."""
2175
1407
        self.bzrdir = to_convert
2176
 
        if pb is not None:
2177
 
            warnings.warn("pb parameter to convert() is deprecated")
2178
 
        self.pb = ui.ui_factory.nested_progress_bar()
2179
 
        try:
2180
 
            ui.ui_factory.note('starting upgrade from format 4 to 5')
2181
 
            if isinstance(self.bzrdir.transport, local.LocalTransport):
2182
 
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2183
 
            self._convert_to_weaves()
2184
 
            return BzrDir.open(self.bzrdir.user_url)
2185
 
        finally:
2186
 
            self.pb.finished()
 
1408
        self.pb = pb
 
1409
        self.pb.note('starting upgrade from format 4 to 5')
 
1410
        if isinstance(self.bzrdir.transport, LocalTransport):
 
1411
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
 
1412
        self._convert_to_weaves()
 
1413
        return BzrDir.open(self.bzrdir.root_transport.base)
2187
1414
 
2188
1415
    def _convert_to_weaves(self):
2189
 
        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
 
1416
        self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2190
1417
        try:
2191
1418
            # TODO permissions
2192
1419
            stat = self.bzrdir.transport.stat('weaves')
2220
1447
        self.pb.clear()
2221
1448
        self._write_all_weaves()
2222
1449
        self._write_all_revs()
2223
 
        ui.ui_factory.note('upgraded to weaves:')
2224
 
        ui.ui_factory.note('  %6d revisions and inventories' % len(self.revisions))
2225
 
        ui.ui_factory.note('  %6d revisions not present' % len(self.absent_revisions))
2226
 
        ui.ui_factory.note('  %6d texts' % self.text_count)
 
1450
        self.pb.note('upgraded to weaves:')
 
1451
        self.pb.note('  %6d revisions and inventories', len(self.revisions))
 
1452
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
 
1453
        self.pb.note('  %6d texts', self.text_count)
2227
1454
        self._cleanup_spare_files_after_format4()
2228
 
        self.branch._transport.put_bytes(
2229
 
            'branch-format',
2230
 
            BzrDirFormat5().get_format_string(),
2231
 
            mode=self.bzrdir._get_file_mode())
 
1455
        self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
2232
1456
 
2233
1457
    def _cleanup_spare_files_after_format4(self):
2234
1458
        # FIXME working tree upgrade foo.
2242
1466
        self.bzrdir.transport.delete_tree('text-store')
2243
1467
 
2244
1468
    def _convert_working_inv(self):
2245
 
        inv = xml4.serializer_v4.read_inventory(
2246
 
                self.branch._transport.get('inventory'))
2247
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2248
 
        self.branch._transport.put_bytes('inventory', new_inv_xml,
2249
 
            mode=self.bzrdir._get_file_mode())
 
1469
        inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
 
1470
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1471
        # FIXME inventory is a working tree change.
 
1472
        self.branch.control_files.put('inventory', new_inv_xml)
2250
1473
 
2251
1474
    def _write_all_weaves(self):
2252
1475
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2272
1495
        self.bzrdir.transport.mkdir('revision-store')
2273
1496
        revision_transport = self.bzrdir.transport.clone('revision-store')
2274
1497
        # TODO permissions
2275
 
        from bzrlib.xml5 import serializer_v5
2276
 
        from bzrlib.repofmt.weaverepo import RevisionTextStore
2277
 
        revision_store = RevisionTextStore(revision_transport,
2278
 
            serializer_v5, False, versionedfile.PrefixMapper(),
2279
 
            lambda:True, lambda:True)
 
1498
        _revision_store = TextRevisionStore(TextStore(revision_transport,
 
1499
                                                      prefixed=False,
 
1500
                                                      compressed=True))
2280
1501
        try:
 
1502
            transaction = bzrlib.transactions.WriteTransaction()
2281
1503
            for i, rev_id in enumerate(self.converted_revs):
2282
1504
                self.pb.update('write revision', i, len(self.converted_revs))
2283
 
                text = serializer_v5.write_revision_to_string(
2284
 
                    self.revisions[rev_id])
2285
 
                key = (rev_id,)
2286
 
                revision_store.add_lines(key, None, osutils.split_lines(text))
 
1505
                _revision_store.add_revision(self.revisions[rev_id], transaction)
2287
1506
        finally:
2288
1507
            self.pb.clear()
2289
 
 
 
1508
            
2290
1509
    def _load_one_rev(self, rev_id):
2291
1510
        """Load a revision object into memory.
2292
1511
 
2297
1516
                       len(self.known_revisions))
2298
1517
        if not self.branch.repository.has_revision(rev_id):
2299
1518
            self.pb.clear()
2300
 
            ui.ui_factory.note('revision {%s} not present in branch; '
2301
 
                         'will be converted as a ghost' %
 
1519
            self.pb.note('revision {%s} not present in branch; '
 
1520
                         'will be converted as a ghost',
2302
1521
                         rev_id)
2303
1522
            self.absent_revisions.add(rev_id)
2304
1523
        else:
2305
 
            rev = self.branch.repository.get_revision(rev_id)
 
1524
            rev = self.branch.repository._revision_store.get_revision(rev_id,
 
1525
                self.branch.repository.get_transaction())
2306
1526
            for parent_id in rev.parent_ids:
2307
1527
                self.known_revisions.add(parent_id)
2308
1528
                self.to_read.append(parent_id)
2309
1529
            self.revisions[rev_id] = rev
2310
1530
 
2311
1531
    def _load_old_inventory(self, rev_id):
2312
 
        f = self.branch.repository.inventory_store.get(rev_id)
2313
 
        try:
2314
 
            old_inv_xml = f.read()
2315
 
        finally:
2316
 
            f.close()
2317
 
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2318
 
        inv.revision_id = rev_id
 
1532
        assert rev_id not in self.converted_revs
 
1533
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
 
1534
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
2319
1535
        rev = self.revisions[rev_id]
 
1536
        if rev.inventory_sha1:
 
1537
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
 
1538
                'inventory sha mismatch for {%s}' % rev_id
2320
1539
        return inv
2321
1540
 
2322
1541
    def _load_updated_inventory(self, rev_id):
 
1542
        assert rev_id in self.converted_revs
2323
1543
        inv_xml = self.inv_weave.get_text(rev_id)
2324
 
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
 
1544
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
2325
1545
        return inv
2326
1546
 
2327
1547
    def _convert_one_rev(self, rev_id):
2331
1551
        present_parents = [p for p in rev.parent_ids
2332
1552
                           if p not in self.absent_revisions]
2333
1553
        self._convert_revision_contents(rev, inv, present_parents)
2334
 
        self._store_new_inv(rev, inv, present_parents)
 
1554
        self._store_new_weave(rev, inv, present_parents)
2335
1555
        self.converted_revs.add(rev_id)
2336
1556
 
2337
 
    def _store_new_inv(self, rev, inv, present_parents):
2338
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
 
1557
    def _store_new_weave(self, rev, inv, present_parents):
 
1558
        # the XML is now updated with text versions
 
1559
        if __debug__:
 
1560
            for file_id in inv:
 
1561
                ie = inv[file_id]
 
1562
                if ie.kind == 'root_directory':
 
1563
                    continue
 
1564
                assert hasattr(ie, 'revision'), \
 
1565
                    'no revision on {%s} in {%s}' % \
 
1566
                    (file_id, rev.revision_id)
 
1567
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
2339
1568
        new_inv_sha1 = sha_string(new_inv_xml)
2340
 
        self.inv_weave.add_lines(rev.revision_id,
 
1569
        self.inv_weave.add_lines(rev.revision_id, 
2341
1570
                                 present_parents,
2342
1571
                                 new_inv_xml.splitlines(True))
2343
1572
        rev.inventory_sha1 = new_inv_sha1
2350
1579
        mutter('converting texts of revision {%s}',
2351
1580
               rev_id)
2352
1581
        parent_invs = map(self._load_updated_inventory, present_parents)
2353
 
        entries = inv.iter_entries()
2354
 
        entries.next()
2355
 
        for path, ie in entries:
 
1582
        for file_id in inv:
 
1583
            ie = inv[file_id]
2356
1584
            self._convert_file_version(rev, ie, parent_invs)
2357
1585
 
2358
1586
    def _convert_file_version(self, rev, ie, parent_invs):
2361
1589
        The file needs to be added into the weave if it is a merge
2362
1590
        of >=2 parents or if it's changed from its parent.
2363
1591
        """
 
1592
        if ie.kind == 'root_directory':
 
1593
            return
2364
1594
        file_id = ie.file_id
2365
1595
        rev_id = rev.revision_id
2366
1596
        w = self.text_weaves.get(file_id)
2368
1598
            w = Weave(file_id)
2369
1599
            self.text_weaves[file_id] = w
2370
1600
        text_changed = False
2371
 
        parent_candiate_entries = ie.parent_candidates(parent_invs)
2372
 
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2373
 
        # XXX: Note that this is unordered - and this is tolerable because
2374
 
        # the previous code was also unordered.
2375
 
        previous_entries = dict((head, parent_candiate_entries[head]) for head
2376
 
            in heads)
 
1601
        previous_entries = ie.find_previous_heads(parent_invs,
 
1602
                                                  None,
 
1603
                                                  None,
 
1604
                                                  entry_vf=w)
 
1605
        for old_revision in previous_entries:
 
1606
                # if this fails, its a ghost ?
 
1607
                assert old_revision in self.converted_revs 
2377
1608
        self.snapshot_ie(previous_entries, ie, w, rev_id)
2378
 
 
2379
 
    def get_parent_map(self, revision_ids):
2380
 
        """See graph.StackedParentsProvider.get_parent_map"""
2381
 
        return dict((revision_id, self.revisions[revision_id])
2382
 
                    for revision_id in revision_ids
2383
 
                     if revision_id in self.revisions)
 
1609
        del ie.text_id
 
1610
        assert getattr(ie, 'revision', None) is not None
2384
1611
 
2385
1612
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2386
1613
        # TODO: convert this logic, which is ~= snapshot to
2387
1614
        # a call to:. This needs the path figured out. rather than a work_tree
2388
1615
        # a v4 revision_tree can be given, or something that looks enough like
2389
1616
        # one to give the file content to the entry if it needs it.
2390
 
        # and we need something that looks like a weave store for snapshot to
 
1617
        # and we need something that looks like a weave store for snapshot to 
2391
1618
        # save against.
2392
1619
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2393
1620
        if len(previous_revisions) == 1:
2396
1623
                ie.revision = previous_ie.revision
2397
1624
                return
2398
1625
        if ie.has_text():
2399
 
            f = self.branch.repository._text_store.get(ie.text_id)
2400
 
            try:
2401
 
                file_lines = f.readlines()
2402
 
            finally:
2403
 
                f.close()
 
1626
            text = self.branch.repository.text_store.get(ie.text_id)
 
1627
            file_lines = text.readlines()
 
1628
            assert sha_strings(file_lines) == ie.text_sha1
 
1629
            assert sum(map(len, file_lines)) == ie.text_size
2404
1630
            w.add_lines(rev_id, previous_revisions, file_lines)
2405
1631
            self.text_count += 1
2406
1632
        else:
2436
1662
    def convert(self, to_convert, pb):
2437
1663
        """See Converter.convert()."""
2438
1664
        self.bzrdir = to_convert
2439
 
        pb = ui.ui_factory.nested_progress_bar()
2440
 
        try:
2441
 
            ui.ui_factory.note('starting upgrade from format 5 to 6')
2442
 
            self._convert_to_prefixed()
2443
 
            return BzrDir.open(self.bzrdir.user_url)
2444
 
        finally:
2445
 
            pb.finished()
 
1665
        self.pb = pb
 
1666
        self.pb.note('starting upgrade from format 5 to 6')
 
1667
        self._convert_to_prefixed()
 
1668
        return BzrDir.open(self.bzrdir.root_transport.base)
2446
1669
 
2447
1670
    def _convert_to_prefixed(self):
2448
1671
        from bzrlib.store import TransportStore
2449
1672
        self.bzrdir.transport.delete('branch-format')
2450
1673
        for store_name in ["weaves", "revision-store"]:
2451
 
            ui.ui_factory.note("adding prefixes to %s" % store_name)
 
1674
            self.pb.note("adding prefixes to %s" % store_name)
2452
1675
            store_transport = self.bzrdir.transport.clone(store_name)
2453
1676
            store = TransportStore(store_transport, prefixed=True)
2454
1677
            for urlfilename in store_transport.list_dir('.'):
2456
1679
                if (filename.endswith(".weave") or
2457
1680
                    filename.endswith(".gz") or
2458
1681
                    filename.endswith(".sig")):
2459
 
                    file_id, suffix = os.path.splitext(filename)
 
1682
                    file_id = os.path.splitext(filename)[0]
2460
1683
                else:
2461
1684
                    file_id = filename
2462
 
                    suffix = ''
2463
 
                new_name = store._mapper.map((file_id,)) + suffix
 
1685
                prefix_dir = store.hash_prefix(file_id)
2464
1686
                # FIXME keep track of the dirs made RBC 20060121
2465
1687
                try:
2466
 
                    store_transport.move(filename, new_name)
 
1688
                    store_transport.move(filename, prefix_dir + '/' + filename)
2467
1689
                except errors.NoSuchFile: # catches missing dirs strangely enough
2468
 
                    store_transport.mkdir(osutils.dirname(new_name))
2469
 
                    store_transport.move(filename, new_name)
2470
 
        self.bzrdir.transport.put_bytes(
2471
 
            'branch-format',
2472
 
            BzrDirFormat6().get_format_string(),
2473
 
            mode=self.bzrdir._get_file_mode())
 
1690
                    store_transport.mkdir(prefix_dir)
 
1691
                    store_transport.move(filename, prefix_dir + '/' + filename)
 
1692
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
2474
1693
 
2475
1694
 
2476
1695
class ConvertBzrDir6ToMeta(Converter):
2478
1697
 
2479
1698
    def convert(self, to_convert, pb):
2480
1699
        """See Converter.convert()."""
2481
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2482
 
        from bzrlib.branch import BzrBranchFormat5
2483
1700
        self.bzrdir = to_convert
2484
 
        self.pb = ui.ui_factory.nested_progress_bar()
 
1701
        self.pb = pb
2485
1702
        self.count = 0
2486
1703
        self.total = 20 # the steps we know about
2487
1704
        self.garbage_inventories = []
2488
 
        self.dir_mode = self.bzrdir._get_dir_mode()
2489
 
        self.file_mode = self.bzrdir._get_file_mode()
2490
1705
 
2491
 
        ui.ui_factory.note('starting upgrade from format 6 to metadir')
2492
 
        self.bzrdir.transport.put_bytes(
2493
 
                'branch-format',
2494
 
                "Converting to format 6",
2495
 
                mode=self.file_mode)
 
1706
        self.pb.note('starting upgrade from format 6 to metadir')
 
1707
        self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
2496
1708
        # its faster to move specific files around than to open and use the apis...
2497
1709
        # first off, nuke ancestry.weave, it was never used.
2498
1710
        try:
2508
1720
            if name.startswith('basis-inventory.'):
2509
1721
                self.garbage_inventories.append(name)
2510
1722
        # create new directories for repository, working tree and branch
 
1723
        self.dir_mode = self.bzrdir._control_files._dir_mode
 
1724
        self.file_mode = self.bzrdir._control_files._file_mode
2511
1725
        repository_names = [('inventory.weave', True),
2512
1726
                            ('revision-store', True),
2513
1727
                            ('weaves', True)]
2515
1729
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2516
1730
        self.make_lock('repository')
2517
1731
        # we hard code the formats here because we are converting into
2518
 
        # the meta format. The meta format upgrader can take this to a
 
1732
        # the meta format. The meta format upgrader can take this to a 
2519
1733
        # future format within each component.
2520
 
        self.put_format('repository', RepositoryFormat7())
 
1734
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
2521
1735
        for entry in repository_names:
2522
1736
            self.move_entry('repository', entry)
2523
1737
 
2524
1738
        self.step('Upgrading branch      ')
2525
1739
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2526
1740
        self.make_lock('branch')
2527
 
        self.put_format('branch', BzrBranchFormat5())
 
1741
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
2528
1742
        branch_files = [('revision-history', True),
2529
1743
                        ('branch-name', True),
2530
1744
                        ('parent', False)]
2531
1745
        for entry in branch_files:
2532
1746
            self.move_entry('branch', entry)
2533
1747
 
 
1748
        self.step('Upgrading working tree')
 
1749
        self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
 
1750
        self.make_lock('checkout')
 
1751
        self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
 
1752
        self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
2534
1753
        checkout_files = [('pending-merges', True),
2535
1754
                          ('inventory', True),
2536
1755
                          ('stat-cache', False)]
2537
 
        # If a mandatory checkout file is not present, the branch does not have
2538
 
        # a functional checkout. Do not create a checkout in the converted
2539
 
        # branch.
2540
 
        for name, mandatory in checkout_files:
2541
 
            if mandatory and name not in bzrcontents:
2542
 
                has_checkout = False
2543
 
                break
2544
 
        else:
2545
 
            has_checkout = True
2546
 
        if not has_checkout:
2547
 
            ui.ui_factory.note('No working tree.')
2548
 
            # If some checkout files are there, we may as well get rid of them.
2549
 
            for name, mandatory in checkout_files:
2550
 
                if name in bzrcontents:
2551
 
                    self.bzrdir.transport.delete(name)
2552
 
        else:
2553
 
            from bzrlib.workingtree import WorkingTreeFormat3
2554
 
            self.step('Upgrading working tree')
2555
 
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2556
 
            self.make_lock('checkout')
2557
 
            self.put_format(
2558
 
                'checkout', WorkingTreeFormat3())
2559
 
            self.bzrdir.transport.delete_multi(
2560
 
                self.garbage_inventories, self.pb)
2561
 
            for entry in checkout_files:
2562
 
                self.move_entry('checkout', entry)
2563
 
            if last_revision is not None:
2564
 
                self.bzrdir.transport.put_bytes(
2565
 
                    'checkout/last-revision', last_revision)
2566
 
        self.bzrdir.transport.put_bytes(
2567
 
            'branch-format',
2568
 
            BzrDirMetaFormat1().get_format_string(),
2569
 
            mode=self.file_mode)
2570
 
        self.pb.finished()
2571
 
        return BzrDir.open(self.bzrdir.user_url)
 
1756
        for entry in checkout_files:
 
1757
            self.move_entry('checkout', entry)
 
1758
        if last_revision is not None:
 
1759
            self.bzrdir._control_files.put_utf8('checkout/last-revision',
 
1760
                                                last_revision)
 
1761
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
 
1762
        return BzrDir.open(self.bzrdir.root_transport.base)
2572
1763
 
2573
1764
    def make_lock(self, name):
2574
1765
        """Make a lock for the new control dir name."""
2575
1766
        self.step('Make %s lock' % name)
2576
 
        ld = lockdir.LockDir(self.bzrdir.transport,
2577
 
                             '%s/lock' % name,
2578
 
                             file_modebits=self.file_mode,
2579
 
                             dir_modebits=self.dir_mode)
 
1767
        ld = LockDir(self.bzrdir.transport, 
 
1768
                     '%s/lock' % name,
 
1769
                     file_modebits=self.file_mode,
 
1770
                     dir_modebits=self.dir_mode)
2580
1771
        ld.create()
2581
1772
 
2582
1773
    def move_entry(self, new_dir, entry):
2591
1782
                raise
2592
1783
 
2593
1784
    def put_format(self, dirname, format):
2594
 
        self.bzrdir.transport.put_bytes('%s/format' % dirname,
2595
 
            format.get_format_string(),
2596
 
            self.file_mode)
 
1785
        self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
2597
1786
 
2598
1787
 
2599
1788
class ConvertMetaToMeta(Converter):
2609
1798
    def convert(self, to_convert, pb):
2610
1799
        """See Converter.convert()."""
2611
1800
        self.bzrdir = to_convert
2612
 
        self.pb = ui.ui_factory.nested_progress_bar()
 
1801
        self.pb = pb
2613
1802
        self.count = 0
2614
1803
        self.total = 1
2615
1804
        self.step('checking repository format')
2620
1809
        else:
2621
1810
            if not isinstance(repo._format, self.target_format.repository_format.__class__):
2622
1811
                from bzrlib.repository import CopyConverter
2623
 
                ui.ui_factory.note('starting repository conversion')
 
1812
                self.pb.note('starting repository conversion')
2624
1813
                converter = CopyConverter(self.target_format.repository_format)
2625
1814
                converter.convert(repo, pb)
2626
 
        for branch in self.bzrdir.list_branches():
2627
 
            # TODO: conversions of Branch and Tree should be done by
2628
 
            # InterXFormat lookups/some sort of registry.
2629
 
            # Avoid circular imports
2630
 
            from bzrlib import branch as _mod_branch
2631
 
            old = branch._format.__class__
2632
 
            new = self.target_format.get_branch_format().__class__
2633
 
            while old != new:
2634
 
                if (old == _mod_branch.BzrBranchFormat5 and
2635
 
                    new in (_mod_branch.BzrBranchFormat6,
2636
 
                        _mod_branch.BzrBranchFormat7,
2637
 
                        _mod_branch.BzrBranchFormat8)):
2638
 
                    branch_converter = _mod_branch.Converter5to6()
2639
 
                elif (old == _mod_branch.BzrBranchFormat6 and
2640
 
                    new in (_mod_branch.BzrBranchFormat7,
2641
 
                            _mod_branch.BzrBranchFormat8)):
2642
 
                    branch_converter = _mod_branch.Converter6to7()
2643
 
                elif (old == _mod_branch.BzrBranchFormat7 and
2644
 
                      new is _mod_branch.BzrBranchFormat8):
2645
 
                    branch_converter = _mod_branch.Converter7to8()
2646
 
                else:
2647
 
                    raise errors.BadConversionTarget("No converter", new,
2648
 
                        branch._format)
2649
 
                branch_converter.convert(branch)
2650
 
                branch = self.bzrdir.open_branch()
2651
 
                old = branch._format.__class__
2652
 
        try:
2653
 
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2654
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
2655
 
            pass
2656
 
        else:
2657
 
            # TODO: conversions of Branch and Tree should be done by
2658
 
            # InterXFormat lookups
2659
 
            if (isinstance(tree, workingtree.WorkingTree3) and
2660
 
                not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2661
 
                isinstance(self.target_format.workingtree_format,
2662
 
                    workingtree_4.DirStateWorkingTreeFormat)):
2663
 
                workingtree_4.Converter3to4().convert(tree)
2664
 
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2665
 
                not isinstance(tree, workingtree_4.WorkingTree5) and
2666
 
                isinstance(self.target_format.workingtree_format,
2667
 
                    workingtree_4.WorkingTreeFormat5)):
2668
 
                workingtree_4.Converter4to5().convert(tree)
2669
 
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2670
 
                not isinstance(tree, workingtree_4.WorkingTree6) and
2671
 
                isinstance(self.target_format.workingtree_format,
2672
 
                    workingtree_4.WorkingTreeFormat6)):
2673
 
                workingtree_4.Converter4or5to6().convert(tree)
2674
 
        self.pb.finished()
2675
1815
        return to_convert
2676
 
 
2677
 
 
2678
 
# This is not in remote.py because it's relatively small, and needs to be
2679
 
# registered. Putting it in remote.py creates a circular import problem.
2680
 
# we can make it a lazy object if the control formats is turned into something
2681
 
# like a registry.
2682
 
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2683
 
    """Format representing bzrdirs accessed via a smart server"""
2684
 
 
2685
 
    supports_workingtrees = False
2686
 
 
2687
 
    def __init__(self):
2688
 
        BzrDirMetaFormat1.__init__(self)
2689
 
        # XXX: It's a bit ugly that the network name is here, because we'd
2690
 
        # like to believe that format objects are stateless or at least
2691
 
        # immutable,  However, we do at least avoid mutating the name after
2692
 
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
2693
 
        self._network_name = None
2694
 
 
2695
 
    def __repr__(self):
2696
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
2697
 
            self._network_name)
2698
 
 
2699
 
    def get_format_description(self):
2700
 
        if self._network_name:
2701
 
            real_format = controldir.network_format_registry.get(self._network_name)
2702
 
            return 'Remote: ' + real_format.get_format_description()
2703
 
        return 'bzr remote bzrdir'
2704
 
 
2705
 
    def get_format_string(self):
2706
 
        raise NotImplementedError(self.get_format_string)
2707
 
 
2708
 
    def network_name(self):
2709
 
        if self._network_name:
2710
 
            return self._network_name
2711
 
        else:
2712
 
            raise AssertionError("No network name set.")
2713
 
 
2714
 
    def initialize_on_transport(self, transport):
2715
 
        try:
2716
 
            # hand off the request to the smart server
2717
 
            client_medium = transport.get_smart_medium()
2718
 
        except errors.NoSmartMedium:
2719
 
            # TODO: lookup the local format from a server hint.
2720
 
            local_dir_format = BzrDirMetaFormat1()
2721
 
            return local_dir_format.initialize_on_transport(transport)
2722
 
        client = _SmartClient(client_medium)
2723
 
        path = client.remote_path_from_transport(transport)
2724
 
        try:
2725
 
            response = client.call('BzrDirFormat.initialize', path)
2726
 
        except errors.ErrorFromSmartServer, err:
2727
 
            remote._translate_error(err, path=path)
2728
 
        if response[0] != 'ok':
2729
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2730
 
        format = RemoteBzrDirFormat()
2731
 
        self._supply_sub_formats_to(format)
2732
 
        return remote.RemoteBzrDir(transport, format)
2733
 
 
2734
 
    def parse_NoneTrueFalse(self, arg):
2735
 
        if not arg:
2736
 
            return None
2737
 
        if arg == 'False':
2738
 
            return False
2739
 
        if arg == 'True':
2740
 
            return True
2741
 
        raise AssertionError("invalid arg %r" % arg)
2742
 
 
2743
 
    def _serialize_NoneTrueFalse(self, arg):
2744
 
        if arg is False:
2745
 
            return 'False'
2746
 
        if arg:
2747
 
            return 'True'
2748
 
        return ''
2749
 
 
2750
 
    def _serialize_NoneString(self, arg):
2751
 
        return arg or ''
2752
 
 
2753
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2754
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
2755
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2756
 
        shared_repo=False):
2757
 
        try:
2758
 
            # hand off the request to the smart server
2759
 
            client_medium = transport.get_smart_medium()
2760
 
        except errors.NoSmartMedium:
2761
 
            do_vfs = True
2762
 
        else:
2763
 
            # Decline to open it if the server doesn't support our required
2764
 
            # version (3) so that the VFS-based transport will do it.
2765
 
            if client_medium.should_probe():
2766
 
                try:
2767
 
                    server_version = client_medium.protocol_version()
2768
 
                    if server_version != '2':
2769
 
                        do_vfs = True
2770
 
                    else:
2771
 
                        do_vfs = False
2772
 
                except errors.SmartProtocolError:
2773
 
                    # Apparently there's no usable smart server there, even though
2774
 
                    # the medium supports the smart protocol.
2775
 
                    do_vfs = True
2776
 
            else:
2777
 
                do_vfs = False
2778
 
        if not do_vfs:
2779
 
            client = _SmartClient(client_medium)
2780
 
            path = client.remote_path_from_transport(transport)
2781
 
            if client_medium._is_remote_before((1, 16)):
2782
 
                do_vfs = True
2783
 
        if do_vfs:
2784
 
            # TODO: lookup the local format from a server hint.
2785
 
            local_dir_format = BzrDirMetaFormat1()
2786
 
            self._supply_sub_formats_to(local_dir_format)
2787
 
            return local_dir_format.initialize_on_transport_ex(transport,
2788
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2789
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
2790
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2791
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
2792
 
                vfs_only=True)
2793
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
2794
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
2795
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
2796
 
 
2797
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
2798
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
2799
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
2800
 
        args = []
2801
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
2802
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
2803
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
2804
 
        args.append(self._serialize_NoneString(stacked_on))
2805
 
        # stack_on_pwd is often/usually our transport
2806
 
        if stack_on_pwd:
2807
 
            try:
2808
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
2809
 
                if not stack_on_pwd:
2810
 
                    stack_on_pwd = '.'
2811
 
            except errors.PathNotChild:
2812
 
                pass
2813
 
        args.append(self._serialize_NoneString(stack_on_pwd))
2814
 
        args.append(self._serialize_NoneString(repo_format_name))
2815
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
2816
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
2817
 
        request_network_name = self._network_name or \
2818
 
            BzrDirFormat.get_default_format().network_name()
2819
 
        try:
2820
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
2821
 
                request_network_name, path, *args)
2822
 
        except errors.UnknownSmartMethod:
2823
 
            client._medium._remember_remote_is_before((1,16))
2824
 
            local_dir_format = BzrDirMetaFormat1()
2825
 
            self._supply_sub_formats_to(local_dir_format)
2826
 
            return local_dir_format.initialize_on_transport_ex(transport,
2827
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2828
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
2829
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2830
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
2831
 
                vfs_only=True)
2832
 
        except errors.ErrorFromSmartServer, err:
2833
 
            remote._translate_error(err, path=path)
2834
 
        repo_path = response[0]
2835
 
        bzrdir_name = response[6]
2836
 
        require_stacking = response[7]
2837
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
2838
 
        format = RemoteBzrDirFormat()
2839
 
        format._network_name = bzrdir_name
2840
 
        self._supply_sub_formats_to(format)
2841
 
        bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
2842
 
        if repo_path:
2843
 
            repo_format = remote.response_tuple_to_repo_format(response[1:])
2844
 
            if repo_path == '.':
2845
 
                repo_path = ''
2846
 
            if repo_path:
2847
 
                repo_bzrdir_format = RemoteBzrDirFormat()
2848
 
                repo_bzrdir_format._network_name = response[5]
2849
 
                repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
2850
 
                    repo_bzrdir_format)
2851
 
            else:
2852
 
                repo_bzr = bzrdir
2853
 
            final_stack = response[8] or None
2854
 
            final_stack_pwd = response[9] or None
2855
 
            if final_stack_pwd:
2856
 
                final_stack_pwd = urlutils.join(
2857
 
                    transport.base, final_stack_pwd)
2858
 
            remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
2859
 
            if len(response) > 10:
2860
 
                # Updated server verb that locks remotely.
2861
 
                repo_lock_token = response[10] or None
2862
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
2863
 
                if repo_lock_token:
2864
 
                    remote_repo.dont_leave_lock_in_place()
2865
 
            else:
2866
 
                remote_repo.lock_write()
2867
 
            policy = UseExistingRepository(remote_repo, final_stack,
2868
 
                final_stack_pwd, require_stacking)
2869
 
            policy.acquire_repository()
2870
 
        else:
2871
 
            remote_repo = None
2872
 
            policy = None
2873
 
        bzrdir._format.set_branch_format(self.get_branch_format())
2874
 
        if require_stacking:
2875
 
            # The repo has already been created, but we need to make sure that
2876
 
            # we'll make a stackable branch.
2877
 
            bzrdir._format.require_stacking(_skip_repo=True)
2878
 
        return remote_repo, bzrdir, require_stacking, policy
2879
 
 
2880
 
    def _open(self, transport):
2881
 
        return remote.RemoteBzrDir(transport, self)
2882
 
 
2883
 
    def __eq__(self, other):
2884
 
        if not isinstance(other, RemoteBzrDirFormat):
2885
 
            return False
2886
 
        return self.get_format_description() == other.get_format_description()
2887
 
 
2888
 
    def __return_repository_format(self):
2889
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
2890
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
2891
 
        # that it should use that for init() etc.
2892
 
        result = remote.RemoteRepositoryFormat()
2893
 
        custom_format = getattr(self, '_repository_format', None)
2894
 
        if custom_format:
2895
 
            if isinstance(custom_format, remote.RemoteRepositoryFormat):
2896
 
                return custom_format
2897
 
            else:
2898
 
                # We will use the custom format to create repositories over the
2899
 
                # wire; expose its details like rich_root_data for code to
2900
 
                # query
2901
 
                result._custom_format = custom_format
2902
 
        return result
2903
 
 
2904
 
    def get_branch_format(self):
2905
 
        result = BzrDirMetaFormat1.get_branch_format(self)
2906
 
        if not isinstance(result, remote.RemoteBranchFormat):
2907
 
            new_result = remote.RemoteBranchFormat()
2908
 
            new_result._custom_format = result
2909
 
            # cache the result
2910
 
            self.set_branch_format(new_result)
2911
 
            result = new_result
2912
 
        return result
2913
 
 
2914
 
    repository_format = property(__return_repository_format,
2915
 
        BzrDirMetaFormat1._set_repository_format) #.im_func)
2916
 
 
2917
 
 
2918
 
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2919
 
 
2920
 
 
2921
 
class RepositoryAcquisitionPolicy(object):
2922
 
    """Abstract base class for repository acquisition policies.
2923
 
 
2924
 
    A repository acquisition policy decides how a BzrDir acquires a repository
2925
 
    for a branch that is being created.  The most basic policy decision is
2926
 
    whether to create a new repository or use an existing one.
2927
 
    """
2928
 
    def __init__(self, stack_on, stack_on_pwd, require_stacking):
2929
 
        """Constructor.
2930
 
 
2931
 
        :param stack_on: A location to stack on
2932
 
        :param stack_on_pwd: If stack_on is relative, the location it is
2933
 
            relative to.
2934
 
        :param require_stacking: If True, it is a failure to not stack.
2935
 
        """
2936
 
        self._stack_on = stack_on
2937
 
        self._stack_on_pwd = stack_on_pwd
2938
 
        self._require_stacking = require_stacking
2939
 
 
2940
 
    def configure_branch(self, branch):
2941
 
        """Apply any configuration data from this policy to the branch.
2942
 
 
2943
 
        Default implementation sets repository stacking.
2944
 
        """
2945
 
        if self._stack_on is None:
2946
 
            return
2947
 
        if self._stack_on_pwd is None:
2948
 
            stack_on = self._stack_on
2949
 
        else:
2950
 
            try:
2951
 
                stack_on = urlutils.rebase_url(self._stack_on,
2952
 
                    self._stack_on_pwd,
2953
 
                    branch.user_url)
2954
 
            except errors.InvalidRebaseURLs:
2955
 
                stack_on = self._get_full_stack_on()
2956
 
        try:
2957
 
            branch.set_stacked_on_url(stack_on)
2958
 
        except (errors.UnstackableBranchFormat,
2959
 
                errors.UnstackableRepositoryFormat):
2960
 
            if self._require_stacking:
2961
 
                raise
2962
 
 
2963
 
    def requires_stacking(self):
2964
 
        """Return True if this policy requires stacking."""
2965
 
        return self._stack_on is not None and self._require_stacking
2966
 
 
2967
 
    def _get_full_stack_on(self):
2968
 
        """Get a fully-qualified URL for the stack_on location."""
2969
 
        if self._stack_on is None:
2970
 
            return None
2971
 
        if self._stack_on_pwd is None:
2972
 
            return self._stack_on
2973
 
        else:
2974
 
            return urlutils.join(self._stack_on_pwd, self._stack_on)
2975
 
 
2976
 
    def _add_fallback(self, repository, possible_transports=None):
2977
 
        """Add a fallback to the supplied repository, if stacking is set."""
2978
 
        stack_on = self._get_full_stack_on()
2979
 
        if stack_on is None:
2980
 
            return
2981
 
        try:
2982
 
            stacked_dir = BzrDir.open(stack_on,
2983
 
                                      possible_transports=possible_transports)
2984
 
        except errors.JailBreak:
2985
 
            # We keep the stacking details, but we are in the server code so
2986
 
            # actually stacking is not needed.
2987
 
            return
2988
 
        try:
2989
 
            stacked_repo = stacked_dir.open_branch().repository
2990
 
        except errors.NotBranchError:
2991
 
            stacked_repo = stacked_dir.open_repository()
2992
 
        try:
2993
 
            repository.add_fallback_repository(stacked_repo)
2994
 
        except errors.UnstackableRepositoryFormat:
2995
 
            if self._require_stacking:
2996
 
                raise
2997
 
        else:
2998
 
            self._require_stacking = True
2999
 
 
3000
 
    def acquire_repository(self, make_working_trees=None, shared=False):
3001
 
        """Acquire a repository for this bzrdir.
3002
 
 
3003
 
        Implementations may create a new repository or use a pre-exising
3004
 
        repository.
3005
 
        :param make_working_trees: If creating a repository, set
3006
 
            make_working_trees to this value (if non-None)
3007
 
        :param shared: If creating a repository, make it shared if True
3008
 
        :return: A repository, is_new_flag (True if the repository was
3009
 
            created).
3010
 
        """
3011
 
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
3012
 
 
3013
 
 
3014
 
class CreateRepository(RepositoryAcquisitionPolicy):
3015
 
    """A policy of creating a new repository"""
3016
 
 
3017
 
    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
3018
 
                 require_stacking=False):
3019
 
        """
3020
 
        Constructor.
3021
 
        :param bzrdir: The bzrdir to create the repository on.
3022
 
        :param stack_on: A location to stack on
3023
 
        :param stack_on_pwd: If stack_on is relative, the location it is
3024
 
            relative to.
3025
 
        """
3026
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3027
 
                                             require_stacking)
3028
 
        self._bzrdir = bzrdir
3029
 
 
3030
 
    def acquire_repository(self, make_working_trees=None, shared=False):
3031
 
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
3032
 
 
3033
 
        Creates the desired repository in the bzrdir we already have.
3034
 
        """
3035
 
        stack_on = self._get_full_stack_on()
3036
 
        if stack_on:
3037
 
            format = self._bzrdir._format
3038
 
            format.require_stacking(stack_on=stack_on,
3039
 
                                    possible_transports=[self._bzrdir.root_transport])
3040
 
            if not self._require_stacking:
3041
 
                # We have picked up automatic stacking somewhere.
3042
 
                note('Using default stacking branch %s at %s', self._stack_on,
3043
 
                    self._stack_on_pwd)
3044
 
        repository = self._bzrdir.create_repository(shared=shared)
3045
 
        self._add_fallback(repository,
3046
 
                           possible_transports=[self._bzrdir.transport])
3047
 
        if make_working_trees is not None:
3048
 
            repository.set_make_working_trees(make_working_trees)
3049
 
        return repository, True
3050
 
 
3051
 
 
3052
 
class UseExistingRepository(RepositoryAcquisitionPolicy):
3053
 
    """A policy of reusing an existing repository"""
3054
 
 
3055
 
    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
3056
 
                 require_stacking=False):
3057
 
        """Constructor.
3058
 
 
3059
 
        :param repository: The repository to use.
3060
 
        :param stack_on: A location to stack on
3061
 
        :param stack_on_pwd: If stack_on is relative, the location it is
3062
 
            relative to.
3063
 
        """
3064
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3065
 
                                             require_stacking)
3066
 
        self._repository = repository
3067
 
 
3068
 
    def acquire_repository(self, make_working_trees=None, shared=False):
3069
 
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
3070
 
 
3071
 
        Returns an existing repository to use.
3072
 
        """
3073
 
        self._add_fallback(self._repository,
3074
 
                       possible_transports=[self._repository.bzrdir.transport])
3075
 
        return self._repository, False
3076
 
 
3077
 
 
3078
 
def register_metadir(registry, key,
3079
 
         repository_format, help, native=True, deprecated=False,
3080
 
         branch_format=None,
3081
 
         tree_format=None,
3082
 
         hidden=False,
3083
 
         experimental=False,
3084
 
         alias=False):
3085
 
    """Register a metadir subformat.
3086
 
 
3087
 
    These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3088
 
    by the Repository/Branch/WorkingTreeformats.
3089
 
 
3090
 
    :param repository_format: The fully-qualified repository format class
3091
 
        name as a string.
3092
 
    :param branch_format: Fully-qualified branch format class name as
3093
 
        a string.
3094
 
    :param tree_format: Fully-qualified tree format class name as
3095
 
        a string.
3096
 
    """
3097
 
    # This should be expanded to support setting WorkingTree and Branch
3098
 
    # formats, once BzrDirMetaFormat1 supports that.
3099
 
    def _load(full_name):
3100
 
        mod_name, factory_name = full_name.rsplit('.', 1)
3101
 
        try:
3102
 
            factory = pyutils.get_named_object(mod_name, factory_name)
3103
 
        except ImportError, e:
3104
 
            raise ImportError('failed to load %s: %s' % (full_name, e))
3105
 
        except AttributeError:
3106
 
            raise AttributeError('no factory %s in module %r'
3107
 
                % (full_name, sys.modules[mod_name]))
3108
 
        return factory()
3109
 
 
3110
 
    def helper():
3111
 
        bd = BzrDirMetaFormat1()
3112
 
        if branch_format is not None:
3113
 
            bd.set_branch_format(_load(branch_format))
3114
 
        if tree_format is not None:
3115
 
            bd.workingtree_format = _load(tree_format)
3116
 
        if repository_format is not None:
3117
 
            bd.repository_format = _load(repository_format)
3118
 
        return bd
3119
 
    registry.register(key, helper, help, native, deprecated, hidden,
3120
 
        experimental, alias)
3121
 
 
3122
 
# The pre-0.8 formats have their repository format network name registered in
3123
 
# repository.py. MetaDir formats have their repository format network name
3124
 
# inferred from their disk format string.
3125
 
controldir.format_registry.register('weave', BzrDirFormat6,
3126
 
    'Pre-0.8 format.  Slower than knit and does not'
3127
 
    ' support checkouts or shared repositories.',
3128
 
    hidden=True,
3129
 
    deprecated=True)
3130
 
register_metadir(controldir.format_registry, 'metaweave',
3131
 
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3132
 
    'Transitional format in 0.8.  Slower than knit.',
3133
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
3134
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3135
 
    hidden=True,
3136
 
    deprecated=True)
3137
 
register_metadir(controldir.format_registry, 'knit',
3138
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3139
 
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
3140
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
3141
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3142
 
    hidden=True,
3143
 
    deprecated=True)
3144
 
register_metadir(controldir.format_registry, 'dirstate',
3145
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3146
 
    help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3147
 
        'above when accessed over the network.',
3148
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
3149
 
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3150
 
    # directly from workingtree_4 triggers a circular import.
3151
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3152
 
    hidden=True,
3153
 
    deprecated=True)
3154
 
register_metadir(controldir.format_registry, 'dirstate-tags',
3155
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3156
 
    help='New in 0.15: Fast local operations and improved scaling for '
3157
 
        'network operations. Additionally adds support for tags.'
3158
 
        ' Incompatible with bzr < 0.15.',
3159
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3160
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3161
 
    hidden=True,
3162
 
    deprecated=True)
3163
 
register_metadir(controldir.format_registry, 'rich-root',
3164
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3165
 
    help='New in 1.0.  Better handling of tree roots.  Incompatible with'
3166
 
        ' bzr < 1.0.',
3167
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3168
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3169
 
    hidden=True,
3170
 
    deprecated=True)
3171
 
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
3172
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3173
 
    help='New in 0.15: Fast local operations and improved scaling for '
3174
 
        'network operations. Additionally adds support for versioning nested '
3175
 
        'bzr branches. Incompatible with bzr < 0.15.',
3176
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3177
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3178
 
    experimental=True,
3179
 
    hidden=True,
3180
 
    )
3181
 
register_metadir(controldir.format_registry, 'pack-0.92',
3182
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3183
 
    help='New in 0.92: Pack-based format with data compatible with '
3184
 
        'dirstate-tags format repositories. Interoperates with '
3185
 
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3186
 
        ,
3187
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3188
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3189
 
    )
3190
 
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
3191
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3192
 
    help='New in 0.92: Pack-based format with data compatible with '
3193
 
        'dirstate-with-subtree format repositories. Interoperates with '
3194
 
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3195
 
        ,
3196
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3197
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3198
 
    hidden=True,
3199
 
    experimental=True,
3200
 
    )
3201
 
register_metadir(controldir.format_registry, 'rich-root-pack',
3202
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3203
 
    help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3204
 
         '(needed for bzr-svn and bzr-git).',
3205
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3206
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3207
 
    hidden=True,
3208
 
    )
3209
 
register_metadir(controldir.format_registry, '1.6',
3210
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3211
 
    help='A format that allows a branch to indicate that there is another '
3212
 
         '(stacked) repository that should be used to access data that is '
3213
 
         'not present locally.',
3214
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3215
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3216
 
    hidden=True,
3217
 
    )
3218
 
register_metadir(controldir.format_registry, '1.6.1-rich-root',
3219
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3220
 
    help='A variant of 1.6 that supports rich-root data '
3221
 
         '(needed for bzr-svn and bzr-git).',
3222
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3223
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3224
 
    hidden=True,
3225
 
    )
3226
 
register_metadir(controldir.format_registry, '1.9',
3227
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3228
 
    help='A repository format using B+tree indexes. These indexes '
3229
 
         'are smaller in size, have smarter caching and provide faster '
3230
 
         'performance for most operations.',
3231
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3232
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3233
 
    hidden=True,
3234
 
    )
3235
 
register_metadir(controldir.format_registry, '1.9-rich-root',
3236
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3237
 
    help='A variant of 1.9 that supports rich-root data '
3238
 
         '(needed for bzr-svn and bzr-git).',
3239
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3240
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3241
 
    hidden=True,
3242
 
    )
3243
 
register_metadir(controldir.format_registry, '1.14',
3244
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3245
 
    help='A working-tree format that supports content filtering.',
3246
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3247
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3248
 
    )
3249
 
register_metadir(controldir.format_registry, '1.14-rich-root',
3250
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3251
 
    help='A variant of 1.14 that supports rich-root data '
3252
 
         '(needed for bzr-svn and bzr-git).',
3253
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3254
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3255
 
    )
3256
 
# The following un-numbered 'development' formats should always just be aliases.
3257
 
register_metadir(controldir.format_registry, 'development-rich-root',
3258
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3259
 
    help='Current development format. Supports rich roots. Can convert data '
3260
 
        'to and from rich-root-pack (and anything compatible with '
3261
 
        'rich-root-pack) format repositories. Repositories and branches in '
3262
 
        'this format can only be read by bzr.dev. Please read '
3263
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3264
 
        'before use.',
3265
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3266
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3267
 
    experimental=True,
3268
 
    alias=True,
3269
 
    hidden=True,
3270
 
    )
3271
 
register_metadir(controldir.format_registry, 'development5-subtree',
3272
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3273
 
    help='Development format, subtree variant. Can convert data to and '
3274
 
        'from pack-0.92-subtree (and anything compatible with '
3275
 
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3276
 
        'this format can only be read by bzr.dev. Please read '
3277
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3278
 
        'before use.',
3279
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3280
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3281
 
    experimental=True,
3282
 
    hidden=True,
3283
 
    alias=False,
3284
 
    )
3285
 
 
3286
 
 
3287
 
register_metadir(controldir.format_registry, 'development-subtree',
3288
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
3289
 
    help='Current development format, subtree variant. Can convert data to and '
3290
 
        'from pack-0.92-subtree (and anything compatible with '
3291
 
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3292
 
        'this format can only be read by bzr.dev. Please read '
3293
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3294
 
        'before use.',
3295
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3296
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3297
 
    experimental=True,
3298
 
    hidden=True,
3299
 
    alias=False, # Restore to being an alias when an actual development subtree format is added
3300
 
                 # This current non-alias status is simply because we did not introduce a
3301
 
                 # chk based subtree format.
3302
 
    )
3303
 
 
3304
 
# And the development formats above will have aliased one of the following:
3305
 
register_metadir(controldir.format_registry, 'development6-rich-root',
3306
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3307
 
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3308
 
        'Please read '
3309
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3310
 
        'before use.',
3311
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3312
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3313
 
    hidden=True,
3314
 
    experimental=True,
3315
 
    )
3316
 
 
3317
 
register_metadir(controldir.format_registry, 'development7-rich-root',
3318
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3319
 
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3320
 
        'rich roots. Please read '
3321
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3322
 
        'before use.',
3323
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3324
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3325
 
    hidden=True,
3326
 
    experimental=True,
3327
 
    )
3328
 
 
3329
 
register_metadir(controldir.format_registry, '2a',
3330
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3331
 
    help='First format for bzr 2.0 series.\n'
3332
 
        'Uses group-compress storage.\n'
3333
 
        'Provides rich roots which are a one-way transition.\n',
3334
 
        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
3335
 
        # 'rich roots. Supported by bzr 1.16 and later.',
3336
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3337
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3338
 
    experimental=False,
3339
 
    )
3340
 
 
3341
 
# The following format should be an alias for the rich root equivalent 
3342
 
# of the default format
3343
 
register_metadir(controldir.format_registry, 'default-rich-root',
3344
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3345
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3346
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3347
 
    alias=True,
3348
 
    hidden=True,
3349
 
    help='Same as 2a.')
3350
 
 
3351
 
# The current format that is made on 'bzr init'.
3352
 
format_name = config.GlobalConfig().get_user_option('default_format')
3353
 
if format_name is None:
3354
 
    controldir.format_registry.set_default('2a')
3355
 
else:
3356
 
    controldir.format_registry.set_default(format_name)
3357
 
 
3358
 
# XXX 2010-08-20 JRV: There is still a lot of code relying on
3359
 
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
3360
 
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
3361
 
format_registry = controldir.format_registry