← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Aaron Bentley
  • Date: 2007-07-25 22:54:16 UTC
  • mto: (1551.19.24 Aaron's mergeable stuff)
  • mto: This revision was merged to the branch mainline in revision 2664.
  • Revision ID: abentley@panoramicfeedback.com-20070725225416-ux5bt1v31nxunrkl
remove builtins._merge_helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
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.
 
23
# TODO: Can we move specific formats into separate modules to make this file
 
24
# smaller?
29
25
 
 
26
from cStringIO import StringIO
30
27
import os
31
 
import sys
 
28
import textwrap
32
29
 
33
30
from bzrlib.lazy_import import lazy_import
34
31
lazy_import(globals(), """
35
32
from stat import S_ISDIR
36
 
import textwrap
37
33
 
38
34
import bzrlib
39
35
from bzrlib import (
40
 
    config,
41
36
    errors,
42
 
    graph,
43
37
    lockable_files,
44
38
    lockdir,
45
 
    osutils,
 
39
    registry,
46
40
    remote,
47
41
    revision as _mod_revision,
 
42
    symbol_versioning,
48
43
    ui,
49
44
    urlutils,
50
 
    versionedfile,
51
 
    win32utils,
 
45
    xml4,
 
46
    xml5,
52
47
    workingtree,
53
48
    workingtree_4,
54
 
    xml4,
55
 
    xml5,
56
49
    )
57
50
from bzrlib.osutils import (
 
51
    sha_strings,
58
52
    sha_string,
59
53
    )
60
 
from bzrlib.push import (
61
 
    PushResult,
62
 
    )
63
54
from bzrlib.smart.client import _SmartClient
 
55
from bzrlib.smart import protocol
 
56
from bzrlib.store.revision.text import TextRevisionStore
 
57
from bzrlib.store.text import TextStore
64
58
from bzrlib.store.versioned import WeaveStore
65
59
from bzrlib.transactions import WriteTransaction
66
60
from bzrlib.transport import (
67
61
    do_catching_redirections,
68
62
    get_transport,
69
 
    local,
70
 
    remote as remote_transport,
71
63
    )
72
64
from bzrlib.weave import Weave
73
65
""")
76
68
    mutter,
77
69
    note,
78
70
    )
79
 
 
80
 
from bzrlib import (
81
 
    hooks,
82
 
    registry,
83
 
    symbol_versioning,
84
 
    )
 
71
from bzrlib.transport.local import LocalTransport
85
72
 
86
73
 
87
74
class BzrDir(object):
88
75
    """A .bzr control diretory.
89
 
 
 
76
    
90
77
    BzrDir instances let you create or open any of the things that can be
91
78
    found within .bzr - checkouts, branches and repositories.
92
 
 
93
 
    :ivar transport:
 
79
    
 
80
    transport
94
81
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
95
 
    :ivar root_transport:
96
 
        a transport connected to the directory this bzr was opened from
97
 
        (i.e. the parent directory holding the .bzr directory).
98
 
 
99
 
    Everything in the bzrdir should have the same file permissions.
100
 
 
101
 
    :cvar hooks: An instance of BzrDirHooks.
 
82
    root_transport
 
83
        a transport connected to the directory this bzr was opened from.
102
84
    """
103
85
 
104
86
    def break_lock(self):
136
118
        basedir=None):
137
119
        """Give an error or warning on old formats.
138
120
 
139
 
        :param format: may be any kind of format - workingtree, branch,
 
121
        :param format: may be any kind of format - workingtree, branch, 
140
122
        or repository.
141
123
 
142
 
        :param allow_unsupported: If true, allow opening
143
 
        formats that are strongly deprecated, and which may
 
124
        :param allow_unsupported: If true, allow opening 
 
125
        formats that are strongly deprecated, and which may 
144
126
        have limited functionality.
145
127
 
146
128
        :param recommend_upgrade: If true (default), warn
158
140
                format.get_format_description(),
159
141
                basedir)
160
142
 
161
 
    def clone(self, url, revision_id=None, force_new_repo=False,
162
 
              preserve_stacking=False):
 
143
    def clone(self, url, revision_id=None, force_new_repo=False):
163
144
        """Clone this bzrdir and its contents to url verbatim.
164
145
 
165
 
        :param url: The url create the clone at.  If url's last component does
166
 
            not exist, it will be created.
167
 
        :param revision_id: The tip revision-id to use for any branch or
168
 
            working tree.  If not None, then the clone operation may tune
 
146
        If urls last component does not exist, it will be created.
 
147
 
 
148
        if revision_id is not None, then the clone operation may tune
169
149
            itself to download less data.
170
 
        :param force_new_repo: Do not use a shared repository for the target
 
150
        :param force_new_repo: Do not use a shared repository for the target 
171
151
                               even if one is available.
172
 
        :param preserve_stacking: When cloning a stacked branch, stack the
173
 
            new branch on top of the other branch's stacked-on branch.
174
152
        """
175
153
        return self.clone_on_transport(get_transport(url),
176
154
                                       revision_id=revision_id,
177
 
                                       force_new_repo=force_new_repo,
178
 
                                       preserve_stacking=preserve_stacking)
 
155
                                       force_new_repo=force_new_repo)
179
156
 
180
157
    def clone_on_transport(self, transport, revision_id=None,
181
 
                           force_new_repo=False, preserve_stacking=False,
182
 
                           stacked_on=None):
 
158
                           force_new_repo=False):
183
159
        """Clone this bzrdir and its contents to transport verbatim.
184
160
 
185
 
        :param transport: The transport for the location to produce the clone
186
 
            at.  If the target directory does not exist, it will be created.
187
 
        :param revision_id: The tip revision-id to use for any branch or
188
 
            working tree.  If not None, then the clone operation may tune
 
161
        If the target directory does not exist, it will be created.
 
162
 
 
163
        if revision_id is not None, then the clone operation may tune
189
164
            itself to download less data.
190
 
        :param force_new_repo: Do not use a shared repository for the target,
 
165
        :param force_new_repo: Do not use a shared repository for the target 
191
166
                               even if one is available.
192
 
        :param preserve_stacking: When cloning a stacked branch, stack the
193
 
            new branch on top of the other branch's stacked-on branch.
194
167
        """
195
168
        transport.ensure_base()
196
 
        require_stacking = (stacked_on is not None)
197
 
        format = self.cloning_metadir(require_stacking)
198
 
        # Bug: We create a metadir without knowing if it can support stacking,
199
 
        # we should look up the policy needs first.
200
 
        result = format.initialize_on_transport(transport)
201
 
        repository_policy = None
 
169
        result = self._format.initialize_on_transport(transport)
202
170
        try:
203
171
            local_repo = self.find_repository()
204
172
        except errors.NoRepositoryPresent:
205
173
            local_repo = None
206
 
        try:
207
 
            local_branch = self.open_branch()
208
 
        except errors.NotBranchError:
209
 
            local_branch = None
210
 
        else:
211
 
            # enable fallbacks when branch is not a branch reference
212
 
            if local_branch.repository.has_same_location(local_repo):
213
 
                local_repo = local_branch.repository
214
 
            if preserve_stacking:
215
 
                try:
216
 
                    stacked_on = local_branch.get_stacked_on_url()
217
 
                except (errors.UnstackableBranchFormat,
218
 
                        errors.UnstackableRepositoryFormat,
219
 
                        errors.NotStacked):
220
 
                    pass
221
 
 
222
174
        if local_repo:
223
175
            # may need to copy content in
224
 
            repository_policy = result.determine_repository_policy(
225
 
                force_new_repo, stacked_on, self.root_transport.base,
226
 
                require_stacking=require_stacking)
227
 
            make_working_trees = local_repo.make_working_trees()
228
 
            result_repo, is_new_repo = repository_policy.acquire_repository(
229
 
                make_working_trees, local_repo.is_shared())
230
 
            if not require_stacking and repository_policy._require_stacking:
231
 
                require_stacking = True
232
 
                result._format.require_stacking()
233
 
            if is_new_repo and not require_stacking and revision_id is not None:
234
 
                fetch_spec = graph.PendingAncestryResult(
235
 
                    [revision_id], local_repo)
236
 
                result_repo.fetch(local_repo, fetch_spec=fetch_spec)
 
176
            if force_new_repo:
 
177
                result_repo = local_repo.clone(
 
178
                    result,
 
179
                    revision_id=revision_id)
 
180
                result_repo.set_make_working_trees(local_repo.make_working_trees())
237
181
            else:
238
 
                result_repo.fetch(local_repo, revision_id=revision_id)
239
 
        else:
240
 
            result_repo = None
 
182
                try:
 
183
                    result_repo = result.find_repository()
 
184
                    # fetch content this dir needs.
 
185
                    result_repo.fetch(local_repo, revision_id=revision_id)
 
186
                except errors.NoRepositoryPresent:
 
187
                    # needed to make one anyway.
 
188
                    result_repo = local_repo.clone(
 
189
                        result,
 
190
                        revision_id=revision_id)
 
191
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
241
192
        # 1 if there is a branch present
242
193
        #   make sure its content is available in the target repository
243
194
        #   clone it.
244
 
        if local_branch is not None:
245
 
            result_branch = local_branch.clone(result, revision_id=revision_id,
246
 
                repository_policy=repository_policy)
247
 
        try:
248
 
            # Cheaper to check if the target is not local, than to try making
249
 
            # the tree and fail.
250
 
            result.root_transport.local_abspath('.')
251
 
            if result_repo is None or result_repo.make_working_trees():
252
 
                self.open_workingtree().clone(result)
 
195
        try:
 
196
            self.open_branch().clone(result, revision_id=revision_id)
 
197
        except errors.NotBranchError:
 
198
            pass
 
199
        try:
 
200
            self.open_workingtree().clone(result)
253
201
        except (errors.NoWorkingTree, errors.NotLocalUrl):
254
202
            pass
255
203
        return result
263
211
    @classmethod
264
212
    def create(cls, base, format=None, possible_transports=None):
265
213
        """Create a new BzrDir at the url 'base'.
 
214
        
 
215
        This will call the current default formats initialize with base
 
216
        as the only parameter.
266
217
 
267
218
        :param format: If supplied, the format of branch to create.  If not
268
219
            supplied, the default is used.
269
 
        :param possible_transports: If supplied, a list of transports that
 
220
        :param possible_transports: If supplied, a list of transports that 
270
221
            can be reused to share a remote connection.
271
222
        """
272
223
        if cls is not BzrDir:
276
227
        t.ensure_base()
277
228
        if format is None:
278
229
            format = BzrDirFormat.get_default_format()
279
 
        return format.initialize_on_transport(t)
280
 
 
281
 
    @staticmethod
282
 
    def find_bzrdirs(transport, evaluate=None, list_current=None):
283
 
        """Find bzrdirs recursively from current location.
284
 
 
285
 
        This is intended primarily as a building block for more sophisticated
286
 
        functionality, like finding trees under a directory, or finding
287
 
        branches that use a given repository.
288
 
        :param evaluate: An optional callable that yields recurse, value,
289
 
            where recurse controls whether this bzrdir is recursed into
290
 
            and value is the value to yield.  By default, all bzrdirs
291
 
            are recursed into, and the return value is the bzrdir.
292
 
        :param list_current: if supplied, use this function to list the current
293
 
            directory, instead of Transport.list_dir
294
 
        :return: a generator of found bzrdirs, or whatever evaluate returns.
295
 
        """
296
 
        if list_current is None:
297
 
            def list_current(transport):
298
 
                return transport.list_dir('')
299
 
        if evaluate is None:
300
 
            def evaluate(bzrdir):
301
 
                return True, bzrdir
302
 
 
303
 
        pending = [transport]
304
 
        while len(pending) > 0:
305
 
            current_transport = pending.pop()
306
 
            recurse = True
307
 
            try:
308
 
                bzrdir = BzrDir.open_from_transport(current_transport)
309
 
            except errors.NotBranchError:
310
 
                pass
311
 
            else:
312
 
                recurse, value = evaluate(bzrdir)
313
 
                yield value
314
 
            try:
315
 
                subdirs = list_current(current_transport)
316
 
            except errors.NoSuchFile:
317
 
                continue
318
 
            if recurse:
319
 
                for subdir in sorted(subdirs, reverse=True):
320
 
                    pending.append(current_transport.clone(subdir))
321
 
 
322
 
    @staticmethod
323
 
    def find_branches(transport):
324
 
        """Find all branches under a transport.
325
 
 
326
 
        This will find all branches below the transport, including branches
327
 
        inside other branches.  Where possible, it will use
328
 
        Repository.find_branches.
329
 
 
330
 
        To list all the branches that use a particular Repository, see
331
 
        Repository.find_branches
332
 
        """
333
 
        def evaluate(bzrdir):
334
 
            try:
335
 
                repository = bzrdir.open_repository()
336
 
            except errors.NoRepositoryPresent:
337
 
                pass
338
 
            else:
339
 
                return False, (None, repository)
340
 
            try:
341
 
                branch = bzrdir.open_branch()
342
 
            except errors.NotBranchError:
343
 
                return True, (None, None)
344
 
            else:
345
 
                return True, (branch, None)
346
 
        branches = []
347
 
        for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
348
 
            if repo is not None:
349
 
                branches.extend(repo.find_branches())
350
 
            if branch is not None:
351
 
                branches.append(branch)
352
 
        return branches
353
 
 
354
 
    def destroy_repository(self):
355
 
        """Destroy the repository in this BzrDir"""
356
 
        raise NotImplementedError(self.destroy_repository)
 
230
        return format.initialize(base, possible_transports)
357
231
 
358
232
    def create_branch(self):
359
233
        """Create a branch in this BzrDir.
360
234
 
361
 
        The bzrdir's format will control what branch format is created.
 
235
        The bzrdirs format will control what branch format is created.
362
236
        For more control see BranchFormatXX.create(a_bzrdir).
363
237
        """
364
238
        raise NotImplementedError(self.create_branch)
365
239
 
366
 
    def destroy_branch(self):
367
 
        """Destroy the branch in this BzrDir"""
368
 
        raise NotImplementedError(self.destroy_branch)
369
 
 
370
240
    @staticmethod
371
241
    def create_branch_and_repo(base, force_new_repo=False, format=None):
372
242
        """Create a new BzrDir, Branch and Repository at the url 'base'.
373
243
 
374
 
        This will use the current default BzrDirFormat unless one is
375
 
        specified, and use whatever
 
244
        This will use the current default BzrDirFormat, and use whatever 
376
245
        repository format that that uses via bzrdir.create_branch and
377
246
        create_repository. If a shared repository is available that is used
378
247
        preferentially.
381
250
 
382
251
        :param base: The URL to create the branch at.
383
252
        :param force_new_repo: If True a new repository is always created.
384
 
        :param format: If supplied, the format of branch to create.  If not
385
 
            supplied, the default is used.
386
253
        """
387
254
        bzrdir = BzrDir.create(base, format)
388
255
        bzrdir._find_or_create_repository(force_new_repo)
389
256
        return bzrdir.create_branch()
390
257
 
391
 
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
392
 
                                    stack_on_pwd=None, require_stacking=False):
393
 
        """Return an object representing a policy to use.
394
 
 
395
 
        This controls whether a new repository is created, and the format of
396
 
        that repository, or some existing shared repository used instead.
397
 
 
398
 
        If stack_on is supplied, will not seek a containing shared repo.
399
 
 
400
 
        :param force_new_repo: If True, require a new repository to be created.
401
 
        :param stack_on: If supplied, the location to stack on.  If not
402
 
            supplied, a default_stack_on location may be used.
403
 
        :param stack_on_pwd: If stack_on is relative, the location it is
404
 
            relative to.
405
 
        """
406
 
        def repository_policy(found_bzrdir):
407
 
            stack_on = None
408
 
            stack_on_pwd = None
409
 
            config = found_bzrdir.get_config()
410
 
            stop = False
411
 
            if config is not None:
412
 
                stack_on = config.get_default_stack_on()
413
 
                if stack_on is not None:
414
 
                    stack_on_pwd = found_bzrdir.root_transport.base
415
 
                    stop = True
416
 
            # does it have a repository ?
417
 
            try:
418
 
                repository = found_bzrdir.open_repository()
419
 
            except errors.NoRepositoryPresent:
420
 
                repository = None
421
 
            else:
422
 
                if ((found_bzrdir.root_transport.base !=
423
 
                     self.root_transport.base) and not repository.is_shared()):
424
 
                    # Don't look higher, can't use a higher shared repo.
425
 
                    repository = None
426
 
                    stop = True
427
 
                else:
428
 
                    stop = True
429
 
            if not stop:
430
 
                return None, False
431
 
            if repository:
432
 
                return UseExistingRepository(repository, stack_on,
433
 
                    stack_on_pwd, require_stacking=require_stacking), True
434
 
            else:
435
 
                return CreateRepository(self, stack_on, stack_on_pwd,
436
 
                    require_stacking=require_stacking), True
437
 
 
438
 
        if not force_new_repo:
439
 
            if stack_on is None:
440
 
                policy = self._find_containing(repository_policy)
441
 
                if policy is not None:
442
 
                    return policy
443
 
            else:
444
 
                try:
445
 
                    return UseExistingRepository(self.open_repository(),
446
 
                        stack_on, stack_on_pwd,
447
 
                        require_stacking=require_stacking)
448
 
                except errors.NoRepositoryPresent:
449
 
                    pass
450
 
        return CreateRepository(self, stack_on, stack_on_pwd,
451
 
                                require_stacking=require_stacking)
452
 
 
453
258
    def _find_or_create_repository(self, force_new_repo):
454
259
        """Create a new repository if needed, returning the repository."""
455
 
        policy = self.determine_repository_policy(force_new_repo)
456
 
        return policy.acquire_repository()[0]
457
 
 
 
260
        if force_new_repo:
 
261
            return self.create_repository()
 
262
        try:
 
263
            return self.find_repository()
 
264
        except errors.NoRepositoryPresent:
 
265
            return self.create_repository()
 
266
        
458
267
    @staticmethod
459
268
    def create_branch_convenience(base, force_new_repo=False,
460
269
                                  force_new_tree=None, format=None,
465
274
        if possible, can be told explicitly whether to create a working tree or
466
275
        not.
467
276
 
468
 
        This will use the current default BzrDirFormat unless one is
469
 
        specified, and use whatever
 
277
        This will use the current default BzrDirFormat, and use whatever 
470
278
        repository format that that uses via bzrdir.create_branch and
471
279
        create_repository. If a shared repository is available that is used
472
280
        preferentially. Whatever repository is used, its tree creation policy
474
282
 
475
283
        The created Branch object is returned.
476
284
        If a working tree cannot be made due to base not being a file:// url,
477
 
        no error is raised unless force_new_tree is True, in which case no
 
285
        no error is raised unless force_new_tree is True, in which case no 
478
286
        data is created on disk and NotLocalUrl is raised.
479
287
 
480
288
        :param base: The URL to create the branch at.
481
289
        :param force_new_repo: If True a new repository is always created.
482
 
        :param force_new_tree: If True or False force creation of a tree or
 
290
        :param force_new_tree: If True or False force creation of a tree or 
483
291
                               prevent such creation respectively.
484
 
        :param format: Override for the bzrdir format to create.
 
292
        :param format: Override for the for the bzrdir format to create.
485
293
        :param possible_transports: An optional reusable transports list.
486
294
        """
487
295
        if force_new_tree:
488
296
            # check for non local urls
489
297
            t = get_transport(base, possible_transports)
490
 
            if not isinstance(t, local.LocalTransport):
 
298
            if not isinstance(t, LocalTransport):
491
299
                raise errors.NotLocalUrl(base)
492
300
        bzrdir = BzrDir.create(base, format, possible_transports)
493
301
        repo = bzrdir._find_or_create_repository(force_new_repo)
501
309
        return result
502
310
 
503
311
    @staticmethod
 
312
    def create_repository(base, shared=False, format=None):
 
313
        """Create a new BzrDir and Repository at the url 'base'.
 
314
 
 
315
        If no format is supplied, this will default to the current default
 
316
        BzrDirFormat by default, and use whatever repository format that that
 
317
        uses for bzrdirformat.create_repository.
 
318
 
 
319
        :param shared: Create a shared repository rather than a standalone
 
320
                       repository.
 
321
        The Repository object is returned.
 
322
 
 
323
        This must be overridden as an instance method in child classes, where
 
324
        it should take no parameters and construct whatever repository format
 
325
        that child class desires.
 
326
        """
 
327
        bzrdir = BzrDir.create(base, format)
 
328
        return bzrdir.create_repository(shared)
 
329
 
 
330
    @staticmethod
504
331
    def create_standalone_workingtree(base, format=None):
505
332
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
506
333
 
507
334
        'base' must be a local path or a file:// url.
508
335
 
509
 
        This will use the current default BzrDirFormat unless one is
510
 
        specified, and use whatever
 
336
        This will use the current default BzrDirFormat, and use whatever 
511
337
        repository format that that uses for bzrdirformat.create_workingtree,
512
338
        create_branch and create_repository.
513
339
 
514
 
        :param format: Override for the bzrdir format to create.
515
340
        :return: The WorkingTree object.
516
341
        """
517
342
        t = get_transport(base)
518
 
        if not isinstance(t, local.LocalTransport):
 
343
        if not isinstance(t, LocalTransport):
519
344
            raise errors.NotLocalUrl(base)
520
345
        bzrdir = BzrDir.create_branch_and_repo(base,
521
346
                                               force_new_repo=True,
522
347
                                               format=format).bzrdir
523
348
        return bzrdir.create_workingtree()
524
349
 
525
 
    def create_workingtree(self, revision_id=None, from_branch=None,
526
 
        accelerator_tree=None, hardlink=False):
 
350
    def create_workingtree(self, revision_id=None):
527
351
        """Create a working tree at this BzrDir.
528
 
 
529
 
        :param revision_id: create it as of this revision id.
530
 
        :param from_branch: override bzrdir branch (for lightweight checkouts)
531
 
        :param accelerator_tree: A tree which can be used for retrieving file
532
 
            contents more quickly than the revision tree, i.e. a workingtree.
533
 
            The revision tree will be used for cases where accelerator_tree's
534
 
            content is different.
 
352
        
 
353
        revision_id: create it as of this revision id.
535
354
        """
536
355
        raise NotImplementedError(self.create_workingtree)
537
356
 
538
 
    def backup_bzrdir(self):
539
 
        """Backup this bzr control directory.
540
 
 
541
 
        :return: Tuple with old path name and new path name
542
 
        """
543
 
        pb = ui.ui_factory.nested_progress_bar()
544
 
        try:
545
 
            # FIXME: bug 300001 -- the backup fails if the backup directory
546
 
            # already exists, but it should instead either remove it or make
547
 
            # a new backup directory.
548
 
            #
549
 
            # FIXME: bug 262450 -- the backup directory should have the same
550
 
            # permissions as the .bzr directory (probably a bug in copy_tree)
551
 
            old_path = self.root_transport.abspath('.bzr')
552
 
            new_path = self.root_transport.abspath('backup.bzr')
553
 
            pb.note('making backup of %s' % (old_path,))
554
 
            pb.note('  to %s' % (new_path,))
555
 
            self.root_transport.copy_tree('.bzr', 'backup.bzr')
556
 
            return (old_path, new_path)
557
 
        finally:
558
 
            pb.finished()
559
 
 
560
 
    def retire_bzrdir(self, limit=10000):
 
357
    def retire_bzrdir(self):
561
358
        """Permanently disable the bzrdir.
562
359
 
563
360
        This is done by renaming it to give the user some ability to recover
565
362
 
566
363
        This will have horrible consequences if anyone has anything locked or
567
364
        in use.
568
 
        :param limit: number of times to retry
569
365
        """
570
 
        i  = 0
571
 
        while True:
 
366
        for i in xrange(10000):
572
367
            try:
573
368
                to_path = '.bzr.retired.%d' % i
574
369
                self.root_transport.rename('.bzr', to_path)
575
370
                note("renamed %s to %s"
576
371
                    % (self.root_transport.abspath('.bzr'), to_path))
577
 
                return
 
372
                break
578
373
            except (errors.TransportError, IOError, errors.PathError):
579
 
                i += 1
580
 
                if i > limit:
581
 
                    raise
582
 
                else:
583
 
                    pass
 
374
                pass
584
375
 
585
376
    def destroy_workingtree(self):
586
377
        """Destroy the working tree at this BzrDir.
597
388
        """
598
389
        raise NotImplementedError(self.destroy_workingtree_metadata)
599
390
 
600
 
    def _find_containing(self, evaluate):
601
 
        """Find something in a containing control directory.
602
 
 
603
 
        This method will scan containing control dirs, until it finds what
604
 
        it is looking for, decides that it will never find it, or runs out
605
 
        of containing control directories to check.
606
 
 
607
 
        It is used to implement find_repository and
608
 
        determine_repository_policy.
609
 
 
610
 
        :param evaluate: A function returning (value, stop).  If stop is True,
611
 
            the value will be returned.
 
391
    def find_repository(self):
 
392
        """Find the repository that should be used for a_bzrdir.
 
393
 
 
394
        This does not require a branch as we use it to find the repo for
 
395
        new branches as well as to hook existing branches up to their
 
396
        repository.
612
397
        """
613
 
        found_bzrdir = self
 
398
        try:
 
399
            return self.open_repository()
 
400
        except errors.NoRepositoryPresent:
 
401
            pass
 
402
        next_transport = self.root_transport.clone('..')
614
403
        while True:
615
 
            result, stop = evaluate(found_bzrdir)
616
 
            if stop:
617
 
                return result
618
 
            next_transport = found_bzrdir.root_transport.clone('..')
619
 
            if (found_bzrdir.root_transport.base == next_transport.base):
620
 
                # top of the file system
621
 
                return None
622
404
            # find the next containing bzrdir
623
405
            try:
624
406
                found_bzrdir = BzrDir.open_containing_from_transport(
625
407
                    next_transport)[0]
626
408
            except errors.NotBranchError:
627
 
                return None
628
 
 
629
 
    def find_repository(self):
630
 
        """Find the repository that should be used.
631
 
 
632
 
        This does not require a branch as we use it to find the repo for
633
 
        new branches as well as to hook existing branches up to their
634
 
        repository.
635
 
        """
636
 
        def usable_repository(found_bzrdir):
 
409
                # none found
 
410
                raise errors.NoRepositoryPresent(self)
637
411
            # does it have a repository ?
638
412
            try:
639
413
                repository = found_bzrdir.open_repository()
640
414
            except errors.NoRepositoryPresent:
641
 
                return None, False
642
 
            if found_bzrdir.root_transport.base == self.root_transport.base:
643
 
                return repository, True
644
 
            elif repository.is_shared():
645
 
                return repository, True
 
415
                next_transport = found_bzrdir.root_transport.clone('..')
 
416
                if (found_bzrdir.root_transport.base == next_transport.base):
 
417
                    # top of the file system
 
418
                    break
 
419
                else:
 
420
                    continue
 
421
            if ((found_bzrdir.root_transport.base ==
 
422
                 self.root_transport.base) or repository.is_shared()):
 
423
                return repository
646
424
            else:
647
 
                return None, True
648
 
 
649
 
        found_repo = self._find_containing(usable_repository)
650
 
        if found_repo is None:
651
 
            raise errors.NoRepositoryPresent(self)
652
 
        return found_repo
 
425
                raise errors.NoRepositoryPresent(self)
 
426
        raise errors.NoRepositoryPresent(self)
653
427
 
654
428
    def get_branch_reference(self):
655
429
        """Return the referenced URL for the branch in this bzrdir.
667
441
        IncompatibleFormat if the branch format they are given has
668
442
        a format string, and vice versa.
669
443
 
670
 
        If branch_format is None, the transport is returned with no
671
 
        checking. If it is not None, then the returned transport is
 
444
        If branch_format is None, the transport is returned with no 
 
445
        checking. if it is not None, then the returned transport is
672
446
        guaranteed to point to an existing directory ready for use.
673
447
        """
674
448
        raise NotImplementedError(self.get_branch_transport)
675
 
 
676
 
    def _find_creation_modes(self):
677
 
        """Determine the appropriate modes for files and directories.
678
 
 
679
 
        They're always set to be consistent with the base directory,
680
 
        assuming that this transport allows setting modes.
681
 
        """
682
 
        # TODO: Do we need or want an option (maybe a config setting) to turn
683
 
        # this off or override it for particular locations? -- mbp 20080512
684
 
        if self._mode_check_done:
685
 
            return
686
 
        self._mode_check_done = True
687
 
        try:
688
 
            st = self.transport.stat('.')
689
 
        except errors.TransportNotPossible:
690
 
            self._dir_mode = None
691
 
            self._file_mode = None
692
 
        else:
693
 
            # Check the directory mode, but also make sure the created
694
 
            # directories and files are read-write for this user. This is
695
 
            # mostly a workaround for filesystems which lie about being able to
696
 
            # write to a directory (cygwin & win32)
697
 
            if (st.st_mode & 07777 == 00000):
698
 
                # FTP allows stat but does not return dir/file modes
699
 
                self._dir_mode = None
700
 
                self._file_mode = None
701
 
            else:
702
 
                self._dir_mode = (st.st_mode & 07777) | 00700
703
 
                # Remove the sticky and execute bits for files
704
 
                self._file_mode = self._dir_mode & ~07111
705
 
 
706
 
    def _get_file_mode(self):
707
 
        """Return Unix mode for newly created files, or None.
708
 
        """
709
 
        if not self._mode_check_done:
710
 
            self._find_creation_modes()
711
 
        return self._file_mode
712
 
 
713
 
    def _get_dir_mode(self):
714
 
        """Return Unix mode for newly created directories, or None.
715
 
        """
716
 
        if not self._mode_check_done:
717
 
            self._find_creation_modes()
718
 
        return self._dir_mode
719
 
 
 
449
        
720
450
    def get_repository_transport(self, repository_format):
721
451
        """Get the transport for use by repository format in this BzrDir.
722
452
 
724
454
        IncompatibleFormat if the repository format they are given has
725
455
        a format string, and vice versa.
726
456
 
727
 
        If repository_format is None, the transport is returned with no
728
 
        checking. If it is not None, then the returned transport is
 
457
        If repository_format is None, the transport is returned with no 
 
458
        checking. if it is not None, then the returned transport is
729
459
        guaranteed to point to an existing directory ready for use.
730
460
        """
731
461
        raise NotImplementedError(self.get_repository_transport)
732
 
 
 
462
        
733
463
    def get_workingtree_transport(self, tree_format):
734
464
        """Get the transport for use by workingtree format in this BzrDir.
735
465
 
737
467
        IncompatibleFormat if the workingtree format they are given has a
738
468
        format string, and vice versa.
739
469
 
740
 
        If workingtree_format is None, the transport is returned with no
741
 
        checking. If it is not None, then the returned transport is
 
470
        If workingtree_format is None, the transport is returned with no 
 
471
        checking. if it is not None, then the returned transport is
742
472
        guaranteed to point to an existing directory ready for use.
743
473
        """
744
474
        raise NotImplementedError(self.get_workingtree_transport)
745
 
 
746
 
    def get_config(self):
747
 
        if getattr(self, '_get_config', None) is None:
748
 
            return None
749
 
        return self._get_config()
750
 
 
 
475
        
751
476
    def __init__(self, _transport, _format):
752
477
        """Initialize a Bzr control dir object.
753
 
 
 
478
        
754
479
        Only really common logic should reside here, concrete classes should be
755
480
        made with varying behaviours.
756
481
 
760
485
        self._format = _format
761
486
        self.transport = _transport.clone('.bzr')
762
487
        self.root_transport = _transport
763
 
        self._mode_check_done = False
764
488
 
765
489
    def is_control_filename(self, filename):
766
490
        """True if filename is the name of a path which is reserved for bzrdir's.
767
 
 
 
491
        
768
492
        :param filename: A filename within the root transport of this bzrdir.
769
493
 
770
494
        This is true IF and ONLY IF the filename is part of the namespace reserved
773
497
        this in the future - for instance to make bzr talk with svn working
774
498
        trees.
775
499
        """
776
 
        # this might be better on the BzrDirFormat class because it refers to
777
 
        # all the possible bzrdir disk formats.
778
 
        # This method is tested via the workingtree is_control_filename tests-
779
 
        # it was extracted from WorkingTree.is_control_filename. If the method's
780
 
        # contract is extended beyond the current trivial implementation, please
 
500
        # this might be better on the BzrDirFormat class because it refers to 
 
501
        # all the possible bzrdir disk formats. 
 
502
        # This method is tested via the workingtree is_control_filename tests- 
 
503
        # it was extracted from WorkingTree.is_control_filename. If the methods
 
504
        # contract is extended beyond the current trivial  implementation please
781
505
        # add new tests for it to the appropriate place.
782
506
        return filename == '.bzr' or filename.startswith('.bzr/')
783
507
 
784
508
    def needs_format_conversion(self, format=None):
785
509
        """Return true if this bzrdir needs convert_format run on it.
786
 
 
787
 
        For instance, if the repository format is out of date but the
 
510
        
 
511
        For instance, if the repository format is out of date but the 
788
512
        branch and working tree are not, this should return True.
789
513
 
790
514
        :param format: Optional parameter indicating a specific desired
796
520
    def open_unsupported(base):
797
521
        """Open a branch which is not supported."""
798
522
        return BzrDir.open(base, _unsupported=True)
799
 
 
 
523
        
800
524
    @staticmethod
801
 
    def open(base, _unsupported=False, possible_transports=None):
802
 
        """Open an existing bzrdir, rooted at 'base' (url).
803
 
 
804
 
        :param _unsupported: a private parameter to the BzrDir class.
 
525
    def open(base, _unsupported=False):
 
526
        """Open an existing bzrdir, rooted at 'base' (url)
 
527
        
 
528
        _unsupported is a private parameter to the BzrDir class.
805
529
        """
806
 
        t = get_transport(base, possible_transports=possible_transports)
 
530
        t = get_transport(base)
807
531
        return BzrDir.open_from_transport(t, _unsupported=_unsupported)
808
532
 
809
533
    @staticmethod
814
538
        :param transport: Transport containing the bzrdir.
815
539
        :param _unsupported: private.
816
540
        """
817
 
        for hook in BzrDir.hooks['pre_open']:
818
 
            hook(transport)
819
 
        # Keep initial base since 'transport' may be modified while following
820
 
        # the redirections.
821
541
        base = transport.base
 
542
 
822
543
        def find_format(transport):
823
544
            return transport, BzrDirFormat.find_format(
824
545
                transport, _server_formats=_server_formats)
825
546
 
826
547
        def redirected(transport, e, redirection_notice):
827
 
            redirected_transport = transport._redirected_to(e.source, e.target)
828
 
            if redirected_transport is None:
829
 
                raise errors.NotBranchError(base)
 
548
            qualified_source = e.get_source_url()
 
549
            relpath = transport.relpath(qualified_source)
 
550
            if not e.target.endswith(relpath):
 
551
                # Not redirected to a branch-format, not a branch
 
552
                raise errors.NotBranchError(path=e.target)
 
553
            target = e.target[:-len(relpath)]
830
554
            note('%s is%s redirected to %s',
831
 
                 transport.base, e.permanently, redirected_transport.base)
832
 
            return redirected_transport
 
555
                 transport.base, e.permanently, target)
 
556
            # Let's try with a new transport
 
557
            qualified_target = e.get_target_url()[:-len(relpath)]
 
558
            # FIXME: If 'transport' has a qualifier, this should
 
559
            # be applied again to the new transport *iff* the
 
560
            # schemes used are the same. It's a bit tricky to
 
561
            # verify, so I'll punt for now
 
562
            # -- vila20070212
 
563
            return get_transport(target)
833
564
 
834
565
        try:
835
566
            transport, format = do_catching_redirections(find_format,
841
572
        BzrDir._check_supported(format, _unsupported)
842
573
        return format.open(transport, _found=True)
843
574
 
844
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
575
    def open_branch(self, unsupported=False):
845
576
        """Open the branch object at this BzrDir if one is present.
846
577
 
847
578
        If unsupported is True, then no longer supported branch formats can
848
579
        still be opened.
849
 
 
 
580
        
850
581
        TODO: static convenience version of this?
851
582
        """
852
583
        raise NotImplementedError(self.open_branch)
854
585
    @staticmethod
855
586
    def open_containing(url, possible_transports=None):
856
587
        """Open an existing branch which contains url.
857
 
 
 
588
        
858
589
        :param url: url to search from.
859
590
        See open_containing_from_transport for more detail.
860
591
        """
861
592
        transport = get_transport(url, possible_transports)
862
593
        return BzrDir.open_containing_from_transport(transport)
863
 
 
 
594
    
864
595
    @staticmethod
865
596
    def open_containing_from_transport(a_transport):
866
 
        """Open an existing branch which contains a_transport.base.
 
597
        """Open an existing branch which contains a_transport.base
867
598
 
868
599
        This probes for a branch at a_transport, and searches upwards from there.
869
600
 
870
601
        Basically we keep looking up until we find the control directory or
871
602
        run into the root.  If there isn't one, raises NotBranchError.
872
 
        If there is one and it is either an unrecognised format or an unsupported
 
603
        If there is one and it is either an unrecognised format or an unsupported 
873
604
        format, UnknownFormatError or UnsupportedFormatError are raised.
874
605
        If there is one, it is returned, along with the unused portion of url.
875
606
 
876
 
        :return: The BzrDir that contains the path, and a Unicode path
 
607
        :return: The BzrDir that contains the path, and a Unicode path 
877
608
                for the rest of the URL.
878
609
        """
879
610
        # this gets the normalised url back. I.e. '.' -> the full path.
894
625
                raise errors.NotBranchError(path=url)
895
626
            a_transport = new_t
896
627
 
897
 
    def _get_tree_branch(self):
898
 
        """Return the branch and tree, if any, for this bzrdir.
899
 
 
900
 
        Return None for tree if not present or inaccessible.
901
 
        Raise NotBranchError if no branch is present.
902
 
        :return: (tree, branch)
903
 
        """
904
 
        try:
905
 
            tree = self.open_workingtree()
906
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
907
 
            tree = None
908
 
            branch = self.open_branch()
909
 
        else:
910
 
            branch = tree.branch
911
 
        return tree, branch
912
 
 
913
 
    @classmethod
914
 
    def open_tree_or_branch(klass, location):
915
 
        """Return the branch and working tree at a location.
916
 
 
917
 
        If there is no tree at the location, tree will be None.
918
 
        If there is no branch at the location, an exception will be
919
 
        raised
920
 
        :return: (tree, branch)
921
 
        """
922
 
        bzrdir = klass.open(location)
923
 
        return bzrdir._get_tree_branch()
924
 
 
925
628
    @classmethod
926
629
    def open_containing_tree_or_branch(klass, location):
927
630
        """Return the branch and working tree contained by a location.
933
636
        relpath is the portion of the path that is contained by the branch.
934
637
        """
935
638
        bzrdir, relpath = klass.open_containing(location)
936
 
        tree, branch = bzrdir._get_tree_branch()
 
639
        try:
 
640
            tree = bzrdir.open_workingtree()
 
641
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
642
            tree = None
 
643
            branch = bzrdir.open_branch()
 
644
        else:
 
645
            branch = tree.branch
937
646
        return tree, branch, relpath
938
647
 
939
 
    @classmethod
940
 
    def open_containing_tree_branch_or_repository(klass, location):
941
 
        """Return the working tree, branch and repo contained by a location.
942
 
 
943
 
        Returns (tree, branch, repository, relpath).
944
 
        If there is no tree containing the location, tree will be None.
945
 
        If there is no branch containing the location, branch will be None.
946
 
        If there is no repository containing the location, repository will be
947
 
        None.
948
 
        relpath is the portion of the path that is contained by the innermost
949
 
        BzrDir.
950
 
 
951
 
        If no tree, branch or repository is found, a NotBranchError is raised.
952
 
        """
953
 
        bzrdir, relpath = klass.open_containing(location)
954
 
        try:
955
 
            tree, branch = bzrdir._get_tree_branch()
956
 
        except errors.NotBranchError:
957
 
            try:
958
 
                repo = bzrdir.find_repository()
959
 
                return None, None, repo, relpath
960
 
            except (errors.NoRepositoryPresent):
961
 
                raise errors.NotBranchError(location)
962
 
        return tree, branch, branch.repository, relpath
963
 
 
964
648
    def open_repository(self, _unsupported=False):
965
649
        """Open the repository object at this BzrDir if one is present.
966
650
 
967
 
        This will not follow the Branch object pointer - it's strictly a direct
 
651
        This will not follow the Branch object pointer - its strictly a direct
968
652
        open facility. Most client code should use open_branch().repository to
969
653
        get at a repository.
970
654
 
971
 
        :param _unsupported: a private parameter, not part of the api.
 
655
        _unsupported is a private parameter, not part of the api.
972
656
        TODO: static convenience version of this?
973
657
        """
974
658
        raise NotImplementedError(self.open_repository)
975
659
 
976
660
    def open_workingtree(self, _unsupported=False,
977
 
                         recommend_upgrade=True, from_branch=None):
 
661
            recommend_upgrade=True):
978
662
        """Open the workingtree object at this BzrDir if one is present.
979
663
 
980
664
        :param recommend_upgrade: Optional keyword parameter, when True (the
981
665
            default), emit through the ui module a recommendation that the user
982
666
            upgrade the working tree when the workingtree being opened is old
983
667
            (but still fully supported).
984
 
        :param from_branch: override bzrdir branch (for lightweight checkouts)
985
668
        """
986
669
        raise NotImplementedError(self.open_workingtree)
987
670
 
988
671
    def has_branch(self):
989
672
        """Tell if this bzrdir contains a branch.
990
 
 
 
673
        
991
674
        Note: if you're going to open the branch, you should just go ahead
992
 
        and try, and not ask permission first.  (This method just opens the
993
 
        branch and discards it, and that's somewhat expensive.)
 
675
        and try, and not ask permission first.  (This method just opens the 
 
676
        branch and discards it, and that's somewhat expensive.) 
994
677
        """
995
678
        try:
996
679
            self.open_branch()
1003
686
 
1004
687
        This will still raise an exception if the bzrdir has a workingtree that
1005
688
        is remote & inaccessible.
1006
 
 
 
689
        
1007
690
        Note: if you're going to open the working tree, you should just go ahead
1008
 
        and try, and not ask permission first.  (This method just opens the
1009
 
        workingtree and discards it, and that's somewhat expensive.)
 
691
        and try, and not ask permission first.  (This method just opens the 
 
692
        workingtree and discards it, and that's somewhat expensive.) 
1010
693
        """
1011
694
        try:
1012
695
            self.open_workingtree(recommend_upgrade=False)
1015
698
            return False
1016
699
 
1017
700
    def _cloning_metadir(self):
1018
 
        """Produce a metadir suitable for cloning with.
1019
 
 
1020
 
        :returns: (destination_bzrdir_format, source_repository)
1021
 
        """
 
701
        """Produce a metadir suitable for cloning with"""
1022
702
        result_format = self._format.__class__()
1023
703
        try:
1024
704
            try:
1025
 
                branch = self.open_branch(ignore_fallbacks=True)
 
705
                branch = self.open_branch()
1026
706
                source_repository = branch.repository
1027
 
                result_format._branch_format = branch._format
1028
707
            except errors.NotBranchError:
1029
708
                source_branch = None
1030
709
                source_repository = self.open_repository()
1035
714
            # the fix recommended in bug # 103195 - to delegate this choice the
1036
715
            # repository itself.
1037
716
            repo_format = source_repository._format
1038
 
            if isinstance(repo_format, remote.RemoteRepositoryFormat):
1039
 
                source_repository._ensure_real()
1040
 
                repo_format = source_repository._real_repository._format
1041
 
            result_format.repository_format = repo_format
 
717
            if not isinstance(repo_format, remote.RemoteRepositoryFormat):
 
718
                result_format.repository_format = repo_format
1042
719
        try:
1043
720
            # TODO: Couldn't we just probe for the format in these cases,
1044
721
            # rather than opening the whole tree?  It would be a little
1050
727
            result_format.workingtree_format = tree._format.__class__()
1051
728
        return result_format, source_repository
1052
729
 
1053
 
    def cloning_metadir(self, require_stacking=False):
 
730
    def cloning_metadir(self):
1054
731
        """Produce a metadir suitable for cloning or sprouting with.
1055
732
 
1056
733
        These operations may produce workingtrees (yes, even though they're
1057
 
        "cloning" something that doesn't have a tree), so a viable workingtree
 
734
        "cloning" something that doesn't have a tree, so a viable workingtree
1058
735
        format must be selected.
1059
 
 
1060
 
        :require_stacking: If True, non-stackable formats will be upgraded
1061
 
            to similar stackable formats.
1062
 
        :returns: a BzrDirFormat with all component formats either set
1063
 
            appropriately or set to None if that component should not be
1064
 
            created.
1065
736
        """
1066
737
        format, repository = self._cloning_metadir()
1067
738
        if format._workingtree_format is None:
1069
740
                return format
1070
741
            tree_format = repository._format._matchingbzrdir.workingtree_format
1071
742
            format.workingtree_format = tree_format.__class__()
1072
 
        if require_stacking:
1073
 
            format.require_stacking()
1074
743
        return format
1075
744
 
1076
745
    def checkout_metadir(self):
1077
746
        return self.cloning_metadir()
1078
747
 
1079
748
    def sprout(self, url, revision_id=None, force_new_repo=False,
1080
 
               recurse='down', possible_transports=None,
1081
 
               accelerator_tree=None, hardlink=False, stacked=False,
1082
 
               source_branch=None, create_tree_if_local=True):
 
749
               recurse='down', possible_transports=None):
1083
750
        """Create a copy of this bzrdir prepared for use as a new line of
1084
751
        development.
1085
752
 
1086
 
        If url's last component does not exist, it will be created.
 
753
        If urls last component does not exist, it will be created.
1087
754
 
1088
755
        Attributes related to the identity of the source branch like
1089
756
        branch nickname will be cleaned, a working tree is created
1092
759
 
1093
760
        if revision_id is not None, then the clone operation may tune
1094
761
            itself to download less data.
1095
 
        :param accelerator_tree: A tree which can be used for retrieving file
1096
 
            contents more quickly than the revision tree, i.e. a workingtree.
1097
 
            The revision tree will be used for cases where accelerator_tree's
1098
 
            content is different.
1099
 
        :param hardlink: If true, hard-link files from accelerator_tree,
1100
 
            where possible.
1101
 
        :param stacked: If true, create a stacked branch referring to the
1102
 
            location of this control directory.
1103
 
        :param create_tree_if_local: If true, a working-tree will be created
1104
 
            when working locally.
1105
762
        """
1106
763
        target_transport = get_transport(url, possible_transports)
1107
764
        target_transport.ensure_base()
1108
 
        cloning_format = self.cloning_metadir(stacked)
1109
 
        # Create/update the result branch
 
765
        cloning_format = self.cloning_metadir()
1110
766
        result = cloning_format.initialize_on_transport(target_transport)
1111
 
        # if a stacked branch wasn't requested, we don't create one
1112
 
        # even if the origin was stacked
1113
 
        stacked_branch_url = None
1114
 
        if source_branch is not None:
1115
 
            if stacked:
1116
 
                stacked_branch_url = self.root_transport.base
 
767
        try:
 
768
            source_branch = self.open_branch()
1117
769
            source_repository = source_branch.repository
1118
 
        else:
1119
 
            try:
1120
 
                source_branch = self.open_branch()
1121
 
                source_repository = source_branch.repository
1122
 
                if stacked:
1123
 
                    stacked_branch_url = self.root_transport.base
1124
 
            except errors.NotBranchError:
1125
 
                source_branch = None
1126
 
                try:
1127
 
                    source_repository = self.open_repository()
1128
 
                except errors.NoRepositoryPresent:
1129
 
                    source_repository = None
1130
 
        repository_policy = result.determine_repository_policy(
1131
 
            force_new_repo, stacked_branch_url, require_stacking=stacked)
1132
 
        result_repo, is_new_repo = repository_policy.acquire_repository()
1133
 
        if is_new_repo and revision_id is not None and not stacked:
1134
 
            fetch_spec = graph.PendingAncestryResult(
1135
 
                [revision_id], source_repository)
1136
 
        else:
1137
 
            fetch_spec = None
1138
 
        if source_repository is not None:
1139
 
            # Fetch while stacked to prevent unstacked fetch from
1140
 
            # Branch.sprout.
1141
 
            if fetch_spec is None:
 
770
        except errors.NotBranchError:
 
771
            source_branch = None
 
772
            try:
 
773
                source_repository = self.open_repository()
 
774
            except errors.NoRepositoryPresent:
 
775
                source_repository = None
 
776
        if force_new_repo:
 
777
            result_repo = None
 
778
        else:
 
779
            try:
 
780
                result_repo = result.find_repository()
 
781
            except errors.NoRepositoryPresent:
 
782
                result_repo = None
 
783
        if source_repository is None and result_repo is not None:
 
784
            pass
 
785
        elif source_repository is None and result_repo is None:
 
786
            # no repo available, make a new one
 
787
            result.create_repository()
 
788
        elif source_repository is not None and result_repo is None:
 
789
            # have source, and want to make a new target repo
 
790
            result_repo = source_repository.sprout(result,
 
791
                                                   revision_id=revision_id)
 
792
        else:
 
793
            # fetch needed content into target.
 
794
            if source_repository is not None:
 
795
                # would rather do 
 
796
                # source_repository.copy_content_into(result_repo,
 
797
                #                                     revision_id=revision_id)
 
798
                # so we can override the copy method
1142
799
                result_repo.fetch(source_repository, revision_id=revision_id)
1143
 
            else:
1144
 
                result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1145
 
 
1146
 
        if source_branch is None:
1147
 
            # this is for sprouting a bzrdir without a branch; is that
1148
 
            # actually useful?
1149
 
            # Not especially, but it's part of the contract.
1150
 
            result_branch = result.create_branch()
 
800
        if source_branch is not None:
 
801
            source_branch.sprout(result, revision_id=revision_id)
1151
802
        else:
1152
 
            result_branch = source_branch.sprout(result,
1153
 
                revision_id=revision_id, repository_policy=repository_policy)
1154
 
        mutter("created new branch %r" % (result_branch,))
1155
 
 
1156
 
        # Create/update the result working tree
1157
 
        if (create_tree_if_local and
1158
 
            isinstance(target_transport, local.LocalTransport) and
1159
 
            (result_repo is None or result_repo.make_working_trees())):
1160
 
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1161
 
                hardlink=hardlink)
 
803
            result.create_branch()
 
804
        if isinstance(target_transport, LocalTransport) and (
 
805
            result_repo is None or result_repo.make_working_trees()):
 
806
            wt = result.create_workingtree()
1162
807
            wt.lock_write()
1163
808
            try:
1164
809
                if wt.path2id('') is None:
1175
820
                basis = wt.basis_tree()
1176
821
                basis.lock_read()
1177
822
                subtrees = basis.iter_references()
1178
 
            elif result_branch is not None:
1179
 
                basis = result_branch.basis_tree()
1180
 
                basis.lock_read()
1181
 
                subtrees = basis.iter_references()
 
823
                recurse_branch = wt.branch
1182
824
            elif source_branch is not None:
1183
825
                basis = source_branch.basis_tree()
1184
826
                basis.lock_read()
1185
827
                subtrees = basis.iter_references()
 
828
                recurse_branch = source_branch
1186
829
            else:
1187
830
                subtrees = []
1188
831
                basis = None
1192
835
                    sublocation = source_branch.reference_parent(file_id, path)
1193
836
                    sublocation.bzrdir.sprout(target,
1194
837
                        basis.get_reference_revision(file_id, path),
1195
 
                        force_new_repo=force_new_repo, recurse=recurse,
1196
 
                        stacked=stacked)
 
838
                        force_new_repo=force_new_repo, recurse=recurse)
1197
839
            finally:
1198
840
                if basis is not None:
1199
841
                    basis.unlock()
1200
842
        return result
1201
843
 
1202
 
    def push_branch(self, source, revision_id=None, overwrite=False, 
1203
 
        remember=False):
1204
 
        """Push the source branch into this BzrDir."""
1205
 
        br_to = None
1206
 
        # If we can open a branch, use its direct repository, otherwise see
1207
 
        # if there is a repository without a branch.
1208
 
        try:
1209
 
            br_to = self.open_branch()
1210
 
        except errors.NotBranchError:
1211
 
            # Didn't find a branch, can we find a repository?
1212
 
            repository_to = self.find_repository()
1213
 
        else:
1214
 
            # Found a branch, so we must have found a repository
1215
 
            repository_to = br_to.repository
1216
 
 
1217
 
        push_result = PushResult()
1218
 
        push_result.source_branch = source
1219
 
        if br_to is None:
1220
 
            # We have a repository but no branch, copy the revisions, and then
1221
 
            # create a branch.
1222
 
            repository_to.fetch(source.repository, revision_id=revision_id)
1223
 
            br_to = source.clone(self, revision_id=revision_id)
1224
 
            if source.get_push_location() is None or remember:
1225
 
                source.set_push_location(br_to.base)
1226
 
            push_result.stacked_on = None
1227
 
            push_result.branch_push_result = None
1228
 
            push_result.old_revno = None
1229
 
            push_result.old_revid = _mod_revision.NULL_REVISION
1230
 
            push_result.target_branch = br_to
1231
 
            push_result.master_branch = None
1232
 
            push_result.workingtree_updated = False
1233
 
        else:
1234
 
            # We have successfully opened the branch, remember if necessary:
1235
 
            if source.get_push_location() is None or remember:
1236
 
                source.set_push_location(br_to.base)
1237
 
            try:
1238
 
                tree_to = self.open_workingtree()
1239
 
            except errors.NotLocalUrl:
1240
 
                push_result.branch_push_result = source.push(br_to, 
1241
 
                    overwrite, stop_revision=revision_id)
1242
 
                push_result.workingtree_updated = False
1243
 
            except errors.NoWorkingTree:
1244
 
                push_result.branch_push_result = source.push(br_to,
1245
 
                    overwrite, stop_revision=revision_id)
1246
 
                push_result.workingtree_updated = None # Not applicable
1247
 
            else:
1248
 
                tree_to.lock_write()
1249
 
                try:
1250
 
                    push_result.branch_push_result = source.push(
1251
 
                        tree_to.branch, overwrite, stop_revision=revision_id)
1252
 
                    tree_to.update()
1253
 
                finally:
1254
 
                    tree_to.unlock()
1255
 
                push_result.workingtree_updated = True
1256
 
            push_result.old_revno = push_result.branch_push_result.old_revno
1257
 
            push_result.old_revid = push_result.branch_push_result.old_revid
1258
 
            push_result.target_branch = \
1259
 
                push_result.branch_push_result.target_branch
1260
 
        return push_result
1261
 
 
1262
 
 
1263
 
class BzrDirHooks(hooks.Hooks):
1264
 
    """Hooks for BzrDir operations."""
1265
 
 
1266
 
    def __init__(self):
1267
 
        """Create the default hooks."""
1268
 
        hooks.Hooks.__init__(self)
1269
 
        self.create_hook(hooks.HookPoint('pre_open',
1270
 
            "Invoked before attempting to open a BzrDir with the transport "
1271
 
            "that the open will use.", (1, 14), None))
1272
 
 
1273
 
# install the default hooks
1274
 
BzrDir.hooks = BzrDirHooks()
1275
 
 
1276
844
 
1277
845
class BzrDirPreSplitOut(BzrDir):
1278
846
    """A common class for the all-in-one formats."""
1280
848
    def __init__(self, _transport, _format):
1281
849
        """See BzrDir.__init__."""
1282
850
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
 
851
        assert self._format._lock_class == lockable_files.TransportLock
 
852
        assert self._format._lock_file_name == 'branch-lock'
1283
853
        self._control_files = lockable_files.LockableFiles(
1284
854
                                            self.get_branch_transport(None),
1285
855
                                            self._format._lock_file_name,
1289
859
        """Pre-splitout bzrdirs do not suffer from stale locks."""
1290
860
        raise NotImplementedError(self.break_lock)
1291
861
 
1292
 
    def cloning_metadir(self, require_stacking=False):
1293
 
        """Produce a metadir suitable for cloning with."""
1294
 
        if require_stacking:
1295
 
            return format_registry.make_bzrdir('1.6')
1296
 
        return self._format.__class__()
1297
 
 
1298
 
    def clone(self, url, revision_id=None, force_new_repo=False,
1299
 
              preserve_stacking=False):
1300
 
        """See BzrDir.clone().
1301
 
 
1302
 
        force_new_repo has no effect, since this family of formats always
1303
 
        require a new repository.
1304
 
        preserve_stacking has no effect, since no source branch using this
1305
 
        family of formats can be stacked, so there is no stacking to preserve.
1306
 
        """
 
862
    def clone(self, url, revision_id=None, force_new_repo=False):
 
863
        """See BzrDir.clone()."""
 
864
        from bzrlib.workingtree import WorkingTreeFormat2
1307
865
        self._make_tail(url)
1308
866
        result = self._format._initialize_for_clone(url)
1309
867
        self.open_repository().clone(result, revision_id=revision_id)
1310
868
        from_branch = self.open_branch()
1311
869
        from_branch.clone(result, revision_id=revision_id)
1312
870
        try:
1313
 
            tree = self.open_workingtree()
 
871
            self.open_workingtree().clone(result)
1314
872
        except errors.NotLocalUrl:
1315
873
            # make a new one, this format always has to have one.
1316
 
            result._init_workingtree()
1317
 
        else:
1318
 
            tree.clone(result)
 
874
            try:
 
875
                WorkingTreeFormat2().initialize(result)
 
876
            except errors.NotLocalUrl:
 
877
                # but we cannot do it for remote trees.
 
878
                to_branch = result.open_branch()
 
879
                WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
1319
880
        return result
1320
881
 
1321
882
    def create_branch(self):
1322
883
        """See BzrDir.create_branch."""
1323
 
        return self._format.get_branch_format().initialize(self)
1324
 
 
1325
 
    def destroy_branch(self):
1326
 
        """See BzrDir.destroy_branch."""
1327
 
        raise errors.UnsupportedOperation(self.destroy_branch, self)
 
884
        return self.open_branch()
1328
885
 
1329
886
    def create_repository(self, shared=False):
1330
887
        """See BzrDir.create_repository."""
1332
889
            raise errors.IncompatibleFormat('shared repository', self._format)
1333
890
        return self.open_repository()
1334
891
 
1335
 
    def destroy_repository(self):
1336
 
        """See BzrDir.destroy_repository."""
1337
 
        raise errors.UnsupportedOperation(self.destroy_repository, self)
1338
 
 
1339
 
    def create_workingtree(self, revision_id=None, from_branch=None,
1340
 
                           accelerator_tree=None, hardlink=False):
 
892
    def create_workingtree(self, revision_id=None):
1341
893
        """See BzrDir.create_workingtree."""
1342
 
        # The workingtree is sometimes created when the bzrdir is created,
1343
 
        # but not when cloning.
1344
 
 
1345
894
        # this looks buggy but is not -really-
1346
895
        # because this format creates the workingtree when the bzrdir is
1347
896
        # created
1349
898
        # and that will have set it for us, its only
1350
899
        # specific uses of create_workingtree in isolation
1351
900
        # that can do wonky stuff here, and that only
1352
 
        # happens for creating checkouts, which cannot be
 
901
        # happens for creating checkouts, which cannot be 
1353
902
        # done on this format anyway. So - acceptable wart.
1354
 
        try:
1355
 
            result = self.open_workingtree(recommend_upgrade=False)
1356
 
        except errors.NoSuchFile:
1357
 
            result = self._init_workingtree()
 
903
        result = self.open_workingtree(recommend_upgrade=False)
1358
904
        if revision_id is not None:
1359
905
            if revision_id == _mod_revision.NULL_REVISION:
1360
906
                result.set_parent_ids([])
1362
908
                result.set_parent_ids([revision_id])
1363
909
        return result
1364
910
 
1365
 
    def _init_workingtree(self):
1366
 
        from bzrlib.workingtree import WorkingTreeFormat2
1367
 
        try:
1368
 
            return WorkingTreeFormat2().initialize(self)
1369
 
        except errors.NotLocalUrl:
1370
 
            # Even though we can't access the working tree, we need to
1371
 
            # create its control files.
1372
 
            return WorkingTreeFormat2()._stub_initialize_on_transport(
1373
 
                self.transport, self._control_files._file_mode)
1374
 
 
1375
911
    def destroy_workingtree(self):
1376
912
        """See BzrDir.destroy_workingtree."""
1377
913
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1378
914
 
1379
915
    def destroy_workingtree_metadata(self):
1380
916
        """See BzrDir.destroy_workingtree_metadata."""
1381
 
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
 
917
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
1382
918
                                          self)
1383
919
 
1384
920
    def get_branch_transport(self, branch_format):
1416
952
        # if the format is not the same as the system default,
1417
953
        # an upgrade is needed.
1418
954
        if format is None:
1419
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1420
 
                % 'needs_format_conversion(format=None)')
1421
955
            format = BzrDirFormat.get_default_format()
1422
956
        return not isinstance(self._format, format.__class__)
1423
957
 
1424
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
958
    def open_branch(self, unsupported=False):
1425
959
        """See BzrDir.open_branch."""
1426
960
        from bzrlib.branch import BzrBranchFormat4
1427
961
        format = BzrBranchFormat4()
1429
963
        return format.open(self, _found=True)
1430
964
 
1431
965
    def sprout(self, url, revision_id=None, force_new_repo=False,
1432
 
               possible_transports=None, accelerator_tree=None,
1433
 
               hardlink=False, stacked=False, create_tree_if_local=True,
1434
 
               source_branch=None):
 
966
               possible_transports=None):
1435
967
        """See BzrDir.sprout()."""
1436
 
        if source_branch is not None:
1437
 
            my_branch = self.open_branch()
1438
 
            if source_branch.base != my_branch.base:
1439
 
                raise AssertionError(
1440
 
                    "source branch %r is not within %r with branch %r" %
1441
 
                    (source_branch, self, my_branch))
1442
 
        if stacked:
1443
 
            raise errors.UnstackableBranchFormat(
1444
 
                self._format, self.root_transport.base)
1445
 
        if not create_tree_if_local:
1446
 
            raise errors.MustHaveWorkingTree(
1447
 
                self._format, self.root_transport.base)
1448
968
        from bzrlib.workingtree import WorkingTreeFormat2
1449
969
        self._make_tail(url)
1450
970
        result = self._format._initialize_for_clone(url)
1456
976
            self.open_branch().sprout(result, revision_id=revision_id)
1457
977
        except errors.NotBranchError:
1458
978
            pass
1459
 
 
1460
979
        # we always want a working tree
1461
 
        WorkingTreeFormat2().initialize(result,
1462
 
                                        accelerator_tree=accelerator_tree,
1463
 
                                        hardlink=hardlink)
 
980
        WorkingTreeFormat2().initialize(result)
1464
981
        return result
1465
982
 
1466
983
 
1467
984
class BzrDir4(BzrDirPreSplitOut):
1468
985
    """A .bzr version 4 control object.
1469
 
 
 
986
    
1470
987
    This is a deprecated format and may be removed after sept 2006.
1471
988
    """
1472
989
 
1476
993
 
1477
994
    def needs_format_conversion(self, format=None):
1478
995
        """Format 4 dirs are always in need of conversion."""
1479
 
        if format is None:
1480
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1481
 
                % 'needs_format_conversion(format=None)')
1482
996
        return True
1483
997
 
1484
998
    def open_repository(self):
1530
1044
 
1531
1045
class BzrDirMeta1(BzrDir):
1532
1046
    """A .bzr meta version 1 control object.
1533
 
 
1534
 
    This is the first control object where the
 
1047
    
 
1048
    This is the first control object where the 
1535
1049
    individual aspects are really split out: there are separate repository,
1536
1050
    workingtree and branch subdirectories and any subset of the three can be
1537
1051
    present within a BzrDir.
1545
1059
        """See BzrDir.create_branch."""
1546
1060
        return self._format.get_branch_format().initialize(self)
1547
1061
 
1548
 
    def destroy_branch(self):
1549
 
        """See BzrDir.create_branch."""
1550
 
        self.transport.delete_tree('branch')
1551
 
 
1552
1062
    def create_repository(self, shared=False):
1553
1063
        """See BzrDir.create_repository."""
1554
1064
        return self._format.repository_format.initialize(self, shared)
1555
1065
 
1556
 
    def destroy_repository(self):
1557
 
        """See BzrDir.destroy_repository."""
1558
 
        self.transport.delete_tree('repository')
1559
 
 
1560
 
    def create_workingtree(self, revision_id=None, from_branch=None,
1561
 
                           accelerator_tree=None, hardlink=False):
 
1066
    def create_workingtree(self, revision_id=None):
1562
1067
        """See BzrDir.create_workingtree."""
1563
 
        return self._format.workingtree_format.initialize(
1564
 
            self, revision_id, from_branch=from_branch,
1565
 
            accelerator_tree=accelerator_tree, hardlink=hardlink)
 
1068
        from bzrlib.workingtree import WorkingTreeFormat
 
1069
        return self._format.workingtree_format.initialize(self, revision_id)
1566
1070
 
1567
1071
    def destroy_workingtree(self):
1568
1072
        """See BzrDir.destroy_workingtree."""
1569
1073
        wt = self.open_workingtree(recommend_upgrade=False)
1570
1074
        repository = wt.branch.repository
1571
1075
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1572
 
        wt.revert(old_tree=empty)
 
1076
        wt.revert([], old_tree=empty)
1573
1077
        self.destroy_workingtree_metadata()
1574
1078
 
1575
1079
    def destroy_workingtree_metadata(self):
1640
1144
    def needs_format_conversion(self, format=None):
1641
1145
        """See BzrDir.needs_format_conversion()."""
1642
1146
        if format is None:
1643
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1644
 
                % 'needs_format_conversion(format=None)')
1645
 
        if format is None:
1646
1147
            format = BzrDirFormat.get_default_format()
1647
1148
        if not isinstance(self._format, format.__class__):
1648
1149
            # it is not a meta dir format, conversion is needed.
1672
1173
            pass
1673
1174
        return False
1674
1175
 
1675
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1176
    def open_branch(self, unsupported=False):
1676
1177
        """See BzrDir.open_branch."""
1677
1178
        format = self.find_branch_format()
1678
1179
        self._check_supported(format, unsupported)
1679
 
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
 
1180
        return format.open(self, _found=True)
1680
1181
 
1681
1182
    def open_repository(self, unsupported=False):
1682
1183
        """See BzrDir.open_repository."""
1695
1196
            basedir=self.root_transport.base)
1696
1197
        return format.open(self, _found=True)
1697
1198
 
1698
 
    def _get_config(self):
1699
 
        return config.BzrDirConfig(self.transport)
1700
 
 
1701
1199
 
1702
1200
class BzrDirFormat(object):
1703
1201
    """An encapsulation of the initialization and open routines for a format.
1707
1205
     * a format string,
1708
1206
     * an open routine.
1709
1207
 
1710
 
    Formats are placed in a dict by their format string for reference
 
1208
    Formats are placed in an dict by their format string for reference 
1711
1209
    during bzrdir opening. These should be subclasses of BzrDirFormat
1712
1210
    for consistency.
1713
1211
 
1714
1212
    Once a format is deprecated, just deprecate the initialize and open
1715
 
    methods on the format class. Do not deprecate the object, as the
 
1213
    methods on the format class. Do not deprecate the object, as the 
1716
1214
    object will be created every system load.
1717
1215
    """
1718
1216
 
1724
1222
 
1725
1223
    _control_formats = []
1726
1224
    """The registered control formats - .bzr, ....
1727
 
 
 
1225
    
1728
1226
    This is a list of BzrDirFormat objects.
1729
1227
    """
1730
1228
 
1765
1263
        try:
1766
1264
            return klass._formats[format_string]
1767
1265
        except KeyError:
1768
 
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
 
1266
            raise errors.UnknownFormatError(format=format_string)
1769
1267
 
1770
1268
    @classmethod
1771
1269
    def get_default_format(klass):
1789
1287
        current default format. In the case of plugins we can/should provide
1790
1288
        some means for them to extend the range of returnable converters.
1791
1289
 
1792
 
        :param format: Optional format to override the default format of the
 
1290
        :param format: Optional format to override the default format of the 
1793
1291
                       library.
1794
1292
        """
1795
1293
        raise NotImplementedError(self.get_converter)
1796
1294
 
1797
1295
    def initialize(self, url, possible_transports=None):
1798
1296
        """Create a bzr control dir at this url and return an opened copy.
1799
 
 
 
1297
        
1800
1298
        Subclasses should typically override initialize_on_transport
1801
1299
        instead of this method.
1802
1300
        """
1805
1303
 
1806
1304
    def initialize_on_transport(self, transport):
1807
1305
        """Initialize a new bzrdir in the base directory of a Transport."""
1808
 
        try:
1809
 
            # can we hand off the request to the smart server rather than using
1810
 
            # vfs calls?
1811
 
            client_medium = transport.get_smart_medium()
1812
 
        except errors.NoSmartMedium:
1813
 
            return self._initialize_on_transport_vfs(transport)
1814
 
        else:
1815
 
            # Current RPC's only know how to create bzr metadir1 instances, so
1816
 
            # we still delegate to vfs methods if the requested format is not a
1817
 
            # metadir1
1818
 
            if type(self) != BzrDirMetaFormat1:
1819
 
                return self._initialize_on_transport_vfs(transport)
1820
 
            remote_format = RemoteBzrDirFormat()
1821
 
            self._supply_sub_formats_to(remote_format)
1822
 
            return remote_format.initialize_on_transport(transport)
1823
 
 
1824
 
    def _initialize_on_transport_vfs(self, transport):
1825
 
        """Initialize a new bzrdir using VFS calls.
1826
 
 
1827
 
        :param transport: The transport to create the .bzr directory in.
1828
 
        :return: A
1829
 
        """
1830
 
        # Since we are creating a .bzr directory, inherit the
 
1306
        # Since we don't have a .bzr directory, inherit the
1831
1307
        # mode from the root directory
1832
1308
        temp_control = lockable_files.LockableFiles(transport,
1833
1309
                            '', lockable_files.TransportLock)
1835
1311
                                      # FIXME: RBC 20060121 don't peek under
1836
1312
                                      # the covers
1837
1313
                                      mode=temp_control._dir_mode)
1838
 
        if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1839
 
            win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1840
1314
        file_mode = temp_control._file_mode
1841
1315
        del temp_control
1842
 
        bzrdir_transport = transport.clone('.bzr')
1843
 
        utf8_files = [('README',
1844
 
                       "This is a Bazaar control directory.\n"
1845
 
                       "Do not change any files in this directory.\n"
1846
 
                       "See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
 
1316
        mutter('created control directory in ' + transport.base)
 
1317
        control = transport.clone('.bzr')
 
1318
        utf8_files = [('README', 
 
1319
                       "This is a Bazaar-NG control directory.\n"
 
1320
                       "Do not change any files in this directory.\n"),
1847
1321
                      ('branch-format', self.get_format_string()),
1848
1322
                      ]
1849
1323
        # NB: no need to escape relative paths that are url safe.
1850
 
        control_files = lockable_files.LockableFiles(bzrdir_transport,
1851
 
            self._lock_file_name, self._lock_class)
 
1324
        control_files = lockable_files.LockableFiles(control,
 
1325
                            self._lock_file_name, self._lock_class)
1852
1326
        control_files.create_lock()
1853
1327
        control_files.lock_write()
1854
1328
        try:
1855
 
            for (filename, content) in utf8_files:
1856
 
                bzrdir_transport.put_bytes(filename, content,
1857
 
                    mode=file_mode)
 
1329
            for file, content in utf8_files:
 
1330
                control_files.put_utf8(file, content)
1858
1331
        finally:
1859
1332
            control_files.unlock()
1860
1333
        return self.open(transport, _found=True)
1863
1336
        """Is this format supported?
1864
1337
 
1865
1338
        Supported formats must be initializable and openable.
1866
 
        Unsupported formats may not support initialization or committing or
 
1339
        Unsupported formats may not support initialization or committing or 
1867
1340
        some other features depending on the reason for not being supported.
1868
1341
        """
1869
1342
        return True
1870
1343
 
1871
 
    def network_name(self):
1872
 
        """A simple byte string uniquely identifying this format for RPC calls.
1873
 
 
1874
 
        Bzr control formats use thir disk format string to identify the format
1875
 
        over the wire. Its possible that other control formats have more
1876
 
        complex detection requirements, so we permit them to use any unique and
1877
 
        immutable string they desire.
1878
 
        """
1879
 
        raise NotImplementedError(self.network_name)
1880
 
 
1881
1344
    def same_model(self, target_format):
1882
 
        return (self.repository_format.rich_root_data ==
 
1345
        return (self.repository_format.rich_root_data == 
1883
1346
            target_format.rich_root_data)
1884
1347
 
1885
1348
    @classmethod
1886
1349
    def known_formats(klass):
1887
1350
        """Return all the known formats.
1888
 
 
 
1351
        
1889
1352
        Concrete formats should override _known_formats.
1890
1353
        """
1891
 
        # There is double indirection here to make sure that control
1892
 
        # formats used by more than one dir format will only be probed
 
1354
        # There is double indirection here to make sure that control 
 
1355
        # formats used by more than one dir format will only be probed 
1893
1356
        # once. This can otherwise be quite expensive for remote connections.
1894
1357
        result = set()
1895
1358
        for format in klass._control_formats:
1896
1359
            result.update(format._known_formats())
1897
1360
        return result
1898
 
 
 
1361
    
1899
1362
    @classmethod
1900
1363
    def _known_formats(klass):
1901
1364
        """Return the known format instances for this control format."""
1903
1366
 
1904
1367
    def open(self, transport, _found=False):
1905
1368
        """Return an instance of this format for the dir transport points at.
1906
 
 
 
1369
        
1907
1370
        _found is a private parameter, do not use it.
1908
1371
        """
1909
1372
        if not _found:
1910
1373
            found_format = BzrDirFormat.find_format(transport)
1911
1374
            if not isinstance(found_format, self.__class__):
1912
1375
                raise AssertionError("%s was asked to open %s, but it seems to need "
1913
 
                        "format %s"
 
1376
                        "format %s" 
1914
1377
                        % (self, transport, found_format))
1915
 
            # Allow subclasses - use the found format.
1916
 
            self._supply_sub_formats_to(found_format)
1917
 
            return found_format._open(transport)
1918
1378
        return self._open(transport)
1919
1379
 
1920
1380
    def _open(self, transport):
1928
1388
    @classmethod
1929
1389
    def register_format(klass, format):
1930
1390
        klass._formats[format.get_format_string()] = format
1931
 
        # bzr native formats have a network name of their format string.
1932
 
        network_format_registry.register(format.get_format_string(), format.__class__)
1933
1391
 
1934
1392
    @classmethod
1935
1393
    def register_control_format(klass, format):
1936
1394
        """Register a format that does not use '.bzr' for its control dir.
1937
1395
 
1938
1396
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1939
 
        which BzrDirFormat can inherit from, and renamed to register_format
 
1397
        which BzrDirFormat can inherit from, and renamed to register_format 
1940
1398
        there. It has been done without that for now for simplicity of
1941
1399
        implementation.
1942
1400
        """
1954
1412
        klass._control_server_formats.append(format)
1955
1413
 
1956
1414
    @classmethod
 
1415
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
 
1416
    def set_default_format(klass, format):
 
1417
        klass._set_default_format(format)
 
1418
 
 
1419
    @classmethod
1957
1420
    def _set_default_format(klass, format):
1958
1421
        """Set default format (for testing behavior of defaults only)"""
1959
1422
        klass._default_format = format
1960
1423
 
1961
1424
    def __str__(self):
1962
 
        # Trim the newline
1963
 
        return self.get_format_description().rstrip()
1964
 
 
1965
 
    def _supply_sub_formats_to(self, other_format):
1966
 
        """Give other_format the same values for sub formats as this has.
1967
 
 
1968
 
        This method is expected to be used when parameterising a
1969
 
        RemoteBzrDirFormat instance with the parameters from a
1970
 
        BzrDirMetaFormat1 instance.
1971
 
 
1972
 
        :param other_format: other_format is a format which should be
1973
 
            compatible with whatever sub formats are supported by self.
1974
 
        :return: None.
1975
 
        """
 
1425
        return self.get_format_string()[:-1]
1976
1426
 
1977
1427
    @classmethod
1978
1428
    def unregister_format(klass, format):
 
1429
        assert klass._formats[format.get_format_string()] is format
1979
1430
        del klass._formats[format.get_format_string()]
1980
1431
 
1981
1432
    @classmethod
2010
1461
        """See BzrDirFormat.get_converter()."""
2011
1462
        # there is one and only one upgrade path here.
2012
1463
        return ConvertBzrDir4To5()
2013
 
 
 
1464
        
2014
1465
    def initialize_on_transport(self, transport):
2015
1466
        """Format 4 branches cannot be created."""
2016
1467
        raise errors.UninitializableFormat(self)
2019
1470
        """Format 4 is not supported.
2020
1471
 
2021
1472
        It is not supported because the model changed from 4 to 5 and the
2022
 
        conversion logic is expensive - so doing it on the fly was not
 
1473
        conversion logic is expensive - so doing it on the fly was not 
2023
1474
        feasible.
2024
1475
        """
2025
1476
        return False
2026
1477
 
2027
 
    def network_name(self):
2028
 
        return self.get_format_string()
2029
 
 
2030
1478
    def _open(self, transport):
2031
1479
        """See BzrDirFormat._open."""
2032
1480
        return BzrDir4(transport, self)
2043
1491
 
2044
1492
    This format is a combined format for working tree, branch and repository.
2045
1493
    It has:
2046
 
     - Format 2 working trees [always]
2047
 
     - Format 4 branches [always]
 
1494
     - Format 2 working trees [always] 
 
1495
     - Format 4 branches [always] 
2048
1496
     - Format 5 repositories [always]
2049
1497
       Unhashed stores in the repository.
2050
1498
    """
2055
1503
        """See BzrDirFormat.get_format_string()."""
2056
1504
        return "Bazaar-NG branch, format 5\n"
2057
1505
 
2058
 
    def get_branch_format(self):
2059
 
        from bzrlib import branch
2060
 
        return branch.BzrBranchFormat4()
2061
 
 
2062
1506
    def get_format_description(self):
2063
1507
        """See BzrDirFormat.get_format_description()."""
2064
1508
        return "All-in-one format 5"
2070
1514
 
2071
1515
    def _initialize_for_clone(self, url):
2072
1516
        return self.initialize_on_transport(get_transport(url), _cloning=True)
2073
 
 
 
1517
        
2074
1518
    def initialize_on_transport(self, transport, _cloning=False):
2075
1519
        """Format 5 dirs always have working tree, branch and repository.
2076
 
 
 
1520
        
2077
1521
        Except when they are being cloned.
2078
1522
        """
2079
1523
        from bzrlib.branch import BzrBranchFormat4
2080
1524
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1525
        from bzrlib.workingtree import WorkingTreeFormat2
2081
1526
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
2082
1527
        RepositoryFormat5().initialize(result, _internal=True)
2083
1528
        if not _cloning:
2084
1529
            branch = BzrBranchFormat4().initialize(result)
2085
 
            result._init_workingtree()
 
1530
            try:
 
1531
                WorkingTreeFormat2().initialize(result)
 
1532
            except errors.NotLocalUrl:
 
1533
                # Even though we can't access the working tree, we need to
 
1534
                # create its control files.
 
1535
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
2086
1536
        return result
2087
1537
 
2088
 
    def network_name(self):
2089
 
        return self.get_format_string()
2090
 
 
2091
1538
    def _open(self, transport):
2092
1539
        """See BzrDirFormat._open."""
2093
1540
        return BzrDir5(transport, self)
2104
1551
 
2105
1552
    This format is a combined format for working tree, branch and repository.
2106
1553
    It has:
2107
 
     - Format 2 working trees [always]
2108
 
     - Format 4 branches [always]
 
1554
     - Format 2 working trees [always] 
 
1555
     - Format 4 branches [always] 
2109
1556
     - Format 6 repositories [always]
2110
1557
    """
2111
1558
 
2119
1566
        """See BzrDirFormat.get_format_description()."""
2120
1567
        return "All-in-one format 6"
2121
1568
 
2122
 
    def get_branch_format(self):
2123
 
        from bzrlib import branch
2124
 
        return branch.BzrBranchFormat4()
2125
 
 
2126
1569
    def get_converter(self, format=None):
2127
1570
        """See BzrDirFormat.get_converter()."""
2128
1571
        # there is one and only one upgrade path here.
2129
1572
        return ConvertBzrDir6ToMeta()
2130
 
 
 
1573
        
2131
1574
    def _initialize_for_clone(self, url):
2132
1575
        return self.initialize_on_transport(get_transport(url), _cloning=True)
2133
1576
 
2134
1577
    def initialize_on_transport(self, transport, _cloning=False):
2135
1578
        """Format 6 dirs always have working tree, branch and repository.
2136
 
 
 
1579
        
2137
1580
        Except when they are being cloned.
2138
1581
        """
2139
1582
        from bzrlib.branch import BzrBranchFormat4
2140
1583
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1584
        from bzrlib.workingtree import WorkingTreeFormat2
2141
1585
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
2142
1586
        RepositoryFormat6().initialize(result, _internal=True)
2143
1587
        if not _cloning:
2144
1588
            branch = BzrBranchFormat4().initialize(result)
2145
 
            result._init_workingtree()
 
1589
            try:
 
1590
                WorkingTreeFormat2().initialize(result)
 
1591
            except errors.NotLocalUrl:
 
1592
                # Even though we can't access the working tree, we need to
 
1593
                # create its control files.
 
1594
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
2146
1595
        return result
2147
1596
 
2148
 
    def network_name(self):
2149
 
        return self.get_format_string()
2150
 
 
2151
1597
    def _open(self, transport):
2152
1598
        """See BzrDirFormat._open."""
2153
1599
        return BzrDir6(transport, self)
2175
1621
    def __init__(self):
2176
1622
        self._workingtree_format = None
2177
1623
        self._branch_format = None
2178
 
        self._repository_format = None
2179
1624
 
2180
1625
    def __eq__(self, other):
2181
1626
        if other.__class__ is not self.__class__:
2198
1643
    def set_branch_format(self, format):
2199
1644
        self._branch_format = format
2200
1645
 
2201
 
    def require_stacking(self):
2202
 
        if not self.get_branch_format().supports_stacking():
2203
 
            # We need to make a stacked branch, but the default format for the
2204
 
            # target doesn't support stacking.  So force a branch that *can*
2205
 
            # support stacking.
2206
 
            from bzrlib.branch import BzrBranchFormat7
2207
 
            branch_format = BzrBranchFormat7()
2208
 
            self.set_branch_format(branch_format)
2209
 
            mutter("using %r for stacking" % (branch_format,))
2210
 
            from bzrlib.repofmt import pack_repo
2211
 
            if self.repository_format.rich_root_data:
2212
 
                bzrdir_format_name = '1.6.1-rich-root'
2213
 
                repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2214
 
            else:
2215
 
                bzrdir_format_name = '1.6'
2216
 
                repo_format = pack_repo.RepositoryFormatKnitPack5()
2217
 
            note('Source format does not support stacking, using format:'
2218
 
                 ' \'%s\'\n  %s\n',
2219
 
                 bzrdir_format_name, repo_format.get_format_description())
2220
 
            self.repository_format = repo_format
2221
 
 
2222
1646
    def get_converter(self, format=None):
2223
1647
        """See BzrDirFormat.get_converter()."""
2224
1648
        if format is None:
2236
1660
        """See BzrDirFormat.get_format_description()."""
2237
1661
        return "Meta directory format 1"
2238
1662
 
2239
 
    def network_name(self):
2240
 
        return self.get_format_string()
2241
 
 
2242
1663
    def _open(self, transport):
2243
1664
        """See BzrDirFormat._open."""
2244
1665
        return BzrDirMeta1(transport, self)
2245
1666
 
2246
1667
    def __return_repository_format(self):
2247
1668
        """Circular import protection."""
2248
 
        if self._repository_format:
 
1669
        if getattr(self, '_repository_format', None):
2249
1670
            return self._repository_format
2250
1671
        from bzrlib.repository import RepositoryFormat
2251
1672
        return RepositoryFormat.get_default_format()
2252
1673
 
2253
 
    def _set_repository_format(self, value):
2254
 
        """Allow changing the repository format for metadir formats."""
 
1674
    def __set_repository_format(self, value):
 
1675
        """Allow changint the repository format for metadir formats."""
2255
1676
        self._repository_format = value
2256
1677
 
2257
 
    repository_format = property(__return_repository_format,
2258
 
        _set_repository_format)
2259
 
 
2260
 
    def _supply_sub_formats_to(self, other_format):
2261
 
        """Give other_format the same values for sub formats as this has.
2262
 
 
2263
 
        This method is expected to be used when parameterising a
2264
 
        RemoteBzrDirFormat instance with the parameters from a
2265
 
        BzrDirMetaFormat1 instance.
2266
 
 
2267
 
        :param other_format: other_format is a format which should be
2268
 
            compatible with whatever sub formats are supported by self.
2269
 
        :return: None.
2270
 
        """
2271
 
        if getattr(self, '_repository_format', None) is not None:
2272
 
            other_format.repository_format = self.repository_format
2273
 
        if self._branch_format is not None:
2274
 
            other_format._branch_format = self._branch_format
2275
 
        if self._workingtree_format is not None:
2276
 
            other_format.workingtree_format = self.workingtree_format
 
1678
    repository_format = property(__return_repository_format, __set_repository_format)
2277
1679
 
2278
1680
    def __get_workingtree_format(self):
2279
1681
        if self._workingtree_format is None:
2288
1690
                                  __set_workingtree_format)
2289
1691
 
2290
1692
 
2291
 
network_format_registry = registry.FormatRegistry()
2292
 
"""Registry of formats indexed by their network name.
2293
 
 
2294
 
The network name for a BzrDirFormat is an identifier that can be used when
2295
 
referring to formats with smart server operations. See
2296
 
BzrDirFormat.network_name() for more detail.
2297
 
"""
2298
 
 
2299
 
 
2300
1693
# Register bzr control format
2301
1694
BzrDirFormat.register_control_format(BzrDirFormat)
2302
1695
 
2334
1727
        self.absent_revisions = set()
2335
1728
        self.text_count = 0
2336
1729
        self.revisions = {}
2337
 
 
 
1730
        
2338
1731
    def convert(self, to_convert, pb):
2339
1732
        """See Converter.convert()."""
2340
1733
        self.bzrdir = to_convert
2341
1734
        self.pb = pb
2342
1735
        self.pb.note('starting upgrade from format 4 to 5')
2343
 
        if isinstance(self.bzrdir.transport, local.LocalTransport):
 
1736
        if isinstance(self.bzrdir.transport, LocalTransport):
2344
1737
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2345
1738
        self._convert_to_weaves()
2346
1739
        return BzrDir.open(self.bzrdir.root_transport.base)
2385
1778
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
2386
1779
        self.pb.note('  %6d texts', self.text_count)
2387
1780
        self._cleanup_spare_files_after_format4()
2388
 
        self.branch._transport.put_bytes(
2389
 
            'branch-format',
2390
 
            BzrDirFormat5().get_format_string(),
2391
 
            mode=self.bzrdir._get_file_mode())
 
1781
        self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
2392
1782
 
2393
1783
    def _cleanup_spare_files_after_format4(self):
2394
1784
        # FIXME working tree upgrade foo.
2403
1793
 
2404
1794
    def _convert_working_inv(self):
2405
1795
        inv = xml4.serializer_v4.read_inventory(
2406
 
                self.branch._transport.get('inventory'))
2407
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2408
 
        self.branch._transport.put_bytes('inventory', new_inv_xml,
2409
 
            mode=self.bzrdir._get_file_mode())
 
1796
                    self.branch.control_files.get('inventory'))
 
1797
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
 
1798
        # FIXME inventory is a working tree change.
 
1799
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
2410
1800
 
2411
1801
    def _write_all_weaves(self):
2412
1802
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2432
1822
        self.bzrdir.transport.mkdir('revision-store')
2433
1823
        revision_transport = self.bzrdir.transport.clone('revision-store')
2434
1824
        # TODO permissions
2435
 
        from bzrlib.xml5 import serializer_v5
2436
 
        from bzrlib.repofmt.weaverepo import RevisionTextStore
2437
 
        revision_store = RevisionTextStore(revision_transport,
2438
 
            serializer_v5, False, versionedfile.PrefixMapper(),
2439
 
            lambda:True, lambda:True)
 
1825
        _revision_store = TextRevisionStore(TextStore(revision_transport,
 
1826
                                                      prefixed=False,
 
1827
                                                      compressed=True))
2440
1828
        try:
 
1829
            transaction = WriteTransaction()
2441
1830
            for i, rev_id in enumerate(self.converted_revs):
2442
1831
                self.pb.update('write revision', i, len(self.converted_revs))
2443
 
                text = serializer_v5.write_revision_to_string(
2444
 
                    self.revisions[rev_id])
2445
 
                key = (rev_id,)
2446
 
                revision_store.add_lines(key, None, osutils.split_lines(text))
 
1832
                _revision_store.add_revision(self.revisions[rev_id], transaction)
2447
1833
        finally:
2448
1834
            self.pb.clear()
2449
 
 
 
1835
            
2450
1836
    def _load_one_rev(self, rev_id):
2451
1837
        """Load a revision object into memory.
2452
1838
 
2462
1848
                         rev_id)
2463
1849
            self.absent_revisions.add(rev_id)
2464
1850
        else:
2465
 
            rev = self.branch.repository.get_revision(rev_id)
 
1851
            rev = self.branch.repository._revision_store.get_revision(rev_id,
 
1852
                self.branch.repository.get_transaction())
2466
1853
            for parent_id in rev.parent_ids:
2467
1854
                self.known_revisions.add(parent_id)
2468
1855
                self.to_read.append(parent_id)
2469
1856
            self.revisions[rev_id] = rev
2470
1857
 
2471
1858
    def _load_old_inventory(self, rev_id):
 
1859
        assert rev_id not in self.converted_revs
2472
1860
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2473
1861
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2474
1862
        inv.revision_id = rev_id
2475
1863
        rev = self.revisions[rev_id]
 
1864
        if rev.inventory_sha1:
 
1865
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
 
1866
                'inventory sha mismatch for {%s}' % rev_id
2476
1867
        return inv
2477
1868
 
2478
1869
    def _load_updated_inventory(self, rev_id):
 
1870
        assert rev_id in self.converted_revs
2479
1871
        inv_xml = self.inv_weave.get_text(rev_id)
2480
 
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
 
1872
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
2481
1873
        return inv
2482
1874
 
2483
1875
    def _convert_one_rev(self, rev_id):
2487
1879
        present_parents = [p for p in rev.parent_ids
2488
1880
                           if p not in self.absent_revisions]
2489
1881
        self._convert_revision_contents(rev, inv, present_parents)
2490
 
        self._store_new_inv(rev, inv, present_parents)
 
1882
        self._store_new_weave(rev, inv, present_parents)
2491
1883
        self.converted_revs.add(rev_id)
2492
1884
 
2493
 
    def _store_new_inv(self, rev, inv, present_parents):
 
1885
    def _store_new_weave(self, rev, inv, present_parents):
 
1886
        # the XML is now updated with text versions
 
1887
        if __debug__:
 
1888
            entries = inv.iter_entries()
 
1889
            entries.next()
 
1890
            for path, ie in entries:
 
1891
                assert getattr(ie, 'revision', None) is not None, \
 
1892
                    'no revision on {%s} in {%s}' % \
 
1893
                    (file_id, rev.revision_id)
2494
1894
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2495
1895
        new_inv_sha1 = sha_string(new_inv_xml)
2496
 
        self.inv_weave.add_lines(rev.revision_id,
 
1896
        self.inv_weave.add_lines(rev.revision_id, 
2497
1897
                                 present_parents,
2498
1898
                                 new_inv_xml.splitlines(True))
2499
1899
        rev.inventory_sha1 = new_inv_sha1
2524
1924
            w = Weave(file_id)
2525
1925
            self.text_weaves[file_id] = w
2526
1926
        text_changed = False
2527
 
        parent_candiate_entries = ie.parent_candidates(parent_invs)
2528
 
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2529
 
        # XXX: Note that this is unordered - and this is tolerable because
2530
 
        # the previous code was also unordered.
2531
 
        previous_entries = dict((head, parent_candiate_entries[head]) for head
2532
 
            in heads)
 
1927
        previous_entries = ie.find_previous_heads(parent_invs,
 
1928
                                                  None,
 
1929
                                                  None,
 
1930
                                                  entry_vf=w)
 
1931
        for old_revision in previous_entries:
 
1932
                # if this fails, its a ghost ?
 
1933
                assert old_revision in self.converted_revs, \
 
1934
                    "Revision {%s} not in converted_revs" % old_revision
2533
1935
        self.snapshot_ie(previous_entries, ie, w, rev_id)
2534
1936
        del ie.text_id
2535
 
 
2536
 
    def get_parent_map(self, revision_ids):
2537
 
        """See graph._StackedParentsProvider.get_parent_map"""
2538
 
        return dict((revision_id, self.revisions[revision_id])
2539
 
                    for revision_id in revision_ids
2540
 
                     if revision_id in self.revisions)
 
1937
        assert getattr(ie, 'revision', None) is not None
2541
1938
 
2542
1939
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2543
1940
        # TODO: convert this logic, which is ~= snapshot to
2544
1941
        # a call to:. This needs the path figured out. rather than a work_tree
2545
1942
        # a v4 revision_tree can be given, or something that looks enough like
2546
1943
        # one to give the file content to the entry if it needs it.
2547
 
        # and we need something that looks like a weave store for snapshot to
 
1944
        # and we need something that looks like a weave store for snapshot to 
2548
1945
        # save against.
2549
1946
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2550
1947
        if len(previous_revisions) == 1:
2553
1950
                ie.revision = previous_ie.revision
2554
1951
                return
2555
1952
        if ie.has_text():
2556
 
            text = self.branch.repository._text_store.get(ie.text_id)
 
1953
            text = self.branch.repository.text_store.get(ie.text_id)
2557
1954
            file_lines = text.readlines()
 
1955
            assert sha_strings(file_lines) == ie.text_sha1
 
1956
            assert sum(map(len, file_lines)) == ie.text_size
2558
1957
            w.add_lines(rev_id, previous_revisions, file_lines)
2559
1958
            self.text_count += 1
2560
1959
        else:
2607
2006
                if (filename.endswith(".weave") or
2608
2007
                    filename.endswith(".gz") or
2609
2008
                    filename.endswith(".sig")):
2610
 
                    file_id, suffix = os.path.splitext(filename)
 
2009
                    file_id = os.path.splitext(filename)[0]
2611
2010
                else:
2612
2011
                    file_id = filename
2613
 
                    suffix = ''
2614
 
                new_name = store._mapper.map((file_id,)) + suffix
 
2012
                prefix_dir = store.hash_prefix(file_id)
2615
2013
                # FIXME keep track of the dirs made RBC 20060121
2616
2014
                try:
2617
 
                    store_transport.move(filename, new_name)
 
2015
                    store_transport.move(filename, prefix_dir + '/' + filename)
2618
2016
                except errors.NoSuchFile: # catches missing dirs strangely enough
2619
 
                    store_transport.mkdir(osutils.dirname(new_name))
2620
 
                    store_transport.move(filename, new_name)
2621
 
        self.bzrdir.transport.put_bytes(
2622
 
            'branch-format',
2623
 
            BzrDirFormat6().get_format_string(),
2624
 
            mode=self.bzrdir._get_file_mode())
 
2017
                    store_transport.mkdir(prefix_dir)
 
2018
                    store_transport.move(filename, prefix_dir + '/' + filename)
 
2019
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
2625
2020
 
2626
2021
 
2627
2022
class ConvertBzrDir6ToMeta(Converter):
2636
2031
        self.count = 0
2637
2032
        self.total = 20 # the steps we know about
2638
2033
        self.garbage_inventories = []
2639
 
        self.dir_mode = self.bzrdir._get_dir_mode()
2640
 
        self.file_mode = self.bzrdir._get_file_mode()
2641
2034
 
2642
2035
        self.pb.note('starting upgrade from format 6 to metadir')
2643
 
        self.bzrdir.transport.put_bytes(
2644
 
                'branch-format',
2645
 
                "Converting to format 6",
2646
 
                mode=self.file_mode)
 
2036
        self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
2647
2037
        # its faster to move specific files around than to open and use the apis...
2648
2038
        # first off, nuke ancestry.weave, it was never used.
2649
2039
        try:
2659
2049
            if name.startswith('basis-inventory.'):
2660
2050
                self.garbage_inventories.append(name)
2661
2051
        # create new directories for repository, working tree and branch
 
2052
        self.dir_mode = self.bzrdir._control_files._dir_mode
 
2053
        self.file_mode = self.bzrdir._control_files._file_mode
2662
2054
        repository_names = [('inventory.weave', True),
2663
2055
                            ('revision-store', True),
2664
2056
                            ('weaves', True)]
2666
2058
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2667
2059
        self.make_lock('repository')
2668
2060
        # we hard code the formats here because we are converting into
2669
 
        # the meta format. The meta format upgrader can take this to a
 
2061
        # the meta format. The meta format upgrader can take this to a 
2670
2062
        # future format within each component.
2671
2063
        self.put_format('repository', RepositoryFormat7())
2672
2064
        for entry in repository_names:
2712
2104
            for entry in checkout_files:
2713
2105
                self.move_entry('checkout', entry)
2714
2106
            if last_revision is not None:
2715
 
                self.bzrdir.transport.put_bytes(
 
2107
                self.bzrdir._control_files.put_utf8(
2716
2108
                    'checkout/last-revision', last_revision)
2717
 
        self.bzrdir.transport.put_bytes(
2718
 
            'branch-format',
2719
 
            BzrDirMetaFormat1().get_format_string(),
2720
 
            mode=self.file_mode)
 
2109
        self.bzrdir._control_files.put_utf8(
 
2110
            'branch-format', BzrDirMetaFormat1().get_format_string())
2721
2111
        return BzrDir.open(self.bzrdir.root_transport.base)
2722
2112
 
2723
2113
    def make_lock(self, name):
2741
2131
                raise
2742
2132
 
2743
2133
    def put_format(self, dirname, format):
2744
 
        self.bzrdir.transport.put_bytes('%s/format' % dirname,
2745
 
            format.get_format_string(),
2746
 
            self.file_mode)
 
2134
        self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
2747
2135
 
2748
2136
 
2749
2137
class ConvertMetaToMeta(Converter):
2779
2167
            pass
2780
2168
        else:
2781
2169
            # TODO: conversions of Branch and Tree should be done by
2782
 
            # InterXFormat lookups/some sort of registry.
 
2170
            # InterXFormat lookups
2783
2171
            # Avoid circular imports
2784
2172
            from bzrlib import branch as _mod_branch
2785
 
            old = branch._format.__class__
2786
 
            new = self.target_format.get_branch_format().__class__
2787
 
            while old != new:
2788
 
                if (old == _mod_branch.BzrBranchFormat5 and
2789
 
                    new in (_mod_branch.BzrBranchFormat6,
2790
 
                        _mod_branch.BzrBranchFormat7)):
2791
 
                    branch_converter = _mod_branch.Converter5to6()
2792
 
                elif (old == _mod_branch.BzrBranchFormat6 and
2793
 
                    new == _mod_branch.BzrBranchFormat7):
2794
 
                    branch_converter = _mod_branch.Converter6to7()
2795
 
                else:
2796
 
                    raise errors.BadConversionTarget("No converter", new)
 
2173
            if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
 
2174
                self.target_format.get_branch_format().__class__ is
 
2175
                _mod_branch.BzrBranchFormat6):
 
2176
                branch_converter = _mod_branch.Converter5to6()
2797
2177
                branch_converter.convert(branch)
2798
 
                branch = self.bzrdir.open_branch()
2799
 
                old = branch._format.__class__
2800
2178
        try:
2801
2179
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2802
2180
        except (errors.NoWorkingTree, errors.NotLocalUrl):
2805
2183
            # TODO: conversions of Branch and Tree should be done by
2806
2184
            # InterXFormat lookups
2807
2185
            if (isinstance(tree, workingtree.WorkingTree3) and
2808
 
                not isinstance(tree, workingtree_4.DirStateWorkingTree) and
 
2186
                not isinstance(tree, workingtree_4.WorkingTree4) and
2809
2187
                isinstance(self.target_format.workingtree_format,
2810
 
                    workingtree_4.DirStateWorkingTreeFormat)):
 
2188
                    workingtree_4.WorkingTreeFormat4)):
2811
2189
                workingtree_4.Converter3to4().convert(tree)
2812
 
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2813
 
                not isinstance(tree, workingtree_4.WorkingTree5) and
2814
 
                isinstance(self.target_format.workingtree_format,
2815
 
                    workingtree_4.WorkingTreeFormat5)):
2816
 
                workingtree_4.Converter4to5().convert(tree)
2817
 
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2818
 
                not isinstance(tree, workingtree_4.WorkingTree6) and
2819
 
                isinstance(self.target_format.workingtree_format,
2820
 
                    workingtree_4.WorkingTreeFormat6)):
2821
 
                workingtree_4.Converter4or5to6().convert(tree)
2822
2190
        return to_convert
2823
2191
 
2824
2192
 
2829
2197
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2830
2198
    """Format representing bzrdirs accessed via a smart server"""
2831
2199
 
2832
 
    def __init__(self):
2833
 
        BzrDirMetaFormat1.__init__(self)
2834
 
        self._network_name = None
2835
 
 
2836
2200
    def get_format_description(self):
2837
2201
        return 'bzr remote bzrdir'
2838
 
 
2839
 
    def get_format_string(self):
2840
 
        raise NotImplementedError(self.get_format_string)
2841
 
 
2842
 
    def network_name(self):
2843
 
        if self._network_name:
2844
 
            return self._network_name
2845
 
        else:
2846
 
            raise AssertionError("No network name set.")
2847
 
 
 
2202
    
2848
2203
    @classmethod
2849
2204
    def probe_transport(klass, transport):
2850
2205
        """Return a RemoteBzrDirFormat object if it looks possible."""
2851
2206
        try:
2852
 
            medium = transport.get_smart_medium()
 
2207
            client = transport.get_smart_client()
2853
2208
        except (NotImplementedError, AttributeError,
2854
 
                errors.TransportNotPossible, errors.NoSmartMedium,
2855
 
                errors.SmartProtocolError):
 
2209
                errors.TransportNotPossible):
2856
2210
            # no smart server, so not a branch for this format type.
2857
2211
            raise errors.NotBranchError(path=transport.base)
2858
2212
        else:
2859
 
            # Decline to open it if the server doesn't support our required
2860
 
            # version (3) so that the VFS-based transport will do it.
2861
 
            if medium.should_probe():
2862
 
                try:
2863
 
                    server_version = medium.protocol_version()
2864
 
                except errors.SmartProtocolError:
2865
 
                    # Apparently there's no usable smart server there, even though
2866
 
                    # the medium supports the smart protocol.
2867
 
                    raise errors.NotBranchError(path=transport.base)
2868
 
                if server_version != '2':
2869
 
                    raise errors.NotBranchError(path=transport.base)
 
2213
            # Send a 'hello' request in protocol version one, and decline to
 
2214
            # open it if the server doesn't support our required version (2) so
 
2215
            # that the VFS-based transport will do it.
 
2216
            request = client.get_request()
 
2217
            smart_protocol = protocol.SmartClientRequestProtocolOne(request)
 
2218
            server_version = smart_protocol.query_version()
 
2219
            if server_version != 2:
 
2220
                raise errors.NotBranchError(path=transport.base)
2870
2221
            return klass()
2871
2222
 
2872
2223
    def initialize_on_transport(self, transport):
2873
2224
        try:
2874
2225
            # hand off the request to the smart server
2875
 
            client_medium = transport.get_smart_medium()
 
2226
            shared_medium = transport.get_shared_medium()
2876
2227
        except errors.NoSmartMedium:
2877
2228
            # TODO: lookup the local format from a server hint.
2878
2229
            local_dir_format = BzrDirMetaFormat1()
2879
2230
            return local_dir_format.initialize_on_transport(transport)
2880
 
        client = _SmartClient(client_medium)
 
2231
        client = _SmartClient(shared_medium)
2881
2232
        path = client.remote_path_from_transport(transport)
2882
 
        response = client.call('BzrDirFormat.initialize', path)
2883
 
        if response[0] != 'ok':
2884
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2885
 
        format = RemoteBzrDirFormat()
2886
 
        self._supply_sub_formats_to(format)
2887
 
        return remote.RemoteBzrDir(transport, format)
 
2233
        response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
 
2234
                                                    path)
 
2235
        assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
 
2236
        return remote.RemoteBzrDir(transport)
2888
2237
 
2889
2238
    def _open(self, transport):
2890
 
        return remote.RemoteBzrDir(transport, self)
 
2239
        return remote.RemoteBzrDir(transport)
2891
2240
 
2892
2241
    def __eq__(self, other):
2893
2242
        if not isinstance(other, RemoteBzrDirFormat):
2894
2243
            return False
2895
2244
        return self.get_format_description() == other.get_format_description()
2896
2245
 
2897
 
    def __return_repository_format(self):
2898
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
2899
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
2900
 
        # that it should use that for init() etc.
2901
 
        result = remote.RemoteRepositoryFormat()
2902
 
        custom_format = getattr(self, '_repository_format', None)
2903
 
        if custom_format:
2904
 
            if isinstance(custom_format, remote.RemoteRepositoryFormat):
2905
 
                return custom_format
2906
 
            else:
2907
 
                # We will use the custom format to create repositories over the
2908
 
                # wire; expose its details like rich_root_data for code to
2909
 
                # query
2910
 
                result._custom_format = custom_format
2911
 
        return result
2912
 
 
2913
 
    def get_branch_format(self):
2914
 
        result = BzrDirMetaFormat1.get_branch_format(self)
2915
 
        if not isinstance(result, remote.RemoteBranchFormat):
2916
 
            new_result = remote.RemoteBranchFormat()
2917
 
            new_result._custom_format = result
2918
 
            # cache the result
2919
 
            self.set_branch_format(new_result)
2920
 
            result = new_result
2921
 
        return result
2922
 
 
2923
 
    repository_format = property(__return_repository_format,
2924
 
        BzrDirMetaFormat1._set_repository_format) #.im_func)
2925
 
 
2926
2246
 
2927
2247
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2928
2248
 
2929
2249
 
2930
2250
class BzrDirFormatInfo(object):
2931
2251
 
2932
 
    def __init__(self, native, deprecated, hidden, experimental):
 
2252
    def __init__(self, native, deprecated, hidden):
2933
2253
        self.deprecated = deprecated
2934
2254
        self.native = native
2935
2255
        self.hidden = hidden
2936
 
        self.experimental = experimental
2937
2256
 
2938
2257
 
2939
2258
class BzrDirFormatRegistry(registry.Registry):
2940
2259
    """Registry of user-selectable BzrDir subformats.
2941
 
 
 
2260
    
2942
2261
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2943
2262
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
2944
2263
    """
2945
2264
 
2946
 
    def __init__(self):
2947
 
        """Create a BzrDirFormatRegistry."""
2948
 
        self._aliases = set()
2949
 
        self._registration_order = list()
2950
 
        super(BzrDirFormatRegistry, self).__init__()
2951
 
 
2952
 
    def aliases(self):
2953
 
        """Return a set of the format names which are aliases."""
2954
 
        return frozenset(self._aliases)
2955
 
 
2956
2265
    def register_metadir(self, key,
2957
2266
             repository_format, help, native=True, deprecated=False,
2958
2267
             branch_format=None,
2959
2268
             tree_format=None,
2960
 
             hidden=False,
2961
 
             experimental=False,
2962
 
             alias=False):
 
2269
             hidden=False):
2963
2270
        """Register a metadir subformat.
2964
2271
 
2965
2272
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2966
 
        by the Repository/Branch/WorkingTreeformats.
 
2273
        by the Repository format.
2967
2274
 
2968
2275
        :param repository_format: The fully-qualified repository format class
2969
2276
            name as a string.
2997
2304
            if repository_format is not None:
2998
2305
                bd.repository_format = _load(repository_format)
2999
2306
            return bd
3000
 
        self.register(key, helper, help, native, deprecated, hidden,
3001
 
            experimental, alias)
 
2307
        self.register(key, helper, help, native, deprecated, hidden)
3002
2308
 
3003
2309
    def register(self, key, factory, help, native=True, deprecated=False,
3004
 
                 hidden=False, experimental=False, alias=False):
 
2310
                 hidden=False):
3005
2311
        """Register a BzrDirFormat factory.
3006
 
 
 
2312
        
3007
2313
        The factory must be a callable that takes one parameter: the key.
3008
2314
        It must produce an instance of the BzrDirFormat when called.
3009
2315
 
3010
2316
        This function mainly exists to prevent the info object from being
3011
2317
        supplied directly.
3012
2318
        """
3013
 
        registry.Registry.register(self, key, factory, help,
3014
 
            BzrDirFormatInfo(native, deprecated, hidden, experimental))
3015
 
        if alias:
3016
 
            self._aliases.add(key)
3017
 
        self._registration_order.append(key)
 
2319
        registry.Registry.register(self, key, factory, help, 
 
2320
            BzrDirFormatInfo(native, deprecated, hidden))
3018
2321
 
3019
2322
    def register_lazy(self, key, module_name, member_name, help, native=True,
3020
 
        deprecated=False, hidden=False, experimental=False, alias=False):
3021
 
        registry.Registry.register_lazy(self, key, module_name, member_name,
3022
 
            help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3023
 
        if alias:
3024
 
            self._aliases.add(key)
3025
 
        self._registration_order.append(key)
 
2323
                      deprecated=False, hidden=False):
 
2324
        registry.Registry.register_lazy(self, key, module_name, member_name, 
 
2325
            help, BzrDirFormatInfo(native, deprecated, hidden))
3026
2326
 
3027
2327
    def set_default(self, key):
3028
2328
        """Set the 'default' key to be a clone of the supplied key.
3029
 
 
 
2329
        
3030
2330
        This method must be called once and only once.
3031
2331
        """
3032
 
        registry.Registry.register(self, 'default', self.get(key),
 
2332
        registry.Registry.register(self, 'default', self.get(key), 
3033
2333
            self.get_help(key), info=self.get_info(key))
3034
 
        self._aliases.add('default')
3035
2334
 
3036
2335
    def set_default_repository(self, key):
3037
2336
        """Set the FormatRegistry default and Repository default.
3038
 
 
 
2337
        
3039
2338
        This is a transitional method while Repository.set_default_format
3040
2339
        is deprecated.
3041
2340
        """
3043
2342
            self.remove('default')
3044
2343
        self.set_default(key)
3045
2344
        format = self.get('default')()
 
2345
        assert isinstance(format, BzrDirMetaFormat1)
3046
2346
 
3047
2347
    def make_bzrdir(self, key):
3048
2348
        return self.get(key)()
3049
2349
 
3050
2350
    def help_topic(self, topic):
3051
 
        output = ""
3052
 
        default_realkey = None
 
2351
        output = textwrap.dedent("""\
 
2352
            Bazaar directory formats
 
2353
            ------------------------
 
2354
 
 
2355
            These formats can be used for creating branches, working trees, and
 
2356
            repositories.
 
2357
 
 
2358
            """)
3053
2359
        default_help = self.get_help('default')
3054
2360
        help_pairs = []
3055
 
        for key in self._registration_order:
 
2361
        for key in self.keys():
3056
2362
            if key == 'default':
3057
2363
                continue
3058
2364
            help = self.get_help(key)
3064
2370
        def wrapped(key, help, info):
3065
2371
            if info.native:
3066
2372
                help = '(native) ' + help
3067
 
            return ':%s:\n%s\n\n' % (key,
3068
 
                    textwrap.fill(help, initial_indent='    ',
 
2373
            return '  %s:\n%s\n\n' % (key, 
 
2374
                    textwrap.fill(help, initial_indent='    ', 
3069
2375
                    subsequent_indent='    '))
3070
 
        if default_realkey is not None:
3071
 
            output += wrapped(default_realkey, '(default) %s' % default_help,
3072
 
                              self.get_info('default'))
 
2376
        output += wrapped('%s/default' % default_realkey, default_help,
 
2377
                          self.get_info('default'))
3073
2378
        deprecated_pairs = []
3074
 
        experimental_pairs = []
3075
2379
        for key, help in help_pairs:
3076
2380
            info = self.get_info(key)
3077
2381
            if info.hidden:
3078
2382
                continue
3079
2383
            elif info.deprecated:
3080
2384
                deprecated_pairs.append((key, help))
3081
 
            elif info.experimental:
3082
 
                experimental_pairs.append((key, help))
3083
2385
            else:
3084
2386
                output += wrapped(key, help, info)
3085
 
        output += "\nSee ``bzr help formats`` for more about storage formats."
3086
 
        other_output = ""
3087
 
        if len(experimental_pairs) > 0:
3088
 
            other_output += "Experimental formats are shown below.\n\n"
3089
 
            for key, help in experimental_pairs:
3090
 
                info = self.get_info(key)
3091
 
                other_output += wrapped(key, help, info)
3092
 
        else:
3093
 
            other_output += \
3094
 
                "No experimental formats are available.\n\n"
3095
2387
        if len(deprecated_pairs) > 0:
3096
 
            other_output += "\nDeprecated formats are shown below.\n\n"
 
2388
            output += "Deprecated formats\n------------------\n\n"
3097
2389
            for key, help in deprecated_pairs:
3098
2390
                info = self.get_info(key)
3099
 
                other_output += wrapped(key, help, info)
3100
 
        else:
3101
 
            other_output += \
3102
 
                "\nNo deprecated formats are available.\n\n"
3103
 
        other_output += \
3104
 
            "\nSee ``bzr help formats`` for more about storage formats."
3105
 
 
3106
 
        if topic == 'other-formats':
3107
 
            return other_output
3108
 
        else:
3109
 
            return output
3110
 
 
3111
 
 
3112
 
class RepositoryAcquisitionPolicy(object):
3113
 
    """Abstract base class for repository acquisition policies.
3114
 
 
3115
 
    A repository acquisition policy decides how a BzrDir acquires a repository
3116
 
    for a branch that is being created.  The most basic policy decision is
3117
 
    whether to create a new repository or use an existing one.
3118
 
    """
3119
 
    def __init__(self, stack_on, stack_on_pwd, require_stacking):
3120
 
        """Constructor.
3121
 
 
3122
 
        :param stack_on: A location to stack on
3123
 
        :param stack_on_pwd: If stack_on is relative, the location it is
3124
 
            relative to.
3125
 
        :param require_stacking: If True, it is a failure to not stack.
3126
 
        """
3127
 
        self._stack_on = stack_on
3128
 
        self._stack_on_pwd = stack_on_pwd
3129
 
        self._require_stacking = require_stacking
3130
 
 
3131
 
    def configure_branch(self, branch):
3132
 
        """Apply any configuration data from this policy to the branch.
3133
 
 
3134
 
        Default implementation sets repository stacking.
3135
 
        """
3136
 
        if self._stack_on is None:
3137
 
            return
3138
 
        if self._stack_on_pwd is None:
3139
 
            stack_on = self._stack_on
3140
 
        else:
3141
 
            try:
3142
 
                stack_on = urlutils.rebase_url(self._stack_on,
3143
 
                    self._stack_on_pwd,
3144
 
                    branch.bzrdir.root_transport.base)
3145
 
            except errors.InvalidRebaseURLs:
3146
 
                stack_on = self._get_full_stack_on()
3147
 
        try:
3148
 
            branch.set_stacked_on_url(stack_on)
3149
 
        except (errors.UnstackableBranchFormat,
3150
 
                errors.UnstackableRepositoryFormat):
3151
 
            if self._require_stacking:
3152
 
                raise
3153
 
 
3154
 
    def _get_full_stack_on(self):
3155
 
        """Get a fully-qualified URL for the stack_on location."""
3156
 
        if self._stack_on is None:
3157
 
            return None
3158
 
        if self._stack_on_pwd is None:
3159
 
            return self._stack_on
3160
 
        else:
3161
 
            return urlutils.join(self._stack_on_pwd, self._stack_on)
3162
 
 
3163
 
    def _add_fallback(self, repository, possible_transports=None):
3164
 
        """Add a fallback to the supplied repository, if stacking is set."""
3165
 
        stack_on = self._get_full_stack_on()
3166
 
        if stack_on is None:
3167
 
            return
3168
 
        stacked_dir = BzrDir.open(stack_on,
3169
 
                                  possible_transports=possible_transports)
3170
 
        try:
3171
 
            stacked_repo = stacked_dir.open_branch().repository
3172
 
        except errors.NotBranchError:
3173
 
            stacked_repo = stacked_dir.open_repository()
3174
 
        try:
3175
 
            repository.add_fallback_repository(stacked_repo)
3176
 
        except errors.UnstackableRepositoryFormat:
3177
 
            if self._require_stacking:
3178
 
                raise
3179
 
        else:
3180
 
            self._require_stacking = True
3181
 
 
3182
 
    def acquire_repository(self, make_working_trees=None, shared=False):
3183
 
        """Acquire a repository for this bzrdir.
3184
 
 
3185
 
        Implementations may create a new repository or use a pre-exising
3186
 
        repository.
3187
 
        :param make_working_trees: If creating a repository, set
3188
 
            make_working_trees to this value (if non-None)
3189
 
        :param shared: If creating a repository, make it shared if True
3190
 
        :return: A repository, is_new_flag (True if the repository was
3191
 
            created).
3192
 
        """
3193
 
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
3194
 
 
3195
 
 
3196
 
class CreateRepository(RepositoryAcquisitionPolicy):
3197
 
    """A policy of creating a new repository"""
3198
 
 
3199
 
    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
3200
 
                 require_stacking=False):
3201
 
        """
3202
 
        Constructor.
3203
 
        :param bzrdir: The bzrdir to create the repository on.
3204
 
        :param stack_on: A location to stack on
3205
 
        :param stack_on_pwd: If stack_on is relative, the location it is
3206
 
            relative to.
3207
 
        """
3208
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3209
 
                                             require_stacking)
3210
 
        self._bzrdir = bzrdir
3211
 
 
3212
 
    def acquire_repository(self, make_working_trees=None, shared=False):
3213
 
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
3214
 
 
3215
 
        Creates the desired repository in the bzrdir we already have.
3216
 
        """
3217
 
        stack_on = self._get_full_stack_on()
3218
 
        if stack_on:
3219
 
            # Stacking is desired. requested by the target, but does the place it
3220
 
            # points at support stacking? If it doesn't then we should
3221
 
            # not implicitly upgrade. We check this here.
3222
 
            format = self._bzrdir._format
3223
 
            if not (format.repository_format.supports_external_lookups
3224
 
                and format.get_branch_format().supports_stacking()):
3225
 
                # May need to upgrade - but only do if the target also
3226
 
                # supports stacking. Note that this currently wastes
3227
 
                # network round trips to check - but we only do this
3228
 
                # when the source can't stack so it will fade away
3229
 
                # as people do upgrade.
3230
 
                try:
3231
 
                    target_dir = BzrDir.open(stack_on,
3232
 
                        possible_transports=[self._bzrdir.root_transport])
3233
 
                except errors.NotBranchError:
3234
 
                    # Nothing there, don't change formats
3235
 
                    pass
3236
 
                else:
3237
 
                    try:
3238
 
                        target_branch = target_dir.open_branch()
3239
 
                    except errors.NotBranchError:
3240
 
                        # No branch, don't change formats
3241
 
                        pass
3242
 
                    else:
3243
 
                        branch_format = target_branch._format
3244
 
                        repo_format = target_branch.repository._format
3245
 
                        if not (branch_format.supports_stacking()
3246
 
                            and repo_format.supports_external_lookups):
3247
 
                            # Doesn't stack itself, don't force an upgrade
3248
 
                            pass
3249
 
                        else:
3250
 
                            # Does support stacking, use its format.
3251
 
                            format.repository_format = repo_format
3252
 
                            format.set_branch_format(branch_format)
3253
 
                            note('Source format does not support stacking, '
3254
 
                                'using format: \'%s\'\n  %s\n',
3255
 
                                branch_format.get_format_description(),
3256
 
                                repo_format.get_format_description())
3257
 
            if not self._require_stacking:
3258
 
                # We have picked up automatic stacking somewhere.
3259
 
                note('Using default stacking branch %s at %s', self._stack_on,
3260
 
                    self._stack_on_pwd)
3261
 
        repository = self._bzrdir.create_repository(shared=shared)
3262
 
        self._add_fallback(repository,
3263
 
                           possible_transports=[self._bzrdir.transport])
3264
 
        if make_working_trees is not None:
3265
 
            repository.set_make_working_trees(make_working_trees)
3266
 
        return repository, True
3267
 
 
3268
 
 
3269
 
class UseExistingRepository(RepositoryAcquisitionPolicy):
3270
 
    """A policy of reusing an existing repository"""
3271
 
 
3272
 
    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
3273
 
                 require_stacking=False):
3274
 
        """Constructor.
3275
 
 
3276
 
        :param repository: The repository to use.
3277
 
        :param stack_on: A location to stack on
3278
 
        :param stack_on_pwd: If stack_on is relative, the location it is
3279
 
            relative to.
3280
 
        """
3281
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3282
 
                                             require_stacking)
3283
 
        self._repository = repository
3284
 
 
3285
 
    def acquire_repository(self, make_working_trees=None, shared=False):
3286
 
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
3287
 
 
3288
 
        Returns an existing repository to use.
3289
 
        """
3290
 
        self._add_fallback(self._repository,
3291
 
                       possible_transports=[self._repository.bzrdir.transport])
3292
 
        return self._repository, False
3293
 
 
3294
 
 
3295
 
# Please register new formats after old formats so that formats
3296
 
# appear in chronological order and format descriptions can build
3297
 
# on previous ones.
 
2391
                output += wrapped(key, help, info)
 
2392
 
 
2393
        return output
 
2394
 
 
2395
 
3298
2396
format_registry = BzrDirFormatRegistry()
3299
 
# The pre-0.8 formats have their repository format network name registered in
3300
 
# repository.py. MetaDir formats have their repository format network name
3301
 
# inferred from their disk format string.
3302
2397
format_registry.register('weave', BzrDirFormat6,
3303
2398
    'Pre-0.8 format.  Slower than knit and does not'
3304
2399
    ' support checkouts or shared repositories.',
3305
2400
    deprecated=True)
 
2401
format_registry.register_metadir('knit',
 
2402
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2403
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
 
2404
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
2405
    tree_format='bzrlib.workingtree.WorkingTreeFormat3')
3306
2406
format_registry.register_metadir('metaweave',
3307
2407
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3308
2408
    'Transitional format in 0.8.  Slower than knit.',
3309
2409
    branch_format='bzrlib.branch.BzrBranchFormat5',
3310
2410
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3311
2411
    deprecated=True)
3312
 
format_registry.register_metadir('knit',
3313
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3314
 
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
3315
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
3316
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3317
 
    deprecated=True)
3318
2412
format_registry.register_metadir('dirstate',
3319
2413
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3320
2414
    help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3323
2417
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3324
2418
    # directly from workingtree_4 triggers a circular import.
3325
2419
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3326
 
    deprecated=True)
 
2420
    )
3327
2421
format_registry.register_metadir('dirstate-tags',
3328
2422
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3329
2423
    help='New in 0.15: Fast local operations and improved scaling for '
3331
2425
        ' Incompatible with bzr < 0.15.',
3332
2426
    branch_format='bzrlib.branch.BzrBranchFormat6',
3333
2427
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3334
 
    deprecated=True)
3335
 
format_registry.register_metadir('rich-root',
3336
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3337
 
    help='New in 1.0.  Better handling of tree roots.  Incompatible with'
3338
 
        ' bzr < 1.0.',
3339
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3340
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3341
 
    deprecated=True)
 
2428
    )
3342
2429
format_registry.register_metadir('dirstate-with-subtree',
3343
2430
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3344
2431
    help='New in 0.15: Fast local operations and improved scaling for '
3346
2433
        'bzr branches. Incompatible with bzr < 0.15.',
3347
2434
    branch_format='bzrlib.branch.BzrBranchFormat6',
3348
2435
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3349
 
    experimental=True,
3350
 
    hidden=True,
3351
 
    )
3352
 
format_registry.register_metadir('pack-0.92',
3353
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3354
 
    help='New in 0.92: Pack-based format with data compatible with '
3355
 
        'dirstate-tags format repositories. Interoperates with '
3356
 
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3357
 
        'Previously called knitpack-experimental.  '
3358
 
        'For more information, see '
3359
 
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3360
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3361
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3362
 
    )
3363
 
format_registry.register_metadir('pack-0.92-subtree',
3364
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3365
 
    help='New in 0.92: Pack-based format with data compatible with '
3366
 
        'dirstate-with-subtree format repositories. Interoperates with '
3367
 
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3368
 
        'Previously called knitpack-experimental.  '
3369
 
        'For more information, see '
3370
 
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3371
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3372
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3373
 
    hidden=True,
3374
 
    experimental=True,
3375
 
    )
3376
 
format_registry.register_metadir('rich-root-pack',
3377
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3378
 
    help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3379
 
         '(needed for bzr-svn and bzr-git).',
3380
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3381
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3382
 
    )
3383
 
format_registry.register_metadir('1.6',
3384
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3385
 
    help='A format that allows a branch to indicate that there is another '
3386
 
         '(stacked) repository that should be used to access data that is '
3387
 
         'not present locally.',
3388
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3389
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3390
 
    )
3391
 
format_registry.register_metadir('1.6.1-rich-root',
3392
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3393
 
    help='A variant of 1.6 that supports rich-root data '
3394
 
         '(needed for bzr-svn and bzr-git).',
3395
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3396
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3397
 
    )
3398
 
format_registry.register_metadir('1.9',
3399
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3400
 
    help='A repository format using B+tree indexes. These indexes '
3401
 
         'are smaller in size, have smarter caching and provide faster '
3402
 
         'performance for most operations.',
3403
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3404
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3405
 
    )
3406
 
format_registry.register_metadir('1.9-rich-root',
3407
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3408
 
    help='A variant of 1.9 that supports rich-root data '
3409
 
         '(needed for bzr-svn and bzr-git).',
3410
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3411
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3412
 
    )
3413
 
format_registry.register_metadir('1.14',
3414
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3415
 
    help='A working-tree format that supports content filtering.',
3416
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3417
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3418
 
    )
3419
 
format_registry.register_metadir('1.14-rich-root',
3420
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3421
 
    help='A variant of 1.14 that supports rich-root data '
3422
 
         '(needed for bzr-svn and bzr-git).',
3423
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3424
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3425
 
    )
3426
 
# The following two formats should always just be aliases.
3427
 
format_registry.register_metadir('development',
3428
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3429
 
    help='Current development format. Can convert data to and from pack-0.92 '
3430
 
        '(and anything compatible with pack-0.92) format repositories. '
3431
 
        'Repositories and branches in this format can only be read by bzr.dev. '
3432
 
        'Please read '
3433
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3434
 
        'before use.',
3435
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3436
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3437
 
    experimental=True,
3438
 
    alias=True,
3439
 
    )
3440
 
format_registry.register_metadir('development-subtree',
3441
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3442
 
    help='Current development format, subtree variant. Can convert data to and '
3443
 
        'from pack-0.92-subtree (and anything compatible with '
3444
 
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3445
 
        'this format can only be read by bzr.dev. Please read '
3446
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3447
 
        'before use.',
3448
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3449
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3450
 
    experimental=True,
3451
 
    alias=True,
3452
 
    )
3453
 
# And the development formats above will have aliased one of the following:
3454
 
format_registry.register_metadir('development2',
3455
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3456
 
    help='1.6.1 with B+Tree based index. '
3457
 
        'Please read '
3458
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3459
 
        'before use.',
3460
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3461
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3462
 
    hidden=True,
3463
 
    experimental=True,
3464
 
    )
3465
 
format_registry.register_metadir('development2-subtree',
3466
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3467
 
    help='1.6.1-subtree with B+Tree based index. '
3468
 
        'Please read '
3469
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3470
 
        'before use.',
3471
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3472
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3473
 
    hidden=True,
3474
 
    experimental=True,
3475
 
    )
3476
 
# These next two formats should be removed when the gc formats are
3477
 
# updated to use WorkingTreeFormat6 and are merged into bzr.dev
3478
 
format_registry.register_metadir('development-wt6',
3479
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3480
 
    help='1.14 with filtered views. '
3481
 
        'Please read '
3482
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3483
 
        'before use.',
3484
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3485
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3486
 
    hidden=True,
3487
 
    experimental=True,
3488
 
    )
3489
 
format_registry.register_metadir('development-wt6-rich-root',
3490
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3491
 
    help='A variant of development-wt6 that supports rich-root data '
3492
 
         '(needed for bzr-svn and bzr-git).',
3493
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3494
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3495
 
    hidden=True,
3496
 
    experimental=True,
3497
 
    )
3498
 
# The following format should be an alias for the rich root equivalent 
3499
 
# of the default format
3500
 
format_registry.register_metadir('default-rich-root',
3501
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3502
 
    help='Default format, rich root variant. (needed for bzr-svn and bzr-git).',
3503
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3504
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3505
 
    alias=True,
3506
 
    )
3507
 
# The current format that is made on 'bzr init'.
3508
 
format_registry.set_default('pack-0.92')
 
2436
    hidden=True,
 
2437
    )
 
2438
format_registry.set_default('dirstate')