/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Robert Collins
  • Date: 2010-05-04 06:22:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100504062251-1ocjhrl53mum9ehw
Minor local_abspath docstring improvement.

Show diffs side-by-side

added added

removed removed

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