← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Aaron Bentley
  • Date: 2006-06-21 14:30:57 UTC
  • mfrom: (1801.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: abentley@panoramicfeedback.com-20060621143057-776e4b8d707e430e
Install benchmarks. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

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