1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
18
from cStringIO import StringIO
20
from bzrlib.lazy_import import lazy_import
21
lazy_import(globals(), """
22
from copy import deepcopy
23
from unittest import TestSuite
24
from warnings import warn
30
config as _mod_config,
35
revision as _mod_revision,
41
from bzrlib.config import BranchConfig, TreeConfig
42
from bzrlib.lockable_files import LockableFiles, TransportLock
45
from bzrlib.decorators import needs_read_lock, needs_write_lock
46
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
47
HistoryMissing, InvalidRevisionId,
48
InvalidRevisionNumber, LockError, NoSuchFile,
49
NoSuchRevision, NoWorkingTree, NotVersionedError,
50
NotBranchError, UninitializableFormat,
51
UnlistableStore, UnlistableBranch,
53
from bzrlib.symbol_versioning import (deprecated_function,
57
zero_eight, zero_nine,
59
from bzrlib.trace import mutter, note
62
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
63
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
64
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
67
# TODO: Maybe include checks for common corruption of newlines, etc?
69
# TODO: Some operations like log might retrieve the same revisions
70
# repeatedly to calculate deltas. We could perhaps have a weakref
71
# cache in memory to make this faster. In general anything can be
72
# cached in memory between lock and unlock operations. .. nb thats
73
# what the transaction identity map provides
76
######################################################################
80
"""Branch holding a history of revisions.
83
Base directory/url of the branch.
85
hooks: An instance of BranchHooks.
87
# this is really an instance variable - FIXME move it there
91
def __init__(self, *ignored, **ignored_too):
92
raise NotImplementedError('The Branch class is abstract')
95
"""Break a lock if one is present from another instance.
97
Uses the ui factory to ask for confirmation if the lock may be from
100
This will probe the repository for its lock as well.
102
self.control_files.break_lock()
103
self.repository.break_lock()
104
master = self.get_master_branch()
105
if master is not None:
109
@deprecated_method(zero_eight)
110
def open_downlevel(base):
111
"""Open a branch which may be of an old format."""
112
return Branch.open(base, _unsupported=True)
115
def open(base, _unsupported=False):
116
"""Open the branch rooted at base.
118
For instance, if the branch is at URL/.bzr/branch,
119
Branch.open(URL) -> a Branch instance.
121
control = bzrdir.BzrDir.open(base, _unsupported)
122
return control.open_branch(_unsupported)
125
def open_containing(url):
126
"""Open an existing branch which contains url.
128
This probes for a branch at url, and searches upwards from there.
130
Basically we keep looking up until we find the control directory or
131
run into the root. If there isn't one, raises NotBranchError.
132
If there is one and it is either an unrecognised format or an unsupported
133
format, UnknownFormatError or UnsupportedFormatError are raised.
134
If there is one, it is returned, along with the unused portion of url.
136
control, relpath = bzrdir.BzrDir.open_containing(url)
137
return control.open_branch(), relpath
140
@deprecated_function(zero_eight)
141
def initialize(base):
142
"""Create a new working tree and branch, rooted at 'base' (url)
144
NOTE: This will soon be deprecated in favour of creation
147
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
149
@deprecated_function(zero_eight)
150
def setup_caching(self, cache_root):
151
"""Subclasses that care about caching should override this, and set
152
up cached stores located under cache_root.
154
NOTE: This is unused.
158
def get_config(self):
159
return BranchConfig(self)
162
return self.get_config().get_nickname()
164
def _set_nick(self, nick):
165
self.get_config().set_user_option('nickname', nick)
167
nick = property(_get_nick, _set_nick)
170
raise NotImplementedError(self.is_locked)
172
def lock_write(self):
173
raise NotImplementedError(self.lock_write)
176
raise NotImplementedError(self.lock_read)
179
raise NotImplementedError(self.unlock)
181
def peek_lock_mode(self):
182
"""Return lock mode for the Branch: 'r', 'w' or None"""
183
raise NotImplementedError(self.peek_lock_mode)
185
def get_physical_lock_status(self):
186
raise NotImplementedError(self.get_physical_lock_status)
188
def abspath(self, name):
189
"""Return absolute filename for something in the branch
191
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
method and not a tree method.
194
raise NotImplementedError(self.abspath)
196
def bind(self, other):
197
"""Bind the local branch the other branch.
199
:param other: The branch to bind to
202
raise errors.UpgradeRequired(self.base)
205
def fetch(self, from_branch, last_revision=None, pb=None):
206
"""Copy revisions from from_branch into this branch.
208
:param from_branch: Where to copy from.
209
:param last_revision: What revision to stop at (None for at the end
211
:param pb: An optional progress bar to use.
213
Returns the copied revision count and the failed revisions in a tuple:
216
if self.base == from_branch.base:
219
nested_pb = ui.ui_factory.nested_progress_bar()
224
from_branch.lock_read()
226
if last_revision is None:
227
pb.update('get source history')
228
last_revision = from_branch.last_revision()
229
if last_revision is None:
230
last_revision = _mod_revision.NULL_REVISION
231
return self.repository.fetch(from_branch.repository,
232
revision_id=last_revision,
235
if nested_pb is not None:
239
def get_bound_location(self):
240
"""Return the URL of the branch we are bound to.
242
Older format branches cannot bind, please be sure to use a metadir
247
def get_old_bound_location(self):
248
"""Return the URL of the branch we used to be bound to
250
raise errors.UpgradeRequired(self.base)
252
def get_commit_builder(self, parents, config=None, timestamp=None,
253
timezone=None, committer=None, revprops=None,
255
"""Obtain a CommitBuilder for this branch.
257
:param parents: Revision ids of the parents of the new revision.
258
:param config: Optional configuration to use.
259
:param timestamp: Optional timestamp recorded for commit.
260
:param timezone: Optional timezone for timestamp.
261
:param committer: Optional committer to set for commit.
262
:param revprops: Optional dictionary of revision properties.
263
:param revision_id: Optional revision id.
267
config = self.get_config()
269
return self.repository.get_commit_builder(self, parents, config,
270
timestamp, timezone, committer, revprops, revision_id)
272
def get_master_branch(self):
273
"""Return the branch we are bound to.
275
:return: Either a Branch, or None
279
def get_revision_delta(self, revno):
280
"""Return the delta for one revision.
282
The delta is relative to its mainline predecessor, or the
283
empty tree for revision 1.
285
assert isinstance(revno, int)
286
rh = self.revision_history()
287
if not (1 <= revno <= len(rh)):
288
raise InvalidRevisionNumber(revno)
289
return self.repository.get_revision_delta(rh[revno-1])
291
def get_root_id(self):
292
"""Return the id of this branches root"""
293
raise NotImplementedError(self.get_root_id)
295
def print_file(self, file, revision_id):
296
"""Print `file` to stdout."""
297
raise NotImplementedError(self.print_file)
299
def append_revision(self, *revision_ids):
300
raise NotImplementedError(self.append_revision)
302
def set_revision_history(self, rev_history):
303
raise NotImplementedError(self.set_revision_history)
305
def revision_history(self):
306
"""Return sequence of revision hashes on to this branch."""
307
raise NotImplementedError(self.revision_history)
310
"""Return current revision number for this branch.
312
That is equivalent to the number of revisions committed to
315
return len(self.revision_history())
318
"""Older format branches cannot bind or unbind."""
319
raise errors.UpgradeRequired(self.base)
321
def set_append_revisions_only(self, enabled):
322
"""Older format branches are never restricted to append-only"""
323
raise errors.UpgradeRequired(self.base)
325
def last_revision(self):
326
"""Return last revision id, or None"""
327
ph = self.revision_history()
333
def last_revision_info(self):
334
"""Return information about the last revision.
336
:return: A tuple (revno, last_revision_id).
338
rh = self.revision_history()
341
return (revno, rh[-1])
343
return (0, _mod_revision.NULL_REVISION)
345
def missing_revisions(self, other, stop_revision=None):
346
"""Return a list of new revisions that would perfectly fit.
348
If self and other have not diverged, return a list of the revisions
349
present in other, but missing from self.
351
self_history = self.revision_history()
352
self_len = len(self_history)
353
other_history = other.revision_history()
354
other_len = len(other_history)
355
common_index = min(self_len, other_len) -1
356
if common_index >= 0 and \
357
self_history[common_index] != other_history[common_index]:
358
raise DivergedBranches(self, other)
360
if stop_revision is None:
361
stop_revision = other_len
363
assert isinstance(stop_revision, int)
364
if stop_revision > other_len:
365
raise errors.NoSuchRevision(self, stop_revision)
366
return other_history[self_len:stop_revision]
368
def update_revisions(self, other, stop_revision=None):
369
"""Pull in new perfect-fit revisions.
371
:param other: Another Branch to pull from
372
:param stop_revision: Updated until the given revision
375
raise NotImplementedError(self.update_revisions)
377
def revision_id_to_revno(self, revision_id):
378
"""Given a revision id, return its revno"""
379
if revision_id is None:
381
history = self.revision_history()
383
return history.index(revision_id) + 1
385
raise bzrlib.errors.NoSuchRevision(self, revision_id)
387
def get_rev_id(self, revno, history=None):
388
"""Find the revision id of the specified revno."""
392
history = self.revision_history()
393
if revno <= 0 or revno > len(history):
394
raise bzrlib.errors.NoSuchRevision(self, revno)
395
return history[revno - 1]
397
def pull(self, source, overwrite=False, stop_revision=None):
398
"""Mirror source into this branch.
400
This branch is considered to be 'local', having low latency.
402
raise NotImplementedError(self.pull)
404
def push(self, target, overwrite=False, stop_revision=None):
405
"""Mirror this branch into target.
407
This branch is considered to be 'local', having low latency.
409
raise NotImplementedError(self.push)
411
def basis_tree(self):
412
"""Return `Tree` object for last revision."""
413
return self.repository.revision_tree(self.last_revision())
415
def rename_one(self, from_rel, to_rel):
418
This can change the directory or the filename or both.
420
raise NotImplementedError(self.rename_one)
422
def move(self, from_paths, to_name):
425
to_name must exist as a versioned directory.
427
If to_name exists and is a directory, the files are moved into
428
it, keeping their old names. If it is a directory,
430
Note that to_name is only the last component of the new name;
431
this doesn't change the directory.
433
This returns a list of (from_path, to_path) pairs for each
436
raise NotImplementedError(self.move)
438
def get_parent(self):
439
"""Return the parent location of the branch.
441
This is the default location for push/pull/missing. The usual
442
pattern is that the user can override it by specifying a
445
raise NotImplementedError(self.get_parent)
447
def get_submit_branch(self):
448
"""Return the submit location of the branch.
450
This is the default location for bundle. The usual
451
pattern is that the user can override it by specifying a
454
return self.get_config().get_user_option('submit_branch')
456
def set_submit_branch(self, location):
457
"""Return the submit location of the branch.
459
This is the default location for bundle. The usual
460
pattern is that the user can override it by specifying a
463
self.get_config().set_user_option('submit_branch', location)
465
def get_push_location(self):
466
"""Return the None or the location to push this branch to."""
467
raise NotImplementedError(self.get_push_location)
469
def set_push_location(self, location):
470
"""Set a new push location for this branch."""
471
raise NotImplementedError(self.set_push_location)
473
def set_parent(self, url):
474
raise NotImplementedError(self.set_parent)
478
"""Synchronise this branch with the master branch if any.
480
:return: None or the last_revision pivoted out during the update.
484
def check_revno(self, revno):
486
Check whether a revno corresponds to any revision.
487
Zero (the NULL revision) is considered valid.
490
self.check_real_revno(revno)
492
def check_real_revno(self, revno):
494
Check whether a revno corresponds to a real revision.
495
Zero (the NULL revision) is considered invalid
497
if revno < 1 or revno > self.revno():
498
raise InvalidRevisionNumber(revno)
501
def clone(self, *args, **kwargs):
502
"""Clone this branch into to_bzrdir preserving all semantic values.
504
revision_id: if not None, the revision history in the new branch will
505
be truncated to end with revision_id.
507
# for API compatibility, until 0.8 releases we provide the old api:
508
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
509
# after 0.8 releases, the *args and **kwargs should be changed:
510
# def clone(self, to_bzrdir, revision_id=None):
511
if (kwargs.get('to_location', None) or
512
kwargs.get('revision', None) or
513
kwargs.get('basis_branch', None) or
514
(len(args) and isinstance(args[0], basestring))):
515
# backwards compatibility api:
516
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
517
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
520
basis_branch = args[2]
522
basis_branch = kwargs.get('basis_branch', None)
524
basis = basis_branch.bzrdir
529
revision_id = args[1]
531
revision_id = kwargs.get('revision', None)
536
# no default to raise if not provided.
537
url = kwargs.get('to_location')
538
return self.bzrdir.clone(url,
539
revision_id=revision_id,
540
basis=basis).open_branch()
542
# generate args by hand
544
revision_id = args[1]
546
revision_id = kwargs.get('revision_id', None)
550
# no default to raise if not provided.
551
to_bzrdir = kwargs.get('to_bzrdir')
552
result = self._format.initialize(to_bzrdir)
553
self.copy_content_into(result, revision_id=revision_id)
557
def sprout(self, to_bzrdir, revision_id=None):
558
"""Create a new line of development from the branch, into to_bzrdir.
560
revision_id: if not None, the revision history in the new branch will
561
be truncated to end with revision_id.
563
result = self._format.initialize(to_bzrdir)
564
self.copy_content_into(result, revision_id=revision_id)
565
result.set_parent(self.bzrdir.root_transport.base)
568
def _synchronize_history(self, destination, revision_id):
569
"""Synchronize last revision and revision history between branches.
571
This version is most efficient when the destination is also a
572
BzrBranch5, but works for BzrBranch6 as long as the revision
573
history is the true lefthand parent history, and all of the revisions
574
are in the destination's repository. If not, set_revision_history
577
:param destination: The branch to copy the history into
578
:param revision_id: The revision-id to truncate history at. May
579
be None to copy complete history.
581
new_history = self.revision_history()
582
if revision_id is not None:
584
new_history = new_history[:new_history.index(revision_id) + 1]
586
rev = self.repository.get_revision(revision_id)
587
new_history = rev.get_history(self.repository)[1:]
588
destination.set_revision_history(new_history)
591
def copy_content_into(self, destination, revision_id=None):
592
"""Copy the content of self into destination.
594
revision_id: if not None, the revision history in the new branch will
595
be truncated to end with revision_id.
597
self._synchronize_history(destination, revision_id)
599
parent = self.get_parent()
600
except errors.InaccessibleParent, e:
601
mutter('parent was not accessible to copy: %s', e)
604
destination.set_parent(parent)
608
"""Check consistency of the branch.
610
In particular this checks that revisions given in the revision-history
611
do actually match up in the revision graph, and that they're all
612
present in the repository.
614
Callers will typically also want to check the repository.
616
:return: A BranchCheckResult.
618
mainline_parent_id = None
619
for revision_id in self.revision_history():
621
revision = self.repository.get_revision(revision_id)
622
except errors.NoSuchRevision, e:
623
raise errors.BzrCheckError("mainline revision {%s} not in repository"
625
# In general the first entry on the revision history has no parents.
626
# But it's not illegal for it to have parents listed; this can happen
627
# in imports from Arch when the parents weren't reachable.
628
if mainline_parent_id is not None:
629
if mainline_parent_id not in revision.parent_ids:
630
raise errors.BzrCheckError("previous revision {%s} not listed among "
632
% (mainline_parent_id, revision_id))
633
mainline_parent_id = revision_id
634
return BranchCheckResult(self)
636
def _get_checkout_format(self):
637
"""Return the most suitable metadir for a checkout of this branch.
638
Weaves are used if this branch's repostory uses weaves.
640
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
641
from bzrlib.repofmt import weaverepo
642
format = bzrdir.BzrDirMetaFormat1()
643
format.repository_format = weaverepo.RepositoryFormat7()
645
format = self.repository.bzrdir.cloning_metadir()
646
format.branch_format = self._format
649
def create_checkout(self, to_location, revision_id=None,
651
"""Create a checkout of a branch.
653
:param to_location: The url to produce the checkout at
654
:param revision_id: The revision to check out
655
:param lightweight: If True, produce a lightweight checkout, otherwise,
656
produce a bound branch (heavyweight checkout)
657
:return: The tree of the created checkout
659
t = transport.get_transport(to_location)
662
except errors.FileExists:
665
checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
666
BranchReferenceFormat().initialize(checkout, self)
668
format = self._get_checkout_format()
669
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
670
to_location, force_new_tree=False, format=format)
671
checkout = checkout_branch.bzrdir
672
checkout_branch.bind(self)
673
# pull up to the specified revision_id to set the initial
674
# branch tip correctly, and seed it with history.
675
checkout_branch.pull(self, stop_revision=revision_id)
676
return checkout.create_workingtree(revision_id)
679
class BranchFormat(object):
680
"""An encapsulation of the initialization and open routines for a format.
682
Formats provide three things:
683
* An initialization routine,
687
Formats are placed in an dict by their format string for reference
688
during branch opening. Its not required that these be instances, they
689
can be classes themselves with class methods - it simply depends on
690
whether state is needed for a given format or not.
692
Once a format is deprecated, just deprecate the initialize and open
693
methods on the format class. Do not deprecate the object, as the
694
object will be created every time regardless.
697
_default_format = None
698
"""The default format used for new branches."""
701
"""The known formats."""
704
def find_format(klass, a_bzrdir):
705
"""Return the format for the branch object in a_bzrdir."""
707
transport = a_bzrdir.get_branch_transport(None)
708
format_string = transport.get("format").read()
709
return klass._formats[format_string]
711
raise NotBranchError(path=transport.base)
713
raise errors.UnknownFormatError(format=format_string)
716
def get_default_format(klass):
717
"""Return the current default format."""
718
return klass._default_format
720
def get_format_string(self):
721
"""Return the ASCII format string that identifies this format."""
722
raise NotImplementedError(self.get_format_string)
724
def get_format_description(self):
725
"""Return the short format description for this format."""
726
raise NotImplementedError(self.get_format_description)
728
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
730
"""Initialize a branch in a bzrdir, with specified files
732
:param a_bzrdir: The bzrdir to initialize the branch in
733
:param utf8_files: The files to create as a list of
734
(filename, content) tuples
735
:param set_format: If True, set the format with
736
self.get_format_string. (BzrBranch4 has its format set
738
:return: a branch in this format
740
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
741
branch_transport = a_bzrdir.get_branch_transport(self)
743
'metadir': ('lock', lockdir.LockDir),
744
'branch4': ('branch-lock', lockable_files.TransportLock),
746
lock_name, lock_class = lock_map[lock_type]
747
control_files = lockable_files.LockableFiles(branch_transport,
748
lock_name, lock_class)
749
control_files.create_lock()
750
control_files.lock_write()
752
control_files.put_utf8('format', self.get_format_string())
754
for file, content in utf8_files:
755
control_files.put_utf8(file, content)
757
control_files.unlock()
758
return self.open(a_bzrdir, _found=True)
760
def initialize(self, a_bzrdir):
761
"""Create a branch of this format in a_bzrdir."""
762
raise NotImplementedError(self.initialize)
764
def is_supported(self):
765
"""Is this format supported?
767
Supported formats can be initialized and opened.
768
Unsupported formats may not support initialization or committing or
769
some other features depending on the reason for not being supported.
773
def open(self, a_bzrdir, _found=False):
774
"""Return the branch object for a_bzrdir
776
_found is a private parameter, do not use it. It is used to indicate
777
if format probing has already be done.
779
raise NotImplementedError(self.open)
782
def register_format(klass, format):
783
klass._formats[format.get_format_string()] = format
786
def set_default_format(klass, format):
787
klass._default_format = format
790
def unregister_format(klass, format):
791
assert klass._formats[format.get_format_string()] is format
792
del klass._formats[format.get_format_string()]
795
return self.get_format_string().rstrip()
798
class BranchHooks(dict):
799
"""A dictionary mapping hook name to a list of callables for branch hooks.
801
e.g. ['set_rh'] Is the list of items to be called when the
802
set_revision_history function is invoked.
806
"""Create the default hooks.
808
These are all empty initially, because by default nothing should get
812
# Introduced in 0.15:
813
# invoked whenever the revision history has been set
814
# with set_revision_history. The api signature is
815
# (branch, revision_history), and the branch will
818
# invoked after a push operation completes.
819
# the api signature is
820
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
821
# where local is the local branch or None, master is the target
822
# master branch, and the rest should be self explanatory. The source
823
# is read locked and the target branches write locked. Source will
824
# be the local low-latency branch.
825
self['post_push'] = []
826
# invoked after a pull operation completes.
827
# the api signature is
828
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
829
# where local is the local branch or None, master is the target
830
# master branch, and the rest should be self explanatory. The source
831
# is read locked and the target branches write locked. The local
832
# branch is the low-latency branch.
833
self['post_pull'] = []
834
# invoked after a commit operation completes.
835
# the api signature is
836
# (local, master, old_revno, old_revid, new_revno, new_revid)
837
# old_revid is NULL_REVISION for the first commit to a branch.
838
self['post_commit'] = []
839
# invoked after a uncommit operation completes.
840
# the api signature is
841
# (local, master, old_revno, old_revid, new_revno, new_revid) where
842
# local is the local branch or None, master is the target branch,
843
# and an empty branch recieves new_revno of 0, new_revid of None.
844
self['post_uncommit'] = []
846
def install_hook(self, hook_name, a_callable):
847
"""Install a_callable in to the hook hook_name.
849
:param hook_name: A hook name. See the __init__ method of BranchHooks
850
for the complete list of hooks.
851
:param a_callable: The callable to be invoked when the hook triggers.
852
The exact signature will depend on the hook - see the __init__
853
method of BranchHooks for details on each hook.
856
self[hook_name].append(a_callable)
858
raise errors.UnknownHook('branch', hook_name)
861
# install the default hooks into the Branch class.
862
Branch.hooks = BranchHooks()
865
class BzrBranchFormat4(BranchFormat):
866
"""Bzr branch format 4.
869
- a revision-history file.
870
- a branch-lock lock file [ to be shared with the bzrdir ]
873
def get_format_description(self):
874
"""See BranchFormat.get_format_description()."""
875
return "Branch format 4"
877
def initialize(self, a_bzrdir):
878
"""Create a branch of this format in a_bzrdir."""
879
utf8_files = [('revision-history', ''),
882
return self._initialize_helper(a_bzrdir, utf8_files,
883
lock_type='branch4', set_format=False)
886
super(BzrBranchFormat4, self).__init__()
887
self._matchingbzrdir = bzrdir.BzrDirFormat6()
889
def open(self, a_bzrdir, _found=False):
890
"""Return the branch object for a_bzrdir
892
_found is a private parameter, do not use it. It is used to indicate
893
if format probing has already be done.
896
# we are being called directly and must probe.
897
raise NotImplementedError
898
return BzrBranch(_format=self,
899
_control_files=a_bzrdir._control_files,
901
_repository=a_bzrdir.open_repository())
904
return "Bazaar-NG branch format 4"
907
class BzrBranchFormat5(BranchFormat):
908
"""Bzr branch format 5.
911
- a revision-history file.
913
- a lock dir guarding the branch itself
914
- all of this stored in a branch/ subdirectory
915
- works with shared repositories.
917
This format is new in bzr 0.8.
920
def get_format_string(self):
921
"""See BranchFormat.get_format_string()."""
922
return "Bazaar-NG branch format 5\n"
924
def get_format_description(self):
925
"""See BranchFormat.get_format_description()."""
926
return "Branch format 5"
928
def initialize(self, a_bzrdir):
929
"""Create a branch of this format in a_bzrdir."""
930
utf8_files = [('revision-history', ''),
933
return self._initialize_helper(a_bzrdir, utf8_files)
936
super(BzrBranchFormat5, self).__init__()
937
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
939
def open(self, a_bzrdir, _found=False):
940
"""Return the branch object for a_bzrdir
942
_found is a private parameter, do not use it. It is used to indicate
943
if format probing has already be done.
946
format = BranchFormat.find_format(a_bzrdir)
947
assert format.__class__ == self.__class__
948
transport = a_bzrdir.get_branch_transport(None)
949
control_files = lockable_files.LockableFiles(transport, 'lock',
951
return BzrBranch5(_format=self,
952
_control_files=control_files,
954
_repository=a_bzrdir.find_repository())
957
return "Bazaar-NG Metadir branch format 5"
960
class BzrBranchFormat6(BzrBranchFormat5):
961
"""Branch format with last-revision
963
Unlike previous formats, this has no explicit revision history. Instead,
964
this just stores the last-revision, and the left-hand history leading
965
up to there is the history.
967
This format was introduced in bzr 0.15
970
def get_format_string(self):
971
"""See BranchFormat.get_format_string()."""
972
return "Bazaar-NG branch format 6\n"
974
def get_format_description(self):
975
"""See BranchFormat.get_format_description()."""
976
return "Branch format 6"
978
def initialize(self, a_bzrdir):
979
"""Create a branch of this format in a_bzrdir."""
980
utf8_files = [('last-revision', 'null:\n'),
984
return self._initialize_helper(a_bzrdir, utf8_files)
986
def open(self, a_bzrdir, _found=False):
987
"""Return the branch object for a_bzrdir
989
_found is a private parameter, do not use it. It is used to indicate
990
if format probing has already be done.
993
format = BranchFormat.find_format(a_bzrdir)
994
assert format.__class__ == self.__class__
995
transport = a_bzrdir.get_branch_transport(None)
996
control_files = lockable_files.LockableFiles(transport, 'lock',
998
return BzrBranch6(_format=self,
999
_control_files=control_files,
1001
_repository=a_bzrdir.find_repository())
1004
class BranchReferenceFormat(BranchFormat):
1005
"""Bzr branch reference format.
1007
Branch references are used in implementing checkouts, they
1008
act as an alias to the real branch which is at some other url.
1015
def get_format_string(self):
1016
"""See BranchFormat.get_format_string()."""
1017
return "Bazaar-NG Branch Reference Format 1\n"
1019
def get_format_description(self):
1020
"""See BranchFormat.get_format_description()."""
1021
return "Checkout reference format 1"
1023
def initialize(self, a_bzrdir, target_branch=None):
1024
"""Create a branch of this format in a_bzrdir."""
1025
if target_branch is None:
1026
# this format does not implement branch itself, thus the implicit
1027
# creation contract must see it as uninitializable
1028
raise errors.UninitializableFormat(self)
1029
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1030
branch_transport = a_bzrdir.get_branch_transport(self)
1031
branch_transport.put_bytes('location',
1032
target_branch.bzrdir.root_transport.base)
1033
branch_transport.put_bytes('format', self.get_format_string())
1034
return self.open(a_bzrdir, _found=True)
1037
super(BranchReferenceFormat, self).__init__()
1038
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1040
def _make_reference_clone_function(format, a_branch):
1041
"""Create a clone() routine for a branch dynamically."""
1042
def clone(to_bzrdir, revision_id=None):
1043
"""See Branch.clone()."""
1044
return format.initialize(to_bzrdir, a_branch)
1045
# cannot obey revision_id limits when cloning a reference ...
1046
# FIXME RBC 20060210 either nuke revision_id for clone, or
1047
# emit some sort of warning/error to the caller ?!
1050
def open(self, a_bzrdir, _found=False):
1051
"""Return the branch that the branch reference in a_bzrdir points at.
1053
_found is a private parameter, do not use it. It is used to indicate
1054
if format probing has already be done.
1057
format = BranchFormat.find_format(a_bzrdir)
1058
assert format.__class__ == self.__class__
1059
transport = a_bzrdir.get_branch_transport(None)
1060
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1061
result = real_bzrdir.open_branch()
1062
# this changes the behaviour of result.clone to create a new reference
1063
# rather than a copy of the content of the branch.
1064
# I did not use a proxy object because that needs much more extensive
1065
# testing, and we are only changing one behaviour at the moment.
1066
# If we decide to alter more behaviours - i.e. the implicit nickname
1067
# then this should be refactored to introduce a tested proxy branch
1068
# and a subclass of that for use in overriding clone() and ....
1070
result.clone = self._make_reference_clone_function(result)
1074
# formats which have no format string are not discoverable
1075
# and not independently creatable, so are not registered.
1076
__default_format = BzrBranchFormat5()
1077
BranchFormat.register_format(__default_format)
1078
BranchFormat.register_format(BranchReferenceFormat())
1079
BranchFormat.register_format(BzrBranchFormat6())
1080
BranchFormat.set_default_format(__default_format)
1081
_legacy_formats = [BzrBranchFormat4(),
1084
class BzrBranch(Branch):
1085
"""A branch stored in the actual filesystem.
1087
Note that it's "local" in the context of the filesystem; it doesn't
1088
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1089
it's writable, and can be accessed via the normal filesystem API.
1092
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
1093
relax_version_check=DEPRECATED_PARAMETER, _format=None,
1094
_control_files=None, a_bzrdir=None, _repository=None):
1095
"""Create new branch object at a particular location.
1097
transport -- A Transport object, defining how to access files.
1099
init -- If True, create new control files in a previously
1100
unversioned directory. If False, the branch must already
1103
relax_version_check -- If true, the usual check for the branch
1104
version is not applied. This is intended only for
1105
upgrade/recovery type use; it's not guaranteed that
1106
all operations will work on old format branches.
1108
if a_bzrdir is None:
1109
self.bzrdir = bzrdir.BzrDir.open(transport.base)
1111
self.bzrdir = a_bzrdir
1112
self._transport = self.bzrdir.transport.clone('..')
1113
self._base = self._transport.base
1114
self._format = _format
1115
if _control_files is None:
1116
raise ValueError('BzrBranch _control_files is None')
1117
self.control_files = _control_files
1118
if deprecated_passed(init):
1119
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
1120
"deprecated as of bzr 0.8. Please use Branch.create().",
1124
# this is slower than before deprecation, oh well never mind.
1125
# -> its deprecated.
1126
self._initialize(transport.base)
1127
self._check_format(_format)
1128
if deprecated_passed(relax_version_check):
1129
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1130
"relax_version_check parameter is deprecated as of bzr 0.8. "
1131
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1135
if (not relax_version_check
1136
and not self._format.is_supported()):
1137
raise errors.UnsupportedFormatError(format=fmt)
1138
if deprecated_passed(transport):
1139
warn("BzrBranch.__init__(transport=XXX...): The transport "
1140
"parameter is deprecated as of bzr 0.8. "
1141
"Please use Branch.open, or bzrdir.open_branch().",
1144
self.repository = _repository
1147
return '%s(%r)' % (self.__class__.__name__, self.base)
1151
def _get_base(self):
1154
base = property(_get_base, doc="The URL for the root of this branch.")
1156
def _finish_transaction(self):
1157
"""Exit the current transaction."""
1158
return self.control_files._finish_transaction()
1160
def get_transaction(self):
1161
"""Return the current active transaction.
1163
If no transaction is active, this returns a passthrough object
1164
for which all data is immediately flushed and no caching happens.
1166
# this is an explicit function so that we can do tricky stuff
1167
# when the storage in rev_storage is elsewhere.
1168
# we probably need to hook the two 'lock a location' and
1169
# 'have a transaction' together more delicately, so that
1170
# we can have two locks (branch and storage) and one transaction
1171
# ... and finishing the transaction unlocks both, but unlocking
1172
# does not. - RBC 20051121
1173
return self.control_files.get_transaction()
1175
def _set_transaction(self, transaction):
1176
"""Set a new active transaction."""
1177
return self.control_files._set_transaction(transaction)
1179
def abspath(self, name):
1180
"""See Branch.abspath."""
1181
return self.control_files._transport.abspath(name)
1183
def _check_format(self, format):
1184
"""Identify the branch format if needed.
1186
The format is stored as a reference to the format object in
1187
self._format for code that needs to check it later.
1189
The format parameter is either None or the branch format class
1190
used to open this branch.
1192
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1195
format = BranchFormat.find_format(self.bzrdir)
1196
self._format = format
1197
mutter("got branch format %s", self._format)
1200
def get_root_id(self):
1201
"""See Branch.get_root_id."""
1202
tree = self.repository.revision_tree(self.last_revision())
1203
return tree.inventory.root.file_id
1205
def is_locked(self):
1206
return self.control_files.is_locked()
1208
def lock_write(self):
1209
self.repository.lock_write()
1211
self.control_files.lock_write()
1213
self.repository.unlock()
1216
def lock_read(self):
1217
self.repository.lock_read()
1219
self.control_files.lock_read()
1221
self.repository.unlock()
1225
# TODO: test for failed two phase locks. This is known broken.
1227
self.control_files.unlock()
1229
self.repository.unlock()
1231
def peek_lock_mode(self):
1232
if self.control_files._lock_count == 0:
1235
return self.control_files._lock_mode
1237
def get_physical_lock_status(self):
1238
return self.control_files.get_physical_lock_status()
1241
def print_file(self, file, revision_id):
1242
"""See Branch.print_file."""
1243
return self.repository.print_file(file, revision_id)
1246
def append_revision(self, *revision_ids):
1247
"""See Branch.append_revision."""
1248
for revision_id in revision_ids:
1249
_mod_revision.check_not_reserved_id(revision_id)
1250
mutter("add {%s} to revision-history" % revision_id)
1251
rev_history = self.revision_history()
1252
rev_history.extend(revision_ids)
1253
self.set_revision_history(rev_history)
1256
def set_revision_history(self, rev_history):
1257
"""See Branch.set_revision_history."""
1258
self.control_files.put_utf8(
1259
'revision-history', '\n'.join(rev_history))
1260
transaction = self.get_transaction()
1261
history = transaction.map.find_revision_history()
1262
if history is not None:
1263
# update the revision history in the identity map.
1264
history[:] = list(rev_history)
1265
# this call is disabled because revision_history is
1266
# not really an object yet, and the transaction is for objects.
1267
# transaction.register_dirty(history)
1269
transaction.map.add_revision_history(rev_history)
1270
# this call is disabled because revision_history is
1271
# not really an object yet, and the transaction is for objects.
1272
# transaction.register_clean(history)
1273
for hook in Branch.hooks['set_rh']:
1274
hook(self, rev_history)
1277
def set_last_revision(self, revision_id):
1278
self.set_revision_history(self._lefthand_history(revision_id))
1281
def revision_history(self):
1282
"""See Branch.revision_history."""
1283
transaction = self.get_transaction()
1284
history = transaction.map.find_revision_history()
1285
if history is not None:
1286
# mutter("cache hit for revision-history in %s", self)
1287
return list(history)
1288
decode_utf8 = cache_utf8.decode
1289
history = [decode_utf8(l.rstrip('\r\n')) for l in
1290
self.control_files.get('revision-history').readlines()]
1291
transaction.map.add_revision_history(history)
1292
# this call is disabled because revision_history is
1293
# not really an object yet, and the transaction is for objects.
1294
# transaction.register_clean(history, precious=True)
1295
return list(history)
1297
def _lefthand_history(self, revision_id, last_rev=None,
1299
# stop_revision must be a descendant of last_revision
1300
stop_graph = self.repository.get_revision_graph(revision_id)
1301
if last_rev is not None and last_rev not in stop_graph:
1302
# our previous tip is not merged into stop_revision
1303
raise errors.DivergedBranches(self, other_branch)
1304
# make a new revision history from the graph
1305
current_rev_id = revision_id
1307
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1308
new_history.append(current_rev_id)
1309
current_rev_id_parents = stop_graph[current_rev_id]
1311
current_rev_id = current_rev_id_parents[0]
1313
current_rev_id = None
1314
new_history.reverse()
1318
def generate_revision_history(self, revision_id, last_rev=None,
1320
"""Create a new revision history that will finish with revision_id.
1322
:param revision_id: the new tip to use.
1323
:param last_rev: The previous last_revision. If not None, then this
1324
must be a ancestory of revision_id, or DivergedBranches is raised.
1325
:param other_branch: The other branch that DivergedBranches should
1326
raise with respect to.
1328
self.set_revision_history(self._lefthand_history(revision_id,
1329
last_rev, other_branch))
1332
def update_revisions(self, other, stop_revision=None):
1333
"""See Branch.update_revisions."""
1336
if stop_revision is None:
1337
stop_revision = other.last_revision()
1338
if stop_revision is None:
1339
# if there are no commits, we're done.
1341
# whats the current last revision, before we fetch [and change it
1343
last_rev = self.last_revision()
1344
# we fetch here regardless of whether we need to so that we pickup
1346
self.fetch(other, stop_revision)
1347
my_ancestry = self.repository.get_ancestry(last_rev)
1348
if stop_revision in my_ancestry:
1349
# last_revision is a descendant of stop_revision
1351
self.generate_revision_history(stop_revision, last_rev=last_rev,
1356
def basis_tree(self):
1357
"""See Branch.basis_tree."""
1358
return self.repository.revision_tree(self.last_revision())
1360
@deprecated_method(zero_eight)
1361
def working_tree(self):
1362
"""Create a Working tree object for this branch."""
1364
from bzrlib.transport.local import LocalTransport
1365
if (self.base.find('://') != -1 or
1366
not isinstance(self._transport, LocalTransport)):
1367
raise NoWorkingTree(self.base)
1368
return self.bzrdir.open_workingtree()
1371
def pull(self, source, overwrite=False, stop_revision=None,
1372
_hook_master=None, _run_hooks=True):
1375
:param _hook_master: Private parameter - set the branch to
1376
be supplied as the master to push hooks.
1377
:param _run_hooks: Private parameter - allow disabling of
1378
hooks, used when pushing to a master branch.
1382
old_count, old_tip = self.last_revision_info()
1384
self.update_revisions(source, stop_revision)
1385
except DivergedBranches:
1389
self.set_revision_history(source.revision_history())
1390
new_count, new_tip = self.last_revision_info()
1397
for hook in Branch.hooks['post_pull']:
1398
hook(source, _hook_local, _hook_master, old_count, old_tip,
1400
return new_count - old_count
1404
def _get_parent_location(self):
1405
_locs = ['parent', 'pull', 'x-pull']
1408
return self.control_files.get(l).read().strip('\n')
1414
def push(self, target, overwrite=False, stop_revision=None,
1415
_hook_master=None, _run_hooks=True):
1418
:param _hook_master: Private parameter - set the branch to
1419
be supplied as the master to push hooks.
1420
:param _run_hooks: Private parameter - allow disabling of
1421
hooks, used when pushing to a master branch.
1425
old_count, old_tip = target.last_revision_info()
1427
target.update_revisions(self, stop_revision)
1428
except DivergedBranches:
1432
target.set_revision_history(self.revision_history())
1433
new_count, new_tip = target.last_revision_info()
1436
_hook_local = target
1438
_hook_master = target
1440
for hook in Branch.hooks['post_push']:
1441
hook(self, _hook_local, _hook_master, old_count, old_tip,
1443
return new_count - old_count
1447
def get_parent(self):
1448
"""See Branch.get_parent."""
1450
assert self.base[-1] == '/'
1451
parent = self._get_parent_location()
1454
# This is an old-format absolute path to a local branch
1455
# turn it into a url
1456
if parent.startswith('/'):
1457
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1459
return urlutils.join(self.base[:-1], parent)
1460
except errors.InvalidURLJoin, e:
1461
raise errors.InaccessibleParent(parent, self.base)
1463
def get_push_location(self):
1464
"""See Branch.get_push_location."""
1465
push_loc = self.get_config().get_user_option('push_location')
1468
def set_push_location(self, location):
1469
"""See Branch.set_push_location."""
1470
self.get_config().set_user_option(
1471
'push_location', location,
1472
store=_mod_config.STORE_LOCATION_NORECURSE)
1475
def set_parent(self, url):
1476
"""See Branch.set_parent."""
1477
# TODO: Maybe delete old location files?
1478
# URLs should never be unicode, even on the local fs,
1479
# FIXUP this and get_parent in a future branch format bump:
1480
# read and rewrite the file, and have the new format code read
1481
# using .get not .get_utf8. RBC 20060125
1483
if isinstance(url, unicode):
1485
url = url.encode('ascii')
1486
except UnicodeEncodeError:
1487
raise bzrlib.errors.InvalidURL(url,
1488
"Urls must be 7-bit ascii, "
1489
"use bzrlib.urlutils.escape")
1491
url = urlutils.relative_url(self.base, url)
1492
self._set_parent_location(url)
1494
def _set_parent_location(self, url):
1496
self.control_files._transport.delete('parent')
1498
assert isinstance(url, str)
1499
self.control_files.put('parent', StringIO(url + '\n'))
1501
@deprecated_function(zero_nine)
1502
def tree_config(self):
1503
"""DEPRECATED; call get_config instead.
1504
TreeConfig has become part of BranchConfig."""
1505
return TreeConfig(self)
1508
class BzrBranch5(BzrBranch):
1509
"""A format 5 branch. This supports new features over plan branches.
1511
It has support for a master_branch which is the data for bound branches.
1519
super(BzrBranch5, self).__init__(_format=_format,
1520
_control_files=_control_files,
1522
_repository=_repository)
1525
def pull(self, source, overwrite=False, stop_revision=None,
1527
"""Extends branch.pull to be bound branch aware.
1529
:param _run_hooks: Private parameter used to force hook running
1530
off during bound branch double-pushing.
1532
bound_location = self.get_bound_location()
1533
master_branch = None
1534
if bound_location and source.base != bound_location:
1535
# not pulling from master, so we need to update master.
1536
master_branch = self.get_master_branch()
1537
master_branch.lock_write()
1540
# pull from source into master.
1541
master_branch.pull(source, overwrite, stop_revision,
1543
return super(BzrBranch5, self).pull(source, overwrite,
1544
stop_revision, _hook_master=master_branch,
1545
_run_hooks=_run_hooks)
1548
master_branch.unlock()
1551
def push(self, target, overwrite=False, stop_revision=None):
1552
"""Updates branch.push to be bound branch aware."""
1553
bound_location = target.get_bound_location()
1554
master_branch = None
1555
if bound_location and target.base != bound_location:
1556
# not pushing to master, so we need to update master.
1557
master_branch = target.get_master_branch()
1558
master_branch.lock_write()
1561
# push into the master from this branch.
1562
super(BzrBranch5, self).push(master_branch, overwrite,
1563
stop_revision, _run_hooks=False)
1564
# and push into the target branch from this. Note that we push from
1565
# this branch again, because its considered the highest bandwidth
1567
return super(BzrBranch5, self).push(target, overwrite,
1568
stop_revision, _hook_master=master_branch)
1571
master_branch.unlock()
1573
def get_bound_location(self):
1575
return self.control_files.get_utf8('bound').read()[:-1]
1576
except errors.NoSuchFile:
1580
def get_master_branch(self):
1581
"""Return the branch we are bound to.
1583
:return: Either a Branch, or None
1585
This could memoise the branch, but if thats done
1586
it must be revalidated on each new lock.
1587
So for now we just don't memoise it.
1588
# RBC 20060304 review this decision.
1590
bound_loc = self.get_bound_location()
1594
return Branch.open(bound_loc)
1595
except (errors.NotBranchError, errors.ConnectionError), e:
1596
raise errors.BoundBranchConnectionFailure(
1600
def set_bound_location(self, location):
1601
"""Set the target where this branch is bound to.
1603
:param location: URL to the target branch
1606
self.control_files.put_utf8('bound', location+'\n')
1609
self.control_files._transport.delete('bound')
1615
def bind(self, other):
1616
"""Bind this branch to the branch other.
1618
This does not push or pull data between the branches, though it does
1619
check for divergence to raise an error when the branches are not
1620
either the same, or one a prefix of the other. That behaviour may not
1621
be useful, so that check may be removed in future.
1623
:param other: The branch to bind to
1626
# TODO: jam 20051230 Consider checking if the target is bound
1627
# It is debatable whether you should be able to bind to
1628
# a branch which is itself bound.
1629
# Committing is obviously forbidden,
1630
# but binding itself may not be.
1631
# Since we *have* to check at commit time, we don't
1632
# *need* to check here
1634
# we want to raise diverged if:
1635
# last_rev is not in the other_last_rev history, AND
1636
# other_last_rev is not in our history, and do it without pulling
1638
last_rev = self.last_revision()
1639
if last_rev is not None:
1642
other_last_rev = other.last_revision()
1643
if other_last_rev is not None:
1644
# neither branch is new, we have to do some work to
1645
# ascertain diversion.
1646
remote_graph = other.repository.get_revision_graph(
1648
local_graph = self.repository.get_revision_graph(last_rev)
1649
if (last_rev not in remote_graph and
1650
other_last_rev not in local_graph):
1651
raise errors.DivergedBranches(self, other)
1654
self.set_bound_location(other.base)
1658
"""If bound, unbind"""
1659
return self.set_bound_location(None)
1663
"""Synchronise this branch with the master branch if any.
1665
:return: None or the last_revision that was pivoted out during the
1668
master = self.get_master_branch()
1669
if master is not None:
1670
old_tip = self.last_revision()
1671
self.pull(master, overwrite=True)
1672
if old_tip in self.repository.get_ancestry(self.last_revision()):
1678
class BzrBranch6(BzrBranch5):
1681
def last_revision(self):
1682
"""Return last revision id, or None"""
1683
revision_id = self.control_files.get_utf8('last-revision').read()
1684
revision_id = revision_id.rstrip('\n')
1685
if revision_id == _mod_revision.NULL_REVISION:
1690
def set_last_revision(self, revision_id):
1691
if self._get_append_revisions_only():
1692
self._check_history_violation(revision_id)
1693
if revision_id is None:
1694
revision_id = 'null:'
1695
self.control_files.put_utf8('last-revision', revision_id + '\n')
1697
def _check_history_violation(self, revision_id):
1698
last_revision = self.last_revision()
1699
if last_revision is None:
1701
if last_revision not in self._lefthand_history(revision_id):
1702
raise errors.AppendRevisionsOnlyViolation(self.base)
1705
def revision_history(self):
1706
"""Generate the revision history from last revision
1708
return self._lefthand_history(self.last_revision())
1711
def set_revision_history(self, history):
1712
"""Set the last_revision, not revision history"""
1713
if len(history) == 0:
1714
self.set_last_revision('null:')
1716
assert history == self._lefthand_history(history[-1])
1717
self.set_last_revision(history[-1])
1718
for hook in Branch.hooks['set_rh']:
1722
def append_revision(self, *revision_ids):
1723
if len(revision_ids) == 0:
1725
prev_revision = self.last_revision()
1726
for revision in self.repository.get_revisions(revision_ids):
1727
if prev_revision is None:
1728
assert revision.parent_ids == []
1730
assert revision.parent_ids[0] == prev_revision
1731
prev_revision = revision.revision_id
1732
self.set_last_revision(revision_ids[-1])
1734
def _set_config_location(self, name, url, config=None,
1735
make_relative=False):
1737
config = self.get_config()
1741
url = urlutils.relative_url(self.base, url)
1742
config.set_user_option(name, url)
1745
def _get_config_location(self, name, config=None):
1747
config = self.get_config()
1748
location = config.get_user_option(name)
1754
def _set_parent_location(self, url):
1755
"""Set the parent branch"""
1756
self._set_config_location('parent_location', url, make_relative=True)
1759
def _get_parent_location(self):
1760
"""Set the parent branch"""
1761
return self._get_config_location('parent_location')
1763
def set_push_location(self, location):
1764
"""See Branch.set_push_location."""
1765
self._set_config_location('push_location', location)
1767
def set_bound_location(self, location):
1768
"""See Branch.set_push_location."""
1770
config = self.get_config()
1771
if location is None:
1772
if config.get_user_option('bound') != 'True':
1775
config.set_user_option('bound', 'False')
1778
self._set_config_location('bound_location', location,
1780
config.set_user_option('bound', 'True')
1783
def _get_bound_location(self, bound):
1784
"""Return the bound location in the config file.
1786
Return None if the bound parameter does not match"""
1787
config = self.get_config()
1788
config_bound = (config.get_user_option('bound') == 'True')
1789
if config_bound != bound:
1791
return self._get_config_location('bound_location', config=config)
1793
def get_bound_location(self):
1794
"""See Branch.set_push_location."""
1795
return self._get_bound_location(True)
1797
def get_old_bound_location(self):
1798
"""See Branch.get_old_bound_location"""
1799
return self._get_bound_location(False)
1801
def set_append_revisions_only(self, enabled):
1806
self.get_config().set_user_option('append_revisions_only', value)
1808
def _get_append_revisions_only(self):
1809
value = self.get_config().get_user_option('append_revisions_only')
1810
return value == 'True'
1812
def _synchronize_history(self, destination, revision_id):
1813
"""Synchronize last revision and revision history between branches.
1815
This version is most efficient when the destination is also a
1816
BzrBranch6, but works for BzrBranch5, as long as the destination's
1817
repository contains all the lefthand ancestors of the intended
1818
last_revision. If not, set_last_revision will fail.
1820
:param destination: The branch to copy the history into
1821
:param revision_id: The revision-id to truncate history at. May
1822
be None to copy complete history.
1824
if revision_id is None:
1825
revision_id = self.last_revision()
1826
destination.set_last_revision(revision_id)
1829
class BranchTestProviderAdapter(object):
1830
"""A tool to generate a suite testing multiple branch formats at once.
1832
This is done by copying the test once for each transport and injecting
1833
the transport_server, transport_readonly_server, and branch_format
1834
classes into each copy. Each copy is also given a new id() to make it
1838
def __init__(self, transport_server, transport_readonly_server, formats):
1839
self._transport_server = transport_server
1840
self._transport_readonly_server = transport_readonly_server
1841
self._formats = formats
1843
def adapt(self, test):
1844
result = TestSuite()
1845
for branch_format, bzrdir_format in self._formats:
1846
new_test = deepcopy(test)
1847
new_test.transport_server = self._transport_server
1848
new_test.transport_readonly_server = self._transport_readonly_server
1849
new_test.bzrdir_format = bzrdir_format
1850
new_test.branch_format = branch_format
1851
def make_new_test_id():
1852
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1853
return lambda: new_id
1854
new_test.id = make_new_test_id()
1855
result.addTest(new_test)
1859
class BranchCheckResult(object):
1860
"""Results of checking branch consistency.
1865
def __init__(self, branch):
1866
self.branch = branch
1868
def report_results(self, verbose):
1869
"""Report the check results via trace.note.
1871
:param verbose: Requests more detailed display of what was checked,
1874
note('checked branch %s format %s',
1876
self.branch._format)
1879
######################################################################
1883
@deprecated_function(zero_eight)
1884
def is_control_file(*args, **kwargs):
1885
"""See bzrlib.workingtree.is_control_file."""
1886
from bzrlib import workingtree
1887
return workingtree.is_control_file(*args, **kwargs)
1890
class Converter5to6(object):
1891
"""Perform an in-place upgrade of format 5 to format 6"""
1893
def convert(self, branch):
1894
# Data for 5 and 6 can peacefully coexist.
1895
format = BzrBranchFormat6()
1896
new_branch = format.open(branch.bzrdir, _found=True)
1898
# Copy source data into target
1899
new_branch.set_last_revision(branch.last_revision())
1900
new_branch.set_parent(branch.get_parent())
1901
new_branch.set_bound_location(branch.get_bound_location())
1902
new_branch.set_push_location(branch.get_push_location())
1904
# Copying done; now update target format
1905
new_branch.control_files.put_utf8('format',
1906
format.get_format_string())
1908
# Clean up old files
1909
new_branch.control_files._transport.delete('revision-history')
1911
branch.set_parent(None)
1914
branch.set_bound_location(None)
added
removed
bzrlib/branch.py
