/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

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