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, zero_sixteen,
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 Branch Format 6 (bzr 0.15)\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()
101
self._revision_history_cache = None
103
def break_lock(self):
104
"""Break a lock if one is present from another instance.
106
Uses the ui factory to ask for confirmation if the lock may be from
109
This will probe the repository for its lock as well.
111
self.control_files.break_lock()
112
self.repository.break_lock()
113
master = self.get_master_branch()
114
if master is not None:
118
@deprecated_method(zero_eight)
119
def open_downlevel(base):
120
"""Open a branch which may be of an old format."""
121
return Branch.open(base, _unsupported=True)
124
def open(base, _unsupported=False):
125
"""Open the branch rooted at base.
127
For instance, if the branch is at URL/.bzr/branch,
128
Branch.open(URL) -> a Branch instance.
130
control = bzrdir.BzrDir.open(base, _unsupported)
131
return control.open_branch(_unsupported)
134
def open_containing(url):
135
"""Open an existing branch which contains url.
137
This probes for a branch at url, and searches upwards from there.
139
Basically we keep looking up until we find the control directory or
140
run into the root. If there isn't one, raises NotBranchError.
141
If there is one and it is either an unrecognised format or an unsupported
142
format, UnknownFormatError or UnsupportedFormatError are raised.
143
If there is one, it is returned, along with the unused portion of url.
145
control, relpath = bzrdir.BzrDir.open_containing(url)
146
return control.open_branch(), relpath
149
@deprecated_function(zero_eight)
150
def initialize(base):
151
"""Create a new working tree and branch, rooted at 'base' (url)
153
NOTE: This will soon be deprecated in favour of creation
156
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
158
@deprecated_function(zero_eight)
159
def setup_caching(self, cache_root):
160
"""Subclasses that care about caching should override this, and set
161
up cached stores located under cache_root.
163
NOTE: This is unused.
167
def get_config(self):
168
return BranchConfig(self)
171
return self.get_config().get_nickname()
173
def _set_nick(self, nick):
174
self.get_config().set_user_option('nickname', nick)
176
nick = property(_get_nick, _set_nick)
179
raise NotImplementedError(self.is_locked)
181
def lock_write(self):
182
raise NotImplementedError(self.lock_write)
185
raise NotImplementedError(self.lock_read)
188
raise NotImplementedError(self.unlock)
190
def peek_lock_mode(self):
191
"""Return lock mode for the Branch: 'r', 'w' or None"""
192
raise NotImplementedError(self.peek_lock_mode)
194
def get_physical_lock_status(self):
195
raise NotImplementedError(self.get_physical_lock_status)
197
def abspath(self, name):
198
"""Return absolute filename for something in the branch
200
XXX: Robert Collins 20051017 what is this used for? why is it a branch
201
method and not a tree method.
203
raise NotImplementedError(self.abspath)
205
def bind(self, other):
206
"""Bind the local branch the other branch.
208
:param other: The branch to bind to
211
raise errors.UpgradeRequired(self.base)
214
def fetch(self, from_branch, last_revision=None, pb=None):
215
"""Copy revisions from from_branch into this branch.
217
:param from_branch: Where to copy from.
218
:param last_revision: What revision to stop at (None for at the end
220
:param pb: An optional progress bar to use.
222
Returns the copied revision count and the failed revisions in a tuple:
225
if self.base == from_branch.base:
228
nested_pb = ui.ui_factory.nested_progress_bar()
233
from_branch.lock_read()
235
if last_revision is None:
236
pb.update('get source history')
237
last_revision = from_branch.last_revision()
238
if last_revision is None:
239
last_revision = _mod_revision.NULL_REVISION
240
return self.repository.fetch(from_branch.repository,
241
revision_id=last_revision,
244
if nested_pb is not None:
248
def get_bound_location(self):
249
"""Return the URL of the branch we are bound to.
251
Older format branches cannot bind, please be sure to use a metadir
256
def get_old_bound_location(self):
257
"""Return the URL of the branch we used to be bound to
259
raise errors.UpgradeRequired(self.base)
261
def get_commit_builder(self, parents, config=None, timestamp=None,
262
timezone=None, committer=None, revprops=None,
264
"""Obtain a CommitBuilder for this branch.
266
:param parents: Revision ids of the parents of the new revision.
267
:param config: Optional configuration to use.
268
:param timestamp: Optional timestamp recorded for commit.
269
:param timezone: Optional timezone for timestamp.
270
:param committer: Optional committer to set for commit.
271
:param revprops: Optional dictionary of revision properties.
272
:param revision_id: Optional revision id.
276
config = self.get_config()
278
return self.repository.get_commit_builder(self, parents, config,
279
timestamp, timezone, committer, revprops, revision_id)
281
def get_master_branch(self):
282
"""Return the branch we are bound to.
284
:return: Either a Branch, or None
288
def get_revision_delta(self, revno):
289
"""Return the delta for one revision.
291
The delta is relative to its mainline predecessor, or the
292
empty tree for revision 1.
294
assert isinstance(revno, int)
295
rh = self.revision_history()
296
if not (1 <= revno <= len(rh)):
297
raise InvalidRevisionNumber(revno)
298
return self.repository.get_revision_delta(rh[revno-1])
300
@deprecated_method(zero_sixteen)
301
def get_root_id(self):
302
"""Return the id of this branches root
304
Deprecated: branches don't have root ids-- trees do.
305
Use basis_tree().get_root_id() instead.
307
raise NotImplementedError(self.get_root_id)
309
def print_file(self, file, revision_id):
310
"""Print `file` to stdout."""
311
raise NotImplementedError(self.print_file)
313
def append_revision(self, *revision_ids):
314
raise NotImplementedError(self.append_revision)
316
def set_revision_history(self, rev_history):
317
raise NotImplementedError(self.set_revision_history)
319
def _cache_revision_history(self, rev_history):
320
"""Set the cached revision history to rev_history.
322
The revision_history method will use this cache to avoid regenerating
323
the revision history.
325
This API is semi-public; it only for use by subclasses, all other code
326
should consider it to be private.
328
self._revision_history_cache = rev_history
330
def _clear_cached_state(self):
331
"""Clear any cached data on this branch, e.g. cached revision history.
333
This means the next call to revision_history will need to call
334
_gen_revision_history.
336
This API is semi-public; it only for use by subclasses, all other code
337
should consider it to be private.
339
self._revision_history_cache = None
341
def _gen_revision_history(self):
342
"""Return sequence of revision hashes on to this branch.
344
Unlike revision_history, this method always regenerates or rereads the
345
revision history, i.e. it does not cache the result, so repeated calls
348
Concrete subclasses should override this instead of revision_history so
349
that subclasses do not need to deal with caching logic.
351
This API is semi-public; it only for use by subclasses, all other code
352
should consider it to be private.
354
raise NotImplementedError(self._gen_revision_history)
357
def revision_history(self):
358
"""Return sequence of revision hashes on to this branch.
360
This method will cache the revision history for as long as it is safe to
363
if self._revision_history_cache is not None:
364
history = self._revision_history_cache
366
history = self._gen_revision_history()
367
self._cache_revision_history(history)
371
"""Return current revision number for this branch.
373
That is equivalent to the number of revisions committed to
376
return len(self.revision_history())
379
"""Older format branches cannot bind or unbind."""
380
raise errors.UpgradeRequired(self.base)
382
def set_append_revisions_only(self, enabled):
383
"""Older format branches are never restricted to append-only"""
384
raise errors.UpgradeRequired(self.base)
386
def last_revision(self):
387
"""Return last revision id, or None"""
388
ph = self.revision_history()
394
def last_revision_info(self):
395
"""Return information about the last revision.
397
:return: A tuple (revno, last_revision_id).
399
rh = self.revision_history()
402
return (revno, rh[-1])
404
return (0, _mod_revision.NULL_REVISION)
406
def missing_revisions(self, other, stop_revision=None):
407
"""Return a list of new revisions that would perfectly fit.
409
If self and other have not diverged, return a list of the revisions
410
present in other, but missing from self.
412
self_history = self.revision_history()
413
self_len = len(self_history)
414
other_history = other.revision_history()
415
other_len = len(other_history)
416
common_index = min(self_len, other_len) -1
417
if common_index >= 0 and \
418
self_history[common_index] != other_history[common_index]:
419
raise DivergedBranches(self, other)
421
if stop_revision is None:
422
stop_revision = other_len
424
assert isinstance(stop_revision, int)
425
if stop_revision > other_len:
426
raise errors.NoSuchRevision(self, stop_revision)
427
return other_history[self_len:stop_revision]
429
def update_revisions(self, other, stop_revision=None):
430
"""Pull in new perfect-fit revisions.
432
:param other: Another Branch to pull from
433
:param stop_revision: Updated until the given revision
436
raise NotImplementedError(self.update_revisions)
438
def revision_id_to_revno(self, revision_id):
439
"""Given a revision id, return its revno"""
440
if revision_id is None:
442
revision_id = osutils.safe_revision_id(revision_id)
443
history = self.revision_history()
445
return history.index(revision_id) + 1
447
raise bzrlib.errors.NoSuchRevision(self, revision_id)
449
def get_rev_id(self, revno, history=None):
450
"""Find the revision id of the specified revno."""
454
history = self.revision_history()
455
if revno <= 0 or revno > len(history):
456
raise bzrlib.errors.NoSuchRevision(self, revno)
457
return history[revno - 1]
459
def pull(self, source, overwrite=False, stop_revision=None):
460
"""Mirror source into this branch.
462
This branch is considered to be 'local', having low latency.
464
:returns: PullResult instance
466
raise NotImplementedError(self.pull)
468
def push(self, target, overwrite=False, stop_revision=None):
469
"""Mirror this branch into target.
471
This branch is considered to be 'local', having low latency.
473
raise NotImplementedError(self.push)
475
def basis_tree(self):
476
"""Return `Tree` object for last revision."""
477
return self.repository.revision_tree(self.last_revision())
479
def rename_one(self, from_rel, to_rel):
482
This can change the directory or the filename or both.
484
raise NotImplementedError(self.rename_one)
486
def move(self, from_paths, to_name):
489
to_name must exist as a versioned directory.
491
If to_name exists and is a directory, the files are moved into
492
it, keeping their old names. If it is a directory,
494
Note that to_name is only the last component of the new name;
495
this doesn't change the directory.
497
This returns a list of (from_path, to_path) pairs for each
500
raise NotImplementedError(self.move)
502
def get_parent(self):
503
"""Return the parent location of the branch.
505
This is the default location for push/pull/missing. The usual
506
pattern is that the user can override it by specifying a
509
raise NotImplementedError(self.get_parent)
511
def _set_config_location(self, name, url, config=None,
512
make_relative=False):
514
config = self.get_config()
518
url = urlutils.relative_url(self.base, url)
519
config.set_user_option(name, url)
521
def _get_config_location(self, name, config=None):
523
config = self.get_config()
524
location = config.get_user_option(name)
529
def get_submit_branch(self):
530
"""Return the submit location of the branch.
532
This is the default location for bundle. The usual
533
pattern is that the user can override it by specifying a
536
return self.get_config().get_user_option('submit_branch')
538
def set_submit_branch(self, location):
539
"""Return the submit location of the branch.
541
This is the default location for bundle. The usual
542
pattern is that the user can override it by specifying a
545
self.get_config().set_user_option('submit_branch', location)
547
def get_public_branch(self):
548
"""Return the public location of the branch.
550
This is is used by merge directives.
552
return self._get_config_location('public_branch')
554
def set_public_branch(self, location):
555
"""Return the submit location of the branch.
557
This is the default location for bundle. The usual
558
pattern is that the user can override it by specifying a
561
self._set_config_location('public_branch', location)
563
def get_push_location(self):
564
"""Return the None or the location to push this branch to."""
565
raise NotImplementedError(self.get_push_location)
567
def set_push_location(self, location):
568
"""Set a new push location for this branch."""
569
raise NotImplementedError(self.set_push_location)
571
def set_parent(self, url):
572
raise NotImplementedError(self.set_parent)
576
"""Synchronise this branch with the master branch if any.
578
:return: None or the last_revision pivoted out during the update.
582
def check_revno(self, revno):
584
Check whether a revno corresponds to any revision.
585
Zero (the NULL revision) is considered valid.
588
self.check_real_revno(revno)
590
def check_real_revno(self, revno):
592
Check whether a revno corresponds to a real revision.
593
Zero (the NULL revision) is considered invalid
595
if revno < 1 or revno > self.revno():
596
raise InvalidRevisionNumber(revno)
599
def clone(self, *args, **kwargs):
600
"""Clone this branch into to_bzrdir preserving all semantic values.
602
revision_id: if not None, the revision history in the new branch will
603
be truncated to end with revision_id.
605
# for API compatibility, until 0.8 releases we provide the old api:
606
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
607
# after 0.8 releases, the *args and **kwargs should be changed:
608
# def clone(self, to_bzrdir, revision_id=None):
609
if (kwargs.get('to_location', None) or
610
kwargs.get('revision', None) or
611
kwargs.get('basis_branch', None) or
612
(len(args) and isinstance(args[0], basestring))):
613
# backwards compatibility api:
614
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
615
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
618
basis_branch = args[2]
620
basis_branch = kwargs.get('basis_branch', None)
622
basis = basis_branch.bzrdir
627
revision_id = args[1]
629
revision_id = kwargs.get('revision', None)
634
# no default to raise if not provided.
635
url = kwargs.get('to_location')
636
return self.bzrdir.clone(url,
637
revision_id=revision_id,
638
basis=basis).open_branch()
640
# generate args by hand
642
revision_id = args[1]
644
revision_id = kwargs.get('revision_id', None)
648
# no default to raise if not provided.
649
to_bzrdir = kwargs.get('to_bzrdir')
650
result = self._format.initialize(to_bzrdir)
651
self.copy_content_into(result, revision_id=revision_id)
655
def sprout(self, to_bzrdir, revision_id=None):
656
"""Create a new line of development from the branch, into to_bzrdir.
658
revision_id: if not None, the revision history in the new branch will
659
be truncated to end with revision_id.
661
result = self._format.initialize(to_bzrdir)
662
self.copy_content_into(result, revision_id=revision_id)
663
result.set_parent(self.bzrdir.root_transport.base)
666
def _synchronize_history(self, destination, revision_id):
667
"""Synchronize last revision and revision history between branches.
669
This version is most efficient when the destination is also a
670
BzrBranch5, but works for BzrBranch6 as long as the revision
671
history is the true lefthand parent history, and all of the revisions
672
are in the destination's repository. If not, set_revision_history
675
:param destination: The branch to copy the history into
676
:param revision_id: The revision-id to truncate history at. May
677
be None to copy complete history.
679
new_history = self.revision_history()
680
if revision_id is not None:
681
revision_id = osutils.safe_revision_id(revision_id)
683
new_history = new_history[:new_history.index(revision_id) + 1]
685
rev = self.repository.get_revision(revision_id)
686
new_history = rev.get_history(self.repository)[1:]
687
destination.set_revision_history(new_history)
690
def copy_content_into(self, destination, revision_id=None):
691
"""Copy the content of self into destination.
693
revision_id: if not None, the revision history in the new branch will
694
be truncated to end with revision_id.
696
self._synchronize_history(destination, revision_id)
698
parent = self.get_parent()
699
except errors.InaccessibleParent, e:
700
mutter('parent was not accessible to copy: %s', e)
703
destination.set_parent(parent)
704
self.tags.merge_to(destination.tags)
708
"""Check consistency of the branch.
710
In particular this checks that revisions given in the revision-history
711
do actually match up in the revision graph, and that they're all
712
present in the repository.
714
Callers will typically also want to check the repository.
716
:return: A BranchCheckResult.
718
mainline_parent_id = None
719
for revision_id in self.revision_history():
721
revision = self.repository.get_revision(revision_id)
722
except errors.NoSuchRevision, e:
723
raise errors.BzrCheckError("mainline revision {%s} not in repository"
725
# In general the first entry on the revision history has no parents.
726
# But it's not illegal for it to have parents listed; this can happen
727
# in imports from Arch when the parents weren't reachable.
728
if mainline_parent_id is not None:
729
if mainline_parent_id not in revision.parent_ids:
730
raise errors.BzrCheckError("previous revision {%s} not listed among "
732
% (mainline_parent_id, revision_id))
733
mainline_parent_id = revision_id
734
return BranchCheckResult(self)
736
def _get_checkout_format(self):
737
"""Return the most suitable metadir for a checkout of this branch.
738
Weaves are used if this branch's repostory uses weaves.
740
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
741
from bzrlib.repofmt import weaverepo
742
format = bzrdir.BzrDirMetaFormat1()
743
format.repository_format = weaverepo.RepositoryFormat7()
745
format = self.repository.bzrdir.checkout_metadir()
746
format.set_branch_format(self._format)
749
def create_checkout(self, to_location, revision_id=None,
751
"""Create a checkout of a branch.
753
:param to_location: The url to produce the checkout at
754
:param revision_id: The revision to check out
755
:param lightweight: If True, produce a lightweight checkout, otherwise,
756
produce a bound branch (heavyweight checkout)
757
:return: The tree of the created checkout
759
t = transport.get_transport(to_location)
762
except errors.FileExists:
765
format = self._get_checkout_format()
766
checkout = format.initialize_on_transport(t)
767
BranchReferenceFormat().initialize(checkout, self)
769
format = self._get_checkout_format()
770
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
771
to_location, force_new_tree=False, format=format)
772
checkout = checkout_branch.bzrdir
773
checkout_branch.bind(self)
774
# pull up to the specified revision_id to set the initial
775
# branch tip correctly, and seed it with history.
776
checkout_branch.pull(self, stop_revision=revision_id)
777
tree = checkout.create_workingtree(revision_id)
778
basis_tree = tree.basis_tree()
779
basis_tree.lock_read()
781
for path, file_id in basis_tree.iter_references():
782
reference_parent = self.reference_parent(file_id, path)
783
reference_parent.create_checkout(tree.abspath(path),
784
basis_tree.get_reference_revision(file_id, path),
790
def reference_parent(self, file_id, path):
791
"""Return the parent branch for a tree-reference file_id
792
:param file_id: The file_id of the tree reference
793
:param path: The path of the file_id in the tree
794
:return: A branch associated with the file_id
796
# FIXME should provide multiple branches, based on config
797
return Branch.open(self.bzrdir.root_transport.clone(path).base)
799
def supports_tags(self):
800
return self._format.supports_tags()
803
class BranchFormat(object):
804
"""An encapsulation of the initialization and open routines for a format.
806
Formats provide three things:
807
* An initialization routine,
811
Formats are placed in an dict by their format string for reference
812
during branch opening. Its not required that these be instances, they
813
can be classes themselves with class methods - it simply depends on
814
whether state is needed for a given format or not.
816
Once a format is deprecated, just deprecate the initialize and open
817
methods on the format class. Do not deprecate the object, as the
818
object will be created every time regardless.
821
_default_format = None
822
"""The default format used for new branches."""
825
"""The known formats."""
828
def find_format(klass, a_bzrdir):
829
"""Return the format for the branch object in a_bzrdir."""
831
transport = a_bzrdir.get_branch_transport(None)
832
format_string = transport.get("format").read()
833
return klass._formats[format_string]
835
raise NotBranchError(path=transport.base)
837
raise errors.UnknownFormatError(format=format_string)
840
def get_default_format(klass):
841
"""Return the current default format."""
842
return klass._default_format
844
def get_format_string(self):
845
"""Return the ASCII format string that identifies this format."""
846
raise NotImplementedError(self.get_format_string)
848
def get_format_description(self):
849
"""Return the short format description for this format."""
850
raise NotImplementedError(self.get_format_description)
852
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
854
"""Initialize a branch in a bzrdir, with specified files
856
:param a_bzrdir: The bzrdir to initialize the branch in
857
:param utf8_files: The files to create as a list of
858
(filename, content) tuples
859
:param set_format: If True, set the format with
860
self.get_format_string. (BzrBranch4 has its format set
862
:return: a branch in this format
864
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
865
branch_transport = a_bzrdir.get_branch_transport(self)
867
'metadir': ('lock', lockdir.LockDir),
868
'branch4': ('branch-lock', lockable_files.TransportLock),
870
lock_name, lock_class = lock_map[lock_type]
871
control_files = lockable_files.LockableFiles(branch_transport,
872
lock_name, lock_class)
873
control_files.create_lock()
874
control_files.lock_write()
876
control_files.put_utf8('format', self.get_format_string())
878
for file, content in utf8_files:
879
control_files.put_utf8(file, content)
881
control_files.unlock()
882
return self.open(a_bzrdir, _found=True)
884
def initialize(self, a_bzrdir):
885
"""Create a branch of this format in a_bzrdir."""
886
raise NotImplementedError(self.initialize)
888
def is_supported(self):
889
"""Is this format supported?
891
Supported formats can be initialized and opened.
892
Unsupported formats may not support initialization or committing or
893
some other features depending on the reason for not being supported.
897
def open(self, a_bzrdir, _found=False):
898
"""Return the branch object for a_bzrdir
900
_found is a private parameter, do not use it. It is used to indicate
901
if format probing has already be done.
903
raise NotImplementedError(self.open)
906
def register_format(klass, format):
907
klass._formats[format.get_format_string()] = format
910
def set_default_format(klass, format):
911
klass._default_format = format
914
def unregister_format(klass, format):
915
assert klass._formats[format.get_format_string()] is format
916
del klass._formats[format.get_format_string()]
919
return self.get_format_string().rstrip()
921
def supports_tags(self):
922
"""True if this format supports tags stored in the branch"""
923
return False # by default
925
# XXX: Probably doesn't really belong here -- mbp 20070212
926
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
928
branch_transport = a_bzrdir.get_branch_transport(self)
929
control_files = lockable_files.LockableFiles(branch_transport,
930
lock_filename, lock_class)
931
control_files.create_lock()
932
control_files.lock_write()
934
for filename, content in utf8_files:
935
control_files.put_utf8(filename, content)
937
control_files.unlock()
940
class BranchHooks(dict):
941
"""A dictionary mapping hook name to a list of callables for branch hooks.
943
e.g. ['set_rh'] Is the list of items to be called when the
944
set_revision_history function is invoked.
948
"""Create the default hooks.
950
These are all empty initially, because by default nothing should get
954
# Introduced in 0.15:
955
# invoked whenever the revision history has been set
956
# with set_revision_history. The api signature is
957
# (branch, revision_history), and the branch will
960
# invoked after a push operation completes.
961
# the api signature is
963
# containing the members
964
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
965
# where local is the local branch or None, master is the target
966
# master branch, and the rest should be self explanatory. The source
967
# is read locked and the target branches write locked. Source will
968
# be the local low-latency branch.
969
self['post_push'] = []
970
# invoked after a pull operation completes.
971
# the api signature is
973
# containing the members
974
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
975
# where local is the local branch or None, master is the target
976
# master branch, and the rest should be self explanatory. The source
977
# is read locked and the target branches write locked. The local
978
# branch is the low-latency branch.
979
self['post_pull'] = []
980
# invoked after a commit operation completes.
981
# the api signature is
982
# (local, master, old_revno, old_revid, new_revno, new_revid)
983
# old_revid is NULL_REVISION for the first commit to a branch.
984
self['post_commit'] = []
985
# invoked after a uncommit operation completes.
986
# the api signature is
987
# (local, master, old_revno, old_revid, new_revno, new_revid) where
988
# local is the local branch or None, master is the target branch,
989
# and an empty branch recieves new_revno of 0, new_revid of None.
990
self['post_uncommit'] = []
992
def install_hook(self, hook_name, a_callable):
993
"""Install a_callable in to the hook hook_name.
995
:param hook_name: A hook name. See the __init__ method of BranchHooks
996
for the complete list of hooks.
997
:param a_callable: The callable to be invoked when the hook triggers.
998
The exact signature will depend on the hook - see the __init__
999
method of BranchHooks for details on each hook.
1002
self[hook_name].append(a_callable)
1004
raise errors.UnknownHook('branch', hook_name)
1007
# install the default hooks into the Branch class.
1008
Branch.hooks = BranchHooks()
1011
class BzrBranchFormat4(BranchFormat):
1012
"""Bzr branch format 4.
1015
- a revision-history file.
1016
- a branch-lock lock file [ to be shared with the bzrdir ]
1019
def get_format_description(self):
1020
"""See BranchFormat.get_format_description()."""
1021
return "Branch format 4"
1023
def initialize(self, a_bzrdir):
1024
"""Create a branch of this format in a_bzrdir."""
1025
utf8_files = [('revision-history', ''),
1026
('branch-name', ''),
1028
return self._initialize_helper(a_bzrdir, utf8_files,
1029
lock_type='branch4', set_format=False)
1032
super(BzrBranchFormat4, self).__init__()
1033
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1035
def open(self, a_bzrdir, _found=False):
1036
"""Return the branch object for a_bzrdir
1038
_found is a private parameter, do not use it. It is used to indicate
1039
if format probing has already be done.
1042
# we are being called directly and must probe.
1043
raise NotImplementedError
1044
return BzrBranch(_format=self,
1045
_control_files=a_bzrdir._control_files,
1047
_repository=a_bzrdir.open_repository())
1050
return "Bazaar-NG branch format 4"
1053
class BzrBranchFormat5(BranchFormat):
1054
"""Bzr branch format 5.
1057
- a revision-history file.
1059
- a lock dir guarding the branch itself
1060
- all of this stored in a branch/ subdirectory
1061
- works with shared repositories.
1063
This format is new in bzr 0.8.
1066
def get_format_string(self):
1067
"""See BranchFormat.get_format_string()."""
1068
return "Bazaar-NG branch format 5\n"
1070
def get_format_description(self):
1071
"""See BranchFormat.get_format_description()."""
1072
return "Branch format 5"
1074
def initialize(self, a_bzrdir):
1075
"""Create a branch of this format in a_bzrdir."""
1076
utf8_files = [('revision-history', ''),
1077
('branch-name', ''),
1079
return self._initialize_helper(a_bzrdir, utf8_files)
1082
super(BzrBranchFormat5, self).__init__()
1083
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1085
def open(self, a_bzrdir, _found=False):
1086
"""Return the branch object for a_bzrdir
1088
_found is a private parameter, do not use it. It is used to indicate
1089
if format probing has already be done.
1092
format = BranchFormat.find_format(a_bzrdir)
1093
assert format.__class__ == self.__class__
1094
transport = a_bzrdir.get_branch_transport(None)
1095
control_files = lockable_files.LockableFiles(transport, 'lock',
1097
return BzrBranch5(_format=self,
1098
_control_files=control_files,
1100
_repository=a_bzrdir.find_repository())
1103
class BzrBranchFormat6(BzrBranchFormat5):
1104
"""Branch format with last-revision
1106
Unlike previous formats, this has no explicit revision history. Instead,
1107
this just stores the last-revision, and the left-hand history leading
1108
up to there is the history.
1110
This format was introduced in bzr 0.15
1113
def get_format_string(self):
1114
"""See BranchFormat.get_format_string()."""
1115
return "Bazaar Branch Format 6 (bzr 0.15)\n"
1117
def get_format_description(self):
1118
"""See BranchFormat.get_format_description()."""
1119
return "Branch format 6"
1121
def initialize(self, a_bzrdir):
1122
"""Create a branch of this format in a_bzrdir."""
1123
utf8_files = [('last-revision', '0 null:\n'),
1124
('branch-name', ''),
1125
('branch.conf', ''),
1128
return self._initialize_helper(a_bzrdir, utf8_files)
1130
def open(self, a_bzrdir, _found=False):
1131
"""Return the branch object for a_bzrdir
1133
_found is a private parameter, do not use it. It is used to indicate
1134
if format probing has already be done.
1137
format = BranchFormat.find_format(a_bzrdir)
1138
assert format.__class__ == self.__class__
1139
transport = a_bzrdir.get_branch_transport(None)
1140
control_files = lockable_files.LockableFiles(transport, 'lock',
1142
return BzrBranch6(_format=self,
1143
_control_files=control_files,
1145
_repository=a_bzrdir.find_repository())
1147
def supports_tags(self):
1151
class BranchReferenceFormat(BranchFormat):
1152
"""Bzr branch reference format.
1154
Branch references are used in implementing checkouts, they
1155
act as an alias to the real branch which is at some other url.
1162
def get_format_string(self):
1163
"""See BranchFormat.get_format_string()."""
1164
return "Bazaar-NG Branch Reference Format 1\n"
1166
def get_format_description(self):
1167
"""See BranchFormat.get_format_description()."""
1168
return "Checkout reference format 1"
1170
def initialize(self, a_bzrdir, target_branch=None):
1171
"""Create a branch of this format in a_bzrdir."""
1172
if target_branch is None:
1173
# this format does not implement branch itself, thus the implicit
1174
# creation contract must see it as uninitializable
1175
raise errors.UninitializableFormat(self)
1176
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1177
branch_transport = a_bzrdir.get_branch_transport(self)
1178
branch_transport.put_bytes('location',
1179
target_branch.bzrdir.root_transport.base)
1180
branch_transport.put_bytes('format', self.get_format_string())
1181
return self.open(a_bzrdir, _found=True)
1184
super(BranchReferenceFormat, self).__init__()
1185
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1187
def _make_reference_clone_function(format, a_branch):
1188
"""Create a clone() routine for a branch dynamically."""
1189
def clone(to_bzrdir, revision_id=None):
1190
"""See Branch.clone()."""
1191
return format.initialize(to_bzrdir, a_branch)
1192
# cannot obey revision_id limits when cloning a reference ...
1193
# FIXME RBC 20060210 either nuke revision_id for clone, or
1194
# emit some sort of warning/error to the caller ?!
1197
def open(self, a_bzrdir, _found=False):
1198
"""Return the branch that the branch reference in a_bzrdir points at.
1200
_found is a private parameter, do not use it. It is used to indicate
1201
if format probing has already be done.
1204
format = BranchFormat.find_format(a_bzrdir)
1205
assert format.__class__ == self.__class__
1206
transport = a_bzrdir.get_branch_transport(None)
1207
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1208
result = real_bzrdir.open_branch()
1209
# this changes the behaviour of result.clone to create a new reference
1210
# rather than a copy of the content of the branch.
1211
# I did not use a proxy object because that needs much more extensive
1212
# testing, and we are only changing one behaviour at the moment.
1213
# If we decide to alter more behaviours - i.e. the implicit nickname
1214
# then this should be refactored to introduce a tested proxy branch
1215
# and a subclass of that for use in overriding clone() and ....
1217
result.clone = self._make_reference_clone_function(result)
1221
# formats which have no format string are not discoverable
1222
# and not independently creatable, so are not registered.
1223
__default_format = BzrBranchFormat5()
1224
BranchFormat.register_format(__default_format)
1225
BranchFormat.register_format(BranchReferenceFormat())
1226
BranchFormat.register_format(BzrBranchFormat6())
1227
BranchFormat.set_default_format(__default_format)
1228
_legacy_formats = [BzrBranchFormat4(),
1231
class BzrBranch(Branch):
1232
"""A branch stored in the actual filesystem.
1234
Note that it's "local" in the context of the filesystem; it doesn't
1235
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1236
it's writable, and can be accessed via the normal filesystem API.
1239
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
1240
relax_version_check=DEPRECATED_PARAMETER, _format=None,
1241
_control_files=None, a_bzrdir=None, _repository=None):
1242
"""Create new branch object at a particular location.
1244
transport -- A Transport object, defining how to access files.
1246
init -- If True, create new control files in a previously
1247
unversioned directory. If False, the branch must already
1250
relax_version_check -- If true, the usual check for the branch
1251
version is not applied. This is intended only for
1252
upgrade/recovery type use; it's not guaranteed that
1253
all operations will work on old format branches.
1255
Branch.__init__(self)
1256
if a_bzrdir is None:
1257
self.bzrdir = bzrdir.BzrDir.open(transport.base)
1259
self.bzrdir = a_bzrdir
1260
# self._transport used to point to the directory containing the
1261
# control directory, but was not used - now it's just the transport
1262
# for the branch control files. mbp 20070212
1263
self._base = self.bzrdir.transport.clone('..').base
1264
self._format = _format
1265
if _control_files is None:
1266
raise ValueError('BzrBranch _control_files is None')
1267
self.control_files = _control_files
1268
self._transport = _control_files._transport
1269
if deprecated_passed(init):
1270
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
1271
"deprecated as of bzr 0.8. Please use Branch.create().",
1275
# this is slower than before deprecation, oh well never mind.
1276
# -> its deprecated.
1277
self._initialize(transport.base)
1278
self._check_format(_format)
1279
if deprecated_passed(relax_version_check):
1280
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1281
"relax_version_check parameter is deprecated as of bzr 0.8. "
1282
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1286
if (not relax_version_check
1287
and not self._format.is_supported()):
1288
raise errors.UnsupportedFormatError(format=fmt)
1289
if deprecated_passed(transport):
1290
warn("BzrBranch.__init__(transport=XXX...): The transport "
1291
"parameter is deprecated as of bzr 0.8. "
1292
"Please use Branch.open, or bzrdir.open_branch().",
1295
self.repository = _repository
1298
return '%s(%r)' % (self.__class__.__name__, self.base)
1302
def _get_base(self):
1303
"""Returns the directory containing the control directory."""
1306
base = property(_get_base, doc="The URL for the root of this branch.")
1308
def abspath(self, name):
1309
"""See Branch.abspath."""
1310
return self.control_files._transport.abspath(name)
1312
def _check_format(self, format):
1313
"""Identify the branch format if needed.
1315
The format is stored as a reference to the format object in
1316
self._format for code that needs to check it later.
1318
The format parameter is either None or the branch format class
1319
used to open this branch.
1321
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1324
format = BranchFormat.find_format(self.bzrdir)
1325
self._format = format
1326
mutter("got branch format %s", self._format)
1328
@deprecated_method(zero_sixteen)
1330
def get_root_id(self):
1331
"""See Branch.get_root_id."""
1332
tree = self.repository.revision_tree(self.last_revision())
1333
return tree.inventory.root.file_id
1335
def is_locked(self):
1336
return self.control_files.is_locked()
1338
def lock_write(self):
1339
self.repository.lock_write()
1341
self.control_files.lock_write()
1343
self.repository.unlock()
1346
def lock_read(self):
1347
self.repository.lock_read()
1349
self.control_files.lock_read()
1351
self.repository.unlock()
1355
# TODO: test for failed two phase locks. This is known broken.
1357
self.control_files.unlock()
1359
self.repository.unlock()
1360
if not self.control_files.is_locked():
1361
# we just released the lock
1362
self._clear_cached_state()
1364
def peek_lock_mode(self):
1365
if self.control_files._lock_count == 0:
1368
return self.control_files._lock_mode
1370
def get_physical_lock_status(self):
1371
return self.control_files.get_physical_lock_status()
1374
def print_file(self, file, revision_id):
1375
"""See Branch.print_file."""
1376
return self.repository.print_file(file, revision_id)
1379
def append_revision(self, *revision_ids):
1380
"""See Branch.append_revision."""
1381
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1382
for revision_id in revision_ids:
1383
_mod_revision.check_not_reserved_id(revision_id)
1384
mutter("add {%s} to revision-history" % revision_id)
1385
rev_history = self.revision_history()
1386
rev_history.extend(revision_ids)
1387
self.set_revision_history(rev_history)
1389
def _write_revision_history(self, history):
1390
"""Factored out of set_revision_history.
1392
This performs the actual writing to disk.
1393
It is intended to be called by BzrBranch5.set_revision_history."""
1394
self.control_files.put_bytes(
1395
'revision-history', '\n'.join(history))
1398
def set_revision_history(self, rev_history):
1399
"""See Branch.set_revision_history."""
1400
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1401
self._write_revision_history(rev_history)
1402
self._cache_revision_history(rev_history)
1403
for hook in Branch.hooks['set_rh']:
1404
hook(self, rev_history)
1407
def set_last_revision_info(self, revno, revision_id):
1408
revision_id = osutils.safe_revision_id(revision_id)
1409
history = self._lefthand_history(revision_id)
1410
assert len(history) == revno, '%d != %d' % (len(history), revno)
1411
self.set_revision_history(history)
1413
def _gen_revision_history(self):
1414
history = self.control_files.get('revision-history').read().split('\n')
1415
if history[-1:] == ['']:
1416
# There shouldn't be a trailing newline, but just in case.
1420
def _lefthand_history(self, revision_id, last_rev=None,
1422
# stop_revision must be a descendant of last_revision
1423
stop_graph = self.repository.get_revision_graph(revision_id)
1424
if last_rev is not None and last_rev not in stop_graph:
1425
# our previous tip is not merged into stop_revision
1426
raise errors.DivergedBranches(self, other_branch)
1427
# make a new revision history from the graph
1428
current_rev_id = revision_id
1430
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1431
new_history.append(current_rev_id)
1432
current_rev_id_parents = stop_graph[current_rev_id]
1434
current_rev_id = current_rev_id_parents[0]
1436
current_rev_id = None
1437
new_history.reverse()
1441
def generate_revision_history(self, revision_id, last_rev=None,
1443
"""Create a new revision history that will finish with revision_id.
1445
:param revision_id: the new tip to use.
1446
:param last_rev: The previous last_revision. If not None, then this
1447
must be a ancestory of revision_id, or DivergedBranches is raised.
1448
:param other_branch: The other branch that DivergedBranches should
1449
raise with respect to.
1451
revision_id = osutils.safe_revision_id(revision_id)
1452
self.set_revision_history(self._lefthand_history(revision_id,
1453
last_rev, other_branch))
1456
def update_revisions(self, other, stop_revision=None):
1457
"""See Branch.update_revisions."""
1460
if stop_revision is None:
1461
stop_revision = other.last_revision()
1462
if stop_revision is None:
1463
# if there are no commits, we're done.
1466
stop_revision = osutils.safe_revision_id(stop_revision)
1467
# whats the current last revision, before we fetch [and change it
1469
last_rev = self.last_revision()
1470
# we fetch here regardless of whether we need to so that we pickup
1472
self.fetch(other, stop_revision)
1473
my_ancestry = self.repository.get_ancestry(last_rev)
1474
if stop_revision in my_ancestry:
1475
# last_revision is a descendant of stop_revision
1477
self.generate_revision_history(stop_revision, last_rev=last_rev,
1482
def basis_tree(self):
1483
"""See Branch.basis_tree."""
1484
return self.repository.revision_tree(self.last_revision())
1486
@deprecated_method(zero_eight)
1487
def working_tree(self):
1488
"""Create a Working tree object for this branch."""
1490
from bzrlib.transport.local import LocalTransport
1491
if (self.base.find('://') != -1 or
1492
not isinstance(self._transport, LocalTransport)):
1493
raise NoWorkingTree(self.base)
1494
return self.bzrdir.open_workingtree()
1497
def pull(self, source, overwrite=False, stop_revision=None,
1498
_hook_master=None, _run_hooks=True):
1501
:param _hook_master: Private parameter - set the branch to
1502
be supplied as the master to push hooks.
1503
:param _run_hooks: Private parameter - allow disabling of
1504
hooks, used when pushing to a master branch.
1506
result = PullResult()
1507
result.source_branch = source
1508
result.target_branch = self
1511
result.old_revno, result.old_revid = self.last_revision_info()
1513
self.update_revisions(source, stop_revision)
1514
except DivergedBranches:
1518
if stop_revision is None:
1519
stop_revision = source.last_revision()
1520
self.generate_revision_history(stop_revision)
1521
result.tag_conflicts = source.tags.merge_to(self.tags)
1522
result.new_revno, result.new_revid = self.last_revision_info()
1524
result.master_branch = _hook_master
1525
result.local_branch = self
1527
result.master_branch = self
1528
result.local_branch = None
1530
for hook in Branch.hooks['post_pull']:
1536
def _get_parent_location(self):
1537
_locs = ['parent', 'pull', 'x-pull']
1540
return self.control_files.get(l).read().strip('\n')
1546
def push(self, target, overwrite=False, stop_revision=None,
1547
_hook_master=None, _run_hooks=True):
1550
:param _hook_master: Private parameter - set the branch to
1551
be supplied as the master to push hooks.
1552
:param _run_hooks: Private parameter - allow disabling of
1553
hooks, used when pushing to a master branch.
1555
result = PushResult()
1556
result.source_branch = self
1557
result.target_branch = target
1560
result.old_revno, result.old_revid = target.last_revision_info()
1562
target.update_revisions(self, stop_revision)
1563
except DivergedBranches:
1567
target.set_revision_history(self.revision_history())
1568
result.tag_conflicts = self.tags.merge_to(target.tags)
1569
result.new_revno, result.new_revid = target.last_revision_info()
1571
result.master_branch = _hook_master
1572
result.local_branch = target
1574
result.master_branch = target
1575
result.local_branch = None
1577
for hook in Branch.hooks['post_push']:
1583
def get_parent(self):
1584
"""See Branch.get_parent."""
1586
assert self.base[-1] == '/'
1587
parent = self._get_parent_location()
1590
# This is an old-format absolute path to a local branch
1591
# turn it into a url
1592
if parent.startswith('/'):
1593
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1595
return urlutils.join(self.base[:-1], parent)
1596
except errors.InvalidURLJoin, e:
1597
raise errors.InaccessibleParent(parent, self.base)
1599
def get_push_location(self):
1600
"""See Branch.get_push_location."""
1601
push_loc = self.get_config().get_user_option('push_location')
1604
def set_push_location(self, location):
1605
"""See Branch.set_push_location."""
1606
self.get_config().set_user_option(
1607
'push_location', location,
1608
store=_mod_config.STORE_LOCATION_NORECURSE)
1611
def set_parent(self, url):
1612
"""See Branch.set_parent."""
1613
# TODO: Maybe delete old location files?
1614
# URLs should never be unicode, even on the local fs,
1615
# FIXUP this and get_parent in a future branch format bump:
1616
# read and rewrite the file, and have the new format code read
1617
# using .get not .get_utf8. RBC 20060125
1619
if isinstance(url, unicode):
1621
url = url.encode('ascii')
1622
except UnicodeEncodeError:
1623
raise bzrlib.errors.InvalidURL(url,
1624
"Urls must be 7-bit ascii, "
1625
"use bzrlib.urlutils.escape")
1626
url = urlutils.relative_url(self.base, url)
1627
self._set_parent_location(url)
1629
def _set_parent_location(self, url):
1631
self.control_files._transport.delete('parent')
1633
assert isinstance(url, str)
1634
self.control_files.put_bytes('parent', url + '\n')
1636
@deprecated_function(zero_nine)
1637
def tree_config(self):
1638
"""DEPRECATED; call get_config instead.
1639
TreeConfig has become part of BranchConfig."""
1640
return TreeConfig(self)
1643
class BzrBranch5(BzrBranch):
1644
"""A format 5 branch. This supports new features over plan branches.
1646
It has support for a master_branch which is the data for bound branches.
1654
super(BzrBranch5, self).__init__(_format=_format,
1655
_control_files=_control_files,
1657
_repository=_repository)
1660
def pull(self, source, overwrite=False, stop_revision=None,
1662
"""Extends branch.pull to be bound branch aware.
1664
:param _run_hooks: Private parameter used to force hook running
1665
off during bound branch double-pushing.
1667
bound_location = self.get_bound_location()
1668
master_branch = None
1669
if bound_location and source.base != bound_location:
1670
# not pulling from master, so we need to update master.
1671
master_branch = self.get_master_branch()
1672
master_branch.lock_write()
1675
# pull from source into master.
1676
master_branch.pull(source, overwrite, stop_revision,
1678
return super(BzrBranch5, self).pull(source, overwrite,
1679
stop_revision, _hook_master=master_branch,
1680
_run_hooks=_run_hooks)
1683
master_branch.unlock()
1686
def push(self, target, overwrite=False, stop_revision=None):
1687
"""Updates branch.push to be bound branch aware."""
1688
bound_location = target.get_bound_location()
1689
master_branch = None
1690
if bound_location and target.base != bound_location:
1691
# not pushing to master, so we need to update master.
1692
master_branch = target.get_master_branch()
1693
master_branch.lock_write()
1696
# push into the master from this branch.
1697
super(BzrBranch5, self).push(master_branch, overwrite,
1698
stop_revision, _run_hooks=False)
1699
# and push into the target branch from this. Note that we push from
1700
# this branch again, because its considered the highest bandwidth
1702
return super(BzrBranch5, self).push(target, overwrite,
1703
stop_revision, _hook_master=master_branch)
1706
master_branch.unlock()
1708
def get_bound_location(self):
1710
return self.control_files.get_utf8('bound').read()[:-1]
1711
except errors.NoSuchFile:
1715
def get_master_branch(self):
1716
"""Return the branch we are bound to.
1718
:return: Either a Branch, or None
1720
This could memoise the branch, but if thats done
1721
it must be revalidated on each new lock.
1722
So for now we just don't memoise it.
1723
# RBC 20060304 review this decision.
1725
bound_loc = self.get_bound_location()
1729
return Branch.open(bound_loc)
1730
except (errors.NotBranchError, errors.ConnectionError), e:
1731
raise errors.BoundBranchConnectionFailure(
1735
def set_bound_location(self, location):
1736
"""Set the target where this branch is bound to.
1738
:param location: URL to the target branch
1741
self.control_files.put_utf8('bound', location+'\n')
1744
self.control_files._transport.delete('bound')
1750
def bind(self, other):
1751
"""Bind this branch to the branch other.
1753
This does not push or pull data between the branches, though it does
1754
check for divergence to raise an error when the branches are not
1755
either the same, or one a prefix of the other. That behaviour may not
1756
be useful, so that check may be removed in future.
1758
:param other: The branch to bind to
1761
# TODO: jam 20051230 Consider checking if the target is bound
1762
# It is debatable whether you should be able to bind to
1763
# a branch which is itself bound.
1764
# Committing is obviously forbidden,
1765
# but binding itself may not be.
1766
# Since we *have* to check at commit time, we don't
1767
# *need* to check here
1769
# we want to raise diverged if:
1770
# last_rev is not in the other_last_rev history, AND
1771
# other_last_rev is not in our history, and do it without pulling
1773
last_rev = self.last_revision()
1774
if last_rev is not None:
1777
other_last_rev = other.last_revision()
1778
if other_last_rev is not None:
1779
# neither branch is new, we have to do some work to
1780
# ascertain diversion.
1781
remote_graph = other.repository.get_revision_graph(
1783
local_graph = self.repository.get_revision_graph(last_rev)
1784
if (last_rev not in remote_graph and
1785
other_last_rev not in local_graph):
1786
raise errors.DivergedBranches(self, other)
1789
self.set_bound_location(other.base)
1793
"""If bound, unbind"""
1794
return self.set_bound_location(None)
1798
"""Synchronise this branch with the master branch if any.
1800
:return: None or the last_revision that was pivoted out during the
1803
master = self.get_master_branch()
1804
if master is not None:
1805
old_tip = self.last_revision()
1806
self.pull(master, overwrite=True)
1807
if old_tip in self.repository.get_ancestry(self.last_revision()):
1813
class BzrBranchExperimental(BzrBranch5):
1814
"""Bzr experimental branch format
1817
- a revision-history file.
1819
- a lock dir guarding the branch itself
1820
- all of this stored in a branch/ subdirectory
1821
- works with shared repositories.
1822
- a tag dictionary in the branch
1824
This format is new in bzr 0.15, but shouldn't be used for real data,
1827
This class acts as it's own BranchFormat.
1830
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1833
def get_format_string(cls):
1834
"""See BranchFormat.get_format_string()."""
1835
return "Bazaar-NG branch format experimental\n"
1838
def get_format_description(cls):
1839
"""See BranchFormat.get_format_description()."""
1840
return "Experimental branch format"
1843
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1845
branch_transport = a_bzrdir.get_branch_transport(cls)
1846
control_files = lockable_files.LockableFiles(branch_transport,
1847
lock_filename, lock_class)
1848
control_files.create_lock()
1849
control_files.lock_write()
1851
for filename, content in utf8_files:
1852
control_files.put_utf8(filename, content)
1854
control_files.unlock()
1857
def initialize(cls, a_bzrdir):
1858
"""Create a branch of this format in a_bzrdir."""
1859
utf8_files = [('format', cls.get_format_string()),
1860
('revision-history', ''),
1861
('branch-name', ''),
1864
cls._initialize_control_files(a_bzrdir, utf8_files,
1865
'lock', lockdir.LockDir)
1866
return cls.open(a_bzrdir, _found=True)
1869
def open(cls, a_bzrdir, _found=False):
1870
"""Return the branch object for a_bzrdir
1872
_found is a private parameter, do not use it. It is used to indicate
1873
if format probing has already be done.
1876
format = BranchFormat.find_format(a_bzrdir)
1877
assert format.__class__ == cls
1878
transport = a_bzrdir.get_branch_transport(None)
1879
control_files = lockable_files.LockableFiles(transport, 'lock',
1881
return cls(_format=cls,
1882
_control_files=control_files,
1884
_repository=a_bzrdir.find_repository())
1887
def is_supported(cls):
1890
def _make_tags(self):
1891
return BasicTags(self)
1894
def supports_tags(cls):
1898
BranchFormat.register_format(BzrBranchExperimental)
1901
class BzrBranch6(BzrBranch5):
1904
def last_revision_info(self):
1905
revision_string = self.control_files.get('last-revision').read()
1906
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1907
revision_id = cache_utf8.get_cached_utf8(revision_id)
1909
return revno, revision_id
1911
def last_revision(self):
1912
"""Return last revision id, or None"""
1913
revision_id = self.last_revision_info()[1]
1914
if revision_id == _mod_revision.NULL_REVISION:
1918
def _write_last_revision_info(self, revno, revision_id):
1919
"""Simply write out the revision id, with no checks.
1921
Use set_last_revision_info to perform this safely.
1923
Does not update the revision_history cache.
1924
Intended to be called by set_last_revision_info and
1925
_write_revision_history.
1927
if revision_id is None:
1928
revision_id = 'null:'
1929
out_string = '%d %s\n' % (revno, revision_id)
1930
self.control_files.put_bytes('last-revision', out_string)
1933
def set_last_revision_info(self, revno, revision_id):
1934
revision_id = osutils.safe_revision_id(revision_id)
1935
if self._get_append_revisions_only():
1936
self._check_history_violation(revision_id)
1937
self._write_last_revision_info(revno, revision_id)
1938
self._clear_cached_state()
1940
def _check_history_violation(self, revision_id):
1941
last_revision = self.last_revision()
1942
if last_revision is None:
1944
if last_revision not in self._lefthand_history(revision_id):
1945
raise errors.AppendRevisionsOnlyViolation(self.base)
1947
def _gen_revision_history(self):
1948
"""Generate the revision history from last revision
1950
history = list(self.repository.iter_reverse_revision_history(
1951
self.last_revision()))
1955
def _write_revision_history(self, history):
1956
"""Factored out of set_revision_history.
1958
This performs the actual writing to disk, with format-specific checks.
1959
It is intended to be called by BzrBranch5.set_revision_history.
1961
if len(history) == 0:
1962
last_revision = 'null:'
1964
if history != self._lefthand_history(history[-1]):
1965
raise errors.NotLefthandHistory(history)
1966
last_revision = history[-1]
1967
if self._get_append_revisions_only():
1968
self._check_history_violation(last_revision)
1969
self._write_last_revision_info(len(history), last_revision)
1972
def append_revision(self, *revision_ids):
1973
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1974
if len(revision_ids) == 0:
1976
prev_revno, prev_revision = self.last_revision_info()
1977
for revision in self.repository.get_revisions(revision_ids):
1978
if prev_revision == _mod_revision.NULL_REVISION:
1979
if revision.parent_ids != []:
1980
raise errors.NotLeftParentDescendant(self, prev_revision,
1981
revision.revision_id)
1983
if revision.parent_ids[0] != prev_revision:
1984
raise errors.NotLeftParentDescendant(self, prev_revision,
1985
revision.revision_id)
1986
prev_revision = revision.revision_id
1987
self.set_last_revision_info(prev_revno + len(revision_ids),
1991
def _set_parent_location(self, url):
1992
"""Set the parent branch"""
1993
self._set_config_location('parent_location', url, make_relative=True)
1996
def _get_parent_location(self):
1997
"""Set the parent branch"""
1998
return self._get_config_location('parent_location')
2000
def set_push_location(self, location):
2001
"""See Branch.set_push_location."""
2002
self._set_config_location('push_location', location)
2004
def set_bound_location(self, location):
2005
"""See Branch.set_push_location."""
2007
config = self.get_config()
2008
if location is None:
2009
if config.get_user_option('bound') != 'True':
2012
config.set_user_option('bound', 'False')
2015
self._set_config_location('bound_location', location,
2017
config.set_user_option('bound', 'True')
2020
def _get_bound_location(self, bound):
2021
"""Return the bound location in the config file.
2023
Return None if the bound parameter does not match"""
2024
config = self.get_config()
2025
config_bound = (config.get_user_option('bound') == 'True')
2026
if config_bound != bound:
2028
return self._get_config_location('bound_location', config=config)
2030
def get_bound_location(self):
2031
"""See Branch.set_push_location."""
2032
return self._get_bound_location(True)
2034
def get_old_bound_location(self):
2035
"""See Branch.get_old_bound_location"""
2036
return self._get_bound_location(False)
2038
def set_append_revisions_only(self, enabled):
2043
self.get_config().set_user_option('append_revisions_only', value)
2045
def _get_append_revisions_only(self):
2046
value = self.get_config().get_user_option('append_revisions_only')
2047
return value == 'True'
2049
def _synchronize_history(self, destination, revision_id):
2050
"""Synchronize last revision and revision history between branches.
2052
This version is most efficient when the destination is also a
2053
BzrBranch6, but works for BzrBranch5, as long as the destination's
2054
repository contains all the lefthand ancestors of the intended
2055
last_revision. If not, set_last_revision_info will fail.
2057
:param destination: The branch to copy the history into
2058
:param revision_id: The revision-id to truncate history at. May
2059
be None to copy complete history.
2061
if revision_id is None:
2062
revno, revision_id = self.last_revision_info()
2064
revno = self.revision_id_to_revno(revision_id)
2065
destination.set_last_revision_info(revno, revision_id)
2067
def _make_tags(self):
2068
return BasicTags(self)
2071
class BranchTestProviderAdapter(object):
2072
"""A tool to generate a suite testing multiple branch formats at once.
2074
This is done by copying the test once for each transport and injecting
2075
the transport_server, transport_readonly_server, and branch_format
2076
classes into each copy. Each copy is also given a new id() to make it
2080
def __init__(self, transport_server, transport_readonly_server, formats):
2081
self._transport_server = transport_server
2082
self._transport_readonly_server = transport_readonly_server
2083
self._formats = formats
2085
def adapt(self, test):
2086
result = TestSuite()
2087
for branch_format, bzrdir_format in self._formats:
2088
new_test = deepcopy(test)
2089
new_test.transport_server = self._transport_server
2090
new_test.transport_readonly_server = self._transport_readonly_server
2091
new_test.bzrdir_format = bzrdir_format
2092
new_test.branch_format = branch_format
2093
def make_new_test_id():
2094
# the format can be either a class or an instance
2095
name = getattr(branch_format, '__name__',
2096
branch_format.__class__.__name__)
2097
new_id = "%s(%s)" % (new_test.id(), name)
2098
return lambda: new_id
2099
new_test.id = make_new_test_id()
2100
result.addTest(new_test)
2104
######################################################################
2105
# results of operations
2108
class _Result(object):
2110
def _show_tag_conficts(self, to_file):
2111
if not getattr(self, 'tag_conflicts', None):
2113
to_file.write('Conflicting tags:\n')
2114
for name, value1, value2 in self.tag_conflicts:
2115
to_file.write(' %s\n' % (name, ))
2118
class PullResult(_Result):
2119
"""Result of a Branch.pull operation.
2121
:ivar old_revno: Revision number before pull.
2122
:ivar new_revno: Revision number after pull.
2123
:ivar old_revid: Tip revision id before pull.
2124
:ivar new_revid: Tip revision id after pull.
2125
:ivar source_branch: Source (local) branch object.
2126
:ivar master_branch: Master branch of the target, or None.
2127
:ivar target_branch: Target/destination branch object.
2131
# DEPRECATED: pull used to return the change in revno
2132
return self.new_revno - self.old_revno
2134
def report(self, to_file):
2135
if self.old_revid == self.new_revid:
2136
to_file.write('No revisions to pull.\n')
2138
to_file.write('Now on revision %d.\n' % self.new_revno)
2139
self._show_tag_conficts(to_file)
2142
class PushResult(_Result):
2143
"""Result of a Branch.push operation.
2145
:ivar old_revno: Revision number before push.
2146
:ivar new_revno: Revision number after push.
2147
:ivar old_revid: Tip revision id before push.
2148
:ivar new_revid: Tip revision id after push.
2149
:ivar source_branch: Source branch object.
2150
:ivar master_branch: Master branch of the target, or None.
2151
:ivar target_branch: Target/destination branch object.
2155
# DEPRECATED: push used to return the change in revno
2156
return self.new_revno - self.old_revno
2158
def report(self, to_file):
2159
"""Write a human-readable description of the result."""
2160
if self.old_revid == self.new_revid:
2161
to_file.write('No new revisions to push.\n')
2163
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2164
self._show_tag_conficts(to_file)
2167
class BranchCheckResult(object):
2168
"""Results of checking branch consistency.
2173
def __init__(self, branch):
2174
self.branch = branch
2176
def report_results(self, verbose):
2177
"""Report the check results via trace.note.
2179
:param verbose: Requests more detailed display of what was checked,
2182
note('checked branch %s format %s',
2184
self.branch._format)
2187
class Converter5to6(object):
2188
"""Perform an in-place upgrade of format 5 to format 6"""
2190
def convert(self, branch):
2191
# Data for 5 and 6 can peacefully coexist.
2192
format = BzrBranchFormat6()
2193
new_branch = format.open(branch.bzrdir, _found=True)
2195
# Copy source data into target
2196
new_branch.set_last_revision_info(*branch.last_revision_info())
2197
new_branch.set_parent(branch.get_parent())
2198
new_branch.set_bound_location(branch.get_bound_location())
2199
new_branch.set_push_location(branch.get_push_location())
2201
# New branch has no tags by default
2202
new_branch.tags._set_tag_dict({})
2204
# Copying done; now update target format
2205
new_branch.control_files.put_utf8('format',
2206
format.get_format_string())
2208
# Clean up old files
2209
new_branch.control_files._transport.delete('revision-history')
2211
branch.set_parent(None)
2214
branch.set_bound_location(None)
added
removed
bzrlib/branch.py
