← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

Show diffs side-by-side

added added

removed removed

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