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', '0 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)
1255
def _write_revision_history(self, history):
1256
"""Factored out of set_revision_history.
1258
This performs the actual writing to disk.
1259
It is intended to be called by BzrBranch5.set_revision_history."""
1260
self.control_files.put_utf8(
1261
'revision-history', '\n'.join(history))
1264
def set_revision_history(self, rev_history):
1265
"""See Branch.set_revision_history."""
1266
self._write_revision_history(rev_history)
1267
transaction = self.get_transaction()
1268
history = transaction.map.find_revision_history()
1269
if history is not None:
1270
# update the revision history in the identity map.
1271
history[:] = list(rev_history)
1272
# this call is disabled because revision_history is
1273
# not really an object yet, and the transaction is for objects.
1274
# transaction.register_dirty(history)
1276
transaction.map.add_revision_history(rev_history)
1277
# this call is disabled because revision_history is
1278
# not really an object yet, and the transaction is for objects.
1279
# transaction.register_clean(history)
1280
for hook in Branch.hooks['set_rh']:
1281
hook(self, rev_history)
1284
def set_last_revision_info(self, revno, revision_id):
1285
history = self._lefthand_history(revision_id)
1286
assert len(history) == revno, '%d != %d' % (len(history), revno)
1287
self.set_revision_history(history)
1289
def _gen_revision_history(self):
1290
decode_utf8 = cache_utf8.decode
1291
history = [decode_utf8(l.rstrip('\r\n')) for l in
1292
self.control_files.get('revision-history').readlines()]
1296
def revision_history(self):
1297
"""See Branch.revision_history."""
1298
transaction = self.get_transaction()
1299
history = transaction.map.find_revision_history()
1300
if history is not None:
1301
# mutter("cache hit for revision-history in %s", self)
1302
return list(history)
1303
history = self._gen_revision_history()
1304
transaction.map.add_revision_history(history)
1305
# this call is disabled because revision_history is
1306
# not really an object yet, and the transaction is for objects.
1307
# transaction.register_clean(history, precious=True)
1308
return list(history)
1310
def _lefthand_history(self, revision_id, last_rev=None,
1312
# stop_revision must be a descendant of last_revision
1313
stop_graph = self.repository.get_revision_graph(revision_id)
1314
if last_rev is not None and last_rev not in stop_graph:
1315
# our previous tip is not merged into stop_revision
1316
raise errors.DivergedBranches(self, other_branch)
1317
# make a new revision history from the graph
1318
current_rev_id = revision_id
1320
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1321
new_history.append(current_rev_id)
1322
current_rev_id_parents = stop_graph[current_rev_id]
1324
current_rev_id = current_rev_id_parents[0]
1326
current_rev_id = None
1327
new_history.reverse()
1331
def generate_revision_history(self, revision_id, last_rev=None,
1333
"""Create a new revision history that will finish with revision_id.
1335
:param revision_id: the new tip to use.
1336
:param last_rev: The previous last_revision. If not None, then this
1337
must be a ancestory of revision_id, or DivergedBranches is raised.
1338
:param other_branch: The other branch that DivergedBranches should
1339
raise with respect to.
1341
self.set_revision_history(self._lefthand_history(revision_id,
1342
last_rev, other_branch))
1345
def update_revisions(self, other, stop_revision=None):
1346
"""See Branch.update_revisions."""
1349
if stop_revision is None:
1350
stop_revision = other.last_revision()
1351
if stop_revision is None:
1352
# if there are no commits, we're done.
1354
# whats the current last revision, before we fetch [and change it
1356
last_rev = self.last_revision()
1357
# we fetch here regardless of whether we need to so that we pickup
1359
self.fetch(other, stop_revision)
1360
my_ancestry = self.repository.get_ancestry(last_rev)
1361
if stop_revision in my_ancestry:
1362
# last_revision is a descendant of stop_revision
1364
self.generate_revision_history(stop_revision, last_rev=last_rev,
1369
def basis_tree(self):
1370
"""See Branch.basis_tree."""
1371
return self.repository.revision_tree(self.last_revision())
1373
@deprecated_method(zero_eight)
1374
def working_tree(self):
1375
"""Create a Working tree object for this branch."""
1377
from bzrlib.transport.local import LocalTransport
1378
if (self.base.find('://') != -1 or
1379
not isinstance(self._transport, LocalTransport)):
1380
raise NoWorkingTree(self.base)
1381
return self.bzrdir.open_workingtree()
1384
def pull(self, source, overwrite=False, stop_revision=None,
1385
_hook_master=None, _run_hooks=True):
1388
:param _hook_master: Private parameter - set the branch to
1389
be supplied as the master to push hooks.
1390
:param _run_hooks: Private parameter - allow disabling of
1391
hooks, used when pushing to a master branch.
1395
old_count, old_tip = self.last_revision_info()
1397
self.update_revisions(source, stop_revision)
1398
except DivergedBranches:
1402
self.set_revision_history(source.revision_history())
1403
new_count, new_tip = self.last_revision_info()
1410
for hook in Branch.hooks['post_pull']:
1411
hook(source, _hook_local, _hook_master, old_count, old_tip,
1413
return new_count - old_count
1417
def _get_parent_location(self):
1418
_locs = ['parent', 'pull', 'x-pull']
1421
return self.control_files.get(l).read().strip('\n')
1427
def push(self, target, overwrite=False, stop_revision=None,
1428
_hook_master=None, _run_hooks=True):
1431
:param _hook_master: Private parameter - set the branch to
1432
be supplied as the master to push hooks.
1433
:param _run_hooks: Private parameter - allow disabling of
1434
hooks, used when pushing to a master branch.
1438
old_count, old_tip = target.last_revision_info()
1440
target.update_revisions(self, stop_revision)
1441
except DivergedBranches:
1445
target.set_revision_history(self.revision_history())
1446
new_count, new_tip = target.last_revision_info()
1449
_hook_local = target
1451
_hook_master = target
1453
for hook in Branch.hooks['post_push']:
1454
hook(self, _hook_local, _hook_master, old_count, old_tip,
1456
return new_count - old_count
1460
def get_parent(self):
1461
"""See Branch.get_parent."""
1463
assert self.base[-1] == '/'
1464
parent = self._get_parent_location()
1467
# This is an old-format absolute path to a local branch
1468
# turn it into a url
1469
if parent.startswith('/'):
1470
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1472
return urlutils.join(self.base[:-1], parent)
1473
except errors.InvalidURLJoin, e:
1474
raise errors.InaccessibleParent(parent, self.base)
1476
def get_push_location(self):
1477
"""See Branch.get_push_location."""
1478
push_loc = self.get_config().get_user_option('push_location')
1481
def set_push_location(self, location):
1482
"""See Branch.set_push_location."""
1483
self.get_config().set_user_option(
1484
'push_location', location,
1485
store=_mod_config.STORE_LOCATION_NORECURSE)
1488
def set_parent(self, url):
1489
"""See Branch.set_parent."""
1490
# TODO: Maybe delete old location files?
1491
# URLs should never be unicode, even on the local fs,
1492
# FIXUP this and get_parent in a future branch format bump:
1493
# read and rewrite the file, and have the new format code read
1494
# using .get not .get_utf8. RBC 20060125
1496
if isinstance(url, unicode):
1498
url = url.encode('ascii')
1499
except UnicodeEncodeError:
1500
raise bzrlib.errors.InvalidURL(url,
1501
"Urls must be 7-bit ascii, "
1502
"use bzrlib.urlutils.escape")
1504
url = urlutils.relative_url(self.base, url)
1505
self._set_parent_location(url)
1507
def _set_parent_location(self, url):
1509
self.control_files._transport.delete('parent')
1511
assert isinstance(url, str)
1512
self.control_files.put('parent', StringIO(url + '\n'))
1514
@deprecated_function(zero_nine)
1515
def tree_config(self):
1516
"""DEPRECATED; call get_config instead.
1517
TreeConfig has become part of BranchConfig."""
1518
return TreeConfig(self)
1521
class BzrBranch5(BzrBranch):
1522
"""A format 5 branch. This supports new features over plan branches.
1524
It has support for a master_branch which is the data for bound branches.
1532
super(BzrBranch5, self).__init__(_format=_format,
1533
_control_files=_control_files,
1535
_repository=_repository)
1538
def pull(self, source, overwrite=False, stop_revision=None,
1540
"""Extends branch.pull to be bound branch aware.
1542
:param _run_hooks: Private parameter used to force hook running
1543
off during bound branch double-pushing.
1545
bound_location = self.get_bound_location()
1546
master_branch = None
1547
if bound_location and source.base != bound_location:
1548
# not pulling from master, so we need to update master.
1549
master_branch = self.get_master_branch()
1550
master_branch.lock_write()
1553
# pull from source into master.
1554
master_branch.pull(source, overwrite, stop_revision,
1556
return super(BzrBranch5, self).pull(source, overwrite,
1557
stop_revision, _hook_master=master_branch,
1558
_run_hooks=_run_hooks)
1561
master_branch.unlock()
1564
def push(self, target, overwrite=False, stop_revision=None):
1565
"""Updates branch.push to be bound branch aware."""
1566
bound_location = target.get_bound_location()
1567
master_branch = None
1568
if bound_location and target.base != bound_location:
1569
# not pushing to master, so we need to update master.
1570
master_branch = target.get_master_branch()
1571
master_branch.lock_write()
1574
# push into the master from this branch.
1575
super(BzrBranch5, self).push(master_branch, overwrite,
1576
stop_revision, _run_hooks=False)
1577
# and push into the target branch from this. Note that we push from
1578
# this branch again, because its considered the highest bandwidth
1580
return super(BzrBranch5, self).push(target, overwrite,
1581
stop_revision, _hook_master=master_branch)
1584
master_branch.unlock()
1586
def get_bound_location(self):
1588
return self.control_files.get_utf8('bound').read()[:-1]
1589
except errors.NoSuchFile:
1593
def get_master_branch(self):
1594
"""Return the branch we are bound to.
1596
:return: Either a Branch, or None
1598
This could memoise the branch, but if thats done
1599
it must be revalidated on each new lock.
1600
So for now we just don't memoise it.
1601
# RBC 20060304 review this decision.
1603
bound_loc = self.get_bound_location()
1607
return Branch.open(bound_loc)
1608
except (errors.NotBranchError, errors.ConnectionError), e:
1609
raise errors.BoundBranchConnectionFailure(
1613
def set_bound_location(self, location):
1614
"""Set the target where this branch is bound to.
1616
:param location: URL to the target branch
1619
self.control_files.put_utf8('bound', location+'\n')
1622
self.control_files._transport.delete('bound')
1628
def bind(self, other):
1629
"""Bind this branch to the branch other.
1631
This does not push or pull data between the branches, though it does
1632
check for divergence to raise an error when the branches are not
1633
either the same, or one a prefix of the other. That behaviour may not
1634
be useful, so that check may be removed in future.
1636
:param other: The branch to bind to
1639
# TODO: jam 20051230 Consider checking if the target is bound
1640
# It is debatable whether you should be able to bind to
1641
# a branch which is itself bound.
1642
# Committing is obviously forbidden,
1643
# but binding itself may not be.
1644
# Since we *have* to check at commit time, we don't
1645
# *need* to check here
1647
# we want to raise diverged if:
1648
# last_rev is not in the other_last_rev history, AND
1649
# other_last_rev is not in our history, and do it without pulling
1651
last_rev = self.last_revision()
1652
if last_rev is not None:
1655
other_last_rev = other.last_revision()
1656
if other_last_rev is not None:
1657
# neither branch is new, we have to do some work to
1658
# ascertain diversion.
1659
remote_graph = other.repository.get_revision_graph(
1661
local_graph = self.repository.get_revision_graph(last_rev)
1662
if (last_rev not in remote_graph and
1663
other_last_rev not in local_graph):
1664
raise errors.DivergedBranches(self, other)
1667
self.set_bound_location(other.base)
1671
"""If bound, unbind"""
1672
return self.set_bound_location(None)
1676
"""Synchronise this branch with the master branch if any.
1678
:return: None or the last_revision that was pivoted out during the
1681
master = self.get_master_branch()
1682
if master is not None:
1683
old_tip = self.last_revision()
1684
self.pull(master, overwrite=True)
1685
if old_tip in self.repository.get_ancestry(self.last_revision()):
1691
class BzrBranch6(BzrBranch5):
1694
def last_revision_info(self):
1695
revision_string = self.control_files.get_utf8('last-revision').read()
1696
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1698
return revno, revision_id
1700
def last_revision(self):
1701
"""Return last revision id, or None"""
1702
revision_id = self.last_revision_info()[1]
1703
if revision_id == _mod_revision.NULL_REVISION:
1707
def _write_last_revision_info(self, revno, revision_id):
1708
"""Simply write out the revision id, with no checks.
1710
Use set_last_revision_info to perform this safely.
1712
Does not update the revision_history cache.
1713
Intended to be called by set_last_revision_info and
1714
_write_revision_history.
1716
if revision_id is None:
1717
revision_id = 'null:'
1718
out_string = '%d %s\n' % (revno, revision_id)
1719
self.control_files.put_utf8('last-revision', out_string)
1722
def set_last_revision_info(self, revno, revision_id):
1723
if self._get_append_revisions_only():
1724
self._check_history_violation(revision_id)
1725
self._write_last_revision_info(revno, revision_id)
1726
transaction = self.get_transaction()
1727
cached_history = transaction.map.find_revision_history()
1728
if cached_history is not None:
1729
transaction.map.remove_object(cached_history)
1731
def _check_history_violation(self, revision_id):
1732
last_revision = self.last_revision()
1733
if last_revision is None:
1735
if last_revision not in self._lefthand_history(revision_id):
1736
raise errors.AppendRevisionsOnlyViolation(self.base)
1738
def _gen_revision_history(self):
1739
"""Generate the revision history from last revision
1741
history = list(self.repository.iter_reverse_revision_history(
1742
self.last_revision()))
1746
def _write_revision_history(self, history):
1747
"""Factored out of set_revision_history.
1749
This performs the actual writing to disk, with format-specific checks.
1750
It is intended to be called by BzrBranch5.set_revision_history.
1752
if len(history) == 0:
1753
last_revision = 'null:'
1755
if history != self._lefthand_history(history[-1]):
1756
raise errors.NotLefthandHistory(history)
1757
last_revision = history[-1]
1758
if self._get_append_revisions_only():
1759
self._check_history_violation(last_revision)
1760
self._write_last_revision_info(len(history), last_revision)
1763
def append_revision(self, *revision_ids):
1764
if len(revision_ids) == 0:
1766
prev_revno, prev_revision = self.last_revision_info()
1767
for revision in self.repository.get_revisions(revision_ids):
1768
if prev_revision == _mod_revision.NULL_REVISION:
1769
if revision.parent_ids != []:
1770
raise errors.NotLeftParentDescendant(self, prev_revision,
1771
revision.revision_id)
1773
if revision.parent_ids[0] != prev_revision:
1774
raise errors.NotLeftParentDescendant(self, prev_revision,
1775
revision.revision_id)
1776
prev_revision = revision.revision_id
1777
self.set_last_revision_info(prev_revno + len(revision_ids),
1780
def _set_config_location(self, name, url, config=None,
1781
make_relative=False):
1783
config = self.get_config()
1787
url = urlutils.relative_url(self.base, url)
1788
config.set_user_option(name, url)
1791
def _get_config_location(self, name, config=None):
1793
config = self.get_config()
1794
location = config.get_user_option(name)
1800
def _set_parent_location(self, url):
1801
"""Set the parent branch"""
1802
self._set_config_location('parent_location', url, make_relative=True)
1805
def _get_parent_location(self):
1806
"""Set the parent branch"""
1807
return self._get_config_location('parent_location')
1809
def set_push_location(self, location):
1810
"""See Branch.set_push_location."""
1811
self._set_config_location('push_location', location)
1813
def set_bound_location(self, location):
1814
"""See Branch.set_push_location."""
1816
config = self.get_config()
1817
if location is None:
1818
if config.get_user_option('bound') != 'True':
1821
config.set_user_option('bound', 'False')
1824
self._set_config_location('bound_location', location,
1826
config.set_user_option('bound', 'True')
1829
def _get_bound_location(self, bound):
1830
"""Return the bound location in the config file.
1832
Return None if the bound parameter does not match"""
1833
config = self.get_config()
1834
config_bound = (config.get_user_option('bound') == 'True')
1835
if config_bound != bound:
1837
return self._get_config_location('bound_location', config=config)
1839
def get_bound_location(self):
1840
"""See Branch.set_push_location."""
1841
return self._get_bound_location(True)
1843
def get_old_bound_location(self):
1844
"""See Branch.get_old_bound_location"""
1845
return self._get_bound_location(False)
1847
def set_append_revisions_only(self, enabled):
1852
self.get_config().set_user_option('append_revisions_only', value)
1854
def _get_append_revisions_only(self):
1855
value = self.get_config().get_user_option('append_revisions_only')
1856
return value == 'True'
1858
def _synchronize_history(self, destination, revision_id):
1859
"""Synchronize last revision and revision history between branches.
1861
This version is most efficient when the destination is also a
1862
BzrBranch6, but works for BzrBranch5, as long as the destination's
1863
repository contains all the lefthand ancestors of the intended
1864
last_revision. If not, set_last_revision_info will fail.
1866
:param destination: The branch to copy the history into
1867
:param revision_id: The revision-id to truncate history at. May
1868
be None to copy complete history.
1870
if revision_id is None:
1871
revno, revision_id = self.last_revision_info()
1873
revno = self.revision_id_to_revno(revision_id)
1874
destination.set_last_revision_info(revno, revision_id)
1877
class BranchTestProviderAdapter(object):
1878
"""A tool to generate a suite testing multiple branch formats at once.
1880
This is done by copying the test once for each transport and injecting
1881
the transport_server, transport_readonly_server, and branch_format
1882
classes into each copy. Each copy is also given a new id() to make it
1886
def __init__(self, transport_server, transport_readonly_server, formats):
1887
self._transport_server = transport_server
1888
self._transport_readonly_server = transport_readonly_server
1889
self._formats = formats
1891
def adapt(self, test):
1892
result = TestSuite()
1893
for branch_format, bzrdir_format in self._formats:
1894
new_test = deepcopy(test)
1895
new_test.transport_server = self._transport_server
1896
new_test.transport_readonly_server = self._transport_readonly_server
1897
new_test.bzrdir_format = bzrdir_format
1898
new_test.branch_format = branch_format
1899
def make_new_test_id():
1900
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1901
return lambda: new_id
1902
new_test.id = make_new_test_id()
1903
result.addTest(new_test)
1907
class BranchCheckResult(object):
1908
"""Results of checking branch consistency.
1913
def __init__(self, branch):
1914
self.branch = branch
1916
def report_results(self, verbose):
1917
"""Report the check results via trace.note.
1919
:param verbose: Requests more detailed display of what was checked,
1922
note('checked branch %s format %s',
1924
self.branch._format)
1927
######################################################################
1931
@deprecated_function(zero_eight)
1932
def is_control_file(*args, **kwargs):
1933
"""See bzrlib.workingtree.is_control_file."""
1934
from bzrlib import workingtree
1935
return workingtree.is_control_file(*args, **kwargs)
1938
class Converter5to6(object):
1939
"""Perform an in-place upgrade of format 5 to format 6"""
1941
def convert(self, branch):
1942
# Data for 5 and 6 can peacefully coexist.
1943
format = BzrBranchFormat6()
1944
new_branch = format.open(branch.bzrdir, _found=True)
1946
# Copy source data into target
1947
new_branch.set_last_revision_info(*branch.last_revision_info())
1948
new_branch.set_parent(branch.get_parent())
1949
new_branch.set_bound_location(branch.get_bound_location())
1950
new_branch.set_push_location(branch.get_push_location())
1952
# Copying done; now update target format
1953
new_branch.control_files.put_utf8('format',
1954
format.get_format_string())
1956
# Clean up old files
1957
new_branch.control_files._transport.delete('revision-history')
1959
branch.set_parent(None)
1962
branch.set_bound_location(None)
added
removed
bzrlib/branch.py
