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
43
from bzrlib.tag import (
49
from bzrlib.decorators import needs_read_lock, needs_write_lock
50
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
51
HistoryMissing, InvalidRevisionId,
52
InvalidRevisionNumber, LockError, NoSuchFile,
53
NoSuchRevision, NoWorkingTree, NotVersionedError,
54
NotBranchError, UninitializableFormat,
55
UnlistableStore, UnlistableBranch,
57
from bzrlib.symbol_versioning import (deprecated_function,
61
zero_eight, zero_nine,
63
from bzrlib.trace import mutter, note
66
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
67
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
68
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
71
# TODO: Maybe include checks for common corruption of newlines, etc?
73
# TODO: Some operations like log might retrieve the same revisions
74
# repeatedly to calculate deltas. We could perhaps have a weakref
75
# cache in memory to make this faster. In general anything can be
76
# cached in memory between lock and unlock operations. .. nb thats
77
# what the transaction identity map provides
80
######################################################################
84
"""Branch holding a history of revisions.
87
Base directory/url of the branch.
89
hooks: An instance of BranchHooks.
91
# this is really an instance variable - FIXME move it there
95
# override this to set the strategy for storing tags
97
return DisabledTags(self)
99
def __init__(self, *ignored, **ignored_too):
100
self.tags = self._make_tags()
102
def break_lock(self):
103
"""Break a lock if one is present from another instance.
105
Uses the ui factory to ask for confirmation if the lock may be from
108
This will probe the repository for its lock as well.
110
self.control_files.break_lock()
111
self.repository.break_lock()
112
master = self.get_master_branch()
113
if master is not None:
117
@deprecated_method(zero_eight)
118
def open_downlevel(base):
119
"""Open a branch which may be of an old format."""
120
return Branch.open(base, _unsupported=True)
123
def open(base, _unsupported=False):
124
"""Open the branch rooted at base.
126
For instance, if the branch is at URL/.bzr/branch,
127
Branch.open(URL) -> a Branch instance.
129
control = bzrdir.BzrDir.open(base, _unsupported)
130
return control.open_branch(_unsupported)
133
def open_containing(url):
134
"""Open an existing branch which contains url.
136
This probes for a branch at url, and searches upwards from there.
138
Basically we keep looking up until we find the control directory or
139
run into the root. If there isn't one, raises NotBranchError.
140
If there is one and it is either an unrecognised format or an unsupported
141
format, UnknownFormatError or UnsupportedFormatError are raised.
142
If there is one, it is returned, along with the unused portion of url.
144
control, relpath = bzrdir.BzrDir.open_containing(url)
145
return control.open_branch(), relpath
148
@deprecated_function(zero_eight)
149
def initialize(base):
150
"""Create a new working tree and branch, rooted at 'base' (url)
152
NOTE: This will soon be deprecated in favour of creation
155
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
157
@deprecated_function(zero_eight)
158
def setup_caching(self, cache_root):
159
"""Subclasses that care about caching should override this, and set
160
up cached stores located under cache_root.
162
NOTE: This is unused.
166
def get_config(self):
167
return BranchConfig(self)
170
return self.get_config().get_nickname()
172
def _set_nick(self, nick):
173
self.get_config().set_user_option('nickname', nick)
175
nick = property(_get_nick, _set_nick)
178
raise NotImplementedError(self.is_locked)
180
def lock_write(self):
181
raise NotImplementedError(self.lock_write)
184
raise NotImplementedError(self.lock_read)
187
raise NotImplementedError(self.unlock)
189
def peek_lock_mode(self):
190
"""Return lock mode for the Branch: 'r', 'w' or None"""
191
raise NotImplementedError(self.peek_lock_mode)
193
def get_physical_lock_status(self):
194
raise NotImplementedError(self.get_physical_lock_status)
196
def abspath(self, name):
197
"""Return absolute filename for something in the branch
199
XXX: Robert Collins 20051017 what is this used for? why is it a branch
200
method and not a tree method.
202
raise NotImplementedError(self.abspath)
204
def bind(self, other):
205
"""Bind the local branch the other branch.
207
:param other: The branch to bind to
210
raise errors.UpgradeRequired(self.base)
213
def fetch(self, from_branch, last_revision=None, pb=None):
214
"""Copy revisions from from_branch into this branch.
216
:param from_branch: Where to copy from.
217
:param last_revision: What revision to stop at (None for at the end
219
:param pb: An optional progress bar to use.
221
Returns the copied revision count and the failed revisions in a tuple:
224
if self.base == from_branch.base:
227
nested_pb = ui.ui_factory.nested_progress_bar()
232
from_branch.lock_read()
234
if last_revision is None:
235
pb.update('get source history')
236
last_revision = from_branch.last_revision()
237
if last_revision is None:
238
last_revision = _mod_revision.NULL_REVISION
239
return self.repository.fetch(from_branch.repository,
240
revision_id=last_revision,
243
if nested_pb is not None:
247
def get_bound_location(self):
248
"""Return the URL of the branch we are bound to.
250
Older format branches cannot bind, please be sure to use a metadir
255
def get_old_bound_location(self):
256
"""Return the URL of the branch we used to be bound to
258
raise errors.UpgradeRequired(self.base)
260
def get_commit_builder(self, parents, config=None, timestamp=None,
261
timezone=None, committer=None, revprops=None,
263
"""Obtain a CommitBuilder for this branch.
265
:param parents: Revision ids of the parents of the new revision.
266
:param config: Optional configuration to use.
267
:param timestamp: Optional timestamp recorded for commit.
268
:param timezone: Optional timezone for timestamp.
269
:param committer: Optional committer to set for commit.
270
:param revprops: Optional dictionary of revision properties.
271
:param revision_id: Optional revision id.
275
config = self.get_config()
277
return self.repository.get_commit_builder(self, parents, config,
278
timestamp, timezone, committer, revprops, revision_id)
280
def get_master_branch(self):
281
"""Return the branch we are bound to.
283
:return: Either a Branch, or None
287
def get_revision_delta(self, revno):
288
"""Return the delta for one revision.
290
The delta is relative to its mainline predecessor, or the
291
empty tree for revision 1.
293
assert isinstance(revno, int)
294
rh = self.revision_history()
295
if not (1 <= revno <= len(rh)):
296
raise InvalidRevisionNumber(revno)
297
return self.repository.get_revision_delta(rh[revno-1])
299
def get_root_id(self):
300
"""Return the id of this branches root"""
301
raise NotImplementedError(self.get_root_id)
303
def print_file(self, file, revision_id):
304
"""Print `file` to stdout."""
305
raise NotImplementedError(self.print_file)
307
def append_revision(self, *revision_ids):
308
raise NotImplementedError(self.append_revision)
310
def set_revision_history(self, rev_history):
311
raise NotImplementedError(self.set_revision_history)
313
def revision_history(self):
314
"""Return sequence of revision hashes on to this branch."""
315
raise NotImplementedError(self.revision_history)
318
"""Return current revision number for this branch.
320
That is equivalent to the number of revisions committed to
323
return len(self.revision_history())
326
"""Older format branches cannot bind or unbind."""
327
raise errors.UpgradeRequired(self.base)
329
def set_append_revisions_only(self, enabled):
330
"""Older format branches are never restricted to append-only"""
331
raise errors.UpgradeRequired(self.base)
333
def last_revision(self):
334
"""Return last revision id, or None"""
335
ph = self.revision_history()
341
def last_revision_info(self):
342
"""Return information about the last revision.
344
:return: A tuple (revno, last_revision_id).
346
rh = self.revision_history()
349
return (revno, rh[-1])
351
return (0, _mod_revision.NULL_REVISION)
353
def missing_revisions(self, other, stop_revision=None):
354
"""Return a list of new revisions that would perfectly fit.
356
If self and other have not diverged, return a list of the revisions
357
present in other, but missing from self.
359
self_history = self.revision_history()
360
self_len = len(self_history)
361
other_history = other.revision_history()
362
other_len = len(other_history)
363
common_index = min(self_len, other_len) -1
364
if common_index >= 0 and \
365
self_history[common_index] != other_history[common_index]:
366
raise DivergedBranches(self, other)
368
if stop_revision is None:
369
stop_revision = other_len
371
assert isinstance(stop_revision, int)
372
if stop_revision > other_len:
373
raise errors.NoSuchRevision(self, stop_revision)
374
return other_history[self_len:stop_revision]
376
def update_revisions(self, other, stop_revision=None):
377
"""Pull in new perfect-fit revisions.
379
:param other: Another Branch to pull from
380
:param stop_revision: Updated until the given revision
383
raise NotImplementedError(self.update_revisions)
385
def revision_id_to_revno(self, revision_id):
386
"""Given a revision id, return its revno"""
387
if revision_id is None:
389
revision_id = osutils.safe_revision_id(revision_id)
390
history = self.revision_history()
392
return history.index(revision_id) + 1
394
raise bzrlib.errors.NoSuchRevision(self, revision_id)
396
def get_rev_id(self, revno, history=None):
397
"""Find the revision id of the specified revno."""
401
history = self.revision_history()
402
if revno <= 0 or revno > len(history):
403
raise bzrlib.errors.NoSuchRevision(self, revno)
404
return history[revno - 1]
406
def pull(self, source, overwrite=False, stop_revision=None):
407
"""Mirror source into this branch.
409
This branch is considered to be 'local', having low latency.
411
:returns: PullResult instance
413
raise NotImplementedError(self.pull)
415
def push(self, target, overwrite=False, stop_revision=None):
416
"""Mirror this branch into target.
418
This branch is considered to be 'local', having low latency.
420
raise NotImplementedError(self.push)
422
def basis_tree(self):
423
"""Return `Tree` object for last revision."""
424
return self.repository.revision_tree(self.last_revision())
426
def rename_one(self, from_rel, to_rel):
429
This can change the directory or the filename or both.
431
raise NotImplementedError(self.rename_one)
433
def move(self, from_paths, to_name):
436
to_name must exist as a versioned directory.
438
If to_name exists and is a directory, the files are moved into
439
it, keeping their old names. If it is a directory,
441
Note that to_name is only the last component of the new name;
442
this doesn't change the directory.
444
This returns a list of (from_path, to_path) pairs for each
447
raise NotImplementedError(self.move)
449
def get_parent(self):
450
"""Return the parent location of the branch.
452
This is the default location for push/pull/missing. The usual
453
pattern is that the user can override it by specifying a
456
raise NotImplementedError(self.get_parent)
458
def get_submit_branch(self):
459
"""Return the submit location of the branch.
461
This is the default location for bundle. The usual
462
pattern is that the user can override it by specifying a
465
return self.get_config().get_user_option('submit_branch')
467
def set_submit_branch(self, location):
468
"""Return the submit location of the branch.
470
This is the default location for bundle. The usual
471
pattern is that the user can override it by specifying a
474
self.get_config().set_user_option('submit_branch', location)
476
def get_push_location(self):
477
"""Return the None or the location to push this branch to."""
478
raise NotImplementedError(self.get_push_location)
480
def set_push_location(self, location):
481
"""Set a new push location for this branch."""
482
raise NotImplementedError(self.set_push_location)
484
def set_parent(self, url):
485
raise NotImplementedError(self.set_parent)
489
"""Synchronise this branch with the master branch if any.
491
:return: None or the last_revision pivoted out during the update.
495
def check_revno(self, revno):
497
Check whether a revno corresponds to any revision.
498
Zero (the NULL revision) is considered valid.
501
self.check_real_revno(revno)
503
def check_real_revno(self, revno):
505
Check whether a revno corresponds to a real revision.
506
Zero (the NULL revision) is considered invalid
508
if revno < 1 or revno > self.revno():
509
raise InvalidRevisionNumber(revno)
512
def clone(self, *args, **kwargs):
513
"""Clone this branch into to_bzrdir preserving all semantic values.
515
revision_id: if not None, the revision history in the new branch will
516
be truncated to end with revision_id.
518
# for API compatibility, until 0.8 releases we provide the old api:
519
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
520
# after 0.8 releases, the *args and **kwargs should be changed:
521
# def clone(self, to_bzrdir, revision_id=None):
522
if (kwargs.get('to_location', None) or
523
kwargs.get('revision', None) or
524
kwargs.get('basis_branch', None) or
525
(len(args) and isinstance(args[0], basestring))):
526
# backwards compatibility api:
527
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
528
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
531
basis_branch = args[2]
533
basis_branch = kwargs.get('basis_branch', None)
535
basis = basis_branch.bzrdir
540
revision_id = args[1]
542
revision_id = kwargs.get('revision', None)
547
# no default to raise if not provided.
548
url = kwargs.get('to_location')
549
return self.bzrdir.clone(url,
550
revision_id=revision_id,
551
basis=basis).open_branch()
553
# generate args by hand
555
revision_id = args[1]
557
revision_id = kwargs.get('revision_id', None)
561
# no default to raise if not provided.
562
to_bzrdir = kwargs.get('to_bzrdir')
563
result = self._format.initialize(to_bzrdir)
564
self.copy_content_into(result, revision_id=revision_id)
568
def sprout(self, to_bzrdir, revision_id=None):
569
"""Create a new line of development from the branch, into to_bzrdir.
571
revision_id: if not None, the revision history in the new branch will
572
be truncated to end with revision_id.
574
result = self._format.initialize(to_bzrdir)
575
self.copy_content_into(result, revision_id=revision_id)
576
result.set_parent(self.bzrdir.root_transport.base)
579
def _synchronize_history(self, destination, revision_id):
580
"""Synchronize last revision and revision history between branches.
582
This version is most efficient when the destination is also a
583
BzrBranch5, but works for BzrBranch6 as long as the revision
584
history is the true lefthand parent history, and all of the revisions
585
are in the destination's repository. If not, set_revision_history
588
:param destination: The branch to copy the history into
589
:param revision_id: The revision-id to truncate history at. May
590
be None to copy complete history.
592
new_history = self.revision_history()
593
if revision_id is not None:
594
revision_id = osutils.safe_revision_id(revision_id)
596
new_history = new_history[:new_history.index(revision_id) + 1]
598
rev = self.repository.get_revision(revision_id)
599
new_history = rev.get_history(self.repository)[1:]
600
destination.set_revision_history(new_history)
603
def copy_content_into(self, destination, revision_id=None):
604
"""Copy the content of self into destination.
606
revision_id: if not None, the revision history in the new branch will
607
be truncated to end with revision_id.
609
self._synchronize_history(destination, revision_id)
611
parent = self.get_parent()
612
except errors.InaccessibleParent, e:
613
mutter('parent was not accessible to copy: %s', e)
616
destination.set_parent(parent)
620
"""Check consistency of the branch.
622
In particular this checks that revisions given in the revision-history
623
do actually match up in the revision graph, and that they're all
624
present in the repository.
626
Callers will typically also want to check the repository.
628
:return: A BranchCheckResult.
630
mainline_parent_id = None
631
for revision_id in self.revision_history():
633
revision = self.repository.get_revision(revision_id)
634
except errors.NoSuchRevision, e:
635
raise errors.BzrCheckError("mainline revision {%s} not in repository"
637
# In general the first entry on the revision history has no parents.
638
# But it's not illegal for it to have parents listed; this can happen
639
# in imports from Arch when the parents weren't reachable.
640
if mainline_parent_id is not None:
641
if mainline_parent_id not in revision.parent_ids:
642
raise errors.BzrCheckError("previous revision {%s} not listed among "
644
% (mainline_parent_id, revision_id))
645
mainline_parent_id = revision_id
646
return BranchCheckResult(self)
648
def _get_checkout_format(self):
649
"""Return the most suitable metadir for a checkout of this branch.
650
Weaves are used if this branch's repostory uses weaves.
652
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
653
from bzrlib.repofmt import weaverepo
654
format = bzrdir.BzrDirMetaFormat1()
655
format.repository_format = weaverepo.RepositoryFormat7()
657
format = self.repository.bzrdir.checkout_metadir()
658
format.branch_format = self._format
661
def create_checkout(self, to_location, revision_id=None,
663
"""Create a checkout of a branch.
665
:param to_location: The url to produce the checkout at
666
:param revision_id: The revision to check out
667
:param lightweight: If True, produce a lightweight checkout, otherwise,
668
produce a bound branch (heavyweight checkout)
669
:return: The tree of the created checkout
671
t = transport.get_transport(to_location)
674
except errors.FileExists:
677
format = self._get_checkout_format()
678
checkout = format.initialize_on_transport(t)
679
BranchReferenceFormat().initialize(checkout, self)
681
format = self._get_checkout_format()
682
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
683
to_location, force_new_tree=False, format=format)
684
checkout = checkout_branch.bzrdir
685
checkout_branch.bind(self)
686
# pull up to the specified revision_id to set the initial
687
# branch tip correctly, and seed it with history.
688
checkout_branch.pull(self, stop_revision=revision_id)
689
tree = checkout.create_workingtree(revision_id)
690
for path, entry in tree.iter_reference_entries():
691
path = tree.id2path(entry.file_id)
692
reference_parent = self.reference_parent(entry.file_id, path)
693
reference_parent.create_checkout(tree.abspath(path),
694
entry.reference_revision,
698
def reference_parent(self, file_id, path):
699
"""Return the parent branch for a tree-reference file_id
700
:param file_id: The file_id of the tree reference
701
:param path: The path of the file_id in the tree
702
:return: A branch associated with the file_id
704
# FIXME should provide multiple branches, based on config
705
return Branch.open(self.bzrdir.root_transport.clone(path).base)
707
def supports_tags(self):
708
return self._format.supports_tags()
711
class BranchFormat(object):
712
"""An encapsulation of the initialization and open routines for a format.
714
Formats provide three things:
715
* An initialization routine,
719
Formats are placed in an dict by their format string for reference
720
during branch opening. Its not required that these be instances, they
721
can be classes themselves with class methods - it simply depends on
722
whether state is needed for a given format or not.
724
Once a format is deprecated, just deprecate the initialize and open
725
methods on the format class. Do not deprecate the object, as the
726
object will be created every time regardless.
729
_default_format = None
730
"""The default format used for new branches."""
733
"""The known formats."""
736
def find_format(klass, a_bzrdir):
737
"""Return the format for the branch object in a_bzrdir."""
739
transport = a_bzrdir.get_branch_transport(None)
740
format_string = transport.get("format").read()
741
return klass._formats[format_string]
743
raise NotBranchError(path=transport.base)
745
raise errors.UnknownFormatError(format=format_string)
748
def get_default_format(klass):
749
"""Return the current default format."""
750
return klass._default_format
752
def get_format_string(self):
753
"""Return the ASCII format string that identifies this format."""
754
raise NotImplementedError(self.get_format_string)
756
def get_format_description(self):
757
"""Return the short format description for this format."""
758
raise NotImplementedError(self.get_format_description)
760
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
762
"""Initialize a branch in a bzrdir, with specified files
764
:param a_bzrdir: The bzrdir to initialize the branch in
765
:param utf8_files: The files to create as a list of
766
(filename, content) tuples
767
:param set_format: If True, set the format with
768
self.get_format_string. (BzrBranch4 has its format set
770
:return: a branch in this format
772
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
773
branch_transport = a_bzrdir.get_branch_transport(self)
775
'metadir': ('lock', lockdir.LockDir),
776
'branch4': ('branch-lock', lockable_files.TransportLock),
778
lock_name, lock_class = lock_map[lock_type]
779
control_files = lockable_files.LockableFiles(branch_transport,
780
lock_name, lock_class)
781
control_files.create_lock()
782
control_files.lock_write()
784
control_files.put_utf8('format', self.get_format_string())
786
for file, content in utf8_files:
787
control_files.put_utf8(file, content)
789
control_files.unlock()
790
return self.open(a_bzrdir, _found=True)
792
def initialize(self, a_bzrdir):
793
"""Create a branch of this format in a_bzrdir."""
794
raise NotImplementedError(self.initialize)
796
def is_supported(self):
797
"""Is this format supported?
799
Supported formats can be initialized and opened.
800
Unsupported formats may not support initialization or committing or
801
some other features depending on the reason for not being supported.
805
def open(self, a_bzrdir, _found=False):
806
"""Return the branch object for a_bzrdir
808
_found is a private parameter, do not use it. It is used to indicate
809
if format probing has already be done.
811
raise NotImplementedError(self.open)
814
def register_format(klass, format):
815
klass._formats[format.get_format_string()] = format
818
def set_default_format(klass, format):
819
klass._default_format = format
822
def unregister_format(klass, format):
823
assert klass._formats[format.get_format_string()] is format
824
del klass._formats[format.get_format_string()]
827
return self.get_format_string().rstrip()
829
def supports_tags(self):
830
"""True if this format supports tags stored in the branch"""
831
return False # by default
833
# XXX: Probably doesn't really belong here -- mbp 20070212
834
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
836
branch_transport = a_bzrdir.get_branch_transport(self)
837
control_files = lockable_files.LockableFiles(branch_transport,
838
lock_filename, lock_class)
839
control_files.create_lock()
840
control_files.lock_write()
842
for filename, content in utf8_files:
843
control_files.put_utf8(filename, content)
845
control_files.unlock()
848
class BranchHooks(dict):
849
"""A dictionary mapping hook name to a list of callables for branch hooks.
851
e.g. ['set_rh'] Is the list of items to be called when the
852
set_revision_history function is invoked.
856
"""Create the default hooks.
858
These are all empty initially, because by default nothing should get
862
# Introduced in 0.15:
863
# invoked whenever the revision history has been set
864
# with set_revision_history. The api signature is
865
# (branch, revision_history), and the branch will
868
# invoked after a push operation completes.
869
# the api signature is
871
# containing the members
872
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
873
# where local is the local branch or None, master is the target
874
# master branch, and the rest should be self explanatory. The source
875
# is read locked and the target branches write locked. Source will
876
# be the local low-latency branch.
877
self['post_push'] = []
878
# invoked after a pull operation completes.
879
# the api signature is
881
# containing the members
882
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
883
# where local is the local branch or None, master is the target
884
# master branch, and the rest should be self explanatory. The source
885
# is read locked and the target branches write locked. The local
886
# branch is the low-latency branch.
887
self['post_pull'] = []
888
# invoked after a commit operation completes.
889
# the api signature is
890
# (local, master, old_revno, old_revid, new_revno, new_revid)
891
# old_revid is NULL_REVISION for the first commit to a branch.
892
self['post_commit'] = []
893
# invoked after a uncommit operation completes.
894
# the api signature is
895
# (local, master, old_revno, old_revid, new_revno, new_revid) where
896
# local is the local branch or None, master is the target branch,
897
# and an empty branch recieves new_revno of 0, new_revid of None.
898
self['post_uncommit'] = []
900
def install_hook(self, hook_name, a_callable):
901
"""Install a_callable in to the hook hook_name.
903
:param hook_name: A hook name. See the __init__ method of BranchHooks
904
for the complete list of hooks.
905
:param a_callable: The callable to be invoked when the hook triggers.
906
The exact signature will depend on the hook - see the __init__
907
method of BranchHooks for details on each hook.
910
self[hook_name].append(a_callable)
912
raise errors.UnknownHook('branch', hook_name)
915
# install the default hooks into the Branch class.
916
Branch.hooks = BranchHooks()
919
class BzrBranchFormat4(BranchFormat):
920
"""Bzr branch format 4.
923
- a revision-history file.
924
- a branch-lock lock file [ to be shared with the bzrdir ]
927
def get_format_description(self):
928
"""See BranchFormat.get_format_description()."""
929
return "Branch format 4"
931
def initialize(self, a_bzrdir):
932
"""Create a branch of this format in a_bzrdir."""
933
utf8_files = [('revision-history', ''),
936
return self._initialize_helper(a_bzrdir, utf8_files,
937
lock_type='branch4', set_format=False)
940
super(BzrBranchFormat4, self).__init__()
941
self._matchingbzrdir = bzrdir.BzrDirFormat6()
943
def open(self, a_bzrdir, _found=False):
944
"""Return the branch object for a_bzrdir
946
_found is a private parameter, do not use it. It is used to indicate
947
if format probing has already be done.
950
# we are being called directly and must probe.
951
raise NotImplementedError
952
return BzrBranch(_format=self,
953
_control_files=a_bzrdir._control_files,
955
_repository=a_bzrdir.open_repository())
958
return "Bazaar-NG branch format 4"
961
class BzrBranchFormat5(BranchFormat):
962
"""Bzr branch format 5.
965
- a revision-history file.
967
- a lock dir guarding the branch itself
968
- all of this stored in a branch/ subdirectory
969
- works with shared repositories.
971
This format is new in bzr 0.8.
974
def get_format_string(self):
975
"""See BranchFormat.get_format_string()."""
976
return "Bazaar-NG branch format 5\n"
978
def get_format_description(self):
979
"""See BranchFormat.get_format_description()."""
980
return "Branch format 5"
982
def initialize(self, a_bzrdir):
983
"""Create a branch of this format in a_bzrdir."""
984
utf8_files = [('revision-history', ''),
987
return self._initialize_helper(a_bzrdir, utf8_files)
990
super(BzrBranchFormat5, self).__init__()
991
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
993
def open(self, a_bzrdir, _found=False):
994
"""Return the branch object for a_bzrdir
996
_found is a private parameter, do not use it. It is used to indicate
997
if format probing has already be done.
1000
format = BranchFormat.find_format(a_bzrdir)
1001
assert format.__class__ == self.__class__
1002
transport = a_bzrdir.get_branch_transport(None)
1003
control_files = lockable_files.LockableFiles(transport, 'lock',
1005
return BzrBranch5(_format=self,
1006
_control_files=control_files,
1008
_repository=a_bzrdir.find_repository())
1011
class BzrBranchFormat6(BzrBranchFormat5):
1012
"""Branch format with last-revision
1014
Unlike previous formats, this has no explicit revision history. Instead,
1015
this just stores the last-revision, and the left-hand history leading
1016
up to there is the history.
1018
This format was introduced in bzr 0.15
1021
def get_format_string(self):
1022
"""See BranchFormat.get_format_string()."""
1023
return "Bazaar-NG branch format 6\n"
1025
def get_format_description(self):
1026
"""See BranchFormat.get_format_description()."""
1027
return "Branch format 6"
1029
def initialize(self, a_bzrdir):
1030
"""Create a branch of this format in a_bzrdir."""
1031
utf8_files = [('last-revision', '0 null:\n'),
1032
('branch-name', ''),
1033
('branch.conf', ''),
1036
return self._initialize_helper(a_bzrdir, utf8_files)
1038
def open(self, a_bzrdir, _found=False):
1039
"""Return the branch object for a_bzrdir
1041
_found is a private parameter, do not use it. It is used to indicate
1042
if format probing has already be done.
1045
format = BranchFormat.find_format(a_bzrdir)
1046
assert format.__class__ == self.__class__
1047
transport = a_bzrdir.get_branch_transport(None)
1048
control_files = lockable_files.LockableFiles(transport, 'lock',
1050
return BzrBranch6(_format=self,
1051
_control_files=control_files,
1053
_repository=a_bzrdir.find_repository())
1055
def supports_tags(self):
1059
class BranchReferenceFormat(BranchFormat):
1060
"""Bzr branch reference format.
1062
Branch references are used in implementing checkouts, they
1063
act as an alias to the real branch which is at some other url.
1070
def get_format_string(self):
1071
"""See BranchFormat.get_format_string()."""
1072
return "Bazaar-NG Branch Reference Format 1\n"
1074
def get_format_description(self):
1075
"""See BranchFormat.get_format_description()."""
1076
return "Checkout reference format 1"
1078
def initialize(self, a_bzrdir, target_branch=None):
1079
"""Create a branch of this format in a_bzrdir."""
1080
if target_branch is None:
1081
# this format does not implement branch itself, thus the implicit
1082
# creation contract must see it as uninitializable
1083
raise errors.UninitializableFormat(self)
1084
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1085
branch_transport = a_bzrdir.get_branch_transport(self)
1086
branch_transport.put_bytes('location',
1087
target_branch.bzrdir.root_transport.base)
1088
branch_transport.put_bytes('format', self.get_format_string())
1089
return self.open(a_bzrdir, _found=True)
1092
super(BranchReferenceFormat, self).__init__()
1093
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1095
def _make_reference_clone_function(format, a_branch):
1096
"""Create a clone() routine for a branch dynamically."""
1097
def clone(to_bzrdir, revision_id=None):
1098
"""See Branch.clone()."""
1099
return format.initialize(to_bzrdir, a_branch)
1100
# cannot obey revision_id limits when cloning a reference ...
1101
# FIXME RBC 20060210 either nuke revision_id for clone, or
1102
# emit some sort of warning/error to the caller ?!
1105
def open(self, a_bzrdir, _found=False):
1106
"""Return the branch that the branch reference in a_bzrdir points at.
1108
_found is a private parameter, do not use it. It is used to indicate
1109
if format probing has already be done.
1112
format = BranchFormat.find_format(a_bzrdir)
1113
assert format.__class__ == self.__class__
1114
transport = a_bzrdir.get_branch_transport(None)
1115
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1116
result = real_bzrdir.open_branch()
1117
# this changes the behaviour of result.clone to create a new reference
1118
# rather than a copy of the content of the branch.
1119
# I did not use a proxy object because that needs much more extensive
1120
# testing, and we are only changing one behaviour at the moment.
1121
# If we decide to alter more behaviours - i.e. the implicit nickname
1122
# then this should be refactored to introduce a tested proxy branch
1123
# and a subclass of that for use in overriding clone() and ....
1125
result.clone = self._make_reference_clone_function(result)
1129
# formats which have no format string are not discoverable
1130
# and not independently creatable, so are not registered.
1131
__default_format = BzrBranchFormat5()
1132
BranchFormat.register_format(__default_format)
1133
BranchFormat.register_format(BranchReferenceFormat())
1134
BranchFormat.register_format(BzrBranchFormat6())
1135
BranchFormat.set_default_format(__default_format)
1136
_legacy_formats = [BzrBranchFormat4(),
1139
class BzrBranch(Branch):
1140
"""A branch stored in the actual filesystem.
1142
Note that it's "local" in the context of the filesystem; it doesn't
1143
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1144
it's writable, and can be accessed via the normal filesystem API.
1147
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
1148
relax_version_check=DEPRECATED_PARAMETER, _format=None,
1149
_control_files=None, a_bzrdir=None, _repository=None):
1150
"""Create new branch object at a particular location.
1152
transport -- A Transport object, defining how to access files.
1154
init -- If True, create new control files in a previously
1155
unversioned directory. If False, the branch must already
1158
relax_version_check -- If true, the usual check for the branch
1159
version is not applied. This is intended only for
1160
upgrade/recovery type use; it's not guaranteed that
1161
all operations will work on old format branches.
1163
Branch.__init__(self)
1164
if a_bzrdir is None:
1165
self.bzrdir = bzrdir.BzrDir.open(transport.base)
1167
self.bzrdir = a_bzrdir
1168
# self._transport used to point to the directory containing the
1169
# control directory, but was not used - now it's just the transport
1170
# for the branch control files. mbp 20070212
1171
self._base = self.bzrdir.transport.clone('..').base
1172
self._format = _format
1173
if _control_files is None:
1174
raise ValueError('BzrBranch _control_files is None')
1175
self.control_files = _control_files
1176
self._transport = _control_files._transport
1177
if deprecated_passed(init):
1178
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
1179
"deprecated as of bzr 0.8. Please use Branch.create().",
1183
# this is slower than before deprecation, oh well never mind.
1184
# -> its deprecated.
1185
self._initialize(transport.base)
1186
self._check_format(_format)
1187
if deprecated_passed(relax_version_check):
1188
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1189
"relax_version_check parameter is deprecated as of bzr 0.8. "
1190
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1194
if (not relax_version_check
1195
and not self._format.is_supported()):
1196
raise errors.UnsupportedFormatError(format=fmt)
1197
if deprecated_passed(transport):
1198
warn("BzrBranch.__init__(transport=XXX...): The transport "
1199
"parameter is deprecated as of bzr 0.8. "
1200
"Please use Branch.open, or bzrdir.open_branch().",
1203
self.repository = _repository
1206
return '%s(%r)' % (self.__class__.__name__, self.base)
1210
def _get_base(self):
1211
"""Returns the directory containing the control directory."""
1214
base = property(_get_base, doc="The URL for the root of this branch.")
1216
def _finish_transaction(self):
1217
"""Exit the current transaction."""
1218
return self.control_files._finish_transaction()
1220
def get_transaction(self):
1221
"""Return the current active transaction.
1223
If no transaction is active, this returns a passthrough object
1224
for which all data is immediately flushed and no caching happens.
1226
# this is an explicit function so that we can do tricky stuff
1227
# when the storage in rev_storage is elsewhere.
1228
# we probably need to hook the two 'lock a location' and
1229
# 'have a transaction' together more delicately, so that
1230
# we can have two locks (branch and storage) and one transaction
1231
# ... and finishing the transaction unlocks both, but unlocking
1232
# does not. - RBC 20051121
1233
return self.control_files.get_transaction()
1235
def _set_transaction(self, transaction):
1236
"""Set a new active transaction."""
1237
return self.control_files._set_transaction(transaction)
1239
def abspath(self, name):
1240
"""See Branch.abspath."""
1241
return self.control_files._transport.abspath(name)
1243
def _check_format(self, format):
1244
"""Identify the branch format if needed.
1246
The format is stored as a reference to the format object in
1247
self._format for code that needs to check it later.
1249
The format parameter is either None or the branch format class
1250
used to open this branch.
1252
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1255
format = BranchFormat.find_format(self.bzrdir)
1256
self._format = format
1257
mutter("got branch format %s", self._format)
1260
def get_root_id(self):
1261
"""See Branch.get_root_id."""
1262
tree = self.repository.revision_tree(self.last_revision())
1263
return tree.inventory.root.file_id
1265
def is_locked(self):
1266
return self.control_files.is_locked()
1268
def lock_write(self):
1269
self.repository.lock_write()
1271
self.control_files.lock_write()
1273
self.repository.unlock()
1276
def lock_read(self):
1277
self.repository.lock_read()
1279
self.control_files.lock_read()
1281
self.repository.unlock()
1285
# TODO: test for failed two phase locks. This is known broken.
1287
self.control_files.unlock()
1289
self.repository.unlock()
1291
def peek_lock_mode(self):
1292
if self.control_files._lock_count == 0:
1295
return self.control_files._lock_mode
1297
def get_physical_lock_status(self):
1298
return self.control_files.get_physical_lock_status()
1301
def print_file(self, file, revision_id):
1302
"""See Branch.print_file."""
1303
return self.repository.print_file(file, revision_id)
1306
def append_revision(self, *revision_ids):
1307
"""See Branch.append_revision."""
1308
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1309
for revision_id in revision_ids:
1310
_mod_revision.check_not_reserved_id(revision_id)
1311
mutter("add {%s} to revision-history" % revision_id)
1312
rev_history = self.revision_history()
1313
rev_history.extend(revision_ids)
1314
self.set_revision_history(rev_history)
1316
def _write_revision_history(self, history):
1317
"""Factored out of set_revision_history.
1319
This performs the actual writing to disk.
1320
It is intended to be called by BzrBranch5.set_revision_history."""
1321
self.control_files.put_bytes(
1322
'revision-history', '\n'.join(history))
1325
def set_revision_history(self, rev_history):
1326
"""See Branch.set_revision_history."""
1327
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1328
self._write_revision_history(rev_history)
1329
transaction = self.get_transaction()
1330
history = transaction.map.find_revision_history()
1331
if history is not None:
1332
# update the revision history in the identity map.
1333
history[:] = list(rev_history)
1334
# this call is disabled because revision_history is
1335
# not really an object yet, and the transaction is for objects.
1336
# transaction.register_dirty(history)
1338
transaction.map.add_revision_history(rev_history)
1339
# this call is disabled because revision_history is
1340
# not really an object yet, and the transaction is for objects.
1341
# transaction.register_clean(history)
1342
for hook in Branch.hooks['set_rh']:
1343
hook(self, rev_history)
1346
def set_last_revision_info(self, revno, revision_id):
1347
revision_id = osutils.safe_revision_id(revision_id)
1348
history = self._lefthand_history(revision_id)
1349
assert len(history) == revno, '%d != %d' % (len(history), revno)
1350
self.set_revision_history(history)
1352
def _gen_revision_history(self):
1353
history = [l.rstrip('\r\n') for l in
1354
self.control_files.get('revision-history').readlines()]
1358
def revision_history(self):
1359
"""See Branch.revision_history."""
1360
transaction = self.get_transaction()
1361
history = transaction.map.find_revision_history()
1362
if history is not None:
1363
# mutter("cache hit for revision-history in %s", self)
1364
return list(history)
1365
history = self._gen_revision_history()
1366
transaction.map.add_revision_history(history)
1367
# this call is disabled because revision_history is
1368
# not really an object yet, and the transaction is for objects.
1369
# transaction.register_clean(history, precious=True)
1370
return list(history)
1372
def _lefthand_history(self, revision_id, last_rev=None,
1374
# stop_revision must be a descendant of last_revision
1375
stop_graph = self.repository.get_revision_graph(revision_id)
1376
if last_rev is not None and last_rev not in stop_graph:
1377
# our previous tip is not merged into stop_revision
1378
raise errors.DivergedBranches(self, other_branch)
1379
# make a new revision history from the graph
1380
current_rev_id = revision_id
1382
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1383
new_history.append(current_rev_id)
1384
current_rev_id_parents = stop_graph[current_rev_id]
1386
current_rev_id = current_rev_id_parents[0]
1388
current_rev_id = None
1389
new_history.reverse()
1393
def generate_revision_history(self, revision_id, last_rev=None,
1395
"""Create a new revision history that will finish with revision_id.
1397
:param revision_id: the new tip to use.
1398
:param last_rev: The previous last_revision. If not None, then this
1399
must be a ancestory of revision_id, or DivergedBranches is raised.
1400
:param other_branch: The other branch that DivergedBranches should
1401
raise with respect to.
1403
revision_id = osutils.safe_revision_id(revision_id)
1404
self.set_revision_history(self._lefthand_history(revision_id,
1405
last_rev, other_branch))
1408
def update_revisions(self, other, stop_revision=None):
1409
"""See Branch.update_revisions."""
1412
if stop_revision is None:
1413
stop_revision = other.last_revision()
1414
if stop_revision is None:
1415
# if there are no commits, we're done.
1418
stop_revision = osutils.safe_revision_id(stop_revision)
1419
# whats the current last revision, before we fetch [and change it
1421
last_rev = self.last_revision()
1422
# we fetch here regardless of whether we need to so that we pickup
1424
self.fetch(other, stop_revision)
1425
my_ancestry = self.repository.get_ancestry(last_rev)
1426
if stop_revision in my_ancestry:
1427
# last_revision is a descendant of stop_revision
1429
self.generate_revision_history(stop_revision, last_rev=last_rev,
1434
def basis_tree(self):
1435
"""See Branch.basis_tree."""
1436
return self.repository.revision_tree(self.last_revision())
1438
@deprecated_method(zero_eight)
1439
def working_tree(self):
1440
"""Create a Working tree object for this branch."""
1442
from bzrlib.transport.local import LocalTransport
1443
if (self.base.find('://') != -1 or
1444
not isinstance(self._transport, LocalTransport)):
1445
raise NoWorkingTree(self.base)
1446
return self.bzrdir.open_workingtree()
1449
def pull(self, source, overwrite=False, stop_revision=None,
1450
_hook_master=None, _run_hooks=True):
1453
:param _hook_master: Private parameter - set the branch to
1454
be supplied as the master to push hooks.
1455
:param _run_hooks: Private parameter - allow disabling of
1456
hooks, used when pushing to a master branch.
1458
result = PullResult()
1459
result.source_branch = source
1460
result.target_branch = self
1463
result.old_revno, result.old_revid = self.last_revision_info()
1465
self.update_revisions(source, stop_revision)
1466
except DivergedBranches:
1470
if stop_revision is None:
1471
stop_revision = source.last_revision()
1472
self.generate_revision_history(stop_revision)
1473
result.tag_conflicts = source.tags.merge_to(self.tags)
1474
result.new_revno, result.new_revid = self.last_revision_info()
1476
result.master_branch = _hook_master
1477
result.local_branch = self
1479
result.master_branch = self
1480
result.local_branch = None
1482
for hook in Branch.hooks['post_pull']:
1488
def _get_parent_location(self):
1489
_locs = ['parent', 'pull', 'x-pull']
1492
return self.control_files.get(l).read().strip('\n')
1498
def push(self, target, overwrite=False, stop_revision=None,
1499
_hook_master=None, _run_hooks=True):
1502
:param _hook_master: Private parameter - set the branch to
1503
be supplied as the master to push hooks.
1504
:param _run_hooks: Private parameter - allow disabling of
1505
hooks, used when pushing to a master branch.
1507
result = PushResult()
1508
result.source_branch = self
1509
result.target_branch = target
1512
result.old_revno, result.old_revid = target.last_revision_info()
1514
target.update_revisions(self, stop_revision)
1515
except DivergedBranches:
1519
target.set_revision_history(self.revision_history())
1520
result.tag_conflicts = self.tags.merge_to(target.tags)
1521
result.new_revno, result.new_revid = target.last_revision_info()
1523
result.master_branch = _hook_master
1524
result.local_branch = target
1526
result.master_branch = target
1527
result.local_branch = None
1529
for hook in Branch.hooks['post_push']:
1535
def get_parent(self):
1536
"""See Branch.get_parent."""
1538
assert self.base[-1] == '/'
1539
parent = self._get_parent_location()
1542
# This is an old-format absolute path to a local branch
1543
# turn it into a url
1544
if parent.startswith('/'):
1545
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1547
return urlutils.join(self.base[:-1], parent)
1548
except errors.InvalidURLJoin, e:
1549
raise errors.InaccessibleParent(parent, self.base)
1551
def get_push_location(self):
1552
"""See Branch.get_push_location."""
1553
push_loc = self.get_config().get_user_option('push_location')
1556
def set_push_location(self, location):
1557
"""See Branch.set_push_location."""
1558
self.get_config().set_user_option(
1559
'push_location', location,
1560
store=_mod_config.STORE_LOCATION_NORECURSE)
1563
def set_parent(self, url):
1564
"""See Branch.set_parent."""
1565
# TODO: Maybe delete old location files?
1566
# URLs should never be unicode, even on the local fs,
1567
# FIXUP this and get_parent in a future branch format bump:
1568
# read and rewrite the file, and have the new format code read
1569
# using .get not .get_utf8. RBC 20060125
1571
if isinstance(url, unicode):
1573
url = url.encode('ascii')
1574
except UnicodeEncodeError:
1575
raise bzrlib.errors.InvalidURL(url,
1576
"Urls must be 7-bit ascii, "
1577
"use bzrlib.urlutils.escape")
1578
url = urlutils.relative_url(self.base, url)
1579
self._set_parent_location(url)
1581
def _set_parent_location(self, url):
1583
self.control_files._transport.delete('parent')
1585
assert isinstance(url, str)
1586
self.control_files.put_bytes('parent', url + '\n')
1588
@deprecated_function(zero_nine)
1589
def tree_config(self):
1590
"""DEPRECATED; call get_config instead.
1591
TreeConfig has become part of BranchConfig."""
1592
return TreeConfig(self)
1595
class BzrBranch5(BzrBranch):
1596
"""A format 5 branch. This supports new features over plan branches.
1598
It has support for a master_branch which is the data for bound branches.
1606
super(BzrBranch5, self).__init__(_format=_format,
1607
_control_files=_control_files,
1609
_repository=_repository)
1612
def pull(self, source, overwrite=False, stop_revision=None,
1614
"""Extends branch.pull to be bound branch aware.
1616
:param _run_hooks: Private parameter used to force hook running
1617
off during bound branch double-pushing.
1619
bound_location = self.get_bound_location()
1620
master_branch = None
1621
if bound_location and source.base != bound_location:
1622
# not pulling from master, so we need to update master.
1623
master_branch = self.get_master_branch()
1624
master_branch.lock_write()
1627
# pull from source into master.
1628
master_branch.pull(source, overwrite, stop_revision,
1630
return super(BzrBranch5, self).pull(source, overwrite,
1631
stop_revision, _hook_master=master_branch,
1632
_run_hooks=_run_hooks)
1635
master_branch.unlock()
1638
def push(self, target, overwrite=False, stop_revision=None):
1639
"""Updates branch.push to be bound branch aware."""
1640
bound_location = target.get_bound_location()
1641
master_branch = None
1642
if bound_location and target.base != bound_location:
1643
# not pushing to master, so we need to update master.
1644
master_branch = target.get_master_branch()
1645
master_branch.lock_write()
1648
# push into the master from this branch.
1649
super(BzrBranch5, self).push(master_branch, overwrite,
1650
stop_revision, _run_hooks=False)
1651
# and push into the target branch from this. Note that we push from
1652
# this branch again, because its considered the highest bandwidth
1654
return super(BzrBranch5, self).push(target, overwrite,
1655
stop_revision, _hook_master=master_branch)
1658
master_branch.unlock()
1660
def get_bound_location(self):
1662
return self.control_files.get_utf8('bound').read()[:-1]
1663
except errors.NoSuchFile:
1667
def get_master_branch(self):
1668
"""Return the branch we are bound to.
1670
:return: Either a Branch, or None
1672
This could memoise the branch, but if thats done
1673
it must be revalidated on each new lock.
1674
So for now we just don't memoise it.
1675
# RBC 20060304 review this decision.
1677
bound_loc = self.get_bound_location()
1681
return Branch.open(bound_loc)
1682
except (errors.NotBranchError, errors.ConnectionError), e:
1683
raise errors.BoundBranchConnectionFailure(
1687
def set_bound_location(self, location):
1688
"""Set the target where this branch is bound to.
1690
:param location: URL to the target branch
1693
self.control_files.put_utf8('bound', location+'\n')
1696
self.control_files._transport.delete('bound')
1702
def bind(self, other):
1703
"""Bind this branch to the branch other.
1705
This does not push or pull data between the branches, though it does
1706
check for divergence to raise an error when the branches are not
1707
either the same, or one a prefix of the other. That behaviour may not
1708
be useful, so that check may be removed in future.
1710
:param other: The branch to bind to
1713
# TODO: jam 20051230 Consider checking if the target is bound
1714
# It is debatable whether you should be able to bind to
1715
# a branch which is itself bound.
1716
# Committing is obviously forbidden,
1717
# but binding itself may not be.
1718
# Since we *have* to check at commit time, we don't
1719
# *need* to check here
1721
# we want to raise diverged if:
1722
# last_rev is not in the other_last_rev history, AND
1723
# other_last_rev is not in our history, and do it without pulling
1725
last_rev = self.last_revision()
1726
if last_rev is not None:
1729
other_last_rev = other.last_revision()
1730
if other_last_rev is not None:
1731
# neither branch is new, we have to do some work to
1732
# ascertain diversion.
1733
remote_graph = other.repository.get_revision_graph(
1735
local_graph = self.repository.get_revision_graph(last_rev)
1736
if (last_rev not in remote_graph and
1737
other_last_rev not in local_graph):
1738
raise errors.DivergedBranches(self, other)
1741
self.set_bound_location(other.base)
1745
"""If bound, unbind"""
1746
return self.set_bound_location(None)
1750
"""Synchronise this branch with the master branch if any.
1752
:return: None or the last_revision that was pivoted out during the
1755
master = self.get_master_branch()
1756
if master is not None:
1757
old_tip = self.last_revision()
1758
self.pull(master, overwrite=True)
1759
if old_tip in self.repository.get_ancestry(self.last_revision()):
1765
class BzrBranchExperimental(BzrBranch5):
1766
"""Bzr experimental branch format
1769
- a revision-history file.
1771
- a lock dir guarding the branch itself
1772
- all of this stored in a branch/ subdirectory
1773
- works with shared repositories.
1774
- a tag dictionary in the branch
1776
This format is new in bzr 0.15, but shouldn't be used for real data,
1779
This class acts as it's own BranchFormat.
1782
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1785
def get_format_string(cls):
1786
"""See BranchFormat.get_format_string()."""
1787
return "Bazaar-NG branch format experimental\n"
1790
def get_format_description(cls):
1791
"""See BranchFormat.get_format_description()."""
1792
return "Experimental branch format"
1795
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1797
branch_transport = a_bzrdir.get_branch_transport(cls)
1798
control_files = lockable_files.LockableFiles(branch_transport,
1799
lock_filename, lock_class)
1800
control_files.create_lock()
1801
control_files.lock_write()
1803
for filename, content in utf8_files:
1804
control_files.put_utf8(filename, content)
1806
control_files.unlock()
1809
def initialize(cls, a_bzrdir):
1810
"""Create a branch of this format in a_bzrdir."""
1811
utf8_files = [('format', cls.get_format_string()),
1812
('revision-history', ''),
1813
('branch-name', ''),
1816
cls._initialize_control_files(a_bzrdir, utf8_files,
1817
'lock', lockdir.LockDir)
1818
return cls.open(a_bzrdir, _found=True)
1821
def open(cls, a_bzrdir, _found=False):
1822
"""Return the branch object for a_bzrdir
1824
_found is a private parameter, do not use it. It is used to indicate
1825
if format probing has already be done.
1828
format = BranchFormat.find_format(a_bzrdir)
1829
assert format.__class__ == cls
1830
transport = a_bzrdir.get_branch_transport(None)
1831
control_files = lockable_files.LockableFiles(transport, 'lock',
1833
return cls(_format=cls,
1834
_control_files=control_files,
1836
_repository=a_bzrdir.find_repository())
1839
def is_supported(cls):
1842
def _make_tags(self):
1843
return BasicTags(self)
1846
def supports_tags(cls):
1850
BranchFormat.register_format(BzrBranchExperimental)
1853
class BzrBranch6(BzrBranch5):
1856
def last_revision_info(self):
1857
revision_string = self.control_files.get('last-revision').read()
1858
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1859
revision_id = cache_utf8.get_cached_utf8(revision_id)
1861
return revno, revision_id
1863
def last_revision(self):
1864
"""Return last revision id, or None"""
1865
revision_id = self.last_revision_info()[1]
1866
if revision_id == _mod_revision.NULL_REVISION:
1870
def _write_last_revision_info(self, revno, revision_id):
1871
"""Simply write out the revision id, with no checks.
1873
Use set_last_revision_info to perform this safely.
1875
Does not update the revision_history cache.
1876
Intended to be called by set_last_revision_info and
1877
_write_revision_history.
1879
if revision_id is None:
1880
revision_id = 'null:'
1881
out_string = '%d %s\n' % (revno, revision_id)
1882
self.control_files.put_bytes('last-revision', out_string)
1885
def set_last_revision_info(self, revno, revision_id):
1886
revision_id = osutils.safe_revision_id(revision_id)
1887
if self._get_append_revisions_only():
1888
self._check_history_violation(revision_id)
1889
self._write_last_revision_info(revno, revision_id)
1890
transaction = self.get_transaction()
1891
cached_history = transaction.map.find_revision_history()
1892
if cached_history is not None:
1893
transaction.map.remove_object(cached_history)
1895
def _check_history_violation(self, revision_id):
1896
last_revision = self.last_revision()
1897
if last_revision is None:
1899
if last_revision not in self._lefthand_history(revision_id):
1900
raise errors.AppendRevisionsOnlyViolation(self.base)
1902
def _gen_revision_history(self):
1903
"""Generate the revision history from last revision
1905
history = list(self.repository.iter_reverse_revision_history(
1906
self.last_revision()))
1910
def _write_revision_history(self, history):
1911
"""Factored out of set_revision_history.
1913
This performs the actual writing to disk, with format-specific checks.
1914
It is intended to be called by BzrBranch5.set_revision_history.
1916
if len(history) == 0:
1917
last_revision = 'null:'
1919
if history != self._lefthand_history(history[-1]):
1920
raise errors.NotLefthandHistory(history)
1921
last_revision = history[-1]
1922
if self._get_append_revisions_only():
1923
self._check_history_violation(last_revision)
1924
self._write_last_revision_info(len(history), last_revision)
1927
def append_revision(self, *revision_ids):
1928
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1929
if len(revision_ids) == 0:
1931
prev_revno, prev_revision = self.last_revision_info()
1932
for revision in self.repository.get_revisions(revision_ids):
1933
if prev_revision == _mod_revision.NULL_REVISION:
1934
if revision.parent_ids != []:
1935
raise errors.NotLeftParentDescendant(self, prev_revision,
1936
revision.revision_id)
1938
if revision.parent_ids[0] != prev_revision:
1939
raise errors.NotLeftParentDescendant(self, prev_revision,
1940
revision.revision_id)
1941
prev_revision = revision.revision_id
1942
self.set_last_revision_info(prev_revno + len(revision_ids),
1945
def _set_config_location(self, name, url, config=None,
1946
make_relative=False):
1948
config = self.get_config()
1952
url = urlutils.relative_url(self.base, url)
1953
config.set_user_option(name, url)
1956
def _get_config_location(self, name, config=None):
1958
config = self.get_config()
1959
location = config.get_user_option(name)
1965
def _set_parent_location(self, url):
1966
"""Set the parent branch"""
1967
self._set_config_location('parent_location', url, make_relative=True)
1970
def _get_parent_location(self):
1971
"""Set the parent branch"""
1972
return self._get_config_location('parent_location')
1974
def set_push_location(self, location):
1975
"""See Branch.set_push_location."""
1976
self._set_config_location('push_location', location)
1978
def set_bound_location(self, location):
1979
"""See Branch.set_push_location."""
1981
config = self.get_config()
1982
if location is None:
1983
if config.get_user_option('bound') != 'True':
1986
config.set_user_option('bound', 'False')
1989
self._set_config_location('bound_location', location,
1991
config.set_user_option('bound', 'True')
1994
def _get_bound_location(self, bound):
1995
"""Return the bound location in the config file.
1997
Return None if the bound parameter does not match"""
1998
config = self.get_config()
1999
config_bound = (config.get_user_option('bound') == 'True')
2000
if config_bound != bound:
2002
return self._get_config_location('bound_location', config=config)
2004
def get_bound_location(self):
2005
"""See Branch.set_push_location."""
2006
return self._get_bound_location(True)
2008
def get_old_bound_location(self):
2009
"""See Branch.get_old_bound_location"""
2010
return self._get_bound_location(False)
2012
def set_append_revisions_only(self, enabled):
2017
self.get_config().set_user_option('append_revisions_only', value)
2019
def _get_append_revisions_only(self):
2020
value = self.get_config().get_user_option('append_revisions_only')
2021
return value == 'True'
2023
def _synchronize_history(self, destination, revision_id):
2024
"""Synchronize last revision and revision history between branches.
2026
This version is most efficient when the destination is also a
2027
BzrBranch6, but works for BzrBranch5, as long as the destination's
2028
repository contains all the lefthand ancestors of the intended
2029
last_revision. If not, set_last_revision_info will fail.
2031
:param destination: The branch to copy the history into
2032
:param revision_id: The revision-id to truncate history at. May
2033
be None to copy complete history.
2035
if revision_id is None:
2036
revno, revision_id = self.last_revision_info()
2038
revno = self.revision_id_to_revno(revision_id)
2039
destination.set_last_revision_info(revno, revision_id)
2041
def _make_tags(self):
2042
return BasicTags(self)
2045
class BranchTestProviderAdapter(object):
2046
"""A tool to generate a suite testing multiple branch formats at once.
2048
This is done by copying the test once for each transport and injecting
2049
the transport_server, transport_readonly_server, and branch_format
2050
classes into each copy. Each copy is also given a new id() to make it
2054
def __init__(self, transport_server, transport_readonly_server, formats):
2055
self._transport_server = transport_server
2056
self._transport_readonly_server = transport_readonly_server
2057
self._formats = formats
2059
def adapt(self, test):
2060
result = TestSuite()
2061
for branch_format, bzrdir_format in self._formats:
2062
new_test = deepcopy(test)
2063
new_test.transport_server = self._transport_server
2064
new_test.transport_readonly_server = self._transport_readonly_server
2065
new_test.bzrdir_format = bzrdir_format
2066
new_test.branch_format = branch_format
2067
def make_new_test_id():
2068
# the format can be either a class or an instance
2069
name = getattr(branch_format, '__name__',
2070
branch_format.__class__.__name__)
2071
new_id = "%s(%s)" % (new_test.id(), name)
2072
return lambda: new_id
2073
new_test.id = make_new_test_id()
2074
result.addTest(new_test)
2078
######################################################################
2079
# results of operations
2082
class _Result(object):
2084
def _show_tag_conficts(self, to_file):
2085
if not getattr(self, 'tag_conflicts', None):
2087
to_file.write('Conflicting tags:\n')
2088
for name, value1, value2 in self.tag_conflicts:
2089
to_file.write(' %s\n' % (name, ))
2092
class PullResult(_Result):
2093
"""Result of a Branch.pull operation.
2095
:ivar old_revno: Revision number before pull.
2096
:ivar new_revno: Revision number after pull.
2097
:ivar old_revid: Tip revision id before pull.
2098
:ivar new_revid: Tip revision id after pull.
2099
:ivar source_branch: Source (local) branch object.
2100
:ivar master_branch: Master branch of the target, or None.
2101
:ivar target_branch: Target/destination branch object.
2105
# DEPRECATED: pull used to return the change in revno
2106
return self.new_revno - self.old_revno
2108
def report(self, to_file):
2109
if self.old_revid == self.new_revid:
2110
to_file.write('No revisions to pull.\n')
2112
to_file.write('Now on revision %d.\n' % self.new_revno)
2113
self._show_tag_conficts(to_file)
2116
class PushResult(_Result):
2117
"""Result of a Branch.push operation.
2119
:ivar old_revno: Revision number before push.
2120
:ivar new_revno: Revision number after push.
2121
:ivar old_revid: Tip revision id before push.
2122
:ivar new_revid: Tip revision id after push.
2123
:ivar source_branch: Source branch object.
2124
:ivar master_branch: Master branch of the target, or None.
2125
:ivar target_branch: Target/destination branch object.
2129
# DEPRECATED: push used to return the change in revno
2130
return self.new_revno - self.old_revno
2132
def report(self, to_file):
2133
"""Write a human-readable description of the result."""
2134
if self.old_revid == self.new_revid:
2135
to_file.write('No new revisions to push.\n')
2137
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2138
self._show_tag_conficts(to_file)
2141
class BranchCheckResult(object):
2142
"""Results of checking branch consistency.
2147
def __init__(self, branch):
2148
self.branch = branch
2150
def report_results(self, verbose):
2151
"""Report the check results via trace.note.
2153
:param verbose: Requests more detailed display of what was checked,
2156
note('checked branch %s format %s',
2158
self.branch._format)
2161
class Converter5to6(object):
2162
"""Perform an in-place upgrade of format 5 to format 6"""
2164
def convert(self, branch):
2165
# Data for 5 and 6 can peacefully coexist.
2166
format = BzrBranchFormat6()
2167
new_branch = format.open(branch.bzrdir, _found=True)
2169
# Copy source data into target
2170
new_branch.set_last_revision_info(*branch.last_revision_info())
2171
new_branch.set_parent(branch.get_parent())
2172
new_branch.set_bound_location(branch.get_bound_location())
2173
new_branch.set_push_location(branch.get_push_location())
2175
# New branch has no tags by default
2176
new_branch.tags._set_tag_dict({})
2178
# Copying done; now update target format
2179
new_branch.control_files.put_utf8('format',
2180
format.get_format_string())
2182
# Clean up old files
2183
new_branch.control_files._transport.delete('revision-history')
2185
branch.set_parent(None)
2188
branch.set_bound_location(None)
added
removed
bzrlib/branch.py
