← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Vincent Ladeuil
  • Date: 2007-06-20 14:25:06 UTC
  • mfrom: (2540 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070620142506-txsb1v8538kpsafw
merge bzr.dev @ 2540

Show diffs side-by-side

added added

removed removed

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