← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Ian Clatworthy
  • Date: 2008-03-27 07:51:10 UTC
  • mto: (3311.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3312.
  • Revision ID: ian.clatworthy@canonical.com-20080327075110-afgd7x03ybju06ez
Reduce evangelism in the User Guide

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 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
27
27
 
28
28
# TODO: Move old formats into a plugin to make this file smaller.
29
29
 
 
30
from cStringIO import StringIO
30
31
import os
31
32
import sys
32
33
 
34
35
lazy_import(globals(), """
35
36
from stat import S_ISDIR
36
37
import textwrap
 
38
from warnings import warn
37
39
 
38
40
import bzrlib
39
41
from bzrlib import (
40
 
    config,
41
42
    errors,
42
43
    graph,
43
44
    lockable_files,
44
45
    lockdir,
45
 
    osutils,
 
46
    registry,
46
47
    remote,
47
48
    revision as _mod_revision,
 
49
    symbol_versioning,
48
50
    ui,
49
51
    urlutils,
50
 
    versionedfile,
51
52
    win32utils,
52
53
    workingtree,
53
54
    workingtree_4,
55
56
    xml5,
56
57
    )
57
58
from bzrlib.osutils import (
 
59
    sha_strings,
58
60
    sha_string,
59
61
    )
60
62
from bzrlib.smart.client import _SmartClient
 
63
from bzrlib.smart import protocol
 
64
from bzrlib.store.revision.text import TextRevisionStore
 
65
from bzrlib.store.text import TextStore
61
66
from bzrlib.store.versioned import WeaveStore
62
67
from bzrlib.transactions import WriteTransaction
63
68
from bzrlib.transport import (
64
69
    do_catching_redirections,
65
70
    get_transport,
66
 
    local,
67
71
    )
68
72
from bzrlib.weave import Weave
69
73
""")
72
76
    mutter,
73
77
    note,
74
78
    )
75
 
 
76
 
from bzrlib import (
77
 
    registry,
78
 
    symbol_versioning,
 
79
from bzrlib.transport.local import LocalTransport
 
80
from bzrlib.symbol_versioning import (
 
81
    deprecated_function,
 
82
    deprecated_method,
 
83
    zero_ninetyone,
79
84
    )
80
85
 
81
86
 
85
90
    BzrDir instances let you create or open any of the things that can be
86
91
    found within .bzr - checkouts, branches and repositories.
87
92
    
88
 
    :ivar transport:
 
93
    transport
89
94
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
90
 
    :ivar root_transport:
 
95
    root_transport
91
96
        a transport connected to the directory this bzr was opened from
92
97
        (i.e. the parent directory holding the .bzr directory).
93
 
 
94
 
    Everything in the bzrdir should have the same file permissions.
95
98
    """
96
99
 
97
100
    def break_lock(self):
151
154
                format.get_format_description(),
152
155
                basedir)
153
156
 
154
 
    def clone(self, url, revision_id=None, force_new_repo=False,
155
 
              preserve_stacking=False):
 
157
    def clone(self, url, revision_id=None, force_new_repo=False):
156
158
        """Clone this bzrdir and its contents to url verbatim.
157
159
 
158
 
        :param url: The url create the clone at.  If url's last component does
159
 
            not exist, it will be created.
160
 
        :param revision_id: The tip revision-id to use for any branch or
161
 
            working tree.  If not None, then the clone operation may tune
 
160
        If url's last component does not exist, it will be created.
 
161
 
 
162
        if revision_id is not None, then the clone operation may tune
162
163
            itself to download less data.
163
 
        :param force_new_repo: Do not use a shared repository for the target
 
164
        :param force_new_repo: Do not use a shared repository for the target 
164
165
                               even if one is available.
165
 
        :param preserve_stacking: When cloning a stacked branch, stack the
166
 
            new branch on top of the other branch's stacked-on branch.
167
166
        """
168
167
        return self.clone_on_transport(get_transport(url),
169
168
                                       revision_id=revision_id,
170
 
                                       force_new_repo=force_new_repo,
171
 
                                       preserve_stacking=preserve_stacking)
 
169
                                       force_new_repo=force_new_repo)
172
170
 
173
171
    def clone_on_transport(self, transport, revision_id=None,
174
 
                           force_new_repo=False, preserve_stacking=False,
175
 
                           stacked_on=None):
 
172
                           force_new_repo=False):
176
173
        """Clone this bzrdir and its contents to transport verbatim.
177
174
 
178
 
        :param transport: The transport for the location to produce the clone
179
 
            at.  If the target directory does not exist, it will be created.
180
 
        :param revision_id: The tip revision-id to use for any branch or
181
 
            working tree.  If not None, then the clone operation may tune
 
175
        If the target directory does not exist, it will be created.
 
176
 
 
177
        if revision_id is not None, then the clone operation may tune
182
178
            itself to download less data.
183
 
        :param force_new_repo: Do not use a shared repository for the target,
 
179
        :param force_new_repo: Do not use a shared repository for the target 
184
180
                               even if one is available.
185
 
        :param preserve_stacking: When cloning a stacked branch, stack the
186
 
            new branch on top of the other branch's stacked-on branch.
187
181
        """
188
182
        transport.ensure_base()
189
 
        require_stacking = (stacked_on is not None)
190
 
        metadir = self.cloning_metadir(require_stacking)
191
 
        result = metadir.initialize_on_transport(transport)
192
 
        repository_policy = None
 
183
        result = self._format.initialize_on_transport(transport)
193
184
        try:
194
185
            local_repo = self.find_repository()
195
186
        except errors.NoRepositoryPresent:
196
187
            local_repo = None
197
 
        try:
198
 
            local_branch = self.open_branch()
199
 
        except errors.NotBranchError:
200
 
            local_branch = None
201
 
        else:
202
 
            # enable fallbacks when branch is not a branch reference
203
 
            if local_branch.repository.has_same_location(local_repo):
204
 
                local_repo = local_branch.repository
205
 
            if preserve_stacking:
206
 
                try:
207
 
                    stacked_on = local_branch.get_stacked_on_url()
208
 
                except (errors.UnstackableBranchFormat,
209
 
                        errors.UnstackableRepositoryFormat,
210
 
                        errors.NotStacked):
211
 
                    pass
212
 
 
213
188
        if local_repo:
214
189
            # may need to copy content in
215
 
            repository_policy = result.determine_repository_policy(
216
 
                force_new_repo, stacked_on, self.root_transport.base,
217
 
                require_stacking=require_stacking)
218
 
            make_working_trees = local_repo.make_working_trees()
219
 
            result_repo = repository_policy.acquire_repository(
220
 
                make_working_trees, local_repo.is_shared())
221
 
            result_repo.fetch(local_repo, revision_id=revision_id)
222
 
        else:
223
 
            result_repo = None
 
190
            if force_new_repo:
 
191
                result_repo = local_repo.clone(
 
192
                    result,
 
193
                    revision_id=revision_id)
 
194
                result_repo.set_make_working_trees(local_repo.make_working_trees())
 
195
            else:
 
196
                try:
 
197
                    result_repo = result.find_repository()
 
198
                    # fetch content this dir needs.
 
199
                    result_repo.fetch(local_repo, revision_id=revision_id)
 
200
                except errors.NoRepositoryPresent:
 
201
                    # needed to make one anyway.
 
202
                    result_repo = local_repo.clone(
 
203
                        result,
 
204
                        revision_id=revision_id)
 
205
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
224
206
        # 1 if there is a branch present
225
207
        #   make sure its content is available in the target repository
226
208
        #   clone it.
227
 
        if local_branch is not None:
228
 
            result_branch = local_branch.clone(result, revision_id=revision_id)
229
 
            if repository_policy is not None:
230
 
                repository_policy.configure_branch(result_branch)
 
209
        try:
 
210
            self.open_branch().clone(result, revision_id=revision_id)
 
211
        except errors.NotBranchError:
 
212
            pass
 
213
        try:
 
214
            result_repo = result.find_repository()
 
215
        except errors.NoRepositoryPresent:
 
216
            result_repo = None
231
217
        if result_repo is None or result_repo.make_working_trees():
232
218
            try:
233
219
                self.open_workingtree().clone(result)
332
318
                branches.append(branch)
333
319
        return branches
334
320
 
 
321
 
335
322
    def destroy_repository(self):
336
323
        """Destroy the repository in this BzrDir"""
337
324
        raise NotImplementedError(self.destroy_repository)
369
356
        bzrdir._find_or_create_repository(force_new_repo)
370
357
        return bzrdir.create_branch()
371
358
 
372
 
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
373
 
                                    stack_on_pwd=None, require_stacking=False):
374
 
        """Return an object representing a policy to use.
375
 
 
376
 
        This controls whether a new repository is created, or a shared
377
 
        repository used instead.
378
 
 
379
 
        If stack_on is supplied, will not seek a containing shared repo.
380
 
 
381
 
        :param force_new_repo: If True, require a new repository to be created.
382
 
        :param stack_on: If supplied, the location to stack on.  If not
383
 
            supplied, a default_stack_on location may be used.
384
 
        :param stack_on_pwd: If stack_on is relative, the location it is
385
 
            relative to.
386
 
        """
387
 
        def repository_policy(found_bzrdir):
388
 
            stack_on = None
389
 
            stack_on_pwd = None
390
 
            config = found_bzrdir.get_config()
391
 
            stop = False
392
 
            if config is not None:
393
 
                stack_on = config.get_default_stack_on()
394
 
                if stack_on is not None:
395
 
                    stack_on_pwd = found_bzrdir.root_transport.base
396
 
                    stop = True
397
 
                    note('Using default stacking branch %s at %s', stack_on,
398
 
                         stack_on_pwd)
399
 
            # does it have a repository ?
400
 
            try:
401
 
                repository = found_bzrdir.open_repository()
402
 
            except errors.NoRepositoryPresent:
403
 
                repository = None
404
 
            else:
405
 
                if ((found_bzrdir.root_transport.base !=
406
 
                     self.root_transport.base) and not repository.is_shared()):
407
 
                    repository = None
408
 
                else:
409
 
                    stop = True
410
 
            if not stop:
411
 
                return None, False
412
 
            if repository:
413
 
                return UseExistingRepository(repository, stack_on,
414
 
                    stack_on_pwd, require_stacking=require_stacking), True
415
 
            else:
416
 
                return CreateRepository(self, stack_on, stack_on_pwd,
417
 
                    require_stacking=require_stacking), True
418
 
 
419
 
        if not force_new_repo:
420
 
            if stack_on is None:
421
 
                policy = self._find_containing(repository_policy)
422
 
                if policy is not None:
423
 
                    return policy
424
 
            else:
425
 
                try:
426
 
                    return UseExistingRepository(self.open_repository(),
427
 
                        stack_on, stack_on_pwd,
428
 
                        require_stacking=require_stacking)
429
 
                except errors.NoRepositoryPresent:
430
 
                    pass
431
 
        return CreateRepository(self, stack_on, stack_on_pwd,
432
 
                                require_stacking=require_stacking)
433
 
 
434
359
    def _find_or_create_repository(self, force_new_repo):
435
360
        """Create a new repository if needed, returning the repository."""
436
 
        policy = self.determine_repository_policy(force_new_repo)
437
 
        return policy.acquire_repository()
438
 
 
 
361
        if force_new_repo:
 
362
            return self.create_repository()
 
363
        try:
 
364
            return self.find_repository()
 
365
        except errors.NoRepositoryPresent:
 
366
            return self.create_repository()
 
367
        
439
368
    @staticmethod
440
369
    def create_branch_convenience(base, force_new_repo=False,
441
370
                                  force_new_tree=None, format=None,
468
397
        if force_new_tree:
469
398
            # check for non local urls
470
399
            t = get_transport(base, possible_transports)
471
 
            if not isinstance(t, local.LocalTransport):
 
400
            if not isinstance(t, LocalTransport):
472
401
                raise errors.NotLocalUrl(base)
473
402
        bzrdir = BzrDir.create(base, format, possible_transports)
474
403
        repo = bzrdir._find_or_create_repository(force_new_repo)
482
411
        return result
483
412
 
484
413
    @staticmethod
 
414
    @deprecated_function(zero_ninetyone)
 
415
    def create_repository(base, shared=False, format=None):
 
416
        """Create a new BzrDir and Repository at the url 'base'.
 
417
 
 
418
        If no format is supplied, this will default to the current default
 
419
        BzrDirFormat by default, and use whatever repository format that that
 
420
        uses for bzrdirformat.create_repository.
 
421
 
 
422
        :param shared: Create a shared repository rather than a standalone
 
423
                       repository.
 
424
        The Repository object is returned.
 
425
 
 
426
        This must be overridden as an instance method in child classes, where
 
427
        it should take no parameters and construct whatever repository format
 
428
        that child class desires.
 
429
 
 
430
        This method is deprecated, please call create_repository on a bzrdir
 
431
        instance instead.
 
432
        """
 
433
        bzrdir = BzrDir.create(base, format)
 
434
        return bzrdir.create_repository(shared)
 
435
 
 
436
    @staticmethod
485
437
    def create_standalone_workingtree(base, format=None):
486
438
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
487
439
 
496
448
        :return: The WorkingTree object.
497
449
        """
498
450
        t = get_transport(base)
499
 
        if not isinstance(t, local.LocalTransport):
 
451
        if not isinstance(t, LocalTransport):
500
452
            raise errors.NotLocalUrl(base)
501
453
        bzrdir = BzrDir.create_branch_and_repo(base,
502
454
                                               force_new_repo=True,
556
508
        """
557
509
        raise NotImplementedError(self.destroy_workingtree_metadata)
558
510
 
559
 
    def _find_containing(self, evaluate):
560
 
        """Find something in a containing control directory.
561
 
 
562
 
        This method will scan containing control dirs, until it finds what
563
 
        it is looking for, decides that it will never find it, or runs out
564
 
        of containing control directories to check.
565
 
 
566
 
        It is used to implement find_repository and
567
 
        determine_repository_policy.
568
 
 
569
 
        :param evaluate: A function returning (value, stop).  If stop is True,
570
 
            the value will be returned.
571
 
        """
572
 
        found_bzrdir = self
573
 
        while True:
574
 
            result, stop = evaluate(found_bzrdir)
575
 
            if stop:
576
 
                return result
577
 
            next_transport = found_bzrdir.root_transport.clone('..')
578
 
            if (found_bzrdir.root_transport.base == next_transport.base):
579
 
                # top of the file system
580
 
                return None
581
 
            # find the next containing bzrdir
582
 
            try:
583
 
                found_bzrdir = BzrDir.open_containing_from_transport(
584
 
                    next_transport)[0]
585
 
            except errors.NotBranchError:
586
 
                return None
587
 
 
588
511
    def find_repository(self):
589
512
        """Find the repository that should be used.
590
513
 
592
515
        new branches as well as to hook existing branches up to their
593
516
        repository.
594
517
        """
595
 
        def usable_repository(found_bzrdir):
 
518
        try:
 
519
            return self.open_repository()
 
520
        except errors.NoRepositoryPresent:
 
521
            pass
 
522
        next_transport = self.root_transport.clone('..')
 
523
        while True:
 
524
            # find the next containing bzrdir
 
525
            try:
 
526
                found_bzrdir = BzrDir.open_containing_from_transport(
 
527
                    next_transport)[0]
 
528
            except errors.NotBranchError:
 
529
                # none found
 
530
                raise errors.NoRepositoryPresent(self)
596
531
            # does it have a repository ?
597
532
            try:
598
533
                repository = found_bzrdir.open_repository()
599
534
            except errors.NoRepositoryPresent:
600
 
                return None, False
601
 
            if found_bzrdir.root_transport.base == self.root_transport.base:
602
 
                return repository, True
603
 
            elif repository.is_shared():
604
 
                return repository, True
 
535
                next_transport = found_bzrdir.root_transport.clone('..')
 
536
                if (found_bzrdir.root_transport.base == next_transport.base):
 
537
                    # top of the file system
 
538
                    break
 
539
                else:
 
540
                    continue
 
541
            if ((found_bzrdir.root_transport.base ==
 
542
                 self.root_transport.base) or repository.is_shared()):
 
543
                return repository
605
544
            else:
606
 
                return None, True
607
 
 
608
 
        found_repo = self._find_containing(usable_repository)
609
 
        if found_repo is None:
610
 
            raise errors.NoRepositoryPresent(self)
611
 
        return found_repo
 
545
                raise errors.NoRepositoryPresent(self)
 
546
        raise errors.NoRepositoryPresent(self)
612
547
 
613
548
    def get_branch_reference(self):
614
549
        """Return the referenced URL for the branch in this bzrdir.
631
566
        guaranteed to point to an existing directory ready for use.
632
567
        """
633
568
        raise NotImplementedError(self.get_branch_transport)
634
 
 
635
 
    def _find_creation_modes(self):
636
 
        """Determine the appropriate modes for files and directories.
637
 
 
638
 
        They're always set to be consistent with the base directory,
639
 
        assuming that this transport allows setting modes.
640
 
        """
641
 
        # TODO: Do we need or want an option (maybe a config setting) to turn
642
 
        # this off or override it for particular locations? -- mbp 20080512
643
 
        if self._mode_check_done:
644
 
            return
645
 
        self._mode_check_done = True
646
 
        try:
647
 
            st = self.transport.stat('.')
648
 
        except errors.TransportNotPossible:
649
 
            self._dir_mode = None
650
 
            self._file_mode = None
651
 
        else:
652
 
            # Check the directory mode, but also make sure the created
653
 
            # directories and files are read-write for this user. This is
654
 
            # mostly a workaround for filesystems which lie about being able to
655
 
            # write to a directory (cygwin & win32)
656
 
            if (st.st_mode & 07777 == 00000):
657
 
                # FTP allows stat but does not return dir/file modes
658
 
                self._dir_mode = None
659
 
                self._file_mode = None
660
 
            else:
661
 
                self._dir_mode = (st.st_mode & 07777) | 00700
662
 
                # Remove the sticky and execute bits for files
663
 
                self._file_mode = self._dir_mode & ~07111
664
 
 
665
 
    def _get_file_mode(self):
666
 
        """Return Unix mode for newly created files, or None.
667
 
        """
668
 
        if not self._mode_check_done:
669
 
            self._find_creation_modes()
670
 
        return self._file_mode
671
 
 
672
 
    def _get_dir_mode(self):
673
 
        """Return Unix mode for newly created directories, or None.
674
 
        """
675
 
        if not self._mode_check_done:
676
 
            self._find_creation_modes()
677
 
        return self._dir_mode
678
569
        
679
570
    def get_repository_transport(self, repository_format):
680
571
        """Get the transport for use by repository format in this BzrDir.
701
592
        guaranteed to point to an existing directory ready for use.
702
593
        """
703
594
        raise NotImplementedError(self.get_workingtree_transport)
704
 
 
705
 
    def get_config(self):
706
 
        if getattr(self, '_get_config', None) is None:
707
 
            return None
708
 
        return self._get_config()
709
 
 
 
595
        
710
596
    def __init__(self, _transport, _format):
711
597
        """Initialize a Bzr control dir object.
712
598
        
719
605
        self._format = _format
720
606
        self.transport = _transport.clone('.bzr')
721
607
        self.root_transport = _transport
722
 
        self._mode_check_done = False
723
608
 
724
609
    def is_control_filename(self, filename):
725
610
        """True if filename is the name of a path which is reserved for bzrdir's.
902
787
        tree, branch = bzrdir._get_tree_branch()
903
788
        return tree, branch, relpath
904
789
 
905
 
    @classmethod
906
 
    def open_containing_tree_branch_or_repository(klass, location):
907
 
        """Return the working tree, branch and repo contained by a location.
908
 
 
909
 
        Returns (tree, branch, repository, relpath).
910
 
        If there is no tree containing the location, tree will be None.
911
 
        If there is no branch containing the location, branch will be None.
912
 
        If there is no repository containing the location, repository will be
913
 
        None.
914
 
        relpath is the portion of the path that is contained by the innermost
915
 
        BzrDir.
916
 
 
917
 
        If no tree, branch or repository is found, a NotBranchError is raised.
918
 
        """
919
 
        bzrdir, relpath = klass.open_containing(location)
920
 
        try:
921
 
            tree, branch = bzrdir._get_tree_branch()
922
 
        except errors.NotBranchError:
923
 
            try:
924
 
                repo = bzrdir.find_repository()
925
 
                return None, None, repo, relpath
926
 
            except (errors.NoRepositoryPresent):
927
 
                raise errors.NotBranchError(location)
928
 
        return tree, branch, branch.repository, relpath
929
 
 
930
790
    def open_repository(self, _unsupported=False):
931
791
        """Open the repository object at this BzrDir if one is present.
932
792
 
981
841
            return False
982
842
 
983
843
    def _cloning_metadir(self):
984
 
        """Produce a metadir suitable for cloning with.
985
 
        
986
 
        :returns: (destination_bzrdir_format, source_repository)
987
 
        """
 
844
        """Produce a metadir suitable for cloning with."""
988
845
        result_format = self._format.__class__()
989
846
        try:
990
847
            try:
991
848
                branch = self.open_branch()
992
849
                source_repository = branch.repository
993
 
                result_format._branch_format = branch._format
994
850
            except errors.NotBranchError:
995
851
                source_branch = None
996
852
                source_repository = self.open_repository()
1001
857
            # the fix recommended in bug # 103195 - to delegate this choice the
1002
858
            # repository itself.
1003
859
            repo_format = source_repository._format
1004
 
            if isinstance(repo_format, remote.RemoteRepositoryFormat):
1005
 
                source_repository._ensure_real()
1006
 
                repo_format = source_repository._real_repository._format
1007
 
            result_format.repository_format = repo_format
 
860
            if not isinstance(repo_format, remote.RemoteRepositoryFormat):
 
861
                result_format.repository_format = repo_format
1008
862
        try:
1009
863
            # TODO: Couldn't we just probe for the format in these cases,
1010
864
            # rather than opening the whole tree?  It would be a little
1016
870
            result_format.workingtree_format = tree._format.__class__()
1017
871
        return result_format, source_repository
1018
872
 
1019
 
    def cloning_metadir(self, require_stacking=False):
 
873
    def cloning_metadir(self):
1020
874
        """Produce a metadir suitable for cloning or sprouting with.
1021
875
 
1022
876
        These operations may produce workingtrees (yes, even though they're
1023
877
        "cloning" something that doesn't have a tree), so a viable workingtree
1024
878
        format must be selected.
1025
 
 
1026
 
        :require_stacking: If True, non-stackable formats will be upgraded
1027
 
            to similar stackable formats.
1028
 
        :returns: a BzrDirFormat with all component formats either set
1029
 
            appropriately or set to None if that component should not be
1030
 
            created.
1031
879
        """
1032
880
        format, repository = self._cloning_metadir()
1033
881
        if format._workingtree_format is None:
1035
883
                return format
1036
884
            tree_format = repository._format._matchingbzrdir.workingtree_format
1037
885
            format.workingtree_format = tree_format.__class__()
1038
 
        if (require_stacking and not
1039
 
            format.get_branch_format().supports_stacking()):
1040
 
            # We need to make a stacked branch, but the default format for the
1041
 
            # target doesn't support stacking.  So force a branch that *can*
1042
 
            # support stacking.
1043
 
            from bzrlib.branch import BzrBranchFormat7
1044
 
            format._branch_format = BzrBranchFormat7()
1045
 
            mutter("using %r for stacking" % (format._branch_format,))
1046
 
            from bzrlib.repofmt import pack_repo
1047
 
            if format.repository_format.rich_root_data:
1048
 
                bzrdir_format_name = '1.6.1-rich-root'
1049
 
                repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
1050
 
            else:
1051
 
                bzrdir_format_name = '1.6'
1052
 
                repo_format = pack_repo.RepositoryFormatKnitPack5()
1053
 
            note('Source format does not support stacking, using format:'
1054
 
                 ' \'%s\'\n  %s\n',
1055
 
                 bzrdir_format_name, repo_format.get_format_description())
1056
 
            format.repository_format = repo_format
1057
886
        return format
1058
887
 
1059
888
    def checkout_metadir(self):
1061
890
 
1062
891
    def sprout(self, url, revision_id=None, force_new_repo=False,
1063
892
               recurse='down', possible_transports=None,
1064
 
               accelerator_tree=None, hardlink=False, stacked=False,
1065
 
               source_branch=None):
 
893
               accelerator_tree=None, hardlink=False):
1066
894
        """Create a copy of this bzrdir prepared for use as a new line of
1067
895
        development.
1068
896
 
1081
909
            content is different.
1082
910
        :param hardlink: If true, hard-link files from accelerator_tree,
1083
911
            where possible.
1084
 
        :param stacked: If true, create a stacked branch referring to the
1085
 
            location of this control directory.
1086
912
        """
1087
913
        target_transport = get_transport(url, possible_transports)
1088
914
        target_transport.ensure_base()
1089
 
        cloning_format = self.cloning_metadir(stacked)
1090
 
        # Create/update the result branch
 
915
        cloning_format = self.cloning_metadir()
1091
916
        result = cloning_format.initialize_on_transport(target_transport)
1092
 
        # if a stacked branch wasn't requested, we don't create one
1093
 
        # even if the origin was stacked
1094
 
        stacked_branch_url = None
1095
 
        if source_branch is not None:
1096
 
            if stacked:
1097
 
                stacked_branch_url = self.root_transport.base
 
917
        try:
 
918
            source_branch = self.open_branch()
1098
919
            source_repository = source_branch.repository
1099
 
        else:
1100
 
            try:
1101
 
                source_branch = self.open_branch()
1102
 
                source_repository = source_branch.repository
1103
 
                if stacked:
1104
 
                    stacked_branch_url = self.root_transport.base
1105
 
            except errors.NotBranchError:
1106
 
                source_branch = None
1107
 
                try:
1108
 
                    source_repository = self.open_repository()
1109
 
                except errors.NoRepositoryPresent:
1110
 
                    source_repository = None
1111
 
        repository_policy = result.determine_repository_policy(
1112
 
            force_new_repo, stacked_branch_url, require_stacking=stacked)
1113
 
        result_repo = repository_policy.acquire_repository()
1114
 
        if source_repository is not None:
1115
 
            # Fetch while stacked to prevent unstacked fetch from
1116
 
            # Branch.sprout.
1117
 
            result_repo.fetch(source_repository, revision_id=revision_id)
1118
 
 
1119
 
        if source_branch is None:
1120
 
            # this is for sprouting a bzrdir without a branch; is that
1121
 
            # actually useful?
1122
 
            # Not especially, but it's part of the contract.
1123
 
            result_branch = result.create_branch()
1124
 
        else:
1125
 
            # Force NULL revision to avoid using repository before stacking
1126
 
            # is configured.
1127
 
            result_branch = source_branch.sprout(
1128
 
                result, revision_id=_mod_revision.NULL_REVISION)
1129
 
            parent_location = result_branch.get_parent()
1130
 
        mutter("created new branch %r" % (result_branch,))
1131
 
        repository_policy.configure_branch(result_branch)
 
920
        except errors.NotBranchError:
 
921
            source_branch = None
 
922
            try:
 
923
                source_repository = self.open_repository()
 
924
            except errors.NoRepositoryPresent:
 
925
                source_repository = None
 
926
        if force_new_repo:
 
927
            result_repo = None
 
928
        else:
 
929
            try:
 
930
                result_repo = result.find_repository()
 
931
            except errors.NoRepositoryPresent:
 
932
                result_repo = None
 
933
        if source_repository is None and result_repo is not None:
 
934
            pass
 
935
        elif source_repository is None and result_repo is None:
 
936
            # no repo available, make a new one
 
937
            result.create_repository()
 
938
        elif source_repository is not None and result_repo is None:
 
939
            # have source, and want to make a new target repo
 
940
            result_repo = source_repository.sprout(result,
 
941
                                                   revision_id=revision_id)
 
942
        else:
 
943
            # fetch needed content into target.
 
944
            if source_repository is not None:
 
945
                # would rather do 
 
946
                # source_repository.copy_content_into(result_repo,
 
947
                #                                     revision_id=revision_id)
 
948
                # so we can override the copy method
 
949
                result_repo.fetch(source_repository, revision_id=revision_id)
1132
950
        if source_branch is not None:
1133
 
            source_branch.copy_content_into(result_branch, revision_id)
1134
 
            # Override copy_content_into
1135
 
            result_branch.set_parent(parent_location)
1136
 
 
1137
 
        # Create/update the result working tree
1138
 
        if isinstance(target_transport, local.LocalTransport) and (
 
951
            source_branch.sprout(result, revision_id=revision_id)
 
952
        else:
 
953
            result.create_branch()
 
954
        if isinstance(target_transport, LocalTransport) and (
1139
955
            result_repo is None or result_repo.make_working_trees()):
1140
956
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1141
957
                hardlink=hardlink)
1155
971
                basis = wt.basis_tree()
1156
972
                basis.lock_read()
1157
973
                subtrees = basis.iter_references()
1158
 
            elif result_branch is not None:
1159
 
                basis = result_branch.basis_tree()
1160
 
                basis.lock_read()
1161
 
                subtrees = basis.iter_references()
 
974
                recurse_branch = wt.branch
1162
975
            elif source_branch is not None:
1163
976
                basis = source_branch.basis_tree()
1164
977
                basis.lock_read()
1165
978
                subtrees = basis.iter_references()
 
979
                recurse_branch = source_branch
1166
980
            else:
1167
981
                subtrees = []
1168
982
                basis = None
1172
986
                    sublocation = source_branch.reference_parent(file_id, path)
1173
987
                    sublocation.bzrdir.sprout(target,
1174
988
                        basis.get_reference_revision(file_id, path),
1175
 
                        force_new_repo=force_new_repo, recurse=recurse,
1176
 
                        stacked=stacked)
 
989
                        force_new_repo=force_new_repo, recurse=recurse)
1177
990
            finally:
1178
991
                if basis is not None:
1179
992
                    basis.unlock()
1186
999
    def __init__(self, _transport, _format):
1187
1000
        """See BzrDir.__init__."""
1188
1001
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
 
1002
        assert self._format._lock_class == lockable_files.TransportLock
 
1003
        assert self._format._lock_file_name == 'branch-lock'
1189
1004
        self._control_files = lockable_files.LockableFiles(
1190
1005
                                            self.get_branch_transport(None),
1191
1006
                                            self._format._lock_file_name,
1195
1010
        """Pre-splitout bzrdirs do not suffer from stale locks."""
1196
1011
        raise NotImplementedError(self.break_lock)
1197
1012
 
1198
 
    def cloning_metadir(self, require_stacking=False):
1199
 
        """Produce a metadir suitable for cloning with."""
1200
 
        if require_stacking:
1201
 
            return format_registry.make_bzrdir('1.6')
1202
 
        return self._format.__class__()
1203
 
 
1204
 
    def clone(self, url, revision_id=None, force_new_repo=False,
1205
 
              preserve_stacking=False):
1206
 
        """See BzrDir.clone().
1207
 
 
1208
 
        force_new_repo has no effect, since this family of formats always
1209
 
        require a new repository.
1210
 
        preserve_stacking has no effect, since no source branch using this
1211
 
        family of formats can be stacked, so there is no stacking to preserve.
1212
 
        """
 
1013
    def clone(self, url, revision_id=None, force_new_repo=False):
 
1014
        """See BzrDir.clone()."""
 
1015
        from bzrlib.workingtree import WorkingTreeFormat2
1213
1016
        self._make_tail(url)
1214
1017
        result = self._format._initialize_for_clone(url)
1215
1018
        self.open_repository().clone(result, revision_id=revision_id)
1216
1019
        from_branch = self.open_branch()
1217
1020
        from_branch.clone(result, revision_id=revision_id)
1218
1021
        try:
1219
 
            tree = self.open_workingtree()
 
1022
            self.open_workingtree().clone(result)
1220
1023
        except errors.NotLocalUrl:
1221
1024
            # make a new one, this format always has to have one.
1222
 
            result._init_workingtree()
1223
 
        else:
1224
 
            tree.clone(result)
 
1025
            try:
 
1026
                WorkingTreeFormat2().initialize(result)
 
1027
            except errors.NotLocalUrl:
 
1028
                # but we cannot do it for remote trees.
 
1029
                to_branch = result.open_branch()
 
1030
                WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
1225
1031
        return result
1226
1032
 
1227
1033
    def create_branch(self):
1228
1034
        """See BzrDir.create_branch."""
1229
 
        return self._format.get_branch_format().initialize(self)
 
1035
        return self.open_branch()
1230
1036
 
1231
1037
    def destroy_branch(self):
1232
1038
        """See BzrDir.destroy_branch."""
1245
1051
    def create_workingtree(self, revision_id=None, from_branch=None,
1246
1052
                           accelerator_tree=None, hardlink=False):
1247
1053
        """See BzrDir.create_workingtree."""
1248
 
        # The workingtree is sometimes created when the bzrdir is created,
1249
 
        # but not when cloning.
1250
 
 
1251
1054
        # this looks buggy but is not -really-
1252
1055
        # because this format creates the workingtree when the bzrdir is
1253
1056
        # created
1257
1060
        # that can do wonky stuff here, and that only
1258
1061
        # happens for creating checkouts, which cannot be 
1259
1062
        # done on this format anyway. So - acceptable wart.
1260
 
        try:
1261
 
            result = self.open_workingtree(recommend_upgrade=False)
1262
 
        except errors.NoSuchFile:
1263
 
            result = self._init_workingtree()
 
1063
        result = self.open_workingtree(recommend_upgrade=False)
1264
1064
        if revision_id is not None:
1265
1065
            if revision_id == _mod_revision.NULL_REVISION:
1266
1066
                result.set_parent_ids([])
1268
1068
                result.set_parent_ids([revision_id])
1269
1069
        return result
1270
1070
 
1271
 
    def _init_workingtree(self):
1272
 
        from bzrlib.workingtree import WorkingTreeFormat2
1273
 
        try:
1274
 
            return WorkingTreeFormat2().initialize(self)
1275
 
        except errors.NotLocalUrl:
1276
 
            # Even though we can't access the working tree, we need to
1277
 
            # create its control files.
1278
 
            return WorkingTreeFormat2()._stub_initialize_on_transport(
1279
 
                self.transport, self._control_files._file_mode)
1280
 
 
1281
1071
    def destroy_workingtree(self):
1282
1072
        """See BzrDir.destroy_workingtree."""
1283
1073
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1334
1124
 
1335
1125
    def sprout(self, url, revision_id=None, force_new_repo=False,
1336
1126
               possible_transports=None, accelerator_tree=None,
1337
 
               hardlink=False, stacked=False):
 
1127
               hardlink=False):
1338
1128
        """See BzrDir.sprout()."""
1339
 
        if stacked:
1340
 
            raise errors.UnstackableBranchFormat(
1341
 
                self._format, self.root_transport.base)
1342
1129
        from bzrlib.workingtree import WorkingTreeFormat2
1343
1130
        self._make_tail(url)
1344
1131
        result = self._format._initialize_for_clone(url)
1582
1369
            basedir=self.root_transport.base)
1583
1370
        return format.open(self, _found=True)
1584
1371
 
1585
 
    def _get_config(self):
1586
 
        return config.BzrDirConfig(self.transport)
1587
 
 
1588
1372
 
1589
1373
class BzrDirFormat(object):
1590
1374
    """An encapsulation of the initialization and open routines for a format.
1700
1484
                                      # FIXME: RBC 20060121 don't peek under
1701
1485
                                      # the covers
1702
1486
                                      mode=temp_control._dir_mode)
1703
 
        if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
 
1487
        if sys.platform == 'win32' and isinstance(transport, LocalTransport):
1704
1488
            win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1705
1489
        file_mode = temp_control._file_mode
1706
1490
        del temp_control
1707
 
        bzrdir_transport = transport.clone('.bzr')
1708
 
        utf8_files = [('README',
 
1491
        mutter('created control directory in ' + transport.base)
 
1492
        control = transport.clone('.bzr')
 
1493
        utf8_files = [('README', 
1709
1494
                       "This is a Bazaar control directory.\n"
1710
1495
                       "Do not change any files in this directory.\n"
1711
1496
                       "See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1712
1497
                      ('branch-format', self.get_format_string()),
1713
1498
                      ]
1714
1499
        # NB: no need to escape relative paths that are url safe.
1715
 
        control_files = lockable_files.LockableFiles(bzrdir_transport,
1716
 
            self._lock_file_name, self._lock_class)
 
1500
        control_files = lockable_files.LockableFiles(control,
 
1501
                            self._lock_file_name, self._lock_class)
1717
1502
        control_files.create_lock()
1718
1503
        control_files.lock_write()
1719
1504
        try:
1720
 
            for (filename, content) in utf8_files:
1721
 
                bzrdir_transport.put_bytes(filename, content,
1722
 
                    mode=file_mode)
 
1505
            for file, content in utf8_files:
 
1506
                control_files.put_utf8(file, content)
1723
1507
        finally:
1724
1508
            control_files.unlock()
1725
1509
        return self.open(transport, _found=True)
1804
1588
        klass._control_server_formats.append(format)
1805
1589
 
1806
1590
    @classmethod
 
1591
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
 
1592
    def set_default_format(klass, format):
 
1593
        klass._set_default_format(format)
 
1594
 
 
1595
    @classmethod
1807
1596
    def _set_default_format(klass, format):
1808
1597
        """Set default format (for testing behavior of defaults only)"""
1809
1598
        klass._default_format = format
1814
1603
 
1815
1604
    @classmethod
1816
1605
    def unregister_format(klass, format):
 
1606
        assert klass._formats[format.get_format_string()] is format
1817
1607
        del klass._formats[format.get_format_string()]
1818
1608
 
1819
1609
    @classmethod
1890
1680
        """See BzrDirFormat.get_format_string()."""
1891
1681
        return "Bazaar-NG branch, format 5\n"
1892
1682
 
1893
 
    def get_branch_format(self):
1894
 
        from bzrlib import branch
1895
 
        return branch.BzrBranchFormat4()
1896
 
 
1897
1683
    def get_format_description(self):
1898
1684
        """See BzrDirFormat.get_format_description()."""
1899
1685
        return "All-in-one format 5"
1913
1699
        """
1914
1700
        from bzrlib.branch import BzrBranchFormat4
1915
1701
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1702
        from bzrlib.workingtree import WorkingTreeFormat2
1916
1703
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1917
1704
        RepositoryFormat5().initialize(result, _internal=True)
1918
1705
        if not _cloning:
1919
1706
            branch = BzrBranchFormat4().initialize(result)
1920
 
            result._init_workingtree()
 
1707
            try:
 
1708
                WorkingTreeFormat2().initialize(result)
 
1709
            except errors.NotLocalUrl:
 
1710
                # Even though we can't access the working tree, we need to
 
1711
                # create its control files.
 
1712
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1921
1713
        return result
1922
1714
 
1923
1715
    def _open(self, transport):
1951
1743
        """See BzrDirFormat.get_format_description()."""
1952
1744
        return "All-in-one format 6"
1953
1745
 
1954
 
    def get_branch_format(self):
1955
 
        from bzrlib import branch
1956
 
        return branch.BzrBranchFormat4()
1957
 
 
1958
1746
    def get_converter(self, format=None):
1959
1747
        """See BzrDirFormat.get_converter()."""
1960
1748
        # there is one and only one upgrade path here.
1970
1758
        """
1971
1759
        from bzrlib.branch import BzrBranchFormat4
1972
1760
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1761
        from bzrlib.workingtree import WorkingTreeFormat2
1973
1762
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1974
1763
        RepositoryFormat6().initialize(result, _internal=True)
1975
1764
        if not _cloning:
1976
1765
            branch = BzrBranchFormat4().initialize(result)
1977
 
            result._init_workingtree()
 
1766
            try:
 
1767
                WorkingTreeFormat2().initialize(result)
 
1768
            except errors.NotLocalUrl:
 
1769
                # Even though we can't access the working tree, we need to
 
1770
                # create its control files.
 
1771
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1978
1772
        return result
1979
1773
 
1980
1774
    def _open(self, transport):
2116
1910
        self.bzrdir = to_convert
2117
1911
        self.pb = pb
2118
1912
        self.pb.note('starting upgrade from format 4 to 5')
2119
 
        if isinstance(self.bzrdir.transport, local.LocalTransport):
 
1913
        if isinstance(self.bzrdir.transport, LocalTransport):
2120
1914
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2121
1915
        self._convert_to_weaves()
2122
1916
        return BzrDir.open(self.bzrdir.root_transport.base)
2161
1955
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
2162
1956
        self.pb.note('  %6d texts', self.text_count)
2163
1957
        self._cleanup_spare_files_after_format4()
2164
 
        self.branch._transport.put_bytes(
2165
 
            'branch-format',
2166
 
            BzrDirFormat5().get_format_string(),
2167
 
            mode=self.bzrdir._get_file_mode())
 
1958
        self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
2168
1959
 
2169
1960
    def _cleanup_spare_files_after_format4(self):
2170
1961
        # FIXME working tree upgrade foo.
2179
1970
 
2180
1971
    def _convert_working_inv(self):
2181
1972
        inv = xml4.serializer_v4.read_inventory(
2182
 
                self.branch._transport.get('inventory'))
 
1973
                    self.branch.control_files.get('inventory'))
2183
1974
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2184
 
        self.branch._transport.put_bytes('inventory', new_inv_xml,
2185
 
            mode=self.bzrdir._get_file_mode())
 
1975
        # FIXME inventory is a working tree change.
 
1976
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
2186
1977
 
2187
1978
    def _write_all_weaves(self):
2188
1979
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2208
1999
        self.bzrdir.transport.mkdir('revision-store')
2209
2000
        revision_transport = self.bzrdir.transport.clone('revision-store')
2210
2001
        # TODO permissions
2211
 
        from bzrlib.xml5 import serializer_v5
2212
 
        from bzrlib.repofmt.weaverepo import RevisionTextStore
2213
 
        revision_store = RevisionTextStore(revision_transport,
2214
 
            serializer_v5, False, versionedfile.PrefixMapper(),
2215
 
            lambda:True, lambda:True)
 
2002
        _revision_store = TextRevisionStore(TextStore(revision_transport,
 
2003
                                                      prefixed=False,
 
2004
                                                      compressed=True))
2216
2005
        try:
 
2006
            transaction = WriteTransaction()
2217
2007
            for i, rev_id in enumerate(self.converted_revs):
2218
2008
                self.pb.update('write revision', i, len(self.converted_revs))
2219
 
                text = serializer_v5.write_revision_to_string(
2220
 
                    self.revisions[rev_id])
2221
 
                key = (rev_id,)
2222
 
                revision_store.add_lines(key, None, osutils.split_lines(text))
 
2009
                _revision_store.add_revision(self.revisions[rev_id], transaction)
2223
2010
        finally:
2224
2011
            self.pb.clear()
2225
2012
            
2238
2025
                         rev_id)
2239
2026
            self.absent_revisions.add(rev_id)
2240
2027
        else:
2241
 
            rev = self.branch.repository.get_revision(rev_id)
 
2028
            rev = self.branch.repository._revision_store.get_revision(rev_id,
 
2029
                self.branch.repository.get_transaction())
2242
2030
            for parent_id in rev.parent_ids:
2243
2031
                self.known_revisions.add(parent_id)
2244
2032
                self.to_read.append(parent_id)
2245
2033
            self.revisions[rev_id] = rev
2246
2034
 
2247
2035
    def _load_old_inventory(self, rev_id):
 
2036
        assert rev_id not in self.converted_revs
2248
2037
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2249
2038
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2250
2039
        inv.revision_id = rev_id
2251
2040
        rev = self.revisions[rev_id]
 
2041
        if rev.inventory_sha1:
 
2042
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
 
2043
                'inventory sha mismatch for {%s}' % rev_id
2252
2044
        return inv
2253
2045
 
2254
2046
    def _load_updated_inventory(self, rev_id):
 
2047
        assert rev_id in self.converted_revs
2255
2048
        inv_xml = self.inv_weave.get_text(rev_id)
2256
2049
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2257
2050
        return inv
2267
2060
        self.converted_revs.add(rev_id)
2268
2061
 
2269
2062
    def _store_new_inv(self, rev, inv, present_parents):
 
2063
        # the XML is now updated with text versions
 
2064
        if __debug__:
 
2065
            entries = inv.iter_entries()
 
2066
            entries.next()
 
2067
            for path, ie in entries:
 
2068
                assert getattr(ie, 'revision', None) is not None, \
 
2069
                    'no revision on {%s} in {%s}' % \
 
2070
                    (file_id, rev.revision_id)
2270
2071
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2271
2072
        new_inv_sha1 = sha_string(new_inv_xml)
2272
2073
        self.inv_weave.add_lines(rev.revision_id,
2301
2102
            self.text_weaves[file_id] = w
2302
2103
        text_changed = False
2303
2104
        parent_candiate_entries = ie.parent_candidates(parent_invs)
 
2105
        for old_revision in parent_candiate_entries.keys():
 
2106
            # if this fails, its a ghost ?
 
2107
            assert old_revision in self.converted_revs, \
 
2108
                "Revision {%s} not in converted_revs" % old_revision
2304
2109
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2305
2110
        # XXX: Note that this is unordered - and this is tolerable because 
2306
2111
        # the previous code was also unordered.
2308
2113
            in heads)
2309
2114
        self.snapshot_ie(previous_entries, ie, w, rev_id)
2310
2115
        del ie.text_id
 
2116
        assert getattr(ie, 'revision', None) is not None
2311
2117
 
2312
2118
    @symbol_versioning.deprecated_method(symbol_versioning.one_one)
2313
2119
    def get_parents(self, revision_ids):
2334
2140
                ie.revision = previous_ie.revision
2335
2141
                return
2336
2142
        if ie.has_text():
2337
 
            text = self.branch.repository._text_store.get(ie.text_id)
 
2143
            text = self.branch.repository.weave_store.get(ie.text_id)
2338
2144
            file_lines = text.readlines()
 
2145
            assert sha_strings(file_lines) == ie.text_sha1
 
2146
            assert sum(map(len, file_lines)) == ie.text_size
2339
2147
            w.add_lines(rev_id, previous_revisions, file_lines)
2340
2148
            self.text_count += 1
2341
2149
        else:
2388
2196
                if (filename.endswith(".weave") or
2389
2197
                    filename.endswith(".gz") or
2390
2198
                    filename.endswith(".sig")):
2391
 
                    file_id, suffix = os.path.splitext(filename)
 
2199
                    file_id = os.path.splitext(filename)[0]
2392
2200
                else:
2393
2201
                    file_id = filename
2394
 
                    suffix = ''
2395
 
                new_name = store._mapper.map((file_id,)) + suffix
 
2202
                prefix_dir = store.hash_prefix(file_id)
2396
2203
                # FIXME keep track of the dirs made RBC 20060121
2397
2204
                try:
2398
 
                    store_transport.move(filename, new_name)
 
2205
                    store_transport.move(filename, prefix_dir + '/' + filename)
2399
2206
                except errors.NoSuchFile: # catches missing dirs strangely enough
2400
 
                    store_transport.mkdir(osutils.dirname(new_name))
2401
 
                    store_transport.move(filename, new_name)
2402
 
        self.bzrdir.transport.put_bytes(
2403
 
            'branch-format',
2404
 
            BzrDirFormat6().get_format_string(),
2405
 
            mode=self.bzrdir._get_file_mode())
 
2207
                    store_transport.mkdir(prefix_dir)
 
2208
                    store_transport.move(filename, prefix_dir + '/' + filename)
 
2209
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
2406
2210
 
2407
2211
 
2408
2212
class ConvertBzrDir6ToMeta(Converter):
2417
2221
        self.count = 0
2418
2222
        self.total = 20 # the steps we know about
2419
2223
        self.garbage_inventories = []
2420
 
        self.dir_mode = self.bzrdir._get_dir_mode()
2421
 
        self.file_mode = self.bzrdir._get_file_mode()
2422
2224
 
2423
2225
        self.pb.note('starting upgrade from format 6 to metadir')
2424
 
        self.bzrdir.transport.put_bytes(
2425
 
                'branch-format',
2426
 
                "Converting to format 6",
2427
 
                mode=self.file_mode)
 
2226
        self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
2428
2227
        # its faster to move specific files around than to open and use the apis...
2429
2228
        # first off, nuke ancestry.weave, it was never used.
2430
2229
        try:
2440
2239
            if name.startswith('basis-inventory.'):
2441
2240
                self.garbage_inventories.append(name)
2442
2241
        # create new directories for repository, working tree and branch
 
2242
        self.dir_mode = self.bzrdir._control_files._dir_mode
 
2243
        self.file_mode = self.bzrdir._control_files._file_mode
2443
2244
        repository_names = [('inventory.weave', True),
2444
2245
                            ('revision-store', True),
2445
2246
                            ('weaves', True)]
2493
2294
            for entry in checkout_files:
2494
2295
                self.move_entry('checkout', entry)
2495
2296
            if last_revision is not None:
2496
 
                self.bzrdir.transport.put_bytes(
 
2297
                self.bzrdir._control_files.put_utf8(
2497
2298
                    'checkout/last-revision', last_revision)
2498
 
        self.bzrdir.transport.put_bytes(
2499
 
            'branch-format',
2500
 
            BzrDirMetaFormat1().get_format_string(),
2501
 
            mode=self.file_mode)
 
2299
        self.bzrdir._control_files.put_utf8(
 
2300
            'branch-format', BzrDirMetaFormat1().get_format_string())
2502
2301
        return BzrDir.open(self.bzrdir.root_transport.base)
2503
2302
 
2504
2303
    def make_lock(self, name):
2522
2321
                raise
2523
2322
 
2524
2323
    def put_format(self, dirname, format):
2525
 
        self.bzrdir.transport.put_bytes('%s/format' % dirname,
2526
 
            format.get_format_string(),
2527
 
            self.file_mode)
 
2324
        self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
2528
2325
 
2529
2326
 
2530
2327
class ConvertMetaToMeta(Converter):
2560
2357
            pass
2561
2358
        else:
2562
2359
            # TODO: conversions of Branch and Tree should be done by
2563
 
            # InterXFormat lookups/some sort of registry.
 
2360
            # InterXFormat lookups
2564
2361
            # Avoid circular imports
2565
2362
            from bzrlib import branch as _mod_branch
2566
 
            old = branch._format.__class__
2567
 
            new = self.target_format.get_branch_format().__class__
2568
 
            while old != new:
2569
 
                if (old == _mod_branch.BzrBranchFormat5 and
2570
 
                    new in (_mod_branch.BzrBranchFormat6,
2571
 
                        _mod_branch.BzrBranchFormat7)):
2572
 
                    branch_converter = _mod_branch.Converter5to6()
2573
 
                elif (old == _mod_branch.BzrBranchFormat6 and
2574
 
                    new == _mod_branch.BzrBranchFormat7):
2575
 
                    branch_converter = _mod_branch.Converter6to7()
2576
 
                else:
2577
 
                    raise errors.BadConversionTarget("No converter", new)
 
2363
            if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
 
2364
                self.target_format.get_branch_format().__class__ is
 
2365
                _mod_branch.BzrBranchFormat6):
 
2366
                branch_converter = _mod_branch.Converter5to6()
2578
2367
                branch_converter.convert(branch)
2579
 
                branch = self.bzrdir.open_branch()
2580
 
                old = branch._format.__class__
2581
2368
        try:
2582
2369
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2583
2370
        except (errors.NoWorkingTree, errors.NotLocalUrl):
2609
2396
        try:
2610
2397
            medium = transport.get_smart_medium()
2611
2398
        except (NotImplementedError, AttributeError,
2612
 
                errors.TransportNotPossible, errors.NoSmartMedium,
2613
 
                errors.SmartProtocolError):
 
2399
                errors.TransportNotPossible, errors.NoSmartMedium):
2614
2400
            # no smart server, so not a branch for this format type.
2615
2401
            raise errors.NotBranchError(path=transport.base)
2616
2402
        else:
2617
2403
            # Decline to open it if the server doesn't support our required
2618
 
            # version (3) so that the VFS-based transport will do it.
2619
 
            if medium.should_probe():
2620
 
                try:
2621
 
                    server_version = medium.protocol_version()
2622
 
                except errors.SmartProtocolError:
2623
 
                    # Apparently there's no usable smart server there, even though
2624
 
                    # the medium supports the smart protocol.
2625
 
                    raise errors.NotBranchError(path=transport.base)
2626
 
                if server_version != '2':
2627
 
                    raise errors.NotBranchError(path=transport.base)
 
2404
            # version (2) so that the VFS-based transport will do it.
 
2405
            try:
 
2406
                server_version = medium.protocol_version()
 
2407
            except errors.SmartProtocolError:
 
2408
                # Apparently there's no usable smart server there, even though
 
2409
                # the medium supports the smart protocol.
 
2410
                raise errors.NotBranchError(path=transport.base)
 
2411
            if server_version != 2:
 
2412
                raise errors.NotBranchError(path=transport.base)
2628
2413
            return klass()
2629
2414
 
2630
2415
    def initialize_on_transport(self, transport):
2631
2416
        try:
2632
2417
            # hand off the request to the smart server
2633
 
            client_medium = transport.get_smart_medium()
 
2418
            shared_medium = transport.get_shared_medium()
2634
2419
        except errors.NoSmartMedium:
2635
2420
            # TODO: lookup the local format from a server hint.
2636
2421
            local_dir_format = BzrDirMetaFormat1()
2637
2422
            return local_dir_format.initialize_on_transport(transport)
2638
 
        client = _SmartClient(client_medium)
 
2423
        client = _SmartClient(shared_medium)
2639
2424
        path = client.remote_path_from_transport(transport)
2640
 
        response = client.call('BzrDirFormat.initialize', path)
2641
 
        if response[0] != 'ok':
2642
 
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
2425
        response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
 
2426
                                                    path)
 
2427
        assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
2643
2428
        return remote.RemoteBzrDir(transport)
2644
2429
 
2645
2430
    def _open(self, transport):
2650
2435
            return False
2651
2436
        return self.get_format_description() == other.get_format_description()
2652
2437
 
2653
 
    @property
2654
 
    def repository_format(self):
2655
 
        # Using a property to avoid early loading of remote
2656
 
        return remote.RemoteRepositoryFormat()
2657
 
 
2658
2438
 
2659
2439
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2660
2440
 
2772
2552
            self.remove('default')
2773
2553
        self.set_default(key)
2774
2554
        format = self.get('default')()
 
2555
        assert isinstance(format, BzrDirMetaFormat1)
2775
2556
 
2776
2557
    def make_bzrdir(self, key):
2777
2558
        return self.get(key)()
2829
2610
        return output
2830
2611
 
2831
2612
 
2832
 
class RepositoryAcquisitionPolicy(object):
2833
 
    """Abstract base class for repository acquisition policies.
2834
 
 
2835
 
    A repository acquisition policy decides how a BzrDir acquires a repository
2836
 
    for a branch that is being created.  The most basic policy decision is
2837
 
    whether to create a new repository or use an existing one.
2838
 
    """
2839
 
    def __init__(self, stack_on, stack_on_pwd, require_stacking):
2840
 
        """Constructor.
2841
 
 
2842
 
        :param stack_on: A location to stack on
2843
 
        :param stack_on_pwd: If stack_on is relative, the location it is
2844
 
            relative to.
2845
 
        :param require_stacking: If True, it is a failure to not stack.
2846
 
        """
2847
 
        self._stack_on = stack_on
2848
 
        self._stack_on_pwd = stack_on_pwd
2849
 
        self._require_stacking = require_stacking
2850
 
 
2851
 
    def configure_branch(self, branch):
2852
 
        """Apply any configuration data from this policy to the branch.
2853
 
 
2854
 
        Default implementation sets repository stacking.
2855
 
        """
2856
 
        if self._stack_on is None:
2857
 
            return
2858
 
        if self._stack_on_pwd is None:
2859
 
            stack_on = self._stack_on
2860
 
        else:
2861
 
            try:
2862
 
                stack_on = urlutils.rebase_url(self._stack_on,
2863
 
                    self._stack_on_pwd,
2864
 
                    branch.bzrdir.root_transport.base)
2865
 
            except errors.InvalidRebaseURLs:
2866
 
                stack_on = self._get_full_stack_on()
2867
 
        try:
2868
 
            branch.set_stacked_on_url(stack_on)
2869
 
        except errors.UnstackableBranchFormat:
2870
 
            if self._require_stacking:
2871
 
                raise
2872
 
 
2873
 
    def _get_full_stack_on(self):
2874
 
        """Get a fully-qualified URL for the stack_on location."""
2875
 
        if self._stack_on is None:
2876
 
            return None
2877
 
        if self._stack_on_pwd is None:
2878
 
            return self._stack_on
2879
 
        else:
2880
 
            return urlutils.join(self._stack_on_pwd, self._stack_on)
2881
 
 
2882
 
    def _add_fallback(self, repository):
2883
 
        """Add a fallback to the supplied repository, if stacking is set."""
2884
 
        stack_on = self._get_full_stack_on()
2885
 
        if stack_on is None:
2886
 
            return
2887
 
        stacked_dir = BzrDir.open(stack_on)
2888
 
        try:
2889
 
            stacked_repo = stacked_dir.open_branch().repository
2890
 
        except errors.NotBranchError:
2891
 
            stacked_repo = stacked_dir.open_repository()
2892
 
        try:
2893
 
            repository.add_fallback_repository(stacked_repo)
2894
 
        except errors.UnstackableRepositoryFormat:
2895
 
            if self._require_stacking:
2896
 
                raise
2897
 
 
2898
 
    def acquire_repository(self, make_working_trees=None, shared=False):
2899
 
        """Acquire a repository for this bzrdir.
2900
 
 
2901
 
        Implementations may create a new repository or use a pre-exising
2902
 
        repository.
2903
 
        :param make_working_trees: If creating a repository, set
2904
 
            make_working_trees to this value (if non-None)
2905
 
        :param shared: If creating a repository, make it shared if True
2906
 
        :return: A repository
2907
 
        """
2908
 
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2909
 
 
2910
 
 
2911
 
class CreateRepository(RepositoryAcquisitionPolicy):
2912
 
    """A policy of creating a new repository"""
2913
 
 
2914
 
    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2915
 
                 require_stacking=False):
2916
 
        """
2917
 
        Constructor.
2918
 
        :param bzrdir: The bzrdir to create the repository on.
2919
 
        :param stack_on: A location to stack on
2920
 
        :param stack_on_pwd: If stack_on is relative, the location it is
2921
 
            relative to.
2922
 
        """
2923
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2924
 
                                             require_stacking)
2925
 
        self._bzrdir = bzrdir
2926
 
 
2927
 
    def acquire_repository(self, make_working_trees=None, shared=False):
2928
 
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
2929
 
 
2930
 
        Creates the desired repository in the bzrdir we already have.
2931
 
        """
2932
 
        repository = self._bzrdir.create_repository(shared=shared)
2933
 
        self._add_fallback(repository)
2934
 
        if make_working_trees is not None:
2935
 
            repository.set_make_working_trees(make_working_trees)
2936
 
        return repository
2937
 
 
2938
 
 
2939
 
class UseExistingRepository(RepositoryAcquisitionPolicy):
2940
 
    """A policy of reusing an existing repository"""
2941
 
 
2942
 
    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2943
 
                 require_stacking=False):
2944
 
        """Constructor.
2945
 
 
2946
 
        :param repository: The repository to use.
2947
 
        :param stack_on: A location to stack on
2948
 
        :param stack_on_pwd: If stack_on is relative, the location it is
2949
 
            relative to.
2950
 
        """
2951
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2952
 
                                             require_stacking)
2953
 
        self._repository = repository
2954
 
 
2955
 
    def acquire_repository(self, make_working_trees=None, shared=False):
2956
 
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
2957
 
 
2958
 
        Returns an existing repository to use
2959
 
        """
2960
 
        self._add_fallback(self._repository)
2961
 
        return self._repository
2962
 
 
2963
 
 
2964
2613
format_registry = BzrDirFormatRegistry()
2965
2614
format_registry.register('weave', BzrDirFormat6,
2966
2615
    'Pre-0.8 format.  Slower than knit and does not'
3043
2692
    branch_format='bzrlib.branch.BzrBranchFormat6',
3044
2693
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3045
2694
    )
3046
 
format_registry.register_metadir('1.6',
3047
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3048
 
    help='A branch and pack based repository that supports stacking. ',
3049
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3050
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3051
 
    )
3052
 
format_registry.register_metadir('1.6.1-rich-root',
3053
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3054
 
    help='A branch and pack based repository that supports stacking '
3055
 
         'and rich root data (needed for bzr-svn). ',
3056
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3057
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3058
 
    )
3059
 
format_registry.register_metadir('1.9',
3060
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3061
 
    help='A branch and pack based repository that uses btree indexes. ',
3062
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3063
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3064
 
    )
3065
 
format_registry.register_metadir('1.9-rich-root',
3066
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3067
 
    help='A branch and pack based repository that uses btree indexes '
3068
 
         'and rich root data (needed for bzr-svn). ',
3069
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3070
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3071
 
    )
3072
2695
# The following two formats should always just be aliases.
3073
2696
format_registry.register_metadir('development',
3074
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
 
2697
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
3075
2698
    help='Current development format. Can convert data to and from pack-0.92 '
3076
2699
        '(and anything compatible with pack-0.92) format repositories. '
3077
 
        'Repositories and branches in this format can only be read by bzr.dev. '
 
2700
        'Repositories in this format can only be read by bzr.dev. '
3078
2701
        'Please read '
3079
2702
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3080
2703
        'before use.',
3081
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2704
    branch_format='bzrlib.branch.BzrBranchFormat6',
3082
2705
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3083
2706
    experimental=True,
3084
2707
    alias=True,
3085
2708
    )
3086
2709
format_registry.register_metadir('development-subtree',
3087
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
 
2710
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
3088
2711
    help='Current development format, subtree variant. Can convert data to and '
3089
 
        'from pack-0.92-subtree (and anything compatible with '
3090
 
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3091
 
        'this format can only be read by bzr.dev. Please read '
 
2712
        'from pack-0.92 (and anything compatible with pack-0.92) format '
 
2713
        'repositories. Repositories in this format can only be read by '
 
2714
        'bzr.dev. Please read '
3092
2715
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3093
2716
        'before use.',
3094
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
2717
    branch_format='bzrlib.branch.BzrBranchFormat6',
3095
2718
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3096
2719
    experimental=True,
3097
2720
    alias=True,
3098
2721
    )
3099
 
# And the development formats above will have aliased one of the following:
3100
 
format_registry.register_metadir('development2',
3101
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3102
 
    help='1.6.1 with B+Tree based index. '
3103
 
        'Please read '
3104
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3105
 
        'before use.',
3106
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3107
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3108
 
    hidden=True,
3109
 
    experimental=True,
3110
 
    )
3111
 
format_registry.register_metadir('development2-subtree',
3112
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3113
 
    help='1.6.1-subtree with B+Tree based index. '
3114
 
        'Please read '
3115
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3116
 
        'before use.',
3117
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3118
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3119
 
    hidden=True,
3120
 
    experimental=True,
3121
 
    )
3122
 
# The current format that is made on 'bzr init'.
 
2722
# And the development formats which the will have aliased one of follow:
 
2723
format_registry.register_metadir('development0',
 
2724
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
 
2725
    help='Trivial rename of pack-0.92 to provide a development format. '
 
2726
        'Please read '
 
2727
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
2728
        'before use.',
 
2729
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2730
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
2731
    hidden=True,
 
2732
    experimental=True,
 
2733
    )
 
2734
format_registry.register_metadir('development0-subtree',
 
2735
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
 
2736
    help='Trivial rename of pack-0.92-subtree to provide a development format. '
 
2737
        'Please read '
 
2738
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
2739
        'before use.',
 
2740
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2741
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
2742
    hidden=True,
 
2743
    experimental=True,
 
2744
    )
3123
2745
format_registry.set_default('pack-0.92')