← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-03 07:18:36 UTC
  • mto: (5008.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5009.
  • Revision ID: v.ladeuil+lp@free.fr-20100203071836-u9b86q68fr9ri5s6
Fix NEWS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
18
18
 
19
19
At format 7 this was split out into Branch, Repository and Checkout control
20
20
directories.
 
21
 
 
22
Note: This module has a lot of ``open`` functions/methods that return
 
23
references to in-memory objects. As a rule, there are no matching ``close``
 
24
methods. To free any associated resources, simply stop referencing the
 
25
objects returned.
21
26
"""
22
27
 
23
 
# TODO: remove unittest dependency; put that stuff inside the test suite
 
28
# TODO: Move old formats into a plugin to make this file smaller.
24
29
 
25
 
from copy import deepcopy
26
 
from cStringIO import StringIO
27
30
import os
 
31
import sys
 
32
 
 
33
from bzrlib.lazy_import import lazy_import
 
34
lazy_import(globals(), """
28
35
from stat import S_ISDIR
29
 
from unittest import TestSuite
 
36
import textwrap
30
37
 
31
38
import bzrlib
32
 
import bzrlib.errors as errors
33
 
from bzrlib.lockable_files import LockableFiles, TransportLock
34
 
from bzrlib.lockdir import LockDir
 
39
from bzrlib import (
 
40
    branch,
 
41
    config,
 
42
    errors,
 
43
    graph,
 
44
    lockable_files,
 
45
    lockdir,
 
46
    osutils,
 
47
    remote,
 
48
    repository,
 
49
    revision as _mod_revision,
 
50
    ui,
 
51
    urlutils,
 
52
    versionedfile,
 
53
    win32utils,
 
54
    workingtree,
 
55
    workingtree_4,
 
56
    xml4,
 
57
    xml5,
 
58
    )
35
59
from bzrlib.osutils import (
36
 
                            abspath,
37
 
                            pathjoin,
38
 
                            safe_unicode,
39
 
                            sha_strings,
40
 
                            sha_string,
41
 
                            )
42
 
from bzrlib.store.revision.text import TextRevisionStore
43
 
from bzrlib.store.text import TextStore
 
60
    sha_string,
 
61
    )
 
62
from bzrlib.push import (
 
63
    PushResult,
 
64
    )
 
65
from bzrlib.repofmt import pack_repo
 
66
from bzrlib.smart.client import _SmartClient
44
67
from bzrlib.store.versioned import WeaveStore
45
 
from bzrlib.trace import mutter
46
68
from bzrlib.transactions import WriteTransaction
47
 
from bzrlib.transport import get_transport
48
 
from bzrlib.transport.local import LocalTransport
49
 
import bzrlib.urlutils as urlutils
 
69
from bzrlib.transport import (
 
70
    do_catching_redirections,
 
71
    get_transport,
 
72
    local,
 
73
    )
50
74
from bzrlib.weave import Weave
51
 
from bzrlib.xml4 import serializer_v4
52
 
import bzrlib.xml5
 
75
""")
 
76
 
 
77
from bzrlib.trace import (
 
78
    mutter,
 
79
    note,
 
80
    warning,
 
81
    )
 
82
 
 
83
from bzrlib import (
 
84
    hooks,
 
85
    registry,
 
86
    symbol_versioning,
 
87
    )
53
88
 
54
89
 
55
90
class BzrDir(object):
56
91
    """A .bzr control diretory.
57
 
    
 
92
 
58
93
    BzrDir instances let you create or open any of the things that can be
59
94
    found within .bzr - checkouts, branches and repositories.
60
 
    
61
 
    transport
 
95
 
 
96
    :ivar transport:
62
97
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
63
 
    root_transport
64
 
        a transport connected to the directory this bzr was opened from.
 
98
    :ivar root_transport:
 
99
        a transport connected to the directory this bzr was opened from
 
100
        (i.e. the parent directory holding the .bzr directory).
 
101
 
 
102
    Everything in the bzrdir should have the same file permissions.
 
103
 
 
104
    :cvar hooks: An instance of BzrDirHooks.
65
105
    """
66
106
 
67
107
    def break_lock(self):
70
110
        If there is a tree, the tree is opened and break_lock() called.
71
111
        Otherwise, branch is tried, and finally repository.
72
112
        """
 
113
        # XXX: This seems more like a UI function than something that really
 
114
        # belongs in this class.
73
115
        try:
74
116
            thing_to_unlock = self.open_workingtree()
75
117
        except (errors.NotLocalUrl, errors.NoWorkingTree):
86
128
        """Return true if this bzrdir is one whose format we can convert from."""
87
129
        return True
88
130
 
 
131
    def check_conversion_target(self, target_format):
 
132
        """Check that a bzrdir as a whole can be converted to a new format."""
 
133
        # The only current restriction is that the repository content can be 
 
134
        # fetched compatibly with the target.
 
135
        target_repo_format = target_format.repository_format
 
136
        try:
 
137
            self.open_repository()._format.check_conversion_target(
 
138
                target_repo_format)
 
139
        except errors.NoRepositoryPresent:
 
140
            # No repo, no problem.
 
141
            pass
 
142
 
89
143
    @staticmethod
90
 
    def _check_supported(format, allow_unsupported):
91
 
        """Check whether format is a supported format.
92
 
 
93
 
        If allow_unsupported is True, this is a no-op.
 
144
    def _check_supported(format, allow_unsupported,
 
145
        recommend_upgrade=True,
 
146
        basedir=None):
 
147
        """Give an error or warning on old formats.
 
148
 
 
149
        :param format: may be any kind of format - workingtree, branch,
 
150
        or repository.
 
151
 
 
152
        :param allow_unsupported: If true, allow opening
 
153
        formats that are strongly deprecated, and which may
 
154
        have limited functionality.
 
155
 
 
156
        :param recommend_upgrade: If true (default), warn
 
157
        the user through the ui object that they may wish
 
158
        to upgrade the object.
94
159
        """
 
160
        # TODO: perhaps move this into a base Format class; it's not BzrDir
 
161
        # specific. mbp 20070323
95
162
        if not allow_unsupported and not format.is_supported():
96
163
            # see open_downlevel to open legacy branches.
97
164
            raise errors.UnsupportedFormatError(format=format)
 
165
        if recommend_upgrade \
 
166
            and getattr(format, 'upgrade_recommended', False):
 
167
            ui.ui_factory.recommend_upgrade(
 
168
                format.get_format_description(),
 
169
                basedir)
98
170
 
99
 
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
 
171
    def clone(self, url, revision_id=None, force_new_repo=False,
 
172
              preserve_stacking=False):
100
173
        """Clone this bzrdir and its contents to url verbatim.
101
174
 
102
 
        If urls last component does not exist, it will be created.
103
 
 
104
 
        if revision_id is not None, then the clone operation may tune
105
 
            itself to download less data.
106
 
        :param force_new_repo: Do not use a shared repository for the target 
107
 
                               even if one is available.
108
 
        """
109
 
        self._make_tail(url)
110
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
111
 
        result = self._format.initialize(url)
 
175
        :param url: The url create the clone at.  If url's last component does
 
176
            not exist, it will be created.
 
177
        :param revision_id: The tip revision-id to use for any branch or
 
178
            working tree.  If not None, then the clone operation may tune
 
179
            itself to download less data.
 
180
        :param force_new_repo: Do not use a shared repository for the target
 
181
                               even if one is available.
 
182
        :param preserve_stacking: When cloning a stacked branch, stack the
 
183
            new branch on top of the other branch's stacked-on branch.
 
184
        """
 
185
        return self.clone_on_transport(get_transport(url),
 
186
                                       revision_id=revision_id,
 
187
                                       force_new_repo=force_new_repo,
 
188
                                       preserve_stacking=preserve_stacking)
 
189
 
 
190
    def clone_on_transport(self, transport, revision_id=None,
 
191
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
192
        create_prefix=False, use_existing_dir=True):
 
193
        """Clone this bzrdir and its contents to transport verbatim.
 
194
 
 
195
        :param transport: The transport for the location to produce the clone
 
196
            at.  If the target directory does not exist, it will be created.
 
197
        :param revision_id: The tip revision-id to use for any branch or
 
198
            working tree.  If not None, then the clone operation may tune
 
199
            itself to download less data.
 
200
        :param force_new_repo: Do not use a shared repository for the target,
 
201
                               even if one is available.
 
202
        :param preserve_stacking: When cloning a stacked branch, stack the
 
203
            new branch on top of the other branch's stacked-on branch.
 
204
        :param create_prefix: Create any missing directories leading up to
 
205
            to_transport.
 
206
        :param use_existing_dir: Use an existing directory if one exists.
 
207
        """
 
208
        # Overview: put together a broad description of what we want to end up
 
209
        # with; then make as few api calls as possible to do it.
 
210
        
 
211
        # We may want to create a repo/branch/tree, if we do so what format
 
212
        # would we want for each:
 
213
        require_stacking = (stacked_on is not None)
 
214
        format = self.cloning_metadir(require_stacking)
 
215
        
 
216
        # Figure out what objects we want:
112
217
        try:
113
218
            local_repo = self.find_repository()
114
219
        except errors.NoRepositoryPresent:
115
220
            local_repo = None
 
221
        try:
 
222
            local_branch = self.open_branch()
 
223
        except errors.NotBranchError:
 
224
            local_branch = None
 
225
        else:
 
226
            # enable fallbacks when branch is not a branch reference
 
227
            if local_branch.repository.has_same_location(local_repo):
 
228
                local_repo = local_branch.repository
 
229
            if preserve_stacking:
 
230
                try:
 
231
                    stacked_on = local_branch.get_stacked_on_url()
 
232
                except (errors.UnstackableBranchFormat,
 
233
                        errors.UnstackableRepositoryFormat,
 
234
                        errors.NotStacked):
 
235
                    pass
 
236
        # Bug: We create a metadir without knowing if it can support stacking,
 
237
        # we should look up the policy needs first, or just use it as a hint,
 
238
        # or something.
116
239
        if local_repo:
117
 
            # may need to copy content in
118
 
            if force_new_repo:
119
 
                result_repo = local_repo.clone(
120
 
                    result,
121
 
                    revision_id=revision_id,
122
 
                    basis=basis_repo)
123
 
                result_repo.set_make_working_trees(local_repo.make_working_trees())
124
 
            else:
125
 
                try:
126
 
                    result_repo = result.find_repository()
127
 
                    # fetch content this dir needs.
128
 
                    if basis_repo:
129
 
                        # XXX FIXME RBC 20060214 need tests for this when the basis
130
 
                        # is incomplete
131
 
                        result_repo.fetch(basis_repo, revision_id=revision_id)
 
240
            make_working_trees = local_repo.make_working_trees()
 
241
            want_shared = local_repo.is_shared()
 
242
            repo_format_name = format.repository_format.network_name()
 
243
        else:
 
244
            make_working_trees = False
 
245
            want_shared = False
 
246
            repo_format_name = None
 
247
 
 
248
        result_repo, result, require_stacking, repository_policy = \
 
249
            format.initialize_on_transport_ex(transport,
 
250
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
251
            force_new_repo=force_new_repo, stacked_on=stacked_on,
 
252
            stack_on_pwd=self.root_transport.base,
 
253
            repo_format_name=repo_format_name,
 
254
            make_working_trees=make_working_trees, shared_repo=want_shared)
 
255
        if repo_format_name:
 
256
            try:
 
257
                # If the result repository is in the same place as the
 
258
                # resulting bzr dir, it will have no content, further if the
 
259
                # result is not stacked then we know all content should be
 
260
                # copied, and finally if we are copying up to a specific
 
261
                # revision_id then we can use the pending-ancestry-result which
 
262
                # does not require traversing all of history to describe it.
 
263
                if (result_repo.bzrdir.root_transport.base ==
 
264
                    result.root_transport.base and not require_stacking and
 
265
                    revision_id is not None):
 
266
                    fetch_spec = graph.PendingAncestryResult(
 
267
                        [revision_id], local_repo)
 
268
                    result_repo.fetch(local_repo, fetch_spec=fetch_spec)
 
269
                else:
132
270
                    result_repo.fetch(local_repo, revision_id=revision_id)
133
 
                except errors.NoRepositoryPresent:
134
 
                    # needed to make one anyway.
135
 
                    result_repo = local_repo.clone(
136
 
                        result,
137
 
                        revision_id=revision_id,
138
 
                        basis=basis_repo)
139
 
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
 
271
            finally:
 
272
                result_repo.unlock()
 
273
        else:
 
274
            if result_repo is not None:
 
275
                raise AssertionError('result_repo not None(%r)' % result_repo)
140
276
        # 1 if there is a branch present
141
277
        #   make sure its content is available in the target repository
142
278
        #   clone it.
143
 
        try:
144
 
            self.open_branch().clone(result, revision_id=revision_id)
145
 
        except errors.NotBranchError:
146
 
            pass
147
 
        try:
148
 
            self.open_workingtree().clone(result, basis=basis_tree)
 
279
        if local_branch is not None:
 
280
            result_branch = local_branch.clone(result, revision_id=revision_id,
 
281
                repository_policy=repository_policy)
 
282
        try:
 
283
            # Cheaper to check if the target is not local, than to try making
 
284
            # the tree and fail.
 
285
            result.root_transport.local_abspath('.')
 
286
            if result_repo is None or result_repo.make_working_trees():
 
287
                self.open_workingtree().clone(result)
149
288
        except (errors.NoWorkingTree, errors.NotLocalUrl):
150
289
            pass
151
290
        return result
152
291
 
153
 
    def _get_basis_components(self, basis):
154
 
        """Retrieve the basis components that are available at basis."""
155
 
        if basis is None:
156
 
            return None, None, None
157
 
        try:
158
 
            basis_tree = basis.open_workingtree()
159
 
            basis_branch = basis_tree.branch
160
 
            basis_repo = basis_branch.repository
161
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
162
 
            basis_tree = None
163
 
            try:
164
 
                basis_branch = basis.open_branch()
165
 
                basis_repo = basis_branch.repository
166
 
            except errors.NotBranchError:
167
 
                basis_branch = None
168
 
                try:
169
 
                    basis_repo = basis.open_repository()
170
 
                except errors.NoRepositoryPresent:
171
 
                    basis_repo = None
172
 
        return basis_repo, basis_branch, basis_tree
173
 
 
174
292
    # TODO: This should be given a Transport, and should chdir up; otherwise
175
293
    # this will open a new connection.
176
294
    def _make_tail(self, url):
177
 
        head, tail = urlutils.split(url)
178
 
        if tail and tail != '.':
179
 
            t = bzrlib.transport.get_transport(head)
180
 
            try:
181
 
                t.mkdir(tail)
182
 
            except errors.FileExists:
183
 
                pass
 
295
        t = get_transport(url)
 
296
        t.ensure_base()
184
297
 
185
 
    # TODO: Should take a Transport
186
298
    @classmethod
187
 
    def create(cls, base):
 
299
    def create(cls, base, format=None, possible_transports=None):
188
300
        """Create a new BzrDir at the url 'base'.
189
 
        
190
 
        This will call the current default formats initialize with base
191
 
        as the only parameter.
192
301
 
193
 
        If you need a specific format, consider creating an instance
194
 
        of that and calling initialize().
 
302
        :param format: If supplied, the format of branch to create.  If not
 
303
            supplied, the default is used.
 
304
        :param possible_transports: If supplied, a list of transports that
 
305
            can be reused to share a remote connection.
195
306
        """
196
307
        if cls is not BzrDir:
197
 
            raise AssertionError("BzrDir.create always creates the default format, "
198
 
                    "not one of %r" % cls)
199
 
        head, tail = urlutils.split(base)
200
 
        if tail and tail != '.':
201
 
            t = bzrlib.transport.get_transport(head)
202
 
            try:
203
 
                t.mkdir(tail)
204
 
            except errors.FileExists:
205
 
                pass
206
 
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
 
308
            raise AssertionError("BzrDir.create always creates the default"
 
309
                " format, not one of %r" % cls)
 
310
        t = get_transport(base, possible_transports)
 
311
        t.ensure_base()
 
312
        if format is None:
 
313
            format = BzrDirFormat.get_default_format()
 
314
        return format.initialize_on_transport(t)
 
315
 
 
316
    @staticmethod
 
317
    def find_bzrdirs(transport, evaluate=None, list_current=None):
 
318
        """Find bzrdirs recursively from current location.
 
319
 
 
320
        This is intended primarily as a building block for more sophisticated
 
321
        functionality, like finding trees under a directory, or finding
 
322
        branches that use a given repository.
 
323
        :param evaluate: An optional callable that yields recurse, value,
 
324
            where recurse controls whether this bzrdir is recursed into
 
325
            and value is the value to yield.  By default, all bzrdirs
 
326
            are recursed into, and the return value is the bzrdir.
 
327
        :param list_current: if supplied, use this function to list the current
 
328
            directory, instead of Transport.list_dir
 
329
        :return: a generator of found bzrdirs, or whatever evaluate returns.
 
330
        """
 
331
        if list_current is None:
 
332
            def list_current(transport):
 
333
                return transport.list_dir('')
 
334
        if evaluate is None:
 
335
            def evaluate(bzrdir):
 
336
                return True, bzrdir
 
337
 
 
338
        pending = [transport]
 
339
        while len(pending) > 0:
 
340
            current_transport = pending.pop()
 
341
            recurse = True
 
342
            try:
 
343
                bzrdir = BzrDir.open_from_transport(current_transport)
 
344
            except errors.NotBranchError:
 
345
                pass
 
346
            else:
 
347
                recurse, value = evaluate(bzrdir)
 
348
                yield value
 
349
            try:
 
350
                subdirs = list_current(current_transport)
 
351
            except errors.NoSuchFile:
 
352
                continue
 
353
            if recurse:
 
354
                for subdir in sorted(subdirs, reverse=True):
 
355
                    pending.append(current_transport.clone(subdir))
 
356
 
 
357
    @staticmethod
 
358
    def find_branches(transport):
 
359
        """Find all branches under a transport.
 
360
 
 
361
        This will find all branches below the transport, including branches
 
362
        inside other branches.  Where possible, it will use
 
363
        Repository.find_branches.
 
364
 
 
365
        To list all the branches that use a particular Repository, see
 
366
        Repository.find_branches
 
367
        """
 
368
        def evaluate(bzrdir):
 
369
            try:
 
370
                repository = bzrdir.open_repository()
 
371
            except errors.NoRepositoryPresent:
 
372
                pass
 
373
            else:
 
374
                return False, (None, repository)
 
375
            try:
 
376
                branch = bzrdir.open_branch()
 
377
            except errors.NotBranchError:
 
378
                return True, (None, None)
 
379
            else:
 
380
                return True, (branch, None)
 
381
        branches = []
 
382
        for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
 
383
            if repo is not None:
 
384
                branches.extend(repo.find_branches())
 
385
            if branch is not None:
 
386
                branches.append(branch)
 
387
        return branches
 
388
 
 
389
    def destroy_repository(self):
 
390
        """Destroy the repository in this BzrDir"""
 
391
        raise NotImplementedError(self.destroy_repository)
207
392
 
208
393
    def create_branch(self):
209
394
        """Create a branch in this BzrDir.
210
395
 
211
 
        The bzrdirs format will control what branch format is created.
 
396
        The bzrdir's format will control what branch format is created.
212
397
        For more control see BranchFormatXX.create(a_bzrdir).
213
398
        """
214
399
        raise NotImplementedError(self.create_branch)
215
400
 
 
401
    def destroy_branch(self):
 
402
        """Destroy the branch in this BzrDir"""
 
403
        raise NotImplementedError(self.destroy_branch)
 
404
 
216
405
    @staticmethod
217
 
    def create_branch_and_repo(base, force_new_repo=False):
 
406
    def create_branch_and_repo(base, force_new_repo=False, format=None):
218
407
        """Create a new BzrDir, Branch and Repository at the url 'base'.
219
408
 
220
 
        This will use the current default BzrDirFormat, and use whatever 
 
409
        This will use the current default BzrDirFormat unless one is
 
410
        specified, and use whatever
221
411
        repository format that that uses via bzrdir.create_branch and
222
412
        create_repository. If a shared repository is available that is used
223
413
        preferentially.
226
416
 
227
417
        :param base: The URL to create the branch at.
228
418
        :param force_new_repo: If True a new repository is always created.
 
419
        :param format: If supplied, the format of branch to create.  If not
 
420
            supplied, the default is used.
229
421
        """
230
 
        bzrdir = BzrDir.create(base)
 
422
        bzrdir = BzrDir.create(base, format)
231
423
        bzrdir._find_or_create_repository(force_new_repo)
232
424
        return bzrdir.create_branch()
233
425
 
 
426
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
 
427
                                    stack_on_pwd=None, require_stacking=False):
 
428
        """Return an object representing a policy to use.
 
429
 
 
430
        This controls whether a new repository is created, and the format of
 
431
        that repository, or some existing shared repository used instead.
 
432
 
 
433
        If stack_on is supplied, will not seek a containing shared repo.
 
434
 
 
435
        :param force_new_repo: If True, require a new repository to be created.
 
436
        :param stack_on: If supplied, the location to stack on.  If not
 
437
            supplied, a default_stack_on location may be used.
 
438
        :param stack_on_pwd: If stack_on is relative, the location it is
 
439
            relative to.
 
440
        """
 
441
        def repository_policy(found_bzrdir):
 
442
            stack_on = None
 
443
            stack_on_pwd = None
 
444
            config = found_bzrdir.get_config()
 
445
            stop = False
 
446
            stack_on = config.get_default_stack_on()
 
447
            if stack_on is not None:
 
448
                stack_on_pwd = found_bzrdir.root_transport.base
 
449
                stop = True
 
450
            # does it have a repository ?
 
451
            try:
 
452
                repository = found_bzrdir.open_repository()
 
453
            except errors.NoRepositoryPresent:
 
454
                repository = None
 
455
            else:
 
456
                if ((found_bzrdir.root_transport.base !=
 
457
                     self.root_transport.base) and not repository.is_shared()):
 
458
                    # Don't look higher, can't use a higher shared repo.
 
459
                    repository = None
 
460
                    stop = True
 
461
                else:
 
462
                    stop = True
 
463
            if not stop:
 
464
                return None, False
 
465
            if repository:
 
466
                return UseExistingRepository(repository, stack_on,
 
467
                    stack_on_pwd, require_stacking=require_stacking), True
 
468
            else:
 
469
                return CreateRepository(self, stack_on, stack_on_pwd,
 
470
                    require_stacking=require_stacking), True
 
471
 
 
472
        if not force_new_repo:
 
473
            if stack_on is None:
 
474
                policy = self._find_containing(repository_policy)
 
475
                if policy is not None:
 
476
                    return policy
 
477
            else:
 
478
                try:
 
479
                    return UseExistingRepository(self.open_repository(),
 
480
                        stack_on, stack_on_pwd,
 
481
                        require_stacking=require_stacking)
 
482
                except errors.NoRepositoryPresent:
 
483
                    pass
 
484
        return CreateRepository(self, stack_on, stack_on_pwd,
 
485
                                require_stacking=require_stacking)
 
486
 
234
487
    def _find_or_create_repository(self, force_new_repo):
235
488
        """Create a new repository if needed, returning the repository."""
236
 
        if force_new_repo:
237
 
            return self.create_repository()
238
 
        try:
239
 
            return self.find_repository()
240
 
        except errors.NoRepositoryPresent:
241
 
            return self.create_repository()
242
 
        
 
489
        policy = self.determine_repository_policy(force_new_repo)
 
490
        return policy.acquire_repository()[0]
 
491
 
243
492
    @staticmethod
244
493
    def create_branch_convenience(base, force_new_repo=False,
245
 
                                  force_new_tree=None, format=None):
 
494
                                  force_new_tree=None, format=None,
 
495
                                  possible_transports=None):
246
496
        """Create a new BzrDir, Branch and Repository at the url 'base'.
247
497
 
248
498
        This is a convenience function - it will use an existing repository
249
499
        if possible, can be told explicitly whether to create a working tree or
250
500
        not.
251
501
 
252
 
        This will use the current default BzrDirFormat, and use whatever 
 
502
        This will use the current default BzrDirFormat unless one is
 
503
        specified, and use whatever
253
504
        repository format that that uses via bzrdir.create_branch and
254
505
        create_repository. If a shared repository is available that is used
255
506
        preferentially. Whatever repository is used, its tree creation policy
257
508
 
258
509
        The created Branch object is returned.
259
510
        If a working tree cannot be made due to base not being a file:// url,
260
 
        no error is raised unless force_new_tree is True, in which case no 
 
511
        no error is raised unless force_new_tree is True, in which case no
261
512
        data is created on disk and NotLocalUrl is raised.
262
513
 
263
514
        :param base: The URL to create the branch at.
264
515
        :param force_new_repo: If True a new repository is always created.
265
 
        :param force_new_tree: If True or False force creation of a tree or 
 
516
        :param force_new_tree: If True or False force creation of a tree or
266
517
                               prevent such creation respectively.
267
 
        :param format: Override for the for the bzrdir format to create
 
518
        :param format: Override for the bzrdir format to create.
 
519
        :param possible_transports: An optional reusable transports list.
268
520
        """
269
521
        if force_new_tree:
270
522
            # check for non local urls
271
 
            t = get_transport(safe_unicode(base))
272
 
            if not isinstance(t, LocalTransport):
 
523
            t = get_transport(base, possible_transports)
 
524
            if not isinstance(t, local.LocalTransport):
273
525
                raise errors.NotLocalUrl(base)
274
 
        if format is None:
275
 
            bzrdir = BzrDir.create(base)
276
 
        else:
277
 
            bzrdir = format.initialize(base)
 
526
        bzrdir = BzrDir.create(base, format, possible_transports)
278
527
        repo = bzrdir._find_or_create_repository(force_new_repo)
279
528
        result = bzrdir.create_branch()
280
 
        if force_new_tree or (repo.make_working_trees() and 
 
529
        if force_new_tree or (repo.make_working_trees() and
281
530
                              force_new_tree is None):
282
531
            try:
283
532
                bzrdir.create_workingtree()
284
533
            except errors.NotLocalUrl:
285
534
                pass
286
535
        return result
287
 
        
288
 
    @staticmethod
289
 
    def create_repository(base, shared=False):
290
 
        """Create a new BzrDir and Repository at the url 'base'.
291
 
 
292
 
        This will use the current default BzrDirFormat, and use whatever 
293
 
        repository format that that uses for bzrdirformat.create_repository.
294
 
 
295
 
        ;param shared: Create a shared repository rather than a standalone
296
 
                       repository.
297
 
        The Repository object is returned.
298
 
 
299
 
        This must be overridden as an instance method in child classes, where
300
 
        it should take no parameters and construct whatever repository format
301
 
        that child class desires.
302
 
        """
303
 
        bzrdir = BzrDir.create(base)
304
 
        return bzrdir.create_repository(shared)
305
 
 
306
 
    @staticmethod
307
 
    def create_standalone_workingtree(base):
 
536
 
 
537
    @staticmethod
 
538
    def create_standalone_workingtree(base, format=None):
308
539
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
309
540
 
310
541
        'base' must be a local path or a file:// url.
311
542
 
312
 
        This will use the current default BzrDirFormat, and use whatever 
 
543
        This will use the current default BzrDirFormat unless one is
 
544
        specified, and use whatever
313
545
        repository format that that uses for bzrdirformat.create_workingtree,
314
546
        create_branch and create_repository.
315
547
 
316
 
        The WorkingTree object is returned.
 
548
        :param format: Override for the bzrdir format to create.
 
549
        :return: The WorkingTree object.
317
550
        """
318
 
        t = get_transport(safe_unicode(base))
319
 
        if not isinstance(t, LocalTransport):
 
551
        t = get_transport(base)
 
552
        if not isinstance(t, local.LocalTransport):
320
553
            raise errors.NotLocalUrl(base)
321
 
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
322
 
                                               force_new_repo=True).bzrdir
 
554
        bzrdir = BzrDir.create_branch_and_repo(base,
 
555
                                               force_new_repo=True,
 
556
                                               format=format).bzrdir
323
557
        return bzrdir.create_workingtree()
324
558
 
325
 
    def create_workingtree(self, revision_id=None):
 
559
    def create_workingtree(self, revision_id=None, from_branch=None,
 
560
        accelerator_tree=None, hardlink=False):
326
561
        """Create a working tree at this BzrDir.
327
 
        
328
 
        revision_id: create it as of this revision id.
 
562
 
 
563
        :param revision_id: create it as of this revision id.
 
564
        :param from_branch: override bzrdir branch (for lightweight checkouts)
 
565
        :param accelerator_tree: A tree which can be used for retrieving file
 
566
            contents more quickly than the revision tree, i.e. a workingtree.
 
567
            The revision tree will be used for cases where accelerator_tree's
 
568
            content is different.
329
569
        """
330
570
        raise NotImplementedError(self.create_workingtree)
331
571
 
 
572
    def backup_bzrdir(self):
 
573
        """Backup this bzr control directory.
 
574
 
 
575
        :return: Tuple with old path name and new path name
 
576
        """
 
577
        pb = ui.ui_factory.nested_progress_bar()
 
578
        try:
 
579
            # FIXME: bug 300001 -- the backup fails if the backup directory
 
580
            # already exists, but it should instead either remove it or make
 
581
            # a new backup directory.
 
582
            #
 
583
            # FIXME: bug 262450 -- the backup directory should have the same
 
584
            # permissions as the .bzr directory (probably a bug in copy_tree)
 
585
            old_path = self.root_transport.abspath('.bzr')
 
586
            new_path = self.root_transport.abspath('backup.bzr')
 
587
            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
 
655
            # find the next containing bzrdir
 
656
            try:
 
657
                found_bzrdir = BzrDir.open_containing_from_transport(
 
658
                    next_transport)[0]
 
659
            except errors.NotBranchError:
 
660
                return None
 
661
 
332
662
    def find_repository(self):
333
 
        """Find the repository that should be used for a_bzrdir.
 
663
        """Find the repository that should be used.
334
664
 
335
665
        This does not require a branch as we use it to find the repo for
336
666
        new branches as well as to hook existing branches up to their
337
667
        repository.
338
668
        """
339
 
        try:
340
 
            return self.open_repository()
341
 
        except errors.NoRepositoryPresent:
342
 
            pass
343
 
        next_transport = self.root_transport.clone('..')
344
 
        while True:
345
 
            # find the next containing bzrdir
346
 
            try:
347
 
                found_bzrdir = BzrDir.open_containing_from_transport(
348
 
                    next_transport)[0]
349
 
            except errors.NotBranchError:
350
 
                # none found
351
 
                raise errors.NoRepositoryPresent(self)
 
669
        def usable_repository(found_bzrdir):
352
670
            # does it have a repository ?
353
671
            try:
354
672
                repository = found_bzrdir.open_repository()
355
673
            except errors.NoRepositoryPresent:
356
 
                next_transport = found_bzrdir.root_transport.clone('..')
357
 
                if (found_bzrdir.root_transport.base == next_transport.base):
358
 
                    # top of the file system
359
 
                    break
360
 
                else:
361
 
                    continue
362
 
            if ((found_bzrdir.root_transport.base == 
363
 
                 self.root_transport.base) or repository.is_shared()):
364
 
                return repository
 
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
365
679
            else:
366
 
                raise errors.NoRepositoryPresent(self)
367
 
        raise errors.NoRepositoryPresent(self)
 
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
368
695
 
369
696
    def get_branch_transport(self, branch_format):
370
697
        """Get the transport for use by branch format in this BzrDir.
373
700
        IncompatibleFormat if the branch format they are given has
374
701
        a format string, and vice versa.
375
702
 
376
 
        If branch_format is None, the transport is returned with no 
377
 
        checking. if it is not None, then the returned transport is
 
703
        If branch_format is None, the transport is returned with no
 
704
        checking. If it is not None, then the returned transport is
378
705
        guaranteed to point to an existing directory ready for use.
379
706
        """
380
707
        raise NotImplementedError(self.get_branch_transport)
381
 
        
 
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
 
382
753
    def get_repository_transport(self, repository_format):
383
754
        """Get the transport for use by repository format in this BzrDir.
384
755
 
386
757
        IncompatibleFormat if the repository format they are given has
387
758
        a format string, and vice versa.
388
759
 
389
 
        If repository_format is None, the transport is returned with no 
390
 
        checking. if it is not None, then the returned transport is
 
760
        If repository_format is None, the transport is returned with no
 
761
        checking. If it is not None, then the returned transport is
391
762
        guaranteed to point to an existing directory ready for use.
392
763
        """
393
764
        raise NotImplementedError(self.get_repository_transport)
394
 
        
 
765
 
395
766
    def get_workingtree_transport(self, tree_format):
396
767
        """Get the transport for use by workingtree format in this BzrDir.
397
768
 
398
769
        Note that bzr dirs that do not support format strings will raise
399
 
        IncompatibleFormat if the workingtree format they are given has
400
 
        a format string, and vice versa.
 
770
        IncompatibleFormat if the workingtree format they are given has a
 
771
        format string, and vice versa.
401
772
 
402
 
        If workingtree_format is None, the transport is returned with no 
403
 
        checking. if it is not None, then the returned transport is
 
773
        If workingtree_format is None, the transport is returned with no
 
774
        checking. If it is not None, then the returned transport is
404
775
        guaranteed to point to an existing directory ready for use.
405
776
        """
406
777
        raise NotImplementedError(self.get_workingtree_transport)
407
 
        
 
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
 
408
787
    def __init__(self, _transport, _format):
409
788
        """Initialize a Bzr control dir object.
410
 
        
 
789
 
411
790
        Only really common logic should reside here, concrete classes should be
412
791
        made with varying behaviours.
413
792
 
417
796
        self._format = _format
418
797
        self.transport = _transport.clone('.bzr')
419
798
        self.root_transport = _transport
 
799
        self._mode_check_done = False
420
800
 
421
801
    def is_control_filename(self, filename):
422
802
        """True if filename is the name of a path which is reserved for bzrdir's.
423
 
        
 
803
 
424
804
        :param filename: A filename within the root transport of this bzrdir.
425
805
 
426
806
        This is true IF and ONLY IF the filename is part of the namespace reserved
429
809
        this in the future - for instance to make bzr talk with svn working
430
810
        trees.
431
811
        """
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
 
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
437
817
        # add new tests for it to the appropriate place.
438
818
        return filename == '.bzr' or filename.startswith('.bzr/')
439
819
 
440
820
    def needs_format_conversion(self, format=None):
441
821
        """Return true if this bzrdir needs convert_format run on it.
442
 
        
443
 
        For instance, if the repository format is out of date but the 
 
822
 
 
823
        For instance, if the repository format is out of date but the
444
824
        branch and working tree are not, this should return True.
445
825
 
446
826
        :param format: Optional parameter indicating a specific desired
452
832
    def open_unsupported(base):
453
833
        """Open a branch which is not supported."""
454
834
        return BzrDir.open(base, _unsupported=True)
455
 
        
456
 
    @staticmethod
457
 
    def open(base, _unsupported=False):
458
 
        """Open an existing bzrdir, rooted at 'base' (url)
459
 
        
460
 
        _unsupported is a private parameter to the BzrDir class.
461
 
        """
462
 
        t = get_transport(base)
463
 
        mutter("trying to open %r with transport %r", base, t)
464
 
        format = BzrDirFormat.find_format(t)
 
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
 
465
877
        BzrDir._check_supported(format, _unsupported)
466
 
        return format.open(t, _found=True)
 
878
        return format.open(transport, _found=True)
467
879
 
468
 
    def open_branch(self, unsupported=False):
 
880
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
469
881
        """Open the branch object at this BzrDir if one is present.
470
882
 
471
883
        If unsupported is True, then no longer supported branch formats can
472
884
        still be opened.
473
 
        
 
885
 
474
886
        TODO: static convenience version of this?
475
887
        """
476
888
        raise NotImplementedError(self.open_branch)
477
889
 
478
890
    @staticmethod
479
 
    def open_containing(url):
 
891
    def open_containing(url, possible_transports=None):
480
892
        """Open an existing branch which contains url.
481
 
        
 
893
 
482
894
        :param url: url to search from.
483
895
        See open_containing_from_transport for more detail.
484
896
        """
485
 
        return BzrDir.open_containing_from_transport(get_transport(url))
486
 
    
 
897
        transport = get_transport(url, possible_transports)
 
898
        return BzrDir.open_containing_from_transport(transport)
 
899
 
487
900
    @staticmethod
488
901
    def open_containing_from_transport(a_transport):
489
 
        """Open an existing branch which contains a_transport.base
 
902
        """Open an existing branch which contains a_transport.base.
490
903
 
491
904
        This probes for a branch at a_transport, and searches upwards from there.
492
905
 
493
906
        Basically we keep looking up until we find the control directory or
494
907
        run into the root.  If there isn't one, raises NotBranchError.
495
 
        If there is one and it is either an unrecognised format or an unsupported 
 
908
        If there is one and it is either an unrecognised format or an unsupported
496
909
        format, UnknownFormatError or UnsupportedFormatError are raised.
497
910
        If there is one, it is returned, along with the unused portion of url.
498
911
 
499
 
        :return: The BzrDir that contains the path, and a Unicode path 
 
912
        :return: The BzrDir that contains the path, and a Unicode path
500
913
                for the rest of the URL.
501
914
        """
502
915
        # this gets the normalised url back. I.e. '.' -> the full path.
503
916
        url = a_transport.base
504
917
        while True:
505
918
            try:
506
 
                format = BzrDirFormat.find_format(a_transport)
507
 
                BzrDir._check_supported(format, False)
508
 
                return format.open(a_transport), urlutils.unescape(a_transport.relpath(url))
 
919
                result = BzrDir.open_from_transport(a_transport)
 
920
                return result, urlutils.unescape(a_transport.relpath(url))
509
921
            except errors.NotBranchError, e:
510
 
                ## mutter('not a branch in: %r %s', a_transport.base, e)
511
922
                pass
512
 
            new_t = a_transport.clone('..')
 
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)
513
928
            if new_t.base == a_transport.base:
514
929
                # reached the root, whatever that may be
515
930
                raise errors.NotBranchError(path=url)
516
931
            a_transport = new_t
517
932
 
 
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
 
518
1000
    def open_repository(self, _unsupported=False):
519
1001
        """Open the repository object at this BzrDir if one is present.
520
1002
 
521
 
        This will not follow the Branch object pointer - its strictly a direct
 
1003
        This will not follow the Branch object pointer - it's strictly a direct
522
1004
        open facility. Most client code should use open_branch().repository to
523
1005
        get at a repository.
524
1006
 
525
 
        _unsupported is a private parameter, not part of the api.
 
1007
        :param _unsupported: a private parameter, not part of the api.
526
1008
        TODO: static convenience version of this?
527
1009
        """
528
1010
        raise NotImplementedError(self.open_repository)
529
1011
 
530
 
    def open_workingtree(self, _unsupported=False):
 
1012
    def open_workingtree(self, _unsupported=False,
 
1013
                         recommend_upgrade=True, from_branch=None):
531
1014
        """Open the workingtree object at this BzrDir if one is present.
532
 
        
533
 
        TODO: static convenience version of this?
 
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)
534
1021
        """
535
1022
        raise NotImplementedError(self.open_workingtree)
536
1023
 
537
1024
    def has_branch(self):
538
1025
        """Tell if this bzrdir contains a branch.
539
 
        
 
1026
 
540
1027
        Note: if you're going to open the branch, you should just go ahead
541
 
        and try, and not ask permission first.  (This method just opens the 
542
 
        branch and discards it, and that's somewhat expensive.) 
 
1028
        and try, and not ask permission first.  (This method just opens the
 
1029
        branch and discards it, and that's somewhat expensive.)
543
1030
        """
544
1031
        try:
545
1032
            self.open_branch()
552
1039
 
553
1040
        This will still raise an exception if the bzrdir has a workingtree that
554
1041
        is remote & inaccessible.
555
 
        
 
1042
 
556
1043
        Note: if you're going to open the working tree, you should just go ahead
557
 
        and try, and not ask permission first.  (This method just opens the 
558
 
        workingtree and discards it, and that's somewhat expensive.) 
 
1044
        and try, and not ask permission first.  (This method just opens the
 
1045
        workingtree and discards it, and that's somewhat expensive.)
559
1046
        """
560
1047
        try:
561
 
            self.open_workingtree()
 
1048
            self.open_workingtree(recommend_upgrade=False)
562
1049
            return True
563
1050
        except errors.NoWorkingTree:
564
1051
            return False
565
1052
 
566
 
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
 
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):
567
1123
        """Create a copy of this bzrdir prepared for use as a new line of
568
1124
        development.
569
1125
 
570
 
        If urls last component does not exist, it will be created.
 
1126
        If url's last component does not exist, it will be created.
571
1127
 
572
1128
        Attributes related to the identity of the source branch like
573
1129
        branch nickname will be cleaned, a working tree is created
576
1132
 
577
1133
        if revision_id is not None, then the clone operation may tune
578
1134
            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.
579
1145
        """
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()
 
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
585
1157
            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()
 
1240
        return result
 
1241
 
 
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()
586
1250
        except errors.NotBranchError:
587
 
            source_branch = None
588
 
            try:
589
 
                source_repository = self.open_repository()
590
 
            except errors.NoRepositoryPresent:
591
 
                # copy the entire basis one if there is one
592
 
                # but there is no repository.
593
 
                source_repository = basis_repo
594
 
        if force_new_repo:
595
 
            result_repo = None
596
 
        else:
597
 
            try:
598
 
                result_repo = result.find_repository()
599
 
            except errors.NoRepositoryPresent:
600
 
                result_repo = None
601
 
        if source_repository is None and result_repo is not None:
602
 
            pass
603
 
        elif source_repository is None and result_repo is None:
604
 
            # no repo available, make a new one
605
 
            result.create_repository()
606
 
        elif source_repository is not None and result_repo is None:
607
 
            # have source, and want to make a new target repo
608
 
            # we don't clone the repo because that preserves attributes
609
 
            # like is_shared(), and we have not yet implemented a 
610
 
            # repository sprout().
611
 
            result_repo = result.create_repository()
612
 
        if result_repo is not None:
613
 
            # fetch needed content into target.
614
 
            if basis_repo:
615
 
                # XXX FIXME RBC 20060214 need tests for this when the basis
616
 
                # is incomplete
617
 
                result_repo.fetch(basis_repo, revision_id=revision_id)
618
 
            result_repo.fetch(source_repository, revision_id=revision_id)
619
 
        if source_branch is not None:
620
 
            source_branch.sprout(result, revision_id=revision_id)
621
 
        else:
622
 
            result.create_branch()
623
 
        # TODO: jam 20060426 we probably need a test in here in the
624
 
        #       case that the newly sprouted branch is a remote one
625
 
        if result_repo is None or result_repo.make_working_trees():
626
 
            result.create_workingtree()
627
 
        return result
 
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()
628
1315
 
629
1316
 
630
1317
class BzrDirPreSplitOut(BzrDir):
633
1320
    def __init__(self, _transport, _format):
634
1321
        """See BzrDir.__init__."""
635
1322
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
636
 
        assert self._format._lock_class == TransportLock
637
 
        assert self._format._lock_file_name == 'branch-lock'
638
 
        self._control_files = LockableFiles(self.get_branch_transport(None),
 
1323
        self._control_files = lockable_files.LockableFiles(
 
1324
                                            self.get_branch_transport(None),
639
1325
                                            self._format._lock_file_name,
640
1326
                                            self._format._lock_class)
641
1327
 
643
1329
        """Pre-splitout bzrdirs do not suffer from stale locks."""
644
1330
        raise NotImplementedError(self.break_lock)
645
1331
 
646
 
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
647
 
        """See BzrDir.clone()."""
648
 
        from bzrlib.workingtree import WorkingTreeFormat2
 
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
        """
649
1347
        self._make_tail(url)
650
1348
        result = self._format._initialize_for_clone(url)
651
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
652
 
        self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
 
1349
        self.open_repository().clone(result, revision_id=revision_id)
653
1350
        from_branch = self.open_branch()
654
1351
        from_branch.clone(result, revision_id=revision_id)
655
1352
        try:
656
 
            self.open_workingtree().clone(result, basis=basis_tree)
 
1353
            tree = self.open_workingtree()
657
1354
        except errors.NotLocalUrl:
658
1355
            # make a new one, this format always has to have one.
659
 
            try:
660
 
                WorkingTreeFormat2().initialize(result)
661
 
            except errors.NotLocalUrl:
662
 
                # but we cannot do it for remote trees.
663
 
                to_branch = result.open_branch()
664
 
                WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
 
1356
            result._init_workingtree()
 
1357
        else:
 
1358
            tree.clone(result)
665
1359
        return result
666
1360
 
667
1361
    def create_branch(self):
668
1362
        """See BzrDir.create_branch."""
669
 
        return self.open_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)
670
1368
 
671
1369
    def create_repository(self, shared=False):
672
1370
        """See BzrDir.create_repository."""
674
1372
            raise errors.IncompatibleFormat('shared repository', self._format)
675
1373
        return self.open_repository()
676
1374
 
677
 
    def create_workingtree(self, revision_id=None):
 
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):
678
1381
        """See BzrDir.create_workingtree."""
 
1382
        # The workingtree is sometimes created when the bzrdir is created,
 
1383
        # but not when cloning.
 
1384
 
679
1385
        # this looks buggy but is not -really-
 
1386
        # because this format creates the workingtree when the bzrdir is
 
1387
        # created
680
1388
        # clone and sprout will have set the revision_id
681
1389
        # and that will have set it for us, its only
682
1390
        # specific uses of create_workingtree in isolation
683
1391
        # that can do wonky stuff here, and that only
684
 
        # happens for creating checkouts, which cannot be 
 
1392
        # happens for creating checkouts, which cannot be
685
1393
        # done on this format anyway. So - acceptable wart.
686
 
        result = self.open_workingtree()
 
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()
687
1401
        if revision_id is not None:
688
 
            result.set_last_revision(revision_id)
 
1402
            if revision_id == _mod_revision.NULL_REVISION:
 
1403
                result.set_parent_ids([])
 
1404
            else:
 
1405
                result.set_parent_ids([revision_id])
689
1406
        return result
690
1407
 
 
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
 
691
1427
    def get_branch_transport(self, branch_format):
692
1428
        """See BzrDir.get_branch_transport()."""
693
1429
        if branch_format is None:
723
1459
        # if the format is not the same as the system default,
724
1460
        # an upgrade is needed.
725
1461
        if format is None:
 
1462
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
1463
                % 'needs_format_conversion(format=None)')
726
1464
            format = BzrDirFormat.get_default_format()
727
1465
        return not isinstance(self._format, format.__class__)
728
1466
 
729
 
    def open_branch(self, unsupported=False):
 
1467
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
730
1468
        """See BzrDir.open_branch."""
731
1469
        from bzrlib.branch import BzrBranchFormat4
732
1470
        format = BzrBranchFormat4()
733
1471
        self._check_supported(format, unsupported)
734
1472
        return format.open(self, _found=True)
735
1473
 
736
 
    def sprout(self, url, revision_id=None, basis=None):
 
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):
737
1478
        """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)
738
1491
        from bzrlib.workingtree import WorkingTreeFormat2
739
1492
        self._make_tail(url)
740
1493
        result = self._format._initialize_for_clone(url)
741
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
742
1494
        try:
743
 
            self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
 
1495
            self.open_repository().clone(result, revision_id=revision_id)
744
1496
        except errors.NoRepositoryPresent:
745
1497
            pass
746
1498
        try:
747
1499
            self.open_branch().sprout(result, revision_id=revision_id)
748
1500
        except errors.NotBranchError:
749
1501
            pass
 
1502
 
750
1503
        # we always want a working tree
751
 
        WorkingTreeFormat2().initialize(result)
 
1504
        WorkingTreeFormat2().initialize(result,
 
1505
                                        accelerator_tree=accelerator_tree,
 
1506
                                        hardlink=hardlink)
752
1507
        return result
753
1508
 
754
1509
 
755
1510
class BzrDir4(BzrDirPreSplitOut):
756
1511
    """A .bzr version 4 control object.
757
 
    
 
1512
 
758
1513
    This is a deprecated format and may be removed after sept 2006.
759
1514
    """
760
1515
 
764
1519
 
765
1520
    def needs_format_conversion(self, format=None):
766
1521
        """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)')
767
1525
        return True
768
1526
 
769
1527
    def open_repository(self):
770
1528
        """See BzrDir.open_repository."""
771
 
        from bzrlib.repository import RepositoryFormat4
 
1529
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
772
1530
        return RepositoryFormat4().open(self, _found=True)
773
1531
 
774
1532
 
778
1536
    This is a deprecated format and may be removed after sept 2006.
779
1537
    """
780
1538
 
 
1539
    def has_workingtree(self):
 
1540
        """See BzrDir.has_workingtree."""
 
1541
        return True
 
1542
    
781
1543
    def open_repository(self):
782
1544
        """See BzrDir.open_repository."""
783
 
        from bzrlib.repository import RepositoryFormat5
 
1545
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
784
1546
        return RepositoryFormat5().open(self, _found=True)
785
1547
 
786
 
    def open_workingtree(self, _unsupported=False):
 
1548
    def open_workingtree(self, _unsupported=False,
 
1549
            recommend_upgrade=True):
787
1550
        """See BzrDir.create_workingtree."""
788
1551
        from bzrlib.workingtree import WorkingTreeFormat2
789
 
        return WorkingTreeFormat2().open(self, _found=True)
 
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)
790
1556
 
791
1557
 
792
1558
class BzrDir6(BzrDirPreSplitOut):
795
1561
    This is a deprecated format and may be removed after sept 2006.
796
1562
    """
797
1563
 
 
1564
    def has_workingtree(self):
 
1565
        """See BzrDir.has_workingtree."""
 
1566
        return True
 
1567
    
798
1568
    def open_repository(self):
799
1569
        """See BzrDir.open_repository."""
800
 
        from bzrlib.repository import RepositoryFormat6
 
1570
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
801
1571
        return RepositoryFormat6().open(self, _found=True)
802
1572
 
803
 
    def open_workingtree(self, _unsupported=False):
 
1573
    def open_workingtree(self, _unsupported=False,
 
1574
        recommend_upgrade=True):
804
1575
        """See BzrDir.create_workingtree."""
 
1576
        # we don't warn here about upgrades; that ought to be handled for the
 
1577
        # bzrdir as a whole
805
1578
        from bzrlib.workingtree import WorkingTreeFormat2
806
1579
        return WorkingTreeFormat2().open(self, _found=True)
807
1580
 
808
1581
 
809
1582
class BzrDirMeta1(BzrDir):
810
1583
    """A .bzr meta version 1 control object.
811
 
    
812
 
    This is the first control object where the 
 
1584
 
 
1585
    This is the first control object where the
813
1586
    individual aspects are really split out: there are separate repository,
814
1587
    workingtree and branch subdirectories and any subset of the three can be
815
1588
    present within a BzrDir.
821
1594
 
822
1595
    def create_branch(self):
823
1596
        """See BzrDir.create_branch."""
824
 
        from bzrlib.branch import BranchFormat
825
 
        return BranchFormat.get_default_format().initialize(self)
 
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')
826
1602
 
827
1603
    def create_repository(self, shared=False):
828
1604
        """See BzrDir.create_repository."""
829
1605
        return self._format.repository_format.initialize(self, shared)
830
1606
 
831
 
    def create_workingtree(self, revision_id=None):
 
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):
832
1613
        """See BzrDir.create_workingtree."""
833
 
        from bzrlib.workingtree import WorkingTreeFormat
834
 
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
 
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)
835
1636
 
836
1637
    def _get_mkdir_mode(self):
837
1638
        """Figure out the mode to use when creating a bzrdir subdir."""
838
 
        temp_control = LockableFiles(self.transport, '', TransportLock)
 
1639
        temp_control = lockable_files.LockableFiles(self.transport, '',
 
1640
                                     lockable_files.TransportLock)
839
1641
        return temp_control._dir_mode
840
1642
 
 
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
 
841
1649
    def get_branch_transport(self, branch_format):
842
1650
        """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
843
1653
        if branch_format is None:
844
1654
            return self.transport.clone('branch')
845
1655
        try:
880
1690
            pass
881
1691
        return self.transport.clone('checkout')
882
1692
 
 
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
 
883
1709
    def needs_format_conversion(self, format=None):
884
1710
        """See BzrDir.needs_format_conversion()."""
885
1711
        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:
886
1715
            format = BzrDirFormat.get_default_format()
887
1716
        if not isinstance(self._format, format.__class__):
888
1717
            # it is not a meta dir format, conversion is needed.
895
1724
                return True
896
1725
        except errors.NoRepositoryPresent:
897
1726
            pass
898
 
        # currently there are no other possible conversions for meta1 formats.
 
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
899
1742
        return False
900
1743
 
901
 
    def open_branch(self, unsupported=False):
 
1744
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
902
1745
        """See BzrDir.open_branch."""
903
 
        from bzrlib.branch import BranchFormat
904
 
        format = BranchFormat.find_format(self)
 
1746
        format = self.find_branch_format()
905
1747
        self._check_supported(format, unsupported)
906
 
        return format.open(self, _found=True)
 
1748
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
907
1749
 
908
1750
    def open_repository(self, unsupported=False):
909
1751
        """See BzrDir.open_repository."""
912
1754
        self._check_supported(format, unsupported)
913
1755
        return format.open(self, _found=True)
914
1756
 
915
 
    def open_workingtree(self, unsupported=False):
 
1757
    def open_workingtree(self, unsupported=False,
 
1758
            recommend_upgrade=True):
916
1759
        """See BzrDir.open_workingtree."""
917
1760
        from bzrlib.workingtree import WorkingTreeFormat
918
1761
        format = WorkingTreeFormat.find_format(self)
919
 
        self._check_supported(format, unsupported)
 
1762
        self._check_supported(format, unsupported,
 
1763
            recommend_upgrade,
 
1764
            basedir=self.root_transport.base)
920
1765
        return format.open(self, _found=True)
921
1766
 
 
1767
    def _get_config(self):
 
1768
        return config.TransportConfig(self.transport, 'control.conf')
 
1769
 
922
1770
 
923
1771
class BzrDirFormat(object):
924
1772
    """An encapsulation of the initialization and open routines for a format.
928
1776
     * a format string,
929
1777
     * an open routine.
930
1778
 
931
 
    Formats are placed in an dict by their format string for reference 
 
1779
    Formats are placed in a dict by their format string for reference
932
1780
    during bzrdir opening. These should be subclasses of BzrDirFormat
933
1781
    for consistency.
934
1782
 
935
1783
    Once a format is deprecated, just deprecate the initialize and open
936
 
    methods on the format class. Do not deprecate the object, as the 
 
1784
    methods on the format class. Do not deprecate the object, as the
937
1785
    object will be created every system load.
938
1786
    """
939
1787
 
945
1793
 
946
1794
    _control_formats = []
947
1795
    """The registered control formats - .bzr, ....
948
 
    
 
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
 
949
1803
    This is a list of BzrDirFormat objects.
950
1804
    """
951
1805
 
955
1809
    # TransportLock or LockDir
956
1810
 
957
1811
    @classmethod
958
 
    def find_format(klass, transport):
 
1812
    def find_format(klass, transport, _server_formats=True):
959
1813
        """Return the format present at transport."""
960
 
        for format in klass._control_formats:
 
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:
961
1819
            try:
962
1820
                return format.probe_transport(transport)
963
1821
            except errors.NotBranchError:
967
1825
 
968
1826
    @classmethod
969
1827
    def probe_transport(klass, transport):
970
 
        """Return the .bzrdir style transport present at URL."""
 
1828
        """Return the .bzrdir style format present in a directory."""
971
1829
        try:
972
 
            format_string = transport.get(".bzr/branch-format").read()
 
1830
            format_string = transport.get_bytes(".bzr/branch-format")
973
1831
        except errors.NoSuchFile:
974
1832
            raise errors.NotBranchError(path=transport.base)
975
1833
 
976
1834
        try:
977
1835
            return klass._formats[format_string]
978
1836
        except KeyError:
979
 
            raise errors.UnknownFormatError(format=format_string)
 
1837
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
980
1838
 
981
1839
    @classmethod
982
1840
    def get_default_format(klass):
1000
1858
        current default format. In the case of plugins we can/should provide
1001
1859
        some means for them to extend the range of returnable converters.
1002
1860
 
1003
 
        :param format: Optional format to override the default format of the 
 
1861
        :param format: Optional format to override the default format of the
1004
1862
                       library.
1005
1863
        """
1006
1864
        raise NotImplementedError(self.get_converter)
1007
1865
 
1008
 
    def initialize(self, url):
 
1866
    def initialize(self, url, possible_transports=None):
1009
1867
        """Create a bzr control dir at this url and return an opened copy.
1010
 
        
 
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
 
1011
1873
        Subclasses should typically override initialize_on_transport
1012
1874
        instead of this method.
1013
1875
        """
1014
 
        return self.initialize_on_transport(get_transport(url))
 
1876
        return self.initialize_on_transport(get_transport(url,
 
1877
                                                          possible_transports))
1015
1878
 
1016
1879
    def initialize_on_transport(self, transport):
1017
1880
        """Initialize a new bzrdir in the base directory of a Transport."""
1018
 
        # Since we don't have a .bzr directory, inherit the
 
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
1019
2001
        # mode from the root directory
1020
 
        temp_control = LockableFiles(transport, '', TransportLock)
 
2002
        temp_control = lockable_files.LockableFiles(transport,
 
2003
                            '', lockable_files.TransportLock)
1021
2004
        temp_control._transport.mkdir('.bzr',
1022
2005
                                      # FIXME: RBC 20060121 don't peek under
1023
2006
                                      # the covers
1024
2007
                                      mode=temp_control._dir_mode)
 
2008
        if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
 
2009
            win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1025
2010
        file_mode = temp_control._file_mode
1026
2011
        del temp_control
1027
 
        mutter('created control directory in ' + transport.base)
1028
 
        control = transport.clone('.bzr')
1029
 
        utf8_files = [('README', 
1030
 
                       "This is a Bazaar-NG control directory.\n"
1031
 
                       "Do not change any files in this directory.\n"),
 
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"),
1032
2017
                      ('branch-format', self.get_format_string()),
1033
2018
                      ]
1034
2019
        # NB: no need to escape relative paths that are url safe.
1035
 
        control_files = LockableFiles(control, self._lock_file_name, 
1036
 
                                      self._lock_class)
 
2020
        control_files = lockable_files.LockableFiles(bzrdir_transport,
 
2021
            self._lock_file_name, self._lock_class)
1037
2022
        control_files.create_lock()
1038
2023
        control_files.lock_write()
1039
2024
        try:
1040
 
            for file, content in utf8_files:
1041
 
                control_files.put_utf8(file, content)
 
2025
            for (filename, content) in utf8_files:
 
2026
                bzrdir_transport.put_bytes(filename, content,
 
2027
                    mode=file_mode)
1042
2028
        finally:
1043
2029
            control_files.unlock()
1044
2030
        return self.open(transport, _found=True)
1047
2033
        """Is this format supported?
1048
2034
 
1049
2035
        Supported formats must be initializable and openable.
1050
 
        Unsupported formats may not support initialization or committing or 
 
2036
        Unsupported formats may not support initialization or committing or
1051
2037
        some other features depending on the reason for not being supported.
1052
2038
        """
1053
2039
        return True
1054
2040
 
 
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
 
1055
2055
    @classmethod
1056
2056
    def known_formats(klass):
1057
2057
        """Return all the known formats.
1058
 
        
 
2058
 
1059
2059
        Concrete formats should override _known_formats.
1060
2060
        """
1061
 
        # There is double indirection here to make sure that control 
1062
 
        # formats used by more than one dir format will only be probed 
 
2061
        # There is double indirection here to make sure that control
 
2062
        # formats used by more than one dir format will only be probed
1063
2063
        # once. This can otherwise be quite expensive for remote connections.
1064
2064
        result = set()
1065
2065
        for format in klass._control_formats:
1066
2066
            result.update(format._known_formats())
1067
2067
        return result
1068
 
    
 
2068
 
1069
2069
    @classmethod
1070
2070
    def _known_formats(klass):
1071
2071
        """Return the known format instances for this control format."""
1073
2073
 
1074
2074
    def open(self, transport, _found=False):
1075
2075
        """Return an instance of this format for the dir transport points at.
1076
 
        
 
2076
 
1077
2077
        _found is a private parameter, do not use it.
1078
2078
        """
1079
2079
        if not _found:
1080
 
            assert isinstance(BzrDirFormat.find_format(transport),
1081
 
                              self.__class__)
 
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)
1082
2088
        return self._open(transport)
1083
2089
 
1084
2090
    def _open(self, transport):
1092
2098
    @classmethod
1093
2099
    def register_format(klass, format):
1094
2100
        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__)
1095
2103
 
1096
2104
    @classmethod
1097
2105
    def register_control_format(klass, format):
1098
 
        """Register a format that does not use '.bzrdir' for its control dir.
 
2106
        """Register a format that does not use '.bzr' for its control dir.
1099
2107
 
1100
2108
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1101
 
        which BzrDirFormat can inherit from, and renamed to register_format 
 
2109
        which BzrDirFormat can inherit from, and renamed to register_format
1102
2110
        there. It has been done without that for now for simplicity of
1103
2111
        implementation.
1104
2112
        """
1105
2113
        klass._control_formats.append(format)
1106
2114
 
1107
2115
    @classmethod
1108
 
    def set_default_format(klass, format):
 
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)"""
1109
2129
        klass._default_format = format
1110
2130
 
1111
2131
    def __str__(self):
1112
 
        return self.get_format_string()[:-1]
 
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
        """
1113
2146
 
1114
2147
    @classmethod
1115
2148
    def unregister_format(klass, format):
1116
 
        assert klass._formats[format.get_format_string()] is format
1117
2149
        del klass._formats[format.get_format_string()]
1118
2150
 
1119
2151
    @classmethod
1121
2153
        klass._control_formats.remove(format)
1122
2154
 
1123
2155
 
1124
 
# register BzrDirFormat as a control format
1125
 
BzrDirFormat.register_control_format(BzrDirFormat)
1126
 
 
1127
 
 
1128
2156
class BzrDirFormat4(BzrDirFormat):
1129
2157
    """Bzr dir format 4.
1130
2158
 
1138
2166
    removed in format 5; write support for this format has been removed.
1139
2167
    """
1140
2168
 
1141
 
    _lock_class = TransportLock
 
2169
    _lock_class = lockable_files.TransportLock
1142
2170
 
1143
2171
    def get_format_string(self):
1144
2172
        """See BzrDirFormat.get_format_string()."""
1152
2180
        """See BzrDirFormat.get_converter()."""
1153
2181
        # there is one and only one upgrade path here.
1154
2182
        return ConvertBzrDir4To5()
1155
 
        
 
2183
 
1156
2184
    def initialize_on_transport(self, transport):
1157
2185
        """Format 4 branches cannot be created."""
1158
2186
        raise errors.UninitializableFormat(self)
1161
2189
        """Format 4 is not supported.
1162
2190
 
1163
2191
        It is not supported because the model changed from 4 to 5 and the
1164
 
        conversion logic is expensive - so doing it on the fly was not 
 
2192
        conversion logic is expensive - so doing it on the fly was not
1165
2193
        feasible.
1166
2194
        """
1167
2195
        return False
1168
2196
 
 
2197
    def network_name(self):
 
2198
        return self.get_format_string()
 
2199
 
1169
2200
    def _open(self, transport):
1170
2201
        """See BzrDirFormat._open."""
1171
2202
        return BzrDir4(transport, self)
1172
2203
 
1173
2204
    def __return_repository_format(self):
1174
2205
        """Circular import protection."""
1175
 
        from bzrlib.repository import RepositoryFormat4
1176
 
        return RepositoryFormat4(self)
 
2206
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
2207
        return RepositoryFormat4()
1177
2208
    repository_format = property(__return_repository_format)
1178
2209
 
1179
2210
 
1180
 
class BzrDirFormat5(BzrDirFormat):
 
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):
1181
2237
    """Bzr control format 5.
1182
2238
 
1183
2239
    This format is a combined format for working tree, branch and repository.
1184
2240
    It has:
1185
 
     - Format 2 working trees [always] 
1186
 
     - Format 4 branches [always] 
 
2241
     - Format 2 working trees [always]
 
2242
     - Format 4 branches [always]
1187
2243
     - Format 5 repositories [always]
1188
2244
       Unhashed stores in the repository.
1189
2245
    """
1190
2246
 
1191
 
    _lock_class = TransportLock
 
2247
    _lock_class = lockable_files.TransportLock
1192
2248
 
1193
2249
    def get_format_string(self):
1194
2250
        """See BzrDirFormat.get_format_string()."""
1195
2251
        return "Bazaar-NG branch, format 5\n"
1196
2252
 
 
2253
    def get_branch_format(self):
 
2254
        from bzrlib import branch
 
2255
        return branch.BzrBranchFormat4()
 
2256
 
1197
2257
    def get_format_description(self):
1198
2258
        """See BzrDirFormat.get_format_description()."""
1199
2259
        return "All-in-one format 5"
1205
2265
 
1206
2266
    def _initialize_for_clone(self, url):
1207
2267
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1208
 
        
 
2268
 
1209
2269
    def initialize_on_transport(self, transport, _cloning=False):
1210
2270
        """Format 5 dirs always have working tree, branch and repository.
1211
 
        
 
2271
 
1212
2272
        Except when they are being cloned.
1213
2273
        """
1214
2274
        from bzrlib.branch import BzrBranchFormat4
1215
 
        from bzrlib.repository import RepositoryFormat5
1216
 
        from bzrlib.workingtree import WorkingTreeFormat2
 
2275
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1217
2276
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1218
2277
        RepositoryFormat5().initialize(result, _internal=True)
1219
2278
        if not _cloning:
1220
 
            BzrBranchFormat4().initialize(result)
1221
 
            WorkingTreeFormat2().initialize(result)
 
2279
            branch = BzrBranchFormat4().initialize(result)
 
2280
            result._init_workingtree()
1222
2281
        return result
1223
2282
 
 
2283
    def network_name(self):
 
2284
        return self.get_format_string()
 
2285
 
1224
2286
    def _open(self, transport):
1225
2287
        """See BzrDirFormat._open."""
1226
2288
        return BzrDir5(transport, self)
1227
2289
 
1228
2290
    def __return_repository_format(self):
1229
2291
        """Circular import protection."""
1230
 
        from bzrlib.repository import RepositoryFormat5
1231
 
        return RepositoryFormat5(self)
 
2292
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
2293
        return RepositoryFormat5()
1232
2294
    repository_format = property(__return_repository_format)
1233
2295
 
1234
2296
 
1235
 
class BzrDirFormat6(BzrDirFormat):
 
2297
class BzrDirFormat6(BzrDirFormatAllInOne):
1236
2298
    """Bzr control format 6.
1237
2299
 
1238
2300
    This format is a combined format for working tree, branch and repository.
1239
2301
    It has:
1240
 
     - Format 2 working trees [always] 
1241
 
     - Format 4 branches [always] 
 
2302
     - Format 2 working trees [always]
 
2303
     - Format 4 branches [always]
1242
2304
     - Format 6 repositories [always]
1243
2305
    """
1244
2306
 
1245
 
    _lock_class = TransportLock
 
2307
    _lock_class = lockable_files.TransportLock
1246
2308
 
1247
2309
    def get_format_string(self):
1248
2310
        """See BzrDirFormat.get_format_string()."""
1252
2314
        """See BzrDirFormat.get_format_description()."""
1253
2315
        return "All-in-one format 6"
1254
2316
 
 
2317
    def get_branch_format(self):
 
2318
        from bzrlib import branch
 
2319
        return branch.BzrBranchFormat4()
 
2320
 
1255
2321
    def get_converter(self, format=None):
1256
2322
        """See BzrDirFormat.get_converter()."""
1257
2323
        # there is one and only one upgrade path here.
1258
2324
        return ConvertBzrDir6ToMeta()
1259
 
        
 
2325
 
1260
2326
    def _initialize_for_clone(self, url):
1261
2327
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1262
2328
 
1263
2329
    def initialize_on_transport(self, transport, _cloning=False):
1264
2330
        """Format 6 dirs always have working tree, branch and repository.
1265
 
        
 
2331
 
1266
2332
        Except when they are being cloned.
1267
2333
        """
1268
2334
        from bzrlib.branch import BzrBranchFormat4
1269
 
        from bzrlib.repository import RepositoryFormat6
1270
 
        from bzrlib.workingtree import WorkingTreeFormat2
 
2335
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1271
2336
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1272
2337
        RepositoryFormat6().initialize(result, _internal=True)
1273
2338
        if not _cloning:
1274
 
            BzrBranchFormat4().initialize(result)
1275
 
            try:
1276
 
                WorkingTreeFormat2().initialize(result)
1277
 
            except errors.NotLocalUrl:
1278
 
                # emulate pre-check behaviour for working tree and silently 
1279
 
                # fail.
1280
 
                pass
 
2339
            branch = BzrBranchFormat4().initialize(result)
 
2340
            result._init_workingtree()
1281
2341
        return result
1282
2342
 
 
2343
    def network_name(self):
 
2344
        return self.get_format_string()
 
2345
 
1283
2346
    def _open(self, transport):
1284
2347
        """See BzrDirFormat._open."""
1285
2348
        return BzrDir6(transport, self)
1286
2349
 
1287
2350
    def __return_repository_format(self):
1288
2351
        """Circular import protection."""
1289
 
        from bzrlib.repository import RepositoryFormat6
1290
 
        return RepositoryFormat6(self)
 
2352
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
2353
        return RepositoryFormat6()
1291
2354
    repository_format = property(__return_repository_format)
1292
2355
 
1293
2356
 
1302
2365
     - Format 7 repositories [optional]
1303
2366
    """
1304
2367
 
1305
 
    _lock_class = LockDir
 
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())
1306
2487
 
1307
2488
    def get_converter(self, format=None):
1308
2489
        """See BzrDirFormat.get_converter()."""
1321
2502
        """See BzrDirFormat.get_format_description()."""
1322
2503
        return "Meta directory format 1"
1323
2504
 
 
2505
    def network_name(self):
 
2506
        return self.get_format_string()
 
2507
 
1324
2508
    def _open(self, transport):
1325
2509
        """See BzrDirFormat._open."""
1326
 
        return BzrDirMeta1(transport, self)
 
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)
1327
2516
 
1328
2517
    def __return_repository_format(self):
1329
2518
        """Circular import protection."""
1330
 
        if getattr(self, '_repository_format', None):
 
2519
        if self._repository_format:
1331
2520
            return self._repository_format
1332
2521
        from bzrlib.repository import RepositoryFormat
1333
2522
        return RepositoryFormat.get_default_format()
1334
2523
 
1335
 
    def __set_repository_format(self, value):
1336
 
        """Allow changint the repository format for metadir formats."""
 
2524
    def _set_repository_format(self, value):
 
2525
        """Allow changing the repository format for metadir formats."""
1337
2526
        self._repository_format = value
1338
2527
 
1339
 
    repository_format = property(__return_repository_format, __set_repository_format)
1340
 
 
1341
 
 
 
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
1342
2575
BzrDirFormat.register_format(BzrDirFormat4())
1343
2576
BzrDirFormat.register_format(BzrDirFormat5())
1344
2577
BzrDirFormat.register_format(BzrDirFormat6())
1345
2578
__default_format = BzrDirMetaFormat1()
1346
2579
BzrDirFormat.register_format(__default_format)
1347
 
BzrDirFormat.set_default_format(__default_format)
1348
 
 
1349
 
 
1350
 
class BzrDirTestProviderAdapter(object):
1351
 
    """A tool to generate a suite testing multiple bzrdir formats at once.
1352
 
 
1353
 
    This is done by copying the test once for each transport and injecting
1354
 
    the transport_server, transport_readonly_server, and bzrdir_format
1355
 
    classes into each copy. Each copy is also given a new id() to make it
1356
 
    easy to identify.
1357
 
    """
1358
 
 
1359
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1360
 
        self._transport_server = transport_server
1361
 
        self._transport_readonly_server = transport_readonly_server
1362
 
        self._formats = formats
1363
 
    
1364
 
    def adapt(self, test):
1365
 
        result = TestSuite()
1366
 
        for format in self._formats:
1367
 
            new_test = deepcopy(test)
1368
 
            new_test.transport_server = self._transport_server
1369
 
            new_test.transport_readonly_server = self._transport_readonly_server
1370
 
            new_test.bzrdir_format = format
1371
 
            def make_new_test_id():
1372
 
                new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1373
 
                return lambda: new_id
1374
 
            new_test.id = make_new_test_id()
1375
 
            result.addTest(new_test)
1376
 
        return result
 
2580
BzrDirFormat._default_format = __default_format
1377
2581
 
1378
2582
 
1379
2583
class Converter(object):
1401
2605
        self.absent_revisions = set()
1402
2606
        self.text_count = 0
1403
2607
        self.revisions = {}
1404
 
        
 
2608
 
1405
2609
    def convert(self, to_convert, pb):
1406
2610
        """See Converter.convert()."""
1407
2611
        self.bzrdir = to_convert
1408
2612
        self.pb = pb
1409
 
        self.pb.note('starting upgrade from format 4 to 5')
1410
 
        if isinstance(self.bzrdir.transport, LocalTransport):
 
2613
        ui.ui_factory.note('starting upgrade from format 4 to 5')
 
2614
        if isinstance(self.bzrdir.transport, local.LocalTransport):
1411
2615
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1412
2616
        self._convert_to_weaves()
1413
2617
        return BzrDir.open(self.bzrdir.root_transport.base)
1414
2618
 
1415
2619
    def _convert_to_weaves(self):
1416
 
        self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
 
2620
        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
1417
2621
        try:
1418
2622
            # TODO permissions
1419
2623
            stat = self.bzrdir.transport.stat('weaves')
1447
2651
        self.pb.clear()
1448
2652
        self._write_all_weaves()
1449
2653
        self._write_all_revs()
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)
 
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)
1454
2658
        self._cleanup_spare_files_after_format4()
1455
 
        self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
 
2659
        self.branch._transport.put_bytes(
 
2660
            'branch-format',
 
2661
            BzrDirFormat5().get_format_string(),
 
2662
            mode=self.bzrdir._get_file_mode())
1456
2663
 
1457
2664
    def _cleanup_spare_files_after_format4(self):
1458
2665
        # FIXME working tree upgrade foo.
1466
2673
        self.bzrdir.transport.delete_tree('text-store')
1467
2674
 
1468
2675
    def _convert_working_inv(self):
1469
 
        inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1470
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1471
 
        # FIXME inventory is a working tree change.
1472
 
        self.branch.control_files.put('inventory', new_inv_xml)
 
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())
1473
2681
 
1474
2682
    def _write_all_weaves(self):
1475
2683
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1495
2703
        self.bzrdir.transport.mkdir('revision-store')
1496
2704
        revision_transport = self.bzrdir.transport.clone('revision-store')
1497
2705
        # TODO permissions
1498
 
        _revision_store = TextRevisionStore(TextStore(revision_transport,
1499
 
                                                      prefixed=False,
1500
 
                                                      compressed=True))
 
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)
1501
2711
        try:
1502
 
            transaction = bzrlib.transactions.WriteTransaction()
1503
2712
            for i, rev_id in enumerate(self.converted_revs):
1504
2713
                self.pb.update('write revision', i, len(self.converted_revs))
1505
 
                _revision_store.add_revision(self.revisions[rev_id], transaction)
 
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))
1506
2718
        finally:
1507
2719
            self.pb.clear()
1508
 
            
 
2720
 
1509
2721
    def _load_one_rev(self, rev_id):
1510
2722
        """Load a revision object into memory.
1511
2723
 
1516
2728
                       len(self.known_revisions))
1517
2729
        if not self.branch.repository.has_revision(rev_id):
1518
2730
            self.pb.clear()
1519
 
            self.pb.note('revision {%s} not present in branch; '
1520
 
                         'will be converted as a ghost',
 
2731
            ui.ui_factory.note('revision {%s} not present in branch; '
 
2732
                         'will be converted as a ghost' %
1521
2733
                         rev_id)
1522
2734
            self.absent_revisions.add(rev_id)
1523
2735
        else:
1524
 
            rev = self.branch.repository._revision_store.get_revision(rev_id,
1525
 
                self.branch.repository.get_transaction())
 
2736
            rev = self.branch.repository.get_revision(rev_id)
1526
2737
            for parent_id in rev.parent_ids:
1527
2738
                self.known_revisions.add(parent_id)
1528
2739
                self.to_read.append(parent_id)
1529
2740
            self.revisions[rev_id] = rev
1530
2741
 
1531
2742
    def _load_old_inventory(self, rev_id):
1532
 
        assert rev_id not in self.converted_revs
1533
2743
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1534
 
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
 
2744
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
 
2745
        inv.revision_id = rev_id
1535
2746
        rev = self.revisions[rev_id]
1536
 
        if rev.inventory_sha1:
1537
 
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1538
 
                'inventory sha mismatch for {%s}' % rev_id
1539
2747
        return inv
1540
2748
 
1541
2749
    def _load_updated_inventory(self, rev_id):
1542
 
        assert rev_id in self.converted_revs
1543
2750
        inv_xml = self.inv_weave.get_text(rev_id)
1544
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
2751
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
1545
2752
        return inv
1546
2753
 
1547
2754
    def _convert_one_rev(self, rev_id):
1551
2758
        present_parents = [p for p in rev.parent_ids
1552
2759
                           if p not in self.absent_revisions]
1553
2760
        self._convert_revision_contents(rev, inv, present_parents)
1554
 
        self._store_new_weave(rev, inv, present_parents)
 
2761
        self._store_new_inv(rev, inv, present_parents)
1555
2762
        self.converted_revs.add(rev_id)
1556
2763
 
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)
 
2764
    def _store_new_inv(self, rev, inv, present_parents):
 
2765
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1568
2766
        new_inv_sha1 = sha_string(new_inv_xml)
1569
 
        self.inv_weave.add_lines(rev.revision_id, 
 
2767
        self.inv_weave.add_lines(rev.revision_id,
1570
2768
                                 present_parents,
1571
2769
                                 new_inv_xml.splitlines(True))
1572
2770
        rev.inventory_sha1 = new_inv_sha1
1579
2777
        mutter('converting texts of revision {%s}',
1580
2778
               rev_id)
1581
2779
        parent_invs = map(self._load_updated_inventory, present_parents)
1582
 
        for file_id in inv:
1583
 
            ie = inv[file_id]
 
2780
        entries = inv.iter_entries()
 
2781
        entries.next()
 
2782
        for path, ie in entries:
1584
2783
            self._convert_file_version(rev, ie, parent_invs)
1585
2784
 
1586
2785
    def _convert_file_version(self, rev, ie, parent_invs):
1589
2788
        The file needs to be added into the weave if it is a merge
1590
2789
        of >=2 parents or if it's changed from its parent.
1591
2790
        """
1592
 
        if ie.kind == 'root_directory':
1593
 
            return
1594
2791
        file_id = ie.file_id
1595
2792
        rev_id = rev.revision_id
1596
2793
        w = self.text_weaves.get(file_id)
1598
2795
            w = Weave(file_id)
1599
2796
            self.text_weaves[file_id] = w
1600
2797
        text_changed = False
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 
 
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)
1608
2804
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1609
2805
        del ie.text_id
1610
 
        assert getattr(ie, 'revision', None) is not None
 
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)
1611
2812
 
1612
2813
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1613
2814
        # TODO: convert this logic, which is ~= snapshot to
1614
2815
        # a call to:. This needs the path figured out. rather than a work_tree
1615
2816
        # a v4 revision_tree can be given, or something that looks enough like
1616
2817
        # one to give the file content to the entry if it needs it.
1617
 
        # and we need something that looks like a weave store for snapshot to 
 
2818
        # and we need something that looks like a weave store for snapshot to
1618
2819
        # save against.
1619
2820
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1620
2821
        if len(previous_revisions) == 1:
1623
2824
                ie.revision = previous_ie.revision
1624
2825
                return
1625
2826
        if ie.has_text():
1626
 
            text = self.branch.repository.text_store.get(ie.text_id)
 
2827
            text = self.branch.repository._text_store.get(ie.text_id)
1627
2828
            file_lines = text.readlines()
1628
 
            assert sha_strings(file_lines) == ie.text_sha1
1629
 
            assert sum(map(len, file_lines)) == ie.text_size
1630
2829
            w.add_lines(rev_id, previous_revisions, file_lines)
1631
2830
            self.text_count += 1
1632
2831
        else:
1663
2862
        """See Converter.convert()."""
1664
2863
        self.bzrdir = to_convert
1665
2864
        self.pb = pb
1666
 
        self.pb.note('starting upgrade from format 5 to 6')
 
2865
        ui.ui_factory.note('starting upgrade from format 5 to 6')
1667
2866
        self._convert_to_prefixed()
1668
2867
        return BzrDir.open(self.bzrdir.root_transport.base)
1669
2868
 
1671
2870
        from bzrlib.store import TransportStore
1672
2871
        self.bzrdir.transport.delete('branch-format')
1673
2872
        for store_name in ["weaves", "revision-store"]:
1674
 
            self.pb.note("adding prefixes to %s" % store_name)
 
2873
            ui.ui_factory.note("adding prefixes to %s" % store_name)
1675
2874
            store_transport = self.bzrdir.transport.clone(store_name)
1676
2875
            store = TransportStore(store_transport, prefixed=True)
1677
2876
            for urlfilename in store_transport.list_dir('.'):
1679
2878
                if (filename.endswith(".weave") or
1680
2879
                    filename.endswith(".gz") or
1681
2880
                    filename.endswith(".sig")):
1682
 
                    file_id = os.path.splitext(filename)[0]
 
2881
                    file_id, suffix = os.path.splitext(filename)
1683
2882
                else:
1684
2883
                    file_id = filename
1685
 
                prefix_dir = store.hash_prefix(file_id)
 
2884
                    suffix = ''
 
2885
                new_name = store._mapper.map((file_id,)) + suffix
1686
2886
                # FIXME keep track of the dirs made RBC 20060121
1687
2887
                try:
1688
 
                    store_transport.move(filename, prefix_dir + '/' + filename)
 
2888
                    store_transport.move(filename, new_name)
1689
2889
                except errors.NoSuchFile: # catches missing dirs strangely enough
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())
 
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())
1693
2896
 
1694
2897
 
1695
2898
class ConvertBzrDir6ToMeta(Converter):
1697
2900
 
1698
2901
    def convert(self, to_convert, pb):
1699
2902
        """See Converter.convert()."""
 
2903
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
 
2904
        from bzrlib.branch import BzrBranchFormat5
1700
2905
        self.bzrdir = to_convert
1701
2906
        self.pb = pb
1702
2907
        self.count = 0
1703
2908
        self.total = 20 # the steps we know about
1704
2909
        self.garbage_inventories = []
 
2910
        self.dir_mode = self.bzrdir._get_dir_mode()
 
2911
        self.file_mode = self.bzrdir._get_file_mode()
1705
2912
 
1706
 
        self.pb.note('starting upgrade from format 6 to metadir')
1707
 
        self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
 
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)
1708
2918
        # its faster to move specific files around than to open and use the apis...
1709
2919
        # first off, nuke ancestry.weave, it was never used.
1710
2920
        try:
1720
2930
            if name.startswith('basis-inventory.'):
1721
2931
                self.garbage_inventories.append(name)
1722
2932
        # 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
1725
2933
        repository_names = [('inventory.weave', True),
1726
2934
                            ('revision-store', True),
1727
2935
                            ('weaves', True)]
1729
2937
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1730
2938
        self.make_lock('repository')
1731
2939
        # we hard code the formats here because we are converting into
1732
 
        # the meta format. The meta format upgrader can take this to a 
 
2940
        # the meta format. The meta format upgrader can take this to a
1733
2941
        # future format within each component.
1734
 
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
 
2942
        self.put_format('repository', RepositoryFormat7())
1735
2943
        for entry in repository_names:
1736
2944
            self.move_entry('repository', entry)
1737
2945
 
1738
2946
        self.step('Upgrading branch      ')
1739
2947
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1740
2948
        self.make_lock('branch')
1741
 
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
 
2949
        self.put_format('branch', BzrBranchFormat5())
1742
2950
        branch_files = [('revision-history', True),
1743
2951
                        ('branch-name', True),
1744
2952
                        ('parent', False)]
1745
2953
        for entry in branch_files:
1746
2954
            self.move_entry('branch', entry)
1747
2955
 
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)
1753
2956
        checkout_files = [('pending-merges', True),
1754
2957
                          ('inventory', True),
1755
2958
                          ('stat-cache', False)]
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())
 
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)
1762
2992
        return BzrDir.open(self.bzrdir.root_transport.base)
1763
2993
 
1764
2994
    def make_lock(self, name):
1765
2995
        """Make a lock for the new control dir name."""
1766
2996
        self.step('Make %s lock' % name)
1767
 
        ld = LockDir(self.bzrdir.transport, 
1768
 
                     '%s/lock' % name,
1769
 
                     file_modebits=self.file_mode,
1770
 
                     dir_modebits=self.dir_mode)
 
2997
        ld = lockdir.LockDir(self.bzrdir.transport,
 
2998
                             '%s/lock' % name,
 
2999
                             file_modebits=self.file_mode,
 
3000
                             dir_modebits=self.dir_mode)
1771
3001
        ld.create()
1772
3002
 
1773
3003
    def move_entry(self, new_dir, entry):
1782
3012
                raise
1783
3013
 
1784
3014
    def put_format(self, dirname, format):
1785
 
        self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
 
3015
        self.bzrdir.transport.put_bytes('%s/format' % dirname,
 
3016
            format.get_format_string(),
 
3017
            self.file_mode)
1786
3018
 
1787
3019
 
1788
3020
class ConvertMetaToMeta(Converter):
1809
3041
        else:
1810
3042
            if not isinstance(repo._format, self.target_format.repository_format.__class__):
1811
3043
                from bzrlib.repository import CopyConverter
1812
 
                self.pb.note('starting repository conversion')
 
3044
                ui.ui_factory.note('starting repository conversion')
1813
3045
                converter = CopyConverter(self.target_format.repository_format)
1814
3046
                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)
1815
3099
        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')