1
# Copyright (C) 2006-2011 Canonical Ltd
1
# Copyright (C) 2005, 2006 Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
19
19
At format 7 this was split out into Branch, Repository and Checkout control
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
28
from __future__ import absolute_import
32
from ..lazy_import import lazy_import
33
lazy_import(globals(), """
35
branch as _mod_branch,
41
revision as _mod_revision,
42
transport as _mod_transport,
47
from breezy.bzr import (
48
branch as _mod_bzrbranch,
55
from breezy.bzr import fullhistory as fullhistorybranch
56
from breezy.bzr import knitpack_repo
57
from breezy.transport import (
58
do_catching_redirections,
61
from breezy.i18n import gettext
64
from ..sixish import viewitems
78
class MissingFeature(errors.BzrError):
80
_fmt = ("Missing feature %(feature)s not provided by this "
81
"version of Bazaar or any plugin.")
83
def __init__(self, feature):
84
self.feature = feature
87
class FeatureAlreadyRegistered(errors.BzrError):
89
_fmt = 'The feature %(feature)s has already been registered.'
91
def __init__(self, feature):
92
self.feature = feature
95
class BzrDir(controldir.ControlDir):
23
from copy import deepcopy
25
from cStringIO import StringIO
26
from unittest import TestSuite
29
import bzrlib.errors as errors
30
from bzrlib.lockable_files import LockableFiles, TransportLock
31
from bzrlib.lockdir import LockDir
32
from bzrlib.osutils import safe_unicode
33
from bzrlib.osutils import (
40
from bzrlib.store.revision.text import TextRevisionStore
41
from bzrlib.store.text import TextStore
42
from bzrlib.store.versioned import WeaveStore
43
from bzrlib.symbol_versioning import *
44
from bzrlib.trace import mutter
45
from bzrlib.transactions import WriteTransaction
46
from bzrlib.transport import get_transport, urlunescape
47
from bzrlib.transport.local import LocalTransport
48
from bzrlib.weave import Weave
49
from bzrlib.xml4 import serializer_v4
50
from bzrlib.xml5 import serializer_v5
96
54
"""A .bzr control diretory.
98
56
BzrDir instances let you create or open any of the things that can be
99
57
found within .bzr - checkouts, branches and repositories.
102
60
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
103
:ivar root_transport:
104
a transport connected to the directory this bzr was opened from
105
(i.e. the parent directory holding the .bzr directory).
107
Everything in the bzrdir should have the same file permissions.
109
:cvar hooks: An instance of BzrDirHooks.
62
a transport connected to the directory this bzr was opened from.
112
def break_lock(self):
113
"""Invoke break_lock on the first object in the bzrdir.
115
If there is a tree, the tree is opened and break_lock() called.
116
Otherwise, branch is tried, and finally repository.
65
def can_convert_format(self):
66
"""Return true if this bzrdir is one whose format we can convert from."""
70
def _check_supported(format, allow_unsupported):
71
"""Check whether format is a supported format.
73
If allow_unsupported is True, this is a no-op.
118
# XXX: This seems more like a UI function than something that really
119
# belongs in this class.
121
thing_to_unlock = self.open_workingtree()
122
except (errors.NotLocalUrl, errors.NoWorkingTree):
124
thing_to_unlock = self.open_branch()
125
except errors.NotBranchError:
127
thing_to_unlock = self.open_repository()
128
except errors.NoRepositoryPresent:
130
thing_to_unlock.break_lock()
132
def check_conversion_target(self, target_format):
133
"""Check that a bzrdir as a whole can be converted to a new format."""
134
# The only current restriction is that the repository content can be
135
# fetched compatibly with the target.
136
target_repo_format = target_format.repository_format
138
self.open_repository()._format.check_conversion_target(
140
except errors.NoRepositoryPresent:
141
# No repo, no problem.
144
def clone_on_transport(self, transport, revision_id=None,
145
force_new_repo=False, preserve_stacking=False, stacked_on=None,
146
create_prefix=False, use_existing_dir=True, no_tree=False,
148
"""Clone this bzrdir and its contents to transport verbatim.
150
:param transport: The transport for the location to produce the clone
151
at. If the target directory does not exist, it will be created.
152
:param revision_id: The tip revision-id to use for any branch or
153
working tree. If not None, then the clone operation may tune
75
if not allow_unsupported and not format.is_supported():
76
# see open_downlevel to open legacy branches.
77
raise errors.UnsupportedFormatError(
78
'sorry, format %s not supported' % format,
79
['use a different bzr version',
80
'or remove the .bzr directory'
81
' and "bzr init" again'])
83
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
84
"""Clone this bzrdir and its contents to url verbatim.
86
If urls last component does not exist, it will be created.
88
if revision_id is not None, then the clone operation may tune
154
89
itself to download less data.
155
:param force_new_repo: Do not use a shared repository for the target,
90
:param force_new_repo: Do not use a shared repository for the target
156
91
even if one is available.
157
:param preserve_stacking: When cloning a stacked branch, stack the
158
new branch on top of the other branch's stacked-on branch.
159
:param create_prefix: Create any missing directories leading up to
161
:param use_existing_dir: Use an existing directory if one exists.
162
:param no_tree: If set to true prevents creation of a working tree.
164
# Overview: put together a broad description of what we want to end up
165
# with; then make as few api calls as possible to do it.
167
# We may want to create a repo/branch/tree, if we do so what format
168
# would we want for each:
169
require_stacking = (stacked_on is not None)
170
format = self.cloning_metadir(require_stacking)
172
# Figure out what objects we want:
94
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
95
result = self._format.initialize(url)
174
97
local_repo = self.find_repository()
175
98
except errors.NoRepositoryPresent:
177
local_branches = self.get_branches()
179
local_active_branch = local_branches['']
183
# enable fallbacks when branch is not a branch reference
184
if local_active_branch.repository.has_same_location(local_repo):
185
local_repo = local_active_branch.repository
186
if preserve_stacking:
188
stacked_on = local_active_branch.get_stacked_on_url()
189
except (_mod_branch.UnstackableBranchFormat,
190
errors.UnstackableRepositoryFormat,
193
# Bug: We create a metadir without knowing if it can support stacking,
194
# we should look up the policy needs first, or just use it as a hint,
197
make_working_trees = (local_repo.make_working_trees() and
199
want_shared = local_repo.is_shared()
200
repo_format_name = format.repository_format.network_name()
202
make_working_trees = False
204
repo_format_name = None
206
result_repo, result, require_stacking, repository_policy = \
207
format.initialize_on_transport_ex(
208
transport, use_existing_dir=use_existing_dir,
209
create_prefix=create_prefix, force_new_repo=force_new_repo,
210
stacked_on=stacked_on, stack_on_pwd=self.root_transport.base,
211
repo_format_name=repo_format_name,
212
make_working_trees=make_working_trees, shared_repo=want_shared)
215
# If the result repository is in the same place as the
216
# resulting bzr dir, it will have no content, further if the
217
# result is not stacked then we know all content should be
218
# copied, and finally if we are copying up to a specific
219
# revision_id then we can use the pending-ancestry-result which
220
# does not require traversing all of history to describe it.
221
if (result_repo.user_url == result.user_url
222
and not require_stacking
223
and revision_id is not None):
224
fetch_spec = vf_search.PendingAncestryResult(
225
[revision_id], local_repo)
226
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
101
# may need to copy content in
103
local_repo.clone(result, revision_id=revision_id, basis=basis_repo)
106
result_repo = result.find_repository()
107
# fetch content this dir needs.
109
# XXX FIXME RBC 20060214 need tests for this when the basis
111
result_repo.fetch(basis_repo, revision_id=revision_id)
228
112
result_repo.fetch(local_repo, revision_id=revision_id)
232
if result_repo is not None:
233
raise AssertionError('result_repo not None(%r)' % result_repo)
113
except errors.NoRepositoryPresent:
114
# needed to make one anyway.
115
local_repo.clone(result, revision_id=revision_id, basis=basis_repo)
234
116
# 1 if there is a branch present
235
117
# make sure its content is available in the target repository
237
for name, local_branch in local_branches.items():
239
result, revision_id=(None if name != '' else revision_id),
240
repository_policy=repository_policy,
241
name=name, tag_selector=tag_selector)
243
# Cheaper to check if the target is not local, than to try making
245
result.root_transport.local_abspath('.')
246
if result_repo is None or result_repo.make_working_trees():
247
self.open_workingtree().clone(result, revision_id=revision_id)
120
self.open_branch().clone(result, revision_id=revision_id)
121
except errors.NotBranchError:
124
self.open_workingtree().clone(result, basis=basis_tree)
248
125
except (errors.NoWorkingTree, errors.NotLocalUrl):
252
# TODO: This should be given a Transport, and should chdir up; otherwise
253
# this will open a new connection.
129
def _get_basis_components(self, basis):
130
"""Retrieve the basis components that are available at basis."""
132
return None, None, None
134
basis_tree = basis.open_workingtree()
135
basis_branch = basis_tree.branch
136
basis_repo = basis_branch.repository
137
except (errors.NoWorkingTree, errors.NotLocalUrl):
140
basis_branch = basis.open_branch()
141
basis_repo = basis_branch.repository
142
except errors.NotBranchError:
145
basis_repo = basis.open_repository()
146
except errors.NoRepositoryPresent:
148
return basis_repo, basis_branch, basis_tree
254
150
def _make_tail(self, url):
255
t = _mod_transport.get_transport(url)
258
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
259
stack_on_pwd=None, require_stacking=False):
260
"""Return an object representing a policy to use.
262
This controls whether a new repository is created, and the format of
263
that repository, or some existing shared repository used instead.
265
If stack_on is supplied, will not seek a containing shared repo.
267
:param force_new_repo: If True, require a new repository to be created.
268
:param stack_on: If supplied, the location to stack on. If not
269
supplied, a default_stack_on location may be used.
270
:param stack_on_pwd: If stack_on is relative, the location it is
273
def repository_policy(found_bzrdir):
276
config = found_bzrdir.get_config()
278
stack_on = config.get_default_stack_on()
279
if stack_on is not None:
280
stack_on_pwd = found_bzrdir.user_url
282
# does it have a repository ?
284
repository = found_bzrdir.open_repository()
285
except errors.NoRepositoryPresent:
288
if (found_bzrdir.user_url != self.user_url and
289
not repository.is_shared()):
290
# Don't look higher, can't use a higher shared repo.
298
return UseExistingRepository(
299
repository, stack_on, stack_on_pwd,
300
require_stacking=require_stacking), True
302
return CreateRepository(
303
self, stack_on, stack_on_pwd,
304
require_stacking=require_stacking), True
306
if not force_new_repo:
308
policy = self._find_containing(repository_policy)
309
if policy is not None:
313
return UseExistingRepository(
314
self.open_repository(), stack_on, stack_on_pwd,
315
require_stacking=require_stacking)
316
except errors.NoRepositoryPresent:
318
return CreateRepository(self, stack_on, stack_on_pwd,
319
require_stacking=require_stacking)
151
segments = url.split('/')
152
if segments and segments[-1] not in ('', '.'):
153
parent = '/'.join(segments[:-1])
154
t = bzrlib.transport.get_transport(parent)
156
t.mkdir(segments[-1])
157
except errors.FileExists:
161
def create(cls, base):
162
"""Create a new BzrDir at the url 'base'.
164
This will call the current default formats initialize with base
165
as the only parameter.
167
If you need a specific format, consider creating an instance
168
of that and calling initialize().
170
if cls is not BzrDir:
171
raise AssertionError("BzrDir.create always creates the default format, "
172
"not one of %r" % cls)
173
segments = base.split('/')
174
if segments and segments[-1] not in ('', '.'):
175
parent = '/'.join(segments[:-1])
176
t = bzrlib.transport.get_transport(parent)
178
t.mkdir(segments[-1])
179
except errors.FileExists:
181
return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
183
def create_branch(self):
184
"""Create a branch in this BzrDir.
186
The bzrdirs format will control what branch format is created.
187
For more control see BranchFormatXX.create(a_bzrdir).
189
raise NotImplementedError(self.create_branch)
192
def create_branch_and_repo(base, force_new_repo=False):
193
"""Create a new BzrDir, Branch and Repository at the url 'base'.
195
This will use the current default BzrDirFormat, and use whatever
196
repository format that that uses via bzrdir.create_branch and
197
create_repository. If a shared repository is available that is used
200
The created Branch object is returned.
202
:param base: The URL to create the branch at.
203
:param force_new_repo: If True a new repository is always created.
205
bzrdir = BzrDir.create(base)
206
bzrdir._find_or_create_repository(force_new_repo)
207
return bzrdir.create_branch()
321
209
def _find_or_create_repository(self, force_new_repo):
322
210
"""Create a new repository if needed, returning the repository."""
323
policy = self.determine_repository_policy(force_new_repo)
324
return policy.acquire_repository()[0]
326
def _find_source_repo(self, exit_stack, source_branch):
327
"""Find the source branch and repo for a sprout operation.
329
This is helper intended for use by _sprout.
331
:returns: (source_branch, source_repository). Either or both may be
332
None. If not None, they will be read-locked (and their unlock(s)
333
scheduled via the exit_stack param).
335
if source_branch is not None:
336
exit_stack.enter_context(source_branch.lock_read())
337
return source_branch, source_branch.repository
212
return self.create_repository()
339
source_branch = self.open_branch()
340
source_repository = source_branch.repository
341
except errors.NotBranchError:
344
source_repository = self.open_repository()
345
except errors.NoRepositoryPresent:
346
source_repository = None
348
exit_stack.enter_context(source_repository.lock_read())
214
return self.find_repository()
215
except errors.NoRepositoryPresent:
216
return self.create_repository()
219
def create_branch_convenience(base, force_new_repo=False,
220
force_new_tree=None, format=None):
221
"""Create a new BzrDir, Branch and Repository at the url 'base'.
223
This is a convenience function - it will use an existing repository
224
if possible, can be told explicitly whether to create a working tree or
227
This will use the current default BzrDirFormat, and use whatever
228
repository format that that uses via bzrdir.create_branch and
229
create_repository. If a shared repository is available that is used
230
preferentially. Whatever repository is used, its tree creation policy
233
The created Branch object is returned.
234
If a working tree cannot be made due to base not being a file:// url,
235
no error is raised unless force_new_tree is True, in which case no
236
data is created on disk and NotLocalUrl is raised.
238
:param base: The URL to create the branch at.
239
:param force_new_repo: If True a new repository is always created.
240
:param force_new_tree: If True or False force creation of a tree or
241
prevent such creation respectively.
242
:param format: Override for the for the bzrdir format to create
245
# check for non local urls
246
t = get_transport(safe_unicode(base))
247
if not isinstance(t, LocalTransport):
248
raise errors.NotLocalUrl(base)
250
bzrdir = BzrDir.create(base)
350
exit_stack.enter_context(source_branch.lock_read())
351
return source_branch, source_repository
353
def sprout(self, url, revision_id=None, force_new_repo=False,
354
recurse='down', possible_transports=None,
355
accelerator_tree=None, hardlink=False, stacked=False,
356
source_branch=None, create_tree_if_local=True,
358
"""Create a copy of this controldir prepared for use as a new line of
361
If url's last component does not exist, it will be created.
363
Attributes related to the identity of the source branch like
364
branch nickname will be cleaned, a working tree is created
365
whether one existed before or not; and a local branch is always
368
if revision_id is not None, then the clone operation may tune
369
itself to download less data.
371
:param accelerator_tree: A tree which can be used for retrieving file
372
contents more quickly than the revision tree, i.e. a workingtree.
373
The revision tree will be used for cases where accelerator_tree's
374
content is different.
375
:param hardlink: If true, hard-link files from accelerator_tree,
377
:param stacked: If true, create a stacked branch referring to the
378
location of this control directory.
379
:param create_tree_if_local: If true, a working-tree will be created
380
when working locally.
381
:return: The created control directory
383
with cleanup.ExitStack() as stack:
384
fetch_spec_factory = fetch.FetchSpecFactory()
385
if revision_id is not None:
386
fetch_spec_factory.add_revision_ids([revision_id])
387
fetch_spec_factory.source_branch_stop_revision_id = revision_id
388
if possible_transports is None:
389
possible_transports = []
391
possible_transports = list(possible_transports) + [
393
target_transport = _mod_transport.get_transport(url,
395
target_transport.ensure_base()
396
cloning_format = self.cloning_metadir(stacked)
397
# Create/update the result branch
399
result = controldir.ControlDir.open_from_transport(
401
except errors.NotBranchError:
402
result = cloning_format.initialize_on_transport(target_transport)
403
source_branch, source_repository = self._find_source_repo(
404
stack, source_branch)
405
fetch_spec_factory.source_branch = source_branch
406
# if a stacked branch wasn't requested, we don't create one
407
# even if the origin was stacked
408
if stacked and source_branch is not None:
409
stacked_branch_url = self.root_transport.base
411
stacked_branch_url = None
412
repository_policy = result.determine_repository_policy(
413
force_new_repo, stacked_branch_url, require_stacking=stacked)
414
result_repo, is_new_repo = repository_policy.acquire_repository(
415
possible_transports=possible_transports)
416
stack.enter_context(result_repo.lock_write())
417
fetch_spec_factory.source_repo = source_repository
418
fetch_spec_factory.target_repo = result_repo
419
if stacked or (len(result_repo._fallback_repositories) != 0):
420
target_repo_kind = fetch.TargetRepoKinds.STACKED
422
target_repo_kind = fetch.TargetRepoKinds.EMPTY
424
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
425
fetch_spec_factory.target_repo_kind = target_repo_kind
426
if source_repository is not None:
427
fetch_spec = fetch_spec_factory.make_fetch_spec()
428
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
430
if source_branch is None:
431
# this is for sprouting a controldir without a branch; is that
433
# Not especially, but it's part of the contract.
434
result_branch = result.create_branch()
436
result_branch = source_branch.sprout(
437
result, revision_id=revision_id,
438
repository_policy=repository_policy, repository=result_repo)
439
mutter("created new branch %r" % (result_branch,))
441
# Create/update the result working tree
442
if (create_tree_if_local and not result.has_workingtree()
443
and isinstance(target_transport, local.LocalTransport)
444
and (result_repo is None or result_repo.make_working_trees())
445
and result.open_branch(
447
possible_transports=possible_transports).name == result_branch.name):
448
wt = result.create_workingtree(
449
accelerator_tree=accelerator_tree, hardlink=hardlink,
450
from_branch=result_branch)
451
with wt.lock_write():
452
if not wt.is_versioned(''):
454
wt.set_root_id(self.open_workingtree.path2id(''))
455
except errors.NoWorkingTree:
459
if recurse == 'down':
463
basis = tree.basis_tree()
464
stack.enter_context(basis.lock_read())
465
elif result_branch is not None:
466
basis = tree = result_branch.basis_tree()
467
elif source_branch is not None:
468
basis = tree = source_branch.basis_tree()
470
stack.enter_context(tree.lock_read())
471
subtrees = tree.iter_references()
474
for path in subtrees:
475
target = urlutils.join(url, urlutils.escape(path))
476
sublocation = tree.reference_parent(
477
path, branch=result_branch,
478
possible_transports=possible_transports)
479
if sublocation is None:
481
'Ignoring nested tree %s, parent location unknown.',
484
sublocation.controldir.sprout(
485
target, basis.get_reference_revision(path),
486
force_new_repo=force_new_repo, recurse=recurse,
490
def _available_backup_name(self, base):
491
"""Find a non-existing backup file name based on base.
493
See breezy.osutils.available_backup_name about race conditions.
495
return osutils.available_backup_name(base, self.root_transport.has)
497
def backup_bzrdir(self):
498
"""Backup this bzr control directory.
500
:return: Tuple with old path name and new path name
503
with ui.ui_factory.nested_progress_bar():
504
old_path = self.root_transport.abspath('.bzr')
505
backup_dir = self._available_backup_name('backup.bzr')
506
new_path = self.root_transport.abspath(backup_dir)
508
gettext('making backup of {0}\n to {1}').format(
509
urlutils.unescape_for_display(old_path, 'utf-8'),
510
urlutils.unescape_for_display(new_path, 'utf-8')))
511
self.root_transport.copy_tree('.bzr', backup_dir)
512
return (old_path, new_path)
514
def retire_bzrdir(self, limit=10000):
515
"""Permanently disable the bzrdir.
517
This is done by renaming it to give the user some ability to recover
518
if there was a problem.
520
This will have horrible consequences if anyone has anything locked or
522
:param limit: number of times to retry
527
to_path = '.bzr.retired.%d' % i
528
self.root_transport.rename('.bzr', to_path)
529
note(gettext("renamed {0} to {1}").format(
530
self.root_transport.abspath('.bzr'), to_path))
532
except (errors.TransportError, IOError, errors.PathError):
539
def _find_containing(self, evaluate):
540
"""Find something in a containing control directory.
542
This method will scan containing control dirs, until it finds what
543
it is looking for, decides that it will never find it, or runs out
544
of containing control directories to check.
546
It is used to implement find_repository and
547
determine_repository_policy.
549
:param evaluate: A function returning (value, stop). If stop is True,
550
the value will be returned.
554
result, stop = evaluate(found_bzrdir)
557
next_transport = found_bzrdir.root_transport.clone('..')
558
if (found_bzrdir.user_url == next_transport.base):
559
# top of the file system
561
# find the next containing bzrdir
563
found_bzrdir = self.open_containing_from_transport(
565
except errors.NotBranchError:
252
bzrdir = format.initialize(base)
253
repo = bzrdir._find_or_create_repository(force_new_repo)
254
result = bzrdir.create_branch()
255
if force_new_tree or (repo.make_working_trees() and
256
force_new_tree is None):
258
bzrdir.create_workingtree()
259
except errors.NotLocalUrl:
264
def create_repository(base, shared=False):
265
"""Create a new BzrDir and Repository at the url 'base'.
267
This will use the current default BzrDirFormat, and use whatever
268
repository format that that uses for bzrdirformat.create_repository.
270
;param shared: Create a shared repository rather than a standalone
272
The Repository object is returned.
274
This must be overridden as an instance method in child classes, where
275
it should take no parameters and construct whatever repository format
276
that child class desires.
278
bzrdir = BzrDir.create(base)
279
return bzrdir.create_repository()
282
def create_standalone_workingtree(base):
283
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
285
'base' must be a local path or a file:// url.
287
This will use the current default BzrDirFormat, and use whatever
288
repository format that that uses for bzrdirformat.create_workingtree,
289
create_branch and create_repository.
291
The WorkingTree object is returned.
293
t = get_transport(safe_unicode(base))
294
if not isinstance(t, LocalTransport):
295
raise errors.NotLocalUrl(base)
296
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
297
force_new_repo=True).bzrdir
298
return bzrdir.create_workingtree()
300
def create_workingtree(self, revision_id=None):
301
"""Create a working tree at this BzrDir.
303
revision_id: create it as of this revision id.
305
raise NotImplementedError(self.create_workingtree)
568
307
def find_repository(self):
569
"""Find the repository that should be used.
308
"""Find the repository that should be used for a_bzrdir.
571
310
This does not require a branch as we use it to find the repo for
572
311
new branches as well as to hook existing branches up to their
575
def usable_repository(found_bzrdir):
576
# does it have a repository ?
315
return self.open_repository()
316
except errors.NoRepositoryPresent:
318
next_transport = self.root_transport.clone('..')
321
found_bzrdir = BzrDir.open_containing_from_transport(
323
except errors.NotBranchError:
324
raise errors.NoRepositoryPresent(self)
578
326
repository = found_bzrdir.open_repository()
579
327
except errors.NoRepositoryPresent:
581
if found_bzrdir.user_url == self.user_url:
582
return repository, True
583
elif repository.is_shared():
584
return repository, True
588
found_repo = self._find_containing(usable_repository)
589
if found_repo is None:
590
raise errors.NoRepositoryPresent(self)
593
def _find_creation_modes(self):
594
"""Determine the appropriate modes for files and directories.
596
They're always set to be consistent with the base directory,
597
assuming that this transport allows setting modes.
599
# TODO: Do we need or want an option (maybe a config setting) to turn
600
# this off or override it for particular locations? -- mbp 20080512
601
if self._mode_check_done:
603
self._mode_check_done = True
605
st = self.transport.stat('.')
606
except errors.TransportNotPossible:
607
self._dir_mode = None
608
self._file_mode = None
610
# Check the directory mode, but also make sure the created
611
# directories and files are read-write for this user. This is
612
# mostly a workaround for filesystems which lie about being able to
613
# write to a directory (cygwin & win32)
614
if (st.st_mode & 0o7777 == 00000):
615
# FTP allows stat but does not return dir/file modes
616
self._dir_mode = None
617
self._file_mode = None
619
self._dir_mode = (st.st_mode & 0o7777) | 0o0700
620
# Remove the sticky and execute bits for files
621
self._file_mode = self._dir_mode & ~0o7111
623
def _get_file_mode(self):
624
"""Return Unix mode for newly created files, or None.
626
if not self._mode_check_done:
627
self._find_creation_modes()
628
return self._file_mode
630
def _get_dir_mode(self):
631
"""Return Unix mode for newly created directories, or None.
633
if not self._mode_check_done:
634
self._find_creation_modes()
635
return self._dir_mode
637
def get_config(self):
638
"""Get configuration for this BzrDir."""
639
return config.BzrDirConfig(self)
641
def _get_config(self):
642
"""By default, no configuration is available."""
645
def __init__(self, _transport, _format):
646
"""Initialize a Bzr control dir object.
648
Only really common logic should reside here, concrete classes should be
649
made with varying behaviours.
651
:param _format: the format that is creating this BzrDir instance.
652
:param _transport: the transport this dir is based at.
654
self._format = _format
655
# these are also under the more standard names of
656
# control_transport and user_transport
657
self.transport = _transport.clone('.bzr')
658
self.root_transport = _transport
659
self._mode_check_done = False
662
def user_transport(self):
663
return self.root_transport
666
def control_transport(self):
667
return self.transport
669
def _cloning_metadir(self):
670
"""Produce a metadir suitable for cloning with.
672
:returns: (destination_bzrdir_format, source_repository)
674
result_format = self._format.__class__()
677
branch = self.open_branch(ignore_fallbacks=True)
678
source_repository = branch.repository
679
result_format._branch_format = branch._format
680
except errors.NotBranchError:
681
source_repository = self.open_repository()
682
except errors.NoRepositoryPresent:
683
source_repository = None
685
# XXX TODO: This isinstance is here because we have not implemented
686
# the fix recommended in bug # 103195 - to delegate this choice the
688
repo_format = source_repository._format
689
if isinstance(repo_format, remote.RemoteRepositoryFormat):
690
source_repository._ensure_real()
691
repo_format = source_repository._real_repository._format
692
result_format.repository_format = repo_format
694
# TODO: Couldn't we just probe for the format in these cases,
695
# rather than opening the whole tree? It would be a little
696
# faster. mbp 20070401
697
tree = self.open_workingtree(recommend_upgrade=False)
698
except (errors.NoWorkingTree, errors.NotLocalUrl):
699
result_format.workingtree_format = None
701
result_format.workingtree_format = tree._format.__class__()
702
return result_format, source_repository
704
def cloning_metadir(self, require_stacking=False):
705
"""Produce a metadir suitable for cloning or sprouting with.
707
These operations may produce workingtrees (yes, even though they're
708
"cloning" something that doesn't have a tree), so a viable workingtree
709
format must be selected.
711
:require_stacking: If True, non-stackable formats will be upgraded
712
to similar stackable formats.
713
:returns: a ControlDirFormat with all component formats either set
714
appropriately or set to None if that component should not be
717
format, repository = self._cloning_metadir()
718
if format._workingtree_format is None:
720
if repository is None:
721
# No repository either
723
# We have a repository, so set a working tree? (Why? This seems to
724
# contradict the stated return value in the docstring).
726
repository._format._matchingcontroldir.workingtree_format)
727
format.workingtree_format = tree_format.__class__()
729
format.require_stacking()
732
def get_branch_transport(self, branch_format, name=None):
328
next_transport = found_bzrdir.root_transport.clone('..')
330
if ((found_bzrdir.root_transport.base ==
331
self.root_transport.base) or repository.is_shared()):
334
raise errors.NoRepositoryPresent(self)
335
raise errors.NoRepositoryPresent(self)
337
def get_branch_transport(self, branch_format):
733
338
"""Get the transport for use by branch format in this BzrDir.
735
340
Note that bzr dirs that do not support format strings will raise
736
341
IncompatibleFormat if the branch format they are given has
737
a format string, and vice versa.
342
a format string, and vice verca.
739
If branch_format is None, the transport is returned with no
740
checking. If it is not None, then the returned transport is
344
If branch_format is None, the transport is returned with no
345
checking. if it is not None, then the returned transport is
741
346
guaranteed to point to an existing directory ready for use.
743
348
raise NotImplementedError(self.get_branch_transport)
745
350
def get_repository_transport(self, repository_format):
746
351
"""Get the transport for use by repository format in this BzrDir.
748
353
Note that bzr dirs that do not support format strings will raise
749
354
IncompatibleFormat if the repository format they are given has
750
a format string, and vice versa.
355
a format string, and vice verca.
752
If repository_format is None, the transport is returned with no
753
checking. If it is not None, then the returned transport is
357
If repository_format is None, the transport is returned with no
358
checking. if it is not None, then the returned transport is
754
359
guaranteed to point to an existing directory ready for use.
756
361
raise NotImplementedError(self.get_repository_transport)
758
363
def get_workingtree_transport(self, tree_format):
759
364
"""Get the transport for use by workingtree format in this BzrDir.
761
366
Note that bzr dirs that do not support format strings will raise
762
IncompatibleFormat if the workingtree format they are given has a
763
format string, and vice versa.
367
IncompatibleFormat if the workingtree format they are given has
368
a format string, and vice verca.
765
If workingtree_format is None, the transport is returned with no
766
checking. If it is not None, then the returned transport is
370
If workingtree_format is None, the transport is returned with no
371
checking. if it is not None, then the returned transport is
767
372
guaranteed to point to an existing directory ready for use.
769
374
raise NotImplementedError(self.get_workingtree_transport)
772
def create(cls, base, format=None, possible_transports=None):
773
"""Create a new BzrDir at the url 'base'.
775
:param format: If supplied, the format of branch to create. If not
776
supplied, the default is used.
777
:param possible_transports: If supplied, a list of transports that
778
can be reused to share a remote connection.
780
if cls is not BzrDir:
781
raise AssertionError("BzrDir.create always creates the "
782
"default format, not one of %r" % cls)
783
return controldir.ControlDir.create(
784
base, format=format, possible_transports=possible_transports)
787
return "<%s at %r>" % (self.__class__.__name__, self.user_url)
789
def update_feature_flags(self, updated_flags):
790
"""Update the features required by this bzrdir.
792
:param updated_flags: Dictionary mapping feature names to necessities
793
A necessity can be None to indicate the feature should be removed
795
self.control_files.lock_write()
797
self._format._update_feature_flags(updated_flags)
798
self.transport.put_bytes('branch-format', self._format.as_string())
800
self.control_files.unlock()
376
def __init__(self, _transport, _format):
377
"""Initialize a Bzr control dir object.
379
Only really common logic should reside here, concrete classes should be
380
made with varying behaviours.
382
:param _format: the format that is creating this BzrDir instance.
383
:param _transport: the transport this dir is based at.
385
self._format = _format
386
self.transport = _transport.clone('.bzr')
387
self.root_transport = _transport
389
def needs_format_conversion(self, format=None):
390
"""Return true if this bzrdir needs convert_format run on it.
392
For instance, if the repository format is out of date but the
393
branch and working tree are not, this should return True.
395
:param format: Optional parameter indicating a specific desired
396
format we plan to arrive at.
398
raise NotImplementedError(self.needs_format_conversion)
401
def open_unsupported(base):
402
"""Open a branch which is not supported."""
403
return BzrDir.open(base, _unsupported=True)
406
def open(base, _unsupported=False):
407
"""Open an existing bzrdir, rooted at 'base' (url)
409
_unsupported is a private parameter to the BzrDir class.
411
t = get_transport(base)
412
mutter("trying to open %r with transport %r", base, t)
413
format = BzrDirFormat.find_format(t)
414
BzrDir._check_supported(format, _unsupported)
415
return format.open(t, _found=True)
417
def open_branch(self, unsupported=False):
418
"""Open the branch object at this BzrDir if one is present.
420
If unsupported is True, then no longer supported branch formats can
423
TODO: static convenience version of this?
425
raise NotImplementedError(self.open_branch)
428
def open_containing(url):
429
"""Open an existing branch which contains url.
431
:param url: url to search from.
432
See open_containing_from_transport for more detail.
434
return BzrDir.open_containing_from_transport(get_transport(url))
437
def open_containing_from_transport(a_transport):
438
"""Open an existing branch which contains a_transport.base
440
This probes for a branch at a_transport, and searches upwards from there.
442
Basically we keep looking up until we find the control directory or
443
run into the root. If there isn't one, raises NotBranchError.
444
If there is one and it is either an unrecognised format or an unsupported
445
format, UnknownFormatError or UnsupportedFormatError are raised.
446
If there is one, it is returned, along with the unused portion of url.
448
# this gets the normalised url back. I.e. '.' -> the full path.
449
url = a_transport.base
452
format = BzrDirFormat.find_format(a_transport)
453
BzrDir._check_supported(format, False)
454
return format.open(a_transport), a_transport.relpath(url)
455
except errors.NotBranchError, e:
456
mutter('not a branch in: %r %s', a_transport.base, e)
457
new_t = a_transport.clone('..')
458
if new_t.base == a_transport.base:
459
# reached the root, whatever that may be
460
raise errors.NotBranchError(path=url)
463
def open_repository(self, _unsupported=False):
464
"""Open the repository object at this BzrDir if one is present.
466
This will not follow the Branch object pointer - its strictly a direct
467
open facility. Most client code should use open_branch().repository to
470
_unsupported is a private parameter, not part of the api.
471
TODO: static convenience version of this?
473
raise NotImplementedError(self.open_repository)
475
def open_workingtree(self, _unsupported=False):
476
"""Open the workingtree object at this BzrDir if one is present.
478
TODO: static convenience version of this?
480
raise NotImplementedError(self.open_workingtree)
482
def has_branch(self):
483
"""Tell if this bzrdir contains a branch.
485
Note: if you're going to open the branch, you should just go ahead
486
and try, and not ask permission first. (This method just opens the
487
branch and discards it, and that's somewhat expensive.)
492
except errors.NotBranchError:
495
def has_workingtree(self):
496
"""Tell if this bzrdir contains a working tree.
498
This will still raise an exception if the bzrdir has a workingtree that
499
is remote & inaccessible.
501
Note: if you're going to open the working tree, you should just go ahead
502
and try, and not ask permission first. (This method just opens the
503
workingtree and discards it, and that's somewhat expensive.)
506
self.open_workingtree()
508
except errors.NoWorkingTree:
511
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
512
"""Create a copy of this bzrdir prepared for use as a new line of
515
If urls last component does not exist, it will be created.
517
Attributes related to the identity of the source branch like
518
branch nickname will be cleaned, a working tree is created
519
whether one existed before or not; and a local branch is always
522
if revision_id is not None, then the clone operation may tune
523
itself to download less data.
526
result = self._format.initialize(url)
527
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
529
source_branch = self.open_branch()
530
source_repository = source_branch.repository
531
except errors.NotBranchError:
534
source_repository = self.open_repository()
535
except errors.NoRepositoryPresent:
536
# copy the entire basis one if there is one
537
# but there is no repository.
538
source_repository = basis_repo
543
result_repo = result.find_repository()
544
except errors.NoRepositoryPresent:
546
if source_repository is None and result_repo is not None:
548
elif source_repository is None and result_repo is None:
549
# no repo available, make a new one
550
result.create_repository()
551
elif source_repository is not None and result_repo is None:
552
# have soure, and want to make a new target repo
553
source_repository.clone(result,
554
revision_id=revision_id,
557
# fetch needed content into target.
559
# XXX FIXME RBC 20060214 need tests for this when the basis
561
result_repo.fetch(basis_repo, revision_id=revision_id)
562
result_repo.fetch(source_repository, revision_id=revision_id)
563
if source_branch is not None:
564
source_branch.sprout(result, revision_id=revision_id)
566
result.create_branch()
567
if result_repo is None or result_repo.make_working_trees():
568
result.create_workingtree()
572
class BzrDirPreSplitOut(BzrDir):
573
"""A common class for the all-in-one formats."""
575
def __init__(self, _transport, _format):
576
"""See BzrDir.__init__."""
577
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
578
assert self._format._lock_class == TransportLock
579
assert self._format._lock_file_name == 'branch-lock'
580
self._control_files = LockableFiles(self.get_branch_transport(None),
581
self._format._lock_file_name,
582
self._format._lock_class)
584
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
585
"""See BzrDir.clone()."""
586
from bzrlib.workingtree import WorkingTreeFormat2
588
result = self._format._initialize_for_clone(url)
589
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
590
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
591
self.open_branch().clone(result, revision_id=revision_id)
593
self.open_workingtree().clone(result, basis=basis_tree)
594
except errors.NotLocalUrl:
595
# make a new one, this format always has to have one.
597
WorkingTreeFormat2().initialize(result)
598
except errors.NotLocalUrl:
599
# but we canot do it for remote trees.
603
def create_branch(self):
604
"""See BzrDir.create_branch."""
605
return self.open_branch()
607
def create_repository(self, shared=False):
608
"""See BzrDir.create_repository."""
610
raise errors.IncompatibleFormat('shared repository', self._format)
611
return self.open_repository()
613
def create_workingtree(self, revision_id=None):
614
"""See BzrDir.create_workingtree."""
615
# this looks buggy but is not -really-
616
# clone and sprout will have set the revision_id
617
# and that will have set it for us, its only
618
# specific uses of create_workingtree in isolation
619
# that can do wonky stuff here, and that only
620
# happens for creating checkouts, which cannot be
621
# done on this format anyway. So - acceptable wart.
622
result = self.open_workingtree()
623
if revision_id is not None:
624
result.set_last_revision(revision_id)
627
def get_branch_transport(self, branch_format):
628
"""See BzrDir.get_branch_transport()."""
629
if branch_format is None:
630
return self.transport
632
branch_format.get_format_string()
633
except NotImplementedError:
634
return self.transport
635
raise errors.IncompatibleFormat(branch_format, self._format)
637
def get_repository_transport(self, repository_format):
638
"""See BzrDir.get_repository_transport()."""
639
if repository_format is None:
640
return self.transport
642
repository_format.get_format_string()
643
except NotImplementedError:
644
return self.transport
645
raise errors.IncompatibleFormat(repository_format, self._format)
647
def get_workingtree_transport(self, workingtree_format):
648
"""See BzrDir.get_workingtree_transport()."""
649
if workingtree_format is None:
650
return self.transport
652
workingtree_format.get_format_string()
653
except NotImplementedError:
654
return self.transport
655
raise errors.IncompatibleFormat(workingtree_format, self._format)
657
def needs_format_conversion(self, format=None):
658
"""See BzrDir.needs_format_conversion()."""
659
# if the format is not the same as the system default,
660
# an upgrade is needed.
662
format = BzrDirFormat.get_default_format()
663
return not isinstance(self._format, format.__class__)
665
def open_branch(self, unsupported=False):
666
"""See BzrDir.open_branch."""
667
from bzrlib.branch import BzrBranchFormat4
668
format = BzrBranchFormat4()
669
self._check_supported(format, unsupported)
670
return format.open(self, _found=True)
672
def sprout(self, url, revision_id=None, basis=None):
673
"""See BzrDir.sprout()."""
674
from bzrlib.workingtree import WorkingTreeFormat2
676
result = self._format._initialize_for_clone(url)
677
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
679
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
680
except errors.NoRepositoryPresent:
683
self.open_branch().sprout(result, revision_id=revision_id)
684
except errors.NotBranchError:
686
# we always want a working tree
687
WorkingTreeFormat2().initialize(result)
691
class BzrDir4(BzrDirPreSplitOut):
692
"""A .bzr version 4 control object.
694
This is a deprecated format and may be removed after sept 2006.
697
def create_repository(self, shared=False):
698
"""See BzrDir.create_repository."""
699
return self._format.repository_format.initialize(self, shared)
701
def needs_format_conversion(self, format=None):
702
"""Format 4 dirs are always in need of conversion."""
705
def open_repository(self):
706
"""See BzrDir.open_repository."""
707
from bzrlib.repository import RepositoryFormat4
708
return RepositoryFormat4().open(self, _found=True)
711
class BzrDir5(BzrDirPreSplitOut):
712
"""A .bzr version 5 control object.
714
This is a deprecated format and may be removed after sept 2006.
717
def open_repository(self):
718
"""See BzrDir.open_repository."""
719
from bzrlib.repository import RepositoryFormat5
720
return RepositoryFormat5().open(self, _found=True)
722
def open_workingtree(self, _unsupported=False):
723
"""See BzrDir.create_workingtree."""
724
from bzrlib.workingtree import WorkingTreeFormat2
725
return WorkingTreeFormat2().open(self, _found=True)
728
class BzrDir6(BzrDirPreSplitOut):
729
"""A .bzr version 6 control object.
731
This is a deprecated format and may be removed after sept 2006.
734
def open_repository(self):
735
"""See BzrDir.open_repository."""
736
from bzrlib.repository import RepositoryFormat6
737
return RepositoryFormat6().open(self, _found=True)
739
def open_workingtree(self, _unsupported=False):
740
"""See BzrDir.create_workingtree."""
741
from bzrlib.workingtree import WorkingTreeFormat2
742
return WorkingTreeFormat2().open(self, _found=True)
803
745
class BzrDirMeta1(BzrDir):
804
746
"""A .bzr meta version 1 control object.
806
This is the first control object where the
748
This is the first control object where the
807
749
individual aspects are really split out: there are separate repository,
808
750
workingtree and branch subdirectories and any subset of the three can be
809
751
present within a BzrDir.
812
def _get_branch_path(self, name):
813
"""Obtain the branch path to use.
815
This uses the API specified branch name first, and then falls back to
816
the branch name specified in the URL. If neither of those is specified,
817
it uses the default branch.
819
:param name: Optional branch name to use
820
:return: Relative path to branch
824
return urlutils.join('branches', urlutils.escape(name))
826
def _read_branch_list(self):
827
"""Read the branch list.
829
:return: List of branch names.
832
f = self.control_transport.get('branch-list')
833
except errors.NoSuchFile:
839
ret.append(name.rstrip(b"\n").decode('utf-8'))
844
def _write_branch_list(self, branches):
845
"""Write out the branch list.
847
:param branches: List of utf-8 branch names to write
849
self.transport.put_bytes(
851
b"".join([name.encode('utf-8') + b"\n" for name in branches]))
853
def __init__(self, _transport, _format):
854
super(BzrDirMeta1, self).__init__(_transport, _format)
855
self.control_files = lockable_files.LockableFiles(
856
self.control_transport, self._format._lock_file_name,
857
self._format._lock_class)
859
754
def can_convert_format(self):
860
755
"""See BzrDir.can_convert_format()."""
863
def create_branch(self, name=None, repository=None,
864
append_revisions_only=None):
865
"""See ControlDir.create_branch."""
867
name = self._get_selected_branch()
868
return self._format.get_branch_format().initialize(
869
self, name=name, repository=repository,
870
append_revisions_only=append_revisions_only)
872
def destroy_branch(self, name=None):
873
"""See ControlDir.destroy_branch."""
875
name = self._get_selected_branch()
876
path = self._get_branch_path(name)
878
self.control_files.lock_write()
880
branches = self._read_branch_list()
882
branches.remove(name)
884
raise errors.NotBranchError(name)
885
self._write_branch_list(branches)
887
self.control_files.unlock()
889
self.transport.delete_tree(path)
890
except errors.NoSuchFile:
891
raise errors.NotBranchError(
892
path=urlutils.join(self.transport.base, path), controldir=self)
758
def create_branch(self):
759
"""See BzrDir.create_branch."""
760
from bzrlib.branch import BranchFormat
761
return BranchFormat.get_default_format().initialize(self)
894
763
def create_repository(self, shared=False):
895
764
"""See BzrDir.create_repository."""
896
765
return self._format.repository_format.initialize(self, shared)
898
def destroy_repository(self):
899
"""See BzrDir.destroy_repository."""
901
self.transport.delete_tree('repository')
902
except errors.NoSuchFile:
903
raise errors.NoRepositoryPresent(self)
905
def create_workingtree(self, revision_id=None, from_branch=None,
906
accelerator_tree=None, hardlink=False):
767
def create_workingtree(self, revision_id=None):
907
768
"""See BzrDir.create_workingtree."""
908
return self._format.workingtree_format.initialize(
909
self, revision_id, from_branch=from_branch,
910
accelerator_tree=accelerator_tree, hardlink=hardlink)
912
def destroy_workingtree(self):
913
"""See BzrDir.destroy_workingtree."""
914
wt = self.open_workingtree(recommend_upgrade=False)
915
repository = wt.branch.repository
916
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
917
# We ignore the conflicts returned by wt.revert since we're about to
918
# delete the wt metadata anyway, all that should be left here are
919
# detritus. But see bug #634470 about subtree .bzr dirs.
920
wt.revert(old_tree=empty)
921
self.destroy_workingtree_metadata()
923
def destroy_workingtree_metadata(self):
924
self.transport.delete_tree('checkout')
926
def find_branch_format(self, name=None):
927
"""Find the branch 'format' for this bzrdir.
929
This might be a synthetic object for e.g. RemoteBranch and SVN.
931
from .branch import BranchFormatMetadir
932
return BranchFormatMetadir.find_format(self, name=name)
769
from bzrlib.workingtree import WorkingTreeFormat
770
return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
934
772
def _get_mkdir_mode(self):
935
773
"""Figure out the mode to use when creating a bzrdir subdir."""
936
temp_control = lockable_files.LockableFiles(
937
self.transport, '', lockable_files.TransportLock)
774
temp_control = LockableFiles(self.transport, '', TransportLock)
938
775
return temp_control._dir_mode
940
def get_branch_reference(self, name=None):
941
"""See BzrDir.get_branch_reference()."""
942
from .branch import BranchFormatMetadir
943
format = BranchFormatMetadir.find_format(self, name=name)
944
return format.get_reference(self, name=name)
946
def set_branch_reference(self, target_branch, name=None):
947
format = _mod_bzrbranch.BranchReferenceFormat()
948
if (self.control_url == target_branch.controldir.control_url
949
and name == target_branch.name):
950
raise controldir.BranchReferenceLoop(target_branch)
951
return format.initialize(self, target_branch=target_branch, name=name)
953
def get_branch_transport(self, branch_format, name=None):
777
def get_branch_transport(self, branch_format):
954
778
"""See BzrDir.get_branch_transport()."""
956
name = self._get_selected_branch()
957
path = self._get_branch_path(name)
958
# XXX: this shouldn't implicitly create the directory if it's just
959
# promising to get a transport -- mbp 20090727
960
779
if branch_format is None:
961
return self.transport.clone(path)
780
return self.transport.clone('branch')
963
782
branch_format.get_format_string()
964
783
except NotImplementedError:
965
784
raise errors.IncompatibleFormat(branch_format, self._format)
967
branches = self._read_branch_list()
968
if name not in branches:
969
self.control_files.lock_write()
971
branches = self._read_branch_list()
972
dirname = urlutils.dirname(name)
973
if dirname != u"" and dirname in branches:
974
raise errors.ParentBranchExists(name)
976
b.startswith(name + u"/") for b in branches]
977
if any(child_branches):
978
raise errors.AlreadyBranchError(name)
979
branches.append(name)
980
self._write_branch_list(branches)
982
self.control_files.unlock()
983
branch_transport = self.transport.clone(path)
984
mode = self._get_mkdir_mode()
985
branch_transport.create_prefix(mode=mode)
987
self.transport.mkdir(path, mode=mode)
786
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
988
787
except errors.FileExists:
990
return self.transport.clone(path)
789
return self.transport.clone('branch')
992
791
def get_repository_transport(self, repository_format):
993
792
"""See BzrDir.get_repository_transport()."""
1070
832
except errors.NoRepositoryPresent:
1072
for branch in self.list_branches():
1073
if not isinstance(branch._format,
1074
format.get_branch_format().__class__):
1075
# the branch needs an upgrade.
1078
my_wt = self.open_workingtree(recommend_upgrade=False)
1079
if not isinstance(my_wt._format,
1080
format.workingtree_format.__class__):
1081
# the workingtree needs an upgrade.
1083
except (errors.NoWorkingTree, errors.NotLocalUrl):
834
# currently there are no other possible conversions for meta1 formats.
1087
def open_branch(self, name=None, unsupported=False,
1088
ignore_fallbacks=False, possible_transports=None):
1089
"""See ControlDir.open_branch."""
1091
name = self._get_selected_branch()
1092
format = self.find_branch_format(name=name)
1093
format.check_support_status(unsupported)
1094
if possible_transports is None:
1095
possible_transports = []
1097
possible_transports = list(possible_transports)
1098
possible_transports.append(self.root_transport)
1099
return format.open(self, name=name,
1100
_found=True, ignore_fallbacks=ignore_fallbacks,
1101
possible_transports=possible_transports)
837
def open_branch(self, unsupported=False):
838
"""See BzrDir.open_branch."""
839
from bzrlib.branch import BranchFormat
840
format = BranchFormat.find_format(self)
841
self._check_supported(format, unsupported)
842
return format.open(self, _found=True)
1103
844
def open_repository(self, unsupported=False):
1104
845
"""See BzrDir.open_repository."""
1105
from .repository import RepositoryFormatMetaDir
1106
format = RepositoryFormatMetaDir.find_format(self)
1107
format.check_support_status(unsupported)
846
from bzrlib.repository import RepositoryFormat
847
format = RepositoryFormat.find_format(self)
848
self._check_supported(format, unsupported)
1108
849
return format.open(self, _found=True)
1110
def open_workingtree(self, unsupported=False,
1111
recommend_upgrade=True):
851
def open_workingtree(self, unsupported=False):
1112
852
"""See BzrDir.open_workingtree."""
1113
from .workingtree import WorkingTreeFormatMetaDir
1114
format = WorkingTreeFormatMetaDir.find_format(self)
1115
format.check_support_status(unsupported, recommend_upgrade,
1116
basedir=self.root_transport.base)
853
from bzrlib.workingtree import WorkingTreeFormat
854
format = WorkingTreeFormat.find_format(self)
855
self._check_supported(format, unsupported)
1117
856
return format.open(self, _found=True)
1119
def _get_config(self):
1120
return config.TransportConfig(self.transport, 'control.conf')
1123
class BzrFormat(object):
1124
"""Base class for all formats of things living in metadirs.
1126
This class manages the format string that is stored in the 'format'
1127
or 'branch-format' file.
1129
All classes for (branch-, repository-, workingtree-) formats that
1130
live in meta directories and have their own 'format' file
1131
(i.e. different from .bzr/branch-format) derive from this class,
1132
as well as the relevant base class for their kind
1133
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1135
Each format is identified by a "format" or "branch-format" file with a
1136
single line containing the base format name and then an optional list of
1139
Feature flags are supported as of bzr 2.5. Setting feature flags on formats
1140
will render them inaccessible to older versions of bzr.
1142
:ivar features: Dictionary mapping feature names to their necessity
1145
_present_features = set()
1151
def register_feature(cls, name):
1152
"""Register a feature as being present.
1154
:param name: Name of the feature
1157
raise ValueError("spaces are not allowed in feature names")
1158
if name in cls._present_features:
1159
raise FeatureAlreadyRegistered(name)
1160
cls._present_features.add(name)
1163
def unregister_feature(cls, name):
1164
"""Unregister a feature."""
1165
cls._present_features.remove(name)
1167
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1169
for name, necessity in viewitems(self.features):
1170
if name in self._present_features:
1172
if necessity == b"optional":
1173
mutter("ignoring optional missing feature %s", name)
1175
elif necessity == b"required":
1176
raise MissingFeature(name)
1178
mutter("treating unknown necessity as require for %s",
1180
raise MissingFeature(name)
1183
def get_format_string(cls):
1184
"""Return the ASCII format string that identifies this format."""
1185
raise NotImplementedError(cls.get_format_string)
1188
def from_string(cls, text):
1189
format_string = cls.get_format_string()
1190
if not text.startswith(format_string):
1191
raise AssertionError(
1192
"Invalid format header %r for %r" % (text, cls))
1193
lines = text[len(format_string):].splitlines()
1195
for lineno, line in enumerate(lines):
1197
(necessity, feature) = line.split(b" ", 1)
1199
raise errors.ParseFormatError(format=cls, lineno=lineno + 2,
1200
line=line, text=text)
1201
ret.features[feature] = necessity
1204
def as_string(self):
1205
"""Return the string representation of this format.
1207
lines = [self.get_format_string()]
1208
lines.extend([(item[1] + b" " + item[0] + b"\n")
1209
for item in sorted(viewitems(self.features))])
1210
return b"".join(lines)
1213
def _find_format(klass, registry, kind, format_string):
1215
first_line = format_string[:format_string.index(b"\n") + 1]
1217
first_line = format_string
1219
cls = registry.get(first_line)
1221
raise errors.UnknownFormatError(format=first_line, kind=kind)
1222
return cls.from_string(format_string)
1224
def network_name(self):
1225
"""A simple byte string uniquely identifying this format for RPC calls.
1227
Metadir branch formats use their format string.
1229
return self.as_string()
1231
def __eq__(self, other):
1232
return (self.__class__ is other.__class__
1233
and self.features == other.features)
1235
def _update_feature_flags(self, updated_flags):
1236
"""Update the feature flags in this format.
1238
:param updated_flags: Updated feature flags
1240
for name, necessity in updated_flags.items():
1241
if necessity is None:
1243
del self.features[name]
1247
self.features[name] = necessity
1250
class BzrDirFormat(BzrFormat, controldir.ControlDirFormat):
1251
"""ControlDirFormat base class for .bzr/ directories.
1253
Formats are placed in a dict by their format string for reference
859
class BzrDirFormat(object):
860
"""An encapsulation of the initialization and open routines for a format.
862
Formats provide three things:
863
* An initialization routine,
867
Formats are placed in an dict by their format string for reference
1254
868
during bzrdir opening. These should be subclasses of BzrDirFormat
1255
869
for consistency.
1257
871
Once a format is deprecated, just deprecate the initialize and open
1258
methods on the format class. Do not deprecate the object, as the
872
methods on the format class. Do not deprecate the object, as the
1259
873
object will be created every system load.
876
_default_format = None
877
"""The default format used for new .bzr dirs."""
880
"""The known formats."""
1262
882
_lock_file_name = 'branch-lock'
1264
884
# _lock_class must be set in subclasses to the lock type, typ.
1265
885
# TransportLock or LockDir
888
def find_format(klass, transport):
889
"""Return the format registered for URL."""
891
format_string = transport.get(".bzr/branch-format").read()
892
return klass._formats[format_string]
893
except errors.NoSuchFile:
894
raise errors.NotBranchError(path=transport.base)
896
raise errors.UnknownFormatError(format_string)
899
def get_default_format(klass):
900
"""Return the current default format."""
901
return klass._default_format
903
def get_format_string(self):
904
"""Return the ASCII format string that identifies this format."""
905
raise NotImplementedError(self.get_format_string)
907
def get_format_description(self):
908
"""Return the short description for this format."""
909
raise NotImplementedError(self.get_format_description)
911
def get_converter(self, format=None):
912
"""Return the converter to use to convert bzrdirs needing converts.
914
This returns a bzrlib.bzrdir.Converter object.
916
This should return the best upgrader to step this format towards the
917
current default format. In the case of plugins we can/shouold provide
918
some means for them to extend the range of returnable converters.
920
:param format: Optional format to override the default foramt of the
923
raise NotImplementedError(self.get_converter)
925
def initialize(self, url):
926
"""Create a bzr control dir at this url and return an opened copy.
928
Subclasses should typically override initialize_on_transport
929
instead of this method.
931
return self.initialize_on_transport(get_transport(url))
1267
933
def initialize_on_transport(self, transport):
1268
934
"""Initialize a new bzrdir in the base directory of a Transport."""
1270
# can we hand off the request to the smart server rather than using
1272
client_medium = transport.get_smart_medium()
1273
except errors.NoSmartMedium:
1274
return self._initialize_on_transport_vfs(transport)
1276
# Current RPC's only know how to create bzr metadir1 instances, so
1277
# we still delegate to vfs methods if the requested format is not a
1279
if not isinstance(self, BzrDirMetaFormat1):
1280
return self._initialize_on_transport_vfs(transport)
1281
from .remote import RemoteBzrDirFormat
1282
remote_format = RemoteBzrDirFormat()
1283
self._supply_sub_formats_to(remote_format)
1284
return remote_format.initialize_on_transport(transport)
1286
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1287
create_prefix=False, force_new_repo=False, stacked_on=None,
1288
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1289
shared_repo=False, vfs_only=False):
1290
"""Create this format on transport.
1292
The directory to initialize will be created.
1294
:param force_new_repo: Do not use a shared repository for the target,
1295
even if one is available.
1296
:param create_prefix: Create any missing directories leading up to
1298
:param use_existing_dir: Use an existing directory if one exists.
1299
:param stacked_on: A url to stack any created branch on, None to follow
1300
any target stacking policy.
1301
:param stack_on_pwd: If stack_on is relative, the location it is
1303
:param repo_format_name: If non-None, a repository will be
1304
made-or-found. Should none be found, or if force_new_repo is True
1305
the repo_format_name is used to select the format of repository to
1307
:param make_working_trees: Control the setting of make_working_trees
1308
for a new shared repository when one is made. None to use whatever
1309
default the format has.
1310
:param shared_repo: Control whether made repositories are shared or
1312
:param vfs_only: If True do not attempt to use a smart server
1313
:return: repo, controldir, require_stacking, repository_policy. repo is
1314
None if none was created or found, bzrdir is always valid.
1315
require_stacking is the result of examining the stacked_on
1316
parameter and any stacking policy found for the target.
1319
# Try to hand off to a smart server
1321
client_medium = transport.get_smart_medium()
1322
except errors.NoSmartMedium:
1325
from .remote import RemoteBzrDirFormat
1326
# TODO: lookup the local format from a server hint.
1327
remote_dir_format = RemoteBzrDirFormat()
1328
remote_dir_format._network_name = self.network_name()
1329
self._supply_sub_formats_to(remote_dir_format)
1330
return remote_dir_format.initialize_on_transport_ex(
1331
transport, use_existing_dir=use_existing_dir,
1332
create_prefix=create_prefix, force_new_repo=force_new_repo,
1333
stacked_on=stacked_on, stack_on_pwd=stack_on_pwd,
1334
repo_format_name=repo_format_name,
1335
make_working_trees=make_working_trees,
1336
shared_repo=shared_repo)
1337
# XXX: Refactor the create_prefix/no_create_prefix code into a
1338
# common helper function
1339
# The destination may not exist - if so make it according to policy.
1341
def make_directory(transport):
1342
transport.mkdir('.')
1345
def redirected(transport, e, redirection_notice):
1346
note(redirection_notice)
1347
return transport._redirected_to(e.source, e.target)
1349
transport = do_catching_redirections(make_directory, transport,
1351
except errors.FileExists:
1352
if not use_existing_dir:
1354
except errors.NoSuchFile:
1355
if not create_prefix:
1357
transport.create_prefix()
1359
require_stacking = (stacked_on is not None)
1360
# Now the target directory exists, but doesn't have a .bzr
1361
# directory. So we need to create it, along with any work to create
1362
# all of the dependent branches, etc.
1364
result = self.initialize_on_transport(transport)
1365
if repo_format_name:
1367
# use a custom format
1368
result._format.repository_format = \
1369
repository.network_format_registry.get(repo_format_name)
1370
except AttributeError:
1371
# The format didn't permit it to be set.
1373
# A repository is desired, either in-place or shared.
1374
repository_policy = result.determine_repository_policy(
1375
force_new_repo, stacked_on, stack_on_pwd,
1376
require_stacking=require_stacking)
1377
result_repo, is_new_repo = repository_policy.acquire_repository(
1378
make_working_trees, shared_repo)
1379
if not require_stacking and repository_policy._require_stacking:
1380
require_stacking = True
1381
result._format.require_stacking()
1382
result_repo.lock_write()
1385
repository_policy = None
1386
return result_repo, result, require_stacking, repository_policy
1388
def _initialize_on_transport_vfs(self, transport):
1389
"""Initialize a new bzrdir using VFS calls.
1391
:param transport: The transport to create the .bzr directory in.
1394
# Since we are creating a .bzr directory, inherit the
935
# Since we don'transport have a .bzr directory, inherit the
1395
936
# mode from the root directory
1396
temp_control = lockable_files.LockableFiles(transport,
1397
'', lockable_files.TransportLock)
1399
temp_control._transport.mkdir('.bzr',
1400
# FIXME: RBC 20060121 don't peek under
1402
mode=temp_control._dir_mode)
1403
except errors.FileExists:
1404
raise errors.AlreadyControlDirError(transport.base)
1405
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1406
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
937
temp_control = LockableFiles(transport, '', TransportLock)
938
temp_control._transport.mkdir('.bzr',
939
# FIXME: RBC 20060121 dont peek under
941
mode=temp_control._dir_mode)
1407
942
file_mode = temp_control._file_mode
1408
943
del temp_control
1409
bzrdir_transport = transport.clone('.bzr')
1410
utf8_files = [('README',
1411
b"This is a Bazaar control directory.\n"
1412
b"Do not change any files in this directory.\n"
1413
b"See http://bazaar.canonical.com/ for more information about Bazaar.\n"),
1414
('branch-format', self.as_string()),
944
mutter('created control directory in ' + transport.base)
945
control = transport.clone('.bzr')
946
utf8_files = [('README',
947
"This is a Bazaar-NG control directory.\n"
948
"Do not change any files in this directory.\n"),
949
('branch-format', self.get_format_string()),
1416
951
# NB: no need to escape relative paths that are url safe.
1417
control_files = lockable_files.LockableFiles(bzrdir_transport,
1418
self._lock_file_name, self._lock_class)
952
control_files = LockableFiles(control, self._lock_file_name,
1419
954
control_files.create_lock()
1420
955
control_files.lock_write()
1422
for (filename, content) in utf8_files:
1423
bzrdir_transport.put_bytes(filename, content,
957
for file, content in utf8_files:
958
control_files.put_utf8(file, content)
1426
960
control_files.unlock()
1427
961
return self.open(transport, _found=True)
963
def is_supported(self):
964
"""Is this format supported?
966
Supported formats must be initializable and openable.
967
Unsupported formats may not support initialization or committing or
968
some other features depending on the reason for not being supported.
1429
972
def open(self, transport, _found=False):
1430
973
"""Return an instance of this format for the dir transport points at.
1432
975
_found is a private parameter, do not use it.
1435
found_format = controldir.ControlDirFormat.find_format(transport)
1436
if not isinstance(found_format, self.__class__):
1437
raise AssertionError("%s was asked to open %s, but it seems to need "
1439
% (self, transport, found_format))
1440
# Allow subclasses - use the found format.
1441
self._supply_sub_formats_to(found_format)
1442
return found_format._open(transport)
978
assert isinstance(BzrDirFormat.find_format(transport),
1443
980
return self._open(transport)
1445
982
def _open(self, transport):
1663
1203
def _open(self, transport):
1664
1204
"""See BzrDirFormat._open."""
1665
# Create a new format instance because otherwise initialisation of new
1666
# metadirs share the global default format object leading to alias
1668
format = BzrDirMetaFormat1()
1669
self._supply_sub_formats_to(format)
1670
return BzrDirMeta1(transport, format)
1205
return BzrDirMeta1(transport, self)
1672
1207
def __return_repository_format(self):
1673
1208
"""Circular import protection."""
1674
if self._repository_format:
1209
if getattr(self, '_repository_format', None):
1675
1210
return self._repository_format
1676
from .repository import format_registry
1677
return format_registry.get_default()
1211
from bzrlib.repository import RepositoryFormat
1212
return RepositoryFormat.get_default_format()
1679
def _set_repository_format(self, value):
1680
"""Allow changing the repository format for metadir formats."""
1214
def __set_repository_format(self, value):
1215
"""Allow changint the repository format for metadir formats."""
1681
1216
self._repository_format = value
1683
repository_format = property(__return_repository_format,
1684
_set_repository_format)
1686
def _supply_sub_formats_to(self, other_format):
1687
"""Give other_format the same values for sub formats as this has.
1689
This method is expected to be used when parameterising a
1690
RemoteBzrDirFormat instance with the parameters from a
1691
BzrDirMetaFormat1 instance.
1693
:param other_format: other_format is a format which should be
1694
compatible with whatever sub formats are supported by self.
1697
super(BzrDirMetaFormat1, self)._supply_sub_formats_to(other_format)
1698
if getattr(self, '_repository_format', None) is not None:
1699
other_format.repository_format = self.repository_format
1700
if self._branch_format is not None:
1701
other_format._branch_format = self._branch_format
1702
if self._workingtree_format is not None:
1703
other_format.workingtree_format = self.workingtree_format
1705
def __get_workingtree_format(self):
1706
if self._workingtree_format is None:
1707
from .workingtree import (
1708
format_registry as wt_format_registry,
1710
self._workingtree_format = wt_format_registry.get_default()
1711
return self._workingtree_format
1713
def __set_workingtree_format(self, wt_format):
1714
self._workingtree_format = wt_format
1717
return "<%r>" % (self.__class__.__name__,)
1719
workingtree_format = property(__get_workingtree_format,
1720
__set_workingtree_format)
1723
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1724
"""BzrDirMeta1 format with support for colocated branches."""
1726
colocated_branches = True
1729
def get_format_string(cls):
1730
"""See BzrDirFormat.get_format_string()."""
1731
return b"Bazaar meta directory, format 1 (with colocated branches)\n"
1733
def get_format_description(self):
1734
"""See BzrDirFormat.get_format_description()."""
1735
return "Meta directory format 1 with support for colocated branches"
1737
def _open(self, transport):
1738
"""See BzrDirFormat._open."""
1739
# Create a new format instance because otherwise initialisation of new
1740
# metadirs share the global default format object leading to alias
1742
format = BzrDirMetaFormat1Colo()
1743
self._supply_sub_formats_to(format)
1744
return BzrDirMeta1(transport, format)
1747
class ConvertMetaToMeta(controldir.Converter):
1218
repository_format = property(__return_repository_format, __set_repository_format)
1221
BzrDirFormat.register_format(BzrDirFormat4())
1222
BzrDirFormat.register_format(BzrDirFormat5())
1223
BzrDirFormat.register_format(BzrDirFormat6())
1224
__default_format = BzrDirMetaFormat1()
1225
BzrDirFormat.register_format(__default_format)
1226
BzrDirFormat.set_default_format(__default_format)
1229
class BzrDirTestProviderAdapter(object):
1230
"""A tool to generate a suite testing multiple bzrdir formats at once.
1232
This is done by copying the test once for each transport and injecting
1233
the transport_server, transport_readonly_server, and bzrdir_format
1234
classes into each copy. Each copy is also given a new id() to make it
1238
def __init__(self, transport_server, transport_readonly_server, formats):
1239
self._transport_server = transport_server
1240
self._transport_readonly_server = transport_readonly_server
1241
self._formats = formats
1243
def adapt(self, test):
1244
result = TestSuite()
1245
for format in self._formats:
1246
new_test = deepcopy(test)
1247
new_test.transport_server = self._transport_server
1248
new_test.transport_readonly_server = self._transport_readonly_server
1249
new_test.bzrdir_format = format
1250
def make_new_test_id():
1251
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1252
return lambda: new_id
1253
new_test.id = make_new_test_id()
1254
result.addTest(new_test)
1258
class ScratchDir(BzrDir6):
1259
"""Special test class: a bzrdir that cleans up itself..
1261
>>> d = ScratchDir()
1262
>>> base = d.transport.base
1265
>>> b.transport.__del__()
1270
def __init__(self, files=[], dirs=[], transport=None):
1271
"""Make a test branch.
1273
This creates a temporary directory and runs init-tree in it.
1275
If any files are listed, they are created in the working copy.
1277
if transport is None:
1278
transport = bzrlib.transport.local.ScratchTransport()
1279
# local import for scope restriction
1280
BzrDirFormat6().initialize(transport.base)
1281
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1282
self.create_repository()
1283
self.create_branch()
1284
self.create_workingtree()
1286
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1288
# BzrBranch creates a clone to .bzr and then forgets about the
1289
# original transport. A ScratchTransport() deletes itself and
1290
# everything underneath it when it goes away, so we need to
1291
# grab a local copy to prevent that from happening
1292
self._transport = transport
1295
self._transport.mkdir(d)
1298
self._transport.put(f, 'content of %s' % f)
1302
>>> orig = ScratchDir(files=["file1", "file2"])
1303
>>> os.listdir(orig.base)
1304
[u'.bzr', u'file1', u'file2']
1305
>>> clone = orig.clone()
1306
>>> if os.name != 'nt':
1307
... os.path.samefile(orig.base, clone.base)
1309
... orig.base == clone.base
1312
>>> os.listdir(clone.base)
1313
[u'.bzr', u'file1', u'file2']
1315
from shutil import copytree
1316
from bzrlib.osutils import mkdtemp
1319
copytree(self.base, base, symlinks=True)
1321
transport=bzrlib.transport.local.ScratchTransport(base))
1324
class Converter(object):
1325
"""Converts a disk format object from one format to another."""
1327
def convert(self, to_convert, pb):
1328
"""Perform the conversion of to_convert, giving feedback via pb.
1330
:param to_convert: The disk object to convert.
1331
:param pb: a progress bar to use for progress information.
1334
def step(self, message):
1335
"""Update the pb by a step."""
1337
self.pb.update(message, self.count, self.total)
1340
class ConvertBzrDir4To5(Converter):
1341
"""Converts format 4 bzr dirs to format 5."""
1344
super(ConvertBzrDir4To5, self).__init__()
1345
self.converted_revs = set()
1346
self.absent_revisions = set()
1350
def convert(self, to_convert, pb):
1351
"""See Converter.convert()."""
1352
self.bzrdir = to_convert
1354
self.pb.note('starting upgrade from format 4 to 5')
1355
if isinstance(self.bzrdir.transport, LocalTransport):
1356
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1357
self._convert_to_weaves()
1358
return BzrDir.open(self.bzrdir.root_transport.base)
1360
def _convert_to_weaves(self):
1361
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1364
stat = self.bzrdir.transport.stat('weaves')
1365
if not S_ISDIR(stat.st_mode):
1366
self.bzrdir.transport.delete('weaves')
1367
self.bzrdir.transport.mkdir('weaves')
1368
except errors.NoSuchFile:
1369
self.bzrdir.transport.mkdir('weaves')
1370
# deliberately not a WeaveFile as we want to build it up slowly.
1371
self.inv_weave = Weave('inventory')
1372
# holds in-memory weaves for all files
1373
self.text_weaves = {}
1374
self.bzrdir.transport.delete('branch-format')
1375
self.branch = self.bzrdir.open_branch()
1376
self._convert_working_inv()
1377
rev_history = self.branch.revision_history()
1378
# to_read is a stack holding the revisions we still need to process;
1379
# appending to it adds new highest-priority revisions
1380
self.known_revisions = set(rev_history)
1381
self.to_read = rev_history[-1:]
1383
rev_id = self.to_read.pop()
1384
if (rev_id not in self.revisions
1385
and rev_id not in self.absent_revisions):
1386
self._load_one_rev(rev_id)
1388
to_import = self._make_order()
1389
for i, rev_id in enumerate(to_import):
1390
self.pb.update('converting revision', i, len(to_import))
1391
self._convert_one_rev(rev_id)
1393
self._write_all_weaves()
1394
self._write_all_revs()
1395
self.pb.note('upgraded to weaves:')
1396
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1397
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1398
self.pb.note(' %6d texts', self.text_count)
1399
self._cleanup_spare_files_after_format4()
1400
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1402
def _cleanup_spare_files_after_format4(self):
1403
# FIXME working tree upgrade foo.
1404
for n in 'merged-patches', 'pending-merged-patches':
1406
## assert os.path.getsize(p) == 0
1407
self.bzrdir.transport.delete(n)
1408
except errors.NoSuchFile:
1410
self.bzrdir.transport.delete_tree('inventory-store')
1411
self.bzrdir.transport.delete_tree('text-store')
1413
def _convert_working_inv(self):
1414
inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1415
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1416
# FIXME inventory is a working tree change.
1417
self.branch.control_files.put('inventory', new_inv_xml)
1419
def _write_all_weaves(self):
1420
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1421
weave_transport = self.bzrdir.transport.clone('weaves')
1422
weaves = WeaveStore(weave_transport, prefixed=False)
1423
transaction = WriteTransaction()
1427
for file_id, file_weave in self.text_weaves.items():
1428
self.pb.update('writing weave', i, len(self.text_weaves))
1429
weaves._put_weave(file_id, file_weave, transaction)
1431
self.pb.update('inventory', 0, 1)
1432
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1433
self.pb.update('inventory', 1, 1)
1437
def _write_all_revs(self):
1438
"""Write all revisions out in new form."""
1439
self.bzrdir.transport.delete_tree('revision-store')
1440
self.bzrdir.transport.mkdir('revision-store')
1441
revision_transport = self.bzrdir.transport.clone('revision-store')
1443
_revision_store = TextRevisionStore(TextStore(revision_transport,
1447
transaction = bzrlib.transactions.WriteTransaction()
1448
for i, rev_id in enumerate(self.converted_revs):
1449
self.pb.update('write revision', i, len(self.converted_revs))
1450
_revision_store.add_revision(self.revisions[rev_id], transaction)
1454
def _load_one_rev(self, rev_id):
1455
"""Load a revision object into memory.
1457
Any parents not either loaded or abandoned get queued to be
1459
self.pb.update('loading revision',
1460
len(self.revisions),
1461
len(self.known_revisions))
1462
if not self.branch.repository.has_revision(rev_id):
1464
self.pb.note('revision {%s} not present in branch; '
1465
'will be converted as a ghost',
1467
self.absent_revisions.add(rev_id)
1469
rev = self.branch.repository._revision_store.get_revision(rev_id,
1470
self.branch.repository.get_transaction())
1471
for parent_id in rev.parent_ids:
1472
self.known_revisions.add(parent_id)
1473
self.to_read.append(parent_id)
1474
self.revisions[rev_id] = rev
1476
def _load_old_inventory(self, rev_id):
1477
assert rev_id not in self.converted_revs
1478
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1479
inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1480
rev = self.revisions[rev_id]
1481
if rev.inventory_sha1:
1482
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1483
'inventory sha mismatch for {%s}' % rev_id
1486
def _load_updated_inventory(self, rev_id):
1487
assert rev_id in self.converted_revs
1488
inv_xml = self.inv_weave.get_text(rev_id)
1489
inv = serializer_v5.read_inventory_from_string(inv_xml)
1492
def _convert_one_rev(self, rev_id):
1493
"""Convert revision and all referenced objects to new format."""
1494
rev = self.revisions[rev_id]
1495
inv = self._load_old_inventory(rev_id)
1496
present_parents = [p for p in rev.parent_ids
1497
if p not in self.absent_revisions]
1498
self._convert_revision_contents(rev, inv, present_parents)
1499
self._store_new_weave(rev, inv, present_parents)
1500
self.converted_revs.add(rev_id)
1502
def _store_new_weave(self, rev, inv, present_parents):
1503
# the XML is now updated with text versions
1507
if ie.kind == 'root_directory':
1509
assert hasattr(ie, 'revision'), \
1510
'no revision on {%s} in {%s}' % \
1511
(file_id, rev.revision_id)
1512
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1513
new_inv_sha1 = sha_string(new_inv_xml)
1514
self.inv_weave.add_lines(rev.revision_id,
1516
new_inv_xml.splitlines(True))
1517
rev.inventory_sha1 = new_inv_sha1
1519
def _convert_revision_contents(self, rev, inv, present_parents):
1520
"""Convert all the files within a revision.
1522
Also upgrade the inventory to refer to the text revision ids."""
1523
rev_id = rev.revision_id
1524
mutter('converting texts of revision {%s}',
1526
parent_invs = map(self._load_updated_inventory, present_parents)
1529
self._convert_file_version(rev, ie, parent_invs)
1531
def _convert_file_version(self, rev, ie, parent_invs):
1532
"""Convert one version of one file.
1534
The file needs to be added into the weave if it is a merge
1535
of >=2 parents or if it's changed from its parent.
1537
if ie.kind == 'root_directory':
1539
file_id = ie.file_id
1540
rev_id = rev.revision_id
1541
w = self.text_weaves.get(file_id)
1544
self.text_weaves[file_id] = w
1545
text_changed = False
1546
previous_entries = ie.find_previous_heads(parent_invs,
1550
for old_revision in previous_entries:
1551
# if this fails, its a ghost ?
1552
assert old_revision in self.converted_revs
1553
self.snapshot_ie(previous_entries, ie, w, rev_id)
1555
assert getattr(ie, 'revision', None) is not None
1557
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1558
# TODO: convert this logic, which is ~= snapshot to
1559
# a call to:. This needs the path figured out. rather than a work_tree
1560
# a v4 revision_tree can be given, or something that looks enough like
1561
# one to give the file content to the entry if it needs it.
1562
# and we need something that looks like a weave store for snapshot to
1564
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1565
if len(previous_revisions) == 1:
1566
previous_ie = previous_revisions.values()[0]
1567
if ie._unchanged(previous_ie):
1568
ie.revision = previous_ie.revision
1571
text = self.branch.repository.text_store.get(ie.text_id)
1572
file_lines = text.readlines()
1573
assert sha_strings(file_lines) == ie.text_sha1
1574
assert sum(map(len, file_lines)) == ie.text_size
1575
w.add_lines(rev_id, previous_revisions, file_lines)
1576
self.text_count += 1
1578
w.add_lines(rev_id, previous_revisions, [])
1579
ie.revision = rev_id
1581
def _make_order(self):
1582
"""Return a suitable order for importing revisions.
1584
The order must be such that an revision is imported after all
1585
its (present) parents.
1587
todo = set(self.revisions.keys())
1588
done = self.absent_revisions.copy()
1591
# scan through looking for a revision whose parents
1593
for rev_id in sorted(list(todo)):
1594
rev = self.revisions[rev_id]
1595
parent_ids = set(rev.parent_ids)
1596
if parent_ids.issubset(done):
1597
# can take this one now
1598
order.append(rev_id)
1604
class ConvertBzrDir5To6(Converter):
1605
"""Converts format 5 bzr dirs to format 6."""
1607
def convert(self, to_convert, pb):
1608
"""See Converter.convert()."""
1609
self.bzrdir = to_convert
1611
self.pb.note('starting upgrade from format 5 to 6')
1612
self._convert_to_prefixed()
1613
return BzrDir.open(self.bzrdir.root_transport.base)
1615
def _convert_to_prefixed(self):
1616
from bzrlib.store import TransportStore
1617
self.bzrdir.transport.delete('branch-format')
1618
for store_name in ["weaves", "revision-store"]:
1619
self.pb.note("adding prefixes to %s" % store_name)
1620
store_transport = self.bzrdir.transport.clone(store_name)
1621
store = TransportStore(store_transport, prefixed=True)
1622
for urlfilename in store_transport.list_dir('.'):
1623
filename = urlunescape(urlfilename)
1624
if (filename.endswith(".weave") or
1625
filename.endswith(".gz") or
1626
filename.endswith(".sig")):
1627
file_id = os.path.splitext(filename)[0]
1630
prefix_dir = store.hash_prefix(file_id)
1631
# FIXME keep track of the dirs made RBC 20060121
1633
store_transport.move(filename, prefix_dir + '/' + filename)
1634
except errors.NoSuchFile: # catches missing dirs strangely enough
1635
store_transport.mkdir(prefix_dir)
1636
store_transport.move(filename, prefix_dir + '/' + filename)
1637
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1640
class ConvertBzrDir6ToMeta(Converter):
1641
"""Converts format 6 bzr dirs to metadirs."""
1643
def convert(self, to_convert, pb):
1644
"""See Converter.convert()."""
1645
self.bzrdir = to_convert
1648
self.total = 20 # the steps we know about
1649
self.garbage_inventories = []
1651
self.pb.note('starting upgrade from format 6 to metadir')
1652
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1653
# its faster to move specific files around than to open and use the apis...
1654
# first off, nuke ancestry.weave, it was never used.
1656
self.step('Removing ancestry.weave')
1657
self.bzrdir.transport.delete('ancestry.weave')
1658
except errors.NoSuchFile:
1660
# find out whats there
1661
self.step('Finding branch files')
1662
last_revision = self.bzrdir.open_branch().last_revision()
1663
bzrcontents = self.bzrdir.transport.list_dir('.')
1664
for name in bzrcontents:
1665
if name.startswith('basis-inventory.'):
1666
self.garbage_inventories.append(name)
1667
# create new directories for repository, working tree and branch
1668
self.dir_mode = self.bzrdir._control_files._dir_mode
1669
self.file_mode = self.bzrdir._control_files._file_mode
1670
repository_names = [('inventory.weave', True),
1671
('revision-store', True),
1673
self.step('Upgrading repository ')
1674
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1675
self.make_lock('repository')
1676
# we hard code the formats here because we are converting into
1677
# the meta format. The meta format upgrader can take this to a
1678
# future format within each component.
1679
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1680
for entry in repository_names:
1681
self.move_entry('repository', entry)
1683
self.step('Upgrading branch ')
1684
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1685
self.make_lock('branch')
1686
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1687
branch_files = [('revision-history', True),
1688
('branch-name', True),
1690
for entry in branch_files:
1691
self.move_entry('branch', entry)
1693
self.step('Upgrading working tree')
1694
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1695
self.make_lock('checkout')
1696
self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1697
self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1698
checkout_files = [('pending-merges', True),
1699
('inventory', True),
1700
('stat-cache', False)]
1701
for entry in checkout_files:
1702
self.move_entry('checkout', entry)
1703
if last_revision is not None:
1704
self.bzrdir._control_files.put_utf8('checkout/last-revision',
1706
self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
1707
return BzrDir.open(self.bzrdir.root_transport.base)
1709
def make_lock(self, name):
1710
"""Make a lock for the new control dir name."""
1711
self.step('Make %s lock' % name)
1712
ld = LockDir(self.bzrdir.transport,
1714
file_modebits=self.file_mode,
1715
dir_modebits=self.dir_mode)
1718
def move_entry(self, new_dir, entry):
1719
"""Move then entry name into new_dir."""
1721
mandatory = entry[1]
1722
self.step('Moving %s' % name)
1724
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1725
except errors.NoSuchFile:
1729
def put_format(self, dirname, format):
1730
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1733
class ConvertMetaToMeta(Converter):
1748
1734
"""Converts the components of metadirs."""
1750
1736
def __init__(self, target_format):
added
removed
bzrlib/bzrdir.py
