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 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
def get_root_id(self):
301
"""Return the id of this branches root"""
302
raise NotImplementedError(self.get_root_id)
304
def print_file(self, file, revision_id):
305
"""Print `file` to stdout."""
306
raise NotImplementedError(self.print_file)
308
def append_revision(self, *revision_ids):
309
raise NotImplementedError(self.append_revision)
311
def set_revision_history(self, rev_history):
312
raise NotImplementedError(self.set_revision_history)
314
def _cache_revision_history(self, rev_history):
315
"""Set the cached revision history to rev_history.
317
The revision_history method will use this cache to avoid regenerating
318
the revision history.
320
This API is semi-public; it only for use by subclasses, all other code
321
should consider it to be private.
323
self._revision_history_cache = rev_history
325
def _clear_cached_state(self):
326
"""Clear any cached data on this branch, e.g. cached revision history.
328
This means the next call to revision_history will need to call
329
_gen_revision_history.
331
This API is semi-public; it only for use by subclasses, all other code
332
should consider it to be private.
334
self._revision_history_cache = None
336
def _gen_revision_history(self):
337
"""Return sequence of revision hashes on to this branch.
339
Unlike revision_history, this method always regenerates or rereads the
340
revision history, i.e. it does not cache the result, so repeated calls
343
Concrete subclasses should override this instead of revision_history so
344
that subclasses do not need to deal with caching logic.
346
This API is semi-public; it only for use by subclasses, all other code
347
should consider it to be private.
349
raise NotImplementedError(self._gen_revision_history)
352
def revision_history(self):
353
"""Return sequence of revision hashes on to this branch.
355
This method will cache the revision history for as long as it is safe to
358
if self._revision_history_cache is not None:
359
history = self._revision_history_cache
361
history = self._gen_revision_history()
362
self._cache_revision_history(history)
366
"""Return current revision number for this branch.
368
That is equivalent to the number of revisions committed to
371
return len(self.revision_history())
374
"""Older format branches cannot bind or unbind."""
375
raise errors.UpgradeRequired(self.base)
377
def set_append_revisions_only(self, enabled):
378
"""Older format branches are never restricted to append-only"""
379
raise errors.UpgradeRequired(self.base)
381
def last_revision(self):
382
"""Return last revision id, or None"""
383
ph = self.revision_history()
389
def last_revision_info(self):
390
"""Return information about the last revision.
392
:return: A tuple (revno, last_revision_id).
394
rh = self.revision_history()
397
return (revno, rh[-1])
399
return (0, _mod_revision.NULL_REVISION)
401
def missing_revisions(self, other, stop_revision=None):
402
"""Return a list of new revisions that would perfectly fit.
404
If self and other have not diverged, return a list of the revisions
405
present in other, but missing from self.
407
self_history = self.revision_history()
408
self_len = len(self_history)
409
other_history = other.revision_history()
410
other_len = len(other_history)
411
common_index = min(self_len, other_len) -1
412
if common_index >= 0 and \
413
self_history[common_index] != other_history[common_index]:
414
raise DivergedBranches(self, other)
416
if stop_revision is None:
417
stop_revision = other_len
419
assert isinstance(stop_revision, int)
420
if stop_revision > other_len:
421
raise errors.NoSuchRevision(self, stop_revision)
422
return other_history[self_len:stop_revision]
424
def update_revisions(self, other, stop_revision=None):
425
"""Pull in new perfect-fit revisions.
427
:param other: Another Branch to pull from
428
:param stop_revision: Updated until the given revision
431
raise NotImplementedError(self.update_revisions)
433
def revision_id_to_revno(self, revision_id):
434
"""Given a revision id, return its revno"""
435
if revision_id is None:
437
revision_id = osutils.safe_revision_id(revision_id)
438
history = self.revision_history()
440
return history.index(revision_id) + 1
442
raise bzrlib.errors.NoSuchRevision(self, revision_id)
444
def get_rev_id(self, revno, history=None):
445
"""Find the revision id of the specified revno."""
449
history = self.revision_history()
450
if revno <= 0 or revno > len(history):
451
raise bzrlib.errors.NoSuchRevision(self, revno)
452
return history[revno - 1]
454
def pull(self, source, overwrite=False, stop_revision=None):
455
"""Mirror source into this branch.
457
This branch is considered to be 'local', having low latency.
459
:returns: PullResult instance
461
raise NotImplementedError(self.pull)
463
def push(self, target, overwrite=False, stop_revision=None):
464
"""Mirror this branch into target.
466
This branch is considered to be 'local', having low latency.
468
raise NotImplementedError(self.push)
470
def basis_tree(self):
471
"""Return `Tree` object for last revision."""
472
return self.repository.revision_tree(self.last_revision())
474
def rename_one(self, from_rel, to_rel):
477
This can change the directory or the filename or both.
479
raise NotImplementedError(self.rename_one)
481
def move(self, from_paths, to_name):
484
to_name must exist as a versioned directory.
486
If to_name exists and is a directory, the files are moved into
487
it, keeping their old names. If it is a directory,
489
Note that to_name is only the last component of the new name;
490
this doesn't change the directory.
492
This returns a list of (from_path, to_path) pairs for each
495
raise NotImplementedError(self.move)
497
def get_parent(self):
498
"""Return the parent location of the branch.
500
This is the default location for push/pull/missing. The usual
501
pattern is that the user can override it by specifying a
504
raise NotImplementedError(self.get_parent)
506
def _set_config_location(self, name, url, config=None,
507
make_relative=False):
509
config = self.get_config()
513
url = urlutils.relative_url(self.base, url)
514
config.set_user_option(name, url)
516
def _get_config_location(self, name, config=None):
518
config = self.get_config()
519
location = config.get_user_option(name)
524
def get_submit_branch(self):
525
"""Return the submit location of the branch.
527
This is the default location for bundle. The usual
528
pattern is that the user can override it by specifying a
531
return self.get_config().get_user_option('submit_branch')
533
def set_submit_branch(self, location):
534
"""Return the submit location of the branch.
536
This is the default location for bundle. The usual
537
pattern is that the user can override it by specifying a
540
self.get_config().set_user_option('submit_branch', location)
542
def get_public_branch(self):
543
"""Return the public location of the branch.
545
This is is used by merge directives.
547
return self._get_config_location('public_branch')
549
def set_public_branch(self, location):
550
"""Return the submit location of the branch.
552
This is the default location for bundle. The usual
553
pattern is that the user can override it by specifying a
556
self._set_config_location('public_branch', location)
558
def get_push_location(self):
559
"""Return the None or the location to push this branch to."""
560
raise NotImplementedError(self.get_push_location)
562
def set_push_location(self, location):
563
"""Set a new push location for this branch."""
564
raise NotImplementedError(self.set_push_location)
566
def set_parent(self, url):
567
raise NotImplementedError(self.set_parent)
571
"""Synchronise this branch with the master branch if any.
573
:return: None or the last_revision pivoted out during the update.
577
def check_revno(self, revno):
579
Check whether a revno corresponds to any revision.
580
Zero (the NULL revision) is considered valid.
583
self.check_real_revno(revno)
585
def check_real_revno(self, revno):
587
Check whether a revno corresponds to a real revision.
588
Zero (the NULL revision) is considered invalid
590
if revno < 1 or revno > self.revno():
591
raise InvalidRevisionNumber(revno)
594
def clone(self, to_bzrdir, revision_id=None):
595
"""Clone this branch into to_bzrdir preserving all semantic values.
597
revision_id: if not None, the revision history in the new branch will
598
be truncated to end with revision_id.
600
result = self._format.initialize(to_bzrdir)
601
self.copy_content_into(result, revision_id=revision_id)
605
def sprout(self, to_bzrdir, revision_id=None):
606
"""Create a new line of development from the branch, into to_bzrdir.
608
revision_id: if not None, the revision history in the new branch will
609
be truncated to end with revision_id.
611
result = self._format.initialize(to_bzrdir)
612
self.copy_content_into(result, revision_id=revision_id)
613
result.set_parent(self.bzrdir.root_transport.base)
616
def _synchronize_history(self, destination, revision_id):
617
"""Synchronize last revision and revision history between branches.
619
This version is most efficient when the destination is also a
620
BzrBranch5, but works for BzrBranch6 as long as the revision
621
history is the true lefthand parent history, and all of the revisions
622
are in the destination's repository. If not, set_revision_history
625
:param destination: The branch to copy the history into
626
:param revision_id: The revision-id to truncate history at. May
627
be None to copy complete history.
629
new_history = self.revision_history()
630
if revision_id is not None:
631
revision_id = osutils.safe_revision_id(revision_id)
633
new_history = new_history[:new_history.index(revision_id) + 1]
635
rev = self.repository.get_revision(revision_id)
636
new_history = rev.get_history(self.repository)[1:]
637
destination.set_revision_history(new_history)
640
def copy_content_into(self, destination, revision_id=None):
641
"""Copy the content of self into destination.
643
revision_id: if not None, the revision history in the new branch will
644
be truncated to end with revision_id.
646
self._synchronize_history(destination, revision_id)
648
parent = self.get_parent()
649
except errors.InaccessibleParent, e:
650
mutter('parent was not accessible to copy: %s', e)
653
destination.set_parent(parent)
654
self.tags.merge_to(destination.tags)
658
"""Check consistency of the branch.
660
In particular this checks that revisions given in the revision-history
661
do actually match up in the revision graph, and that they're all
662
present in the repository.
664
Callers will typically also want to check the repository.
666
:return: A BranchCheckResult.
668
mainline_parent_id = None
669
for revision_id in self.revision_history():
671
revision = self.repository.get_revision(revision_id)
672
except errors.NoSuchRevision, e:
673
raise errors.BzrCheckError("mainline revision {%s} not in repository"
675
# In general the first entry on the revision history has no parents.
676
# But it's not illegal for it to have parents listed; this can happen
677
# in imports from Arch when the parents weren't reachable.
678
if mainline_parent_id is not None:
679
if mainline_parent_id not in revision.parent_ids:
680
raise errors.BzrCheckError("previous revision {%s} not listed among "
682
% (mainline_parent_id, revision_id))
683
mainline_parent_id = revision_id
684
return BranchCheckResult(self)
686
def _get_checkout_format(self):
687
"""Return the most suitable metadir for a checkout of this branch.
688
Weaves are used if this branch's repostory uses weaves.
690
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
691
from bzrlib.repofmt import weaverepo
692
format = bzrdir.BzrDirMetaFormat1()
693
format.repository_format = weaverepo.RepositoryFormat7()
695
format = self.repository.bzrdir.checkout_metadir()
696
format.set_branch_format(self._format)
699
def create_checkout(self, to_location, revision_id=None,
701
"""Create a checkout of a branch.
703
:param to_location: The url to produce the checkout at
704
:param revision_id: The revision to check out
705
:param lightweight: If True, produce a lightweight checkout, otherwise,
706
produce a bound branch (heavyweight checkout)
707
:return: The tree of the created checkout
709
t = transport.get_transport(to_location)
712
except errors.FileExists:
715
format = self._get_checkout_format()
716
checkout = format.initialize_on_transport(t)
717
BranchReferenceFormat().initialize(checkout, self)
719
format = self._get_checkout_format()
720
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
721
to_location, force_new_tree=False, format=format)
722
checkout = checkout_branch.bzrdir
723
checkout_branch.bind(self)
724
# pull up to the specified revision_id to set the initial
725
# branch tip correctly, and seed it with history.
726
checkout_branch.pull(self, stop_revision=revision_id)
727
tree = checkout.create_workingtree(revision_id)
728
basis_tree = tree.basis_tree()
729
basis_tree.lock_read()
731
for path, file_id in basis_tree.iter_references():
732
reference_parent = self.reference_parent(file_id, path)
733
reference_parent.create_checkout(tree.abspath(path),
734
basis_tree.get_reference_revision(file_id, path),
740
def reference_parent(self, file_id, path):
741
"""Return the parent branch for a tree-reference file_id
742
:param file_id: The file_id of the tree reference
743
:param path: The path of the file_id in the tree
744
:return: A branch associated with the file_id
746
# FIXME should provide multiple branches, based on config
747
return Branch.open(self.bzrdir.root_transport.clone(path).base)
749
def supports_tags(self):
750
return self._format.supports_tags()
753
class BranchFormat(object):
754
"""An encapsulation of the initialization and open routines for a format.
756
Formats provide three things:
757
* An initialization routine,
761
Formats are placed in an dict by their format string for reference
762
during branch opening. Its not required that these be instances, they
763
can be classes themselves with class methods - it simply depends on
764
whether state is needed for a given format or not.
766
Once a format is deprecated, just deprecate the initialize and open
767
methods on the format class. Do not deprecate the object, as the
768
object will be created every time regardless.
771
_default_format = None
772
"""The default format used for new branches."""
775
"""The known formats."""
778
def find_format(klass, a_bzrdir):
779
"""Return the format for the branch object in a_bzrdir."""
781
transport = a_bzrdir.get_branch_transport(None)
782
format_string = transport.get("format").read()
783
return klass._formats[format_string]
785
raise NotBranchError(path=transport.base)
787
raise errors.UnknownFormatError(format=format_string)
790
def get_default_format(klass):
791
"""Return the current default format."""
792
return klass._default_format
794
def get_format_string(self):
795
"""Return the ASCII format string that identifies this format."""
796
raise NotImplementedError(self.get_format_string)
798
def get_format_description(self):
799
"""Return the short format description for this format."""
800
raise NotImplementedError(self.get_format_description)
802
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
804
"""Initialize a branch in a bzrdir, with specified files
806
:param a_bzrdir: The bzrdir to initialize the branch in
807
:param utf8_files: The files to create as a list of
808
(filename, content) tuples
809
:param set_format: If True, set the format with
810
self.get_format_string. (BzrBranch4 has its format set
812
:return: a branch in this format
814
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
815
branch_transport = a_bzrdir.get_branch_transport(self)
817
'metadir': ('lock', lockdir.LockDir),
818
'branch4': ('branch-lock', lockable_files.TransportLock),
820
lock_name, lock_class = lock_map[lock_type]
821
control_files = lockable_files.LockableFiles(branch_transport,
822
lock_name, lock_class)
823
control_files.create_lock()
824
control_files.lock_write()
826
control_files.put_utf8('format', self.get_format_string())
828
for file, content in utf8_files:
829
control_files.put_utf8(file, content)
831
control_files.unlock()
832
return self.open(a_bzrdir, _found=True)
834
def initialize(self, a_bzrdir):
835
"""Create a branch of this format in a_bzrdir."""
836
raise NotImplementedError(self.initialize)
838
def is_supported(self):
839
"""Is this format supported?
841
Supported formats can be initialized and opened.
842
Unsupported formats may not support initialization or committing or
843
some other features depending on the reason for not being supported.
847
def open(self, a_bzrdir, _found=False):
848
"""Return the branch object for a_bzrdir
850
_found is a private parameter, do not use it. It is used to indicate
851
if format probing has already be done.
853
raise NotImplementedError(self.open)
856
def register_format(klass, format):
857
klass._formats[format.get_format_string()] = format
860
def set_default_format(klass, format):
861
klass._default_format = format
864
def unregister_format(klass, format):
865
assert klass._formats[format.get_format_string()] is format
866
del klass._formats[format.get_format_string()]
869
return self.get_format_string().rstrip()
871
def supports_tags(self):
872
"""True if this format supports tags stored in the branch"""
873
return False # by default
875
# XXX: Probably doesn't really belong here -- mbp 20070212
876
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
878
branch_transport = a_bzrdir.get_branch_transport(self)
879
control_files = lockable_files.LockableFiles(branch_transport,
880
lock_filename, lock_class)
881
control_files.create_lock()
882
control_files.lock_write()
884
for filename, content in utf8_files:
885
control_files.put_utf8(filename, content)
887
control_files.unlock()
890
class BranchHooks(dict):
891
"""A dictionary mapping hook name to a list of callables for branch hooks.
893
e.g. ['set_rh'] Is the list of items to be called when the
894
set_revision_history function is invoked.
898
"""Create the default hooks.
900
These are all empty initially, because by default nothing should get
904
# Introduced in 0.15:
905
# invoked whenever the revision history has been set
906
# with set_revision_history. The api signature is
907
# (branch, revision_history), and the branch will
910
# invoked after a push operation completes.
911
# the api signature is
913
# containing the members
914
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
915
# where local is the local branch or None, master is the target
916
# master branch, and the rest should be self explanatory. The source
917
# is read locked and the target branches write locked. Source will
918
# be the local low-latency branch.
919
self['post_push'] = []
920
# invoked after a pull operation completes.
921
# the api signature is
923
# containing the members
924
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
925
# where local is the local branch or None, master is the target
926
# master branch, and the rest should be self explanatory. The source
927
# is read locked and the target branches write locked. The local
928
# branch is the low-latency branch.
929
self['post_pull'] = []
930
# invoked after a commit operation completes.
931
# the api signature is
932
# (local, master, old_revno, old_revid, new_revno, new_revid)
933
# old_revid is NULL_REVISION for the first commit to a branch.
934
self['post_commit'] = []
935
# invoked after a uncommit operation completes.
936
# the api signature is
937
# (local, master, old_revno, old_revid, new_revno, new_revid) where
938
# local is the local branch or None, master is the target branch,
939
# and an empty branch recieves new_revno of 0, new_revid of None.
940
self['post_uncommit'] = []
942
def install_hook(self, hook_name, a_callable):
943
"""Install a_callable in to the hook hook_name.
945
:param hook_name: A hook name. See the __init__ method of BranchHooks
946
for the complete list of hooks.
947
:param a_callable: The callable to be invoked when the hook triggers.
948
The exact signature will depend on the hook - see the __init__
949
method of BranchHooks for details on each hook.
952
self[hook_name].append(a_callable)
954
raise errors.UnknownHook('branch', hook_name)
957
# install the default hooks into the Branch class.
958
Branch.hooks = BranchHooks()
961
class BzrBranchFormat4(BranchFormat):
962
"""Bzr branch format 4.
965
- a revision-history file.
966
- a branch-lock lock file [ to be shared with the bzrdir ]
969
def get_format_description(self):
970
"""See BranchFormat.get_format_description()."""
971
return "Branch format 4"
973
def initialize(self, a_bzrdir):
974
"""Create a branch of this format in a_bzrdir."""
975
utf8_files = [('revision-history', ''),
978
return self._initialize_helper(a_bzrdir, utf8_files,
979
lock_type='branch4', set_format=False)
982
super(BzrBranchFormat4, self).__init__()
983
self._matchingbzrdir = bzrdir.BzrDirFormat6()
985
def open(self, a_bzrdir, _found=False):
986
"""Return the branch object for a_bzrdir
988
_found is a private parameter, do not use it. It is used to indicate
989
if format probing has already be done.
992
# we are being called directly and must probe.
993
raise NotImplementedError
994
return BzrBranch(_format=self,
995
_control_files=a_bzrdir._control_files,
997
_repository=a_bzrdir.open_repository())
1000
return "Bazaar-NG branch format 4"
1003
class BzrBranchFormat5(BranchFormat):
1004
"""Bzr branch format 5.
1007
- a revision-history file.
1009
- a lock dir guarding the branch itself
1010
- all of this stored in a branch/ subdirectory
1011
- works with shared repositories.
1013
This format is new in bzr 0.8.
1016
def get_format_string(self):
1017
"""See BranchFormat.get_format_string()."""
1018
return "Bazaar-NG branch format 5\n"
1020
def get_format_description(self):
1021
"""See BranchFormat.get_format_description()."""
1022
return "Branch format 5"
1024
def initialize(self, a_bzrdir):
1025
"""Create a branch of this format in a_bzrdir."""
1026
utf8_files = [('revision-history', ''),
1027
('branch-name', ''),
1029
return self._initialize_helper(a_bzrdir, utf8_files)
1032
super(BzrBranchFormat5, self).__init__()
1033
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
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
format = BranchFormat.find_format(a_bzrdir)
1043
assert format.__class__ == self.__class__
1044
transport = a_bzrdir.get_branch_transport(None)
1045
control_files = lockable_files.LockableFiles(transport, 'lock',
1047
return BzrBranch5(_format=self,
1048
_control_files=control_files,
1050
_repository=a_bzrdir.find_repository())
1053
class BzrBranchFormat6(BzrBranchFormat5):
1054
"""Branch format with last-revision
1056
Unlike previous formats, this has no explicit revision history. Instead,
1057
this just stores the last-revision, and the left-hand history leading
1058
up to there is the history.
1060
This format was introduced in bzr 0.15
1063
def get_format_string(self):
1064
"""See BranchFormat.get_format_string()."""
1065
return "Bazaar Branch Format 6 (bzr 0.15)\n"
1067
def get_format_description(self):
1068
"""See BranchFormat.get_format_description()."""
1069
return "Branch format 6"
1071
def initialize(self, a_bzrdir):
1072
"""Create a branch of this format in a_bzrdir."""
1073
utf8_files = [('last-revision', '0 null:\n'),
1074
('branch-name', ''),
1075
('branch.conf', ''),
1078
return self._initialize_helper(a_bzrdir, utf8_files)
1080
def open(self, a_bzrdir, _found=False):
1081
"""Return the branch object for a_bzrdir
1083
_found is a private parameter, do not use it. It is used to indicate
1084
if format probing has already be done.
1087
format = BranchFormat.find_format(a_bzrdir)
1088
assert format.__class__ == self.__class__
1089
transport = a_bzrdir.get_branch_transport(None)
1090
control_files = lockable_files.LockableFiles(transport, 'lock',
1092
return BzrBranch6(_format=self,
1093
_control_files=control_files,
1095
_repository=a_bzrdir.find_repository())
1097
def supports_tags(self):
1101
class BranchReferenceFormat(BranchFormat):
1102
"""Bzr branch reference format.
1104
Branch references are used in implementing checkouts, they
1105
act as an alias to the real branch which is at some other url.
1112
def get_format_string(self):
1113
"""See BranchFormat.get_format_string()."""
1114
return "Bazaar-NG Branch Reference Format 1\n"
1116
def get_format_description(self):
1117
"""See BranchFormat.get_format_description()."""
1118
return "Checkout reference format 1"
1120
def initialize(self, a_bzrdir, target_branch=None):
1121
"""Create a branch of this format in a_bzrdir."""
1122
if target_branch is None:
1123
# this format does not implement branch itself, thus the implicit
1124
# creation contract must see it as uninitializable
1125
raise errors.UninitializableFormat(self)
1126
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1127
branch_transport = a_bzrdir.get_branch_transport(self)
1128
branch_transport.put_bytes('location',
1129
target_branch.bzrdir.root_transport.base)
1130
branch_transport.put_bytes('format', self.get_format_string())
1131
return self.open(a_bzrdir, _found=True)
1134
super(BranchReferenceFormat, self).__init__()
1135
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1137
def _make_reference_clone_function(format, a_branch):
1138
"""Create a clone() routine for a branch dynamically."""
1139
def clone(to_bzrdir, revision_id=None):
1140
"""See Branch.clone()."""
1141
return format.initialize(to_bzrdir, a_branch)
1142
# cannot obey revision_id limits when cloning a reference ...
1143
# FIXME RBC 20060210 either nuke revision_id for clone, or
1144
# emit some sort of warning/error to the caller ?!
1147
def open(self, a_bzrdir, _found=False):
1148
"""Return the branch that the branch reference in a_bzrdir points at.
1150
_found is a private parameter, do not use it. It is used to indicate
1151
if format probing has already be done.
1154
format = BranchFormat.find_format(a_bzrdir)
1155
assert format.__class__ == self.__class__
1156
transport = a_bzrdir.get_branch_transport(None)
1157
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1158
result = real_bzrdir.open_branch()
1159
# this changes the behaviour of result.clone to create a new reference
1160
# rather than a copy of the content of the branch.
1161
# I did not use a proxy object because that needs much more extensive
1162
# testing, and we are only changing one behaviour at the moment.
1163
# If we decide to alter more behaviours - i.e. the implicit nickname
1164
# then this should be refactored to introduce a tested proxy branch
1165
# and a subclass of that for use in overriding clone() and ....
1167
result.clone = self._make_reference_clone_function(result)
1171
# formats which have no format string are not discoverable
1172
# and not independently creatable, so are not registered.
1173
__default_format = BzrBranchFormat5()
1174
BranchFormat.register_format(__default_format)
1175
BranchFormat.register_format(BranchReferenceFormat())
1176
BranchFormat.register_format(BzrBranchFormat6())
1177
BranchFormat.set_default_format(__default_format)
1178
_legacy_formats = [BzrBranchFormat4(),
1181
class BzrBranch(Branch):
1182
"""A branch stored in the actual filesystem.
1184
Note that it's "local" in the context of the filesystem; it doesn't
1185
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1186
it's writable, and can be accessed via the normal filesystem API.
1189
def __init__(self, _format=None,
1190
_control_files=None, a_bzrdir=None, _repository=None):
1191
"""Create new branch object at a particular location."""
1192
Branch.__init__(self)
1193
if a_bzrdir is None:
1194
raise ValueError('a_bzrdir must be supplied')
1196
self.bzrdir = a_bzrdir
1197
# self._transport used to point to the directory containing the
1198
# control directory, but was not used - now it's just the transport
1199
# for the branch control files. mbp 20070212
1200
self._base = self.bzrdir.transport.clone('..').base
1201
self._format = _format
1202
if _control_files is None:
1203
raise ValueError('BzrBranch _control_files is None')
1204
self.control_files = _control_files
1205
self._transport = _control_files._transport
1206
self.repository = _repository
1209
return '%s(%r)' % (self.__class__.__name__, self.base)
1213
def _get_base(self):
1214
"""Returns the directory containing the control directory."""
1217
base = property(_get_base, doc="The URL for the root of this branch.")
1219
def abspath(self, name):
1220
"""See Branch.abspath."""
1221
return self.control_files._transport.abspath(name)
1224
def get_root_id(self):
1225
"""See Branch.get_root_id."""
1226
tree = self.repository.revision_tree(self.last_revision())
1227
return tree.inventory.root.file_id
1229
def is_locked(self):
1230
return self.control_files.is_locked()
1232
def lock_write(self):
1233
self.repository.lock_write()
1235
self.control_files.lock_write()
1237
self.repository.unlock()
1240
def lock_read(self):
1241
self.repository.lock_read()
1243
self.control_files.lock_read()
1245
self.repository.unlock()
1249
# TODO: test for failed two phase locks. This is known broken.
1251
self.control_files.unlock()
1253
self.repository.unlock()
1254
if not self.control_files.is_locked():
1255
# we just released the lock
1256
self._clear_cached_state()
1258
def peek_lock_mode(self):
1259
if self.control_files._lock_count == 0:
1262
return self.control_files._lock_mode
1264
def get_physical_lock_status(self):
1265
return self.control_files.get_physical_lock_status()
1268
def print_file(self, file, revision_id):
1269
"""See Branch.print_file."""
1270
return self.repository.print_file(file, revision_id)
1273
def append_revision(self, *revision_ids):
1274
"""See Branch.append_revision."""
1275
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1276
for revision_id in revision_ids:
1277
_mod_revision.check_not_reserved_id(revision_id)
1278
mutter("add {%s} to revision-history" % revision_id)
1279
rev_history = self.revision_history()
1280
rev_history.extend(revision_ids)
1281
self.set_revision_history(rev_history)
1283
def _write_revision_history(self, history):
1284
"""Factored out of set_revision_history.
1286
This performs the actual writing to disk.
1287
It is intended to be called by BzrBranch5.set_revision_history."""
1288
self.control_files.put_bytes(
1289
'revision-history', '\n'.join(history))
1292
def set_revision_history(self, rev_history):
1293
"""See Branch.set_revision_history."""
1294
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1295
self._write_revision_history(rev_history)
1296
self._cache_revision_history(rev_history)
1297
for hook in Branch.hooks['set_rh']:
1298
hook(self, rev_history)
1301
def set_last_revision_info(self, revno, revision_id):
1302
revision_id = osutils.safe_revision_id(revision_id)
1303
history = self._lefthand_history(revision_id)
1304
assert len(history) == revno, '%d != %d' % (len(history), revno)
1305
self.set_revision_history(history)
1307
def _gen_revision_history(self):
1308
history = self.control_files.get('revision-history').read().split('\n')
1309
if history[-1:] == ['']:
1310
# There shouldn't be a trailing newline, but just in case.
1314
def _lefthand_history(self, revision_id, last_rev=None,
1316
# stop_revision must be a descendant of last_revision
1317
stop_graph = self.repository.get_revision_graph(revision_id)
1318
if last_rev is not None and last_rev not in stop_graph:
1319
# our previous tip is not merged into stop_revision
1320
raise errors.DivergedBranches(self, other_branch)
1321
# make a new revision history from the graph
1322
current_rev_id = revision_id
1324
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1325
new_history.append(current_rev_id)
1326
current_rev_id_parents = stop_graph[current_rev_id]
1328
current_rev_id = current_rev_id_parents[0]
1330
current_rev_id = None
1331
new_history.reverse()
1335
def generate_revision_history(self, revision_id, last_rev=None,
1337
"""Create a new revision history that will finish with revision_id.
1339
:param revision_id: the new tip to use.
1340
:param last_rev: The previous last_revision. If not None, then this
1341
must be a ancestory of revision_id, or DivergedBranches is raised.
1342
:param other_branch: The other branch that DivergedBranches should
1343
raise with respect to.
1345
revision_id = osutils.safe_revision_id(revision_id)
1346
self.set_revision_history(self._lefthand_history(revision_id,
1347
last_rev, other_branch))
1350
def update_revisions(self, other, stop_revision=None):
1351
"""See Branch.update_revisions."""
1354
if stop_revision is None:
1355
stop_revision = other.last_revision()
1356
if stop_revision is None:
1357
# if there are no commits, we're done.
1360
stop_revision = osutils.safe_revision_id(stop_revision)
1361
# whats the current last revision, before we fetch [and change it
1363
last_rev = self.last_revision()
1364
# we fetch here regardless of whether we need to so that we pickup
1366
self.fetch(other, stop_revision)
1367
my_ancestry = self.repository.get_ancestry(last_rev)
1368
if stop_revision in my_ancestry:
1369
# last_revision is a descendant of stop_revision
1371
self.generate_revision_history(stop_revision, last_rev=last_rev,
1376
def basis_tree(self):
1377
"""See Branch.basis_tree."""
1378
return self.repository.revision_tree(self.last_revision())
1380
@deprecated_method(zero_eight)
1381
def working_tree(self):
1382
"""Create a Working tree object for this branch."""
1384
from bzrlib.transport.local import LocalTransport
1385
if (self.base.find('://') != -1 or
1386
not isinstance(self._transport, LocalTransport)):
1387
raise NoWorkingTree(self.base)
1388
return self.bzrdir.open_workingtree()
1391
def pull(self, source, overwrite=False, stop_revision=None,
1392
_hook_master=None, _run_hooks=True):
1395
:param _hook_master: Private parameter - set the branch to
1396
be supplied as the master to push hooks.
1397
:param _run_hooks: Private parameter - allow disabling of
1398
hooks, used when pushing to a master branch.
1400
result = PullResult()
1401
result.source_branch = source
1402
result.target_branch = self
1405
result.old_revno, result.old_revid = self.last_revision_info()
1407
self.update_revisions(source, stop_revision)
1408
except DivergedBranches:
1412
if stop_revision is None:
1413
stop_revision = source.last_revision()
1414
self.generate_revision_history(stop_revision)
1415
result.tag_conflicts = source.tags.merge_to(self.tags)
1416
result.new_revno, result.new_revid = self.last_revision_info()
1418
result.master_branch = _hook_master
1419
result.local_branch = self
1421
result.master_branch = self
1422
result.local_branch = None
1424
for hook in Branch.hooks['post_pull']:
1430
def _get_parent_location(self):
1431
_locs = ['parent', 'pull', 'x-pull']
1434
return self.control_files.get(l).read().strip('\n')
1440
def push(self, target, overwrite=False, stop_revision=None,
1441
_hook_master=None, _run_hooks=True):
1444
:param _hook_master: Private parameter - set the branch to
1445
be supplied as the master to push hooks.
1446
:param _run_hooks: Private parameter - allow disabling of
1447
hooks, used when pushing to a master branch.
1449
result = PushResult()
1450
result.source_branch = self
1451
result.target_branch = target
1454
result.old_revno, result.old_revid = target.last_revision_info()
1456
target.update_revisions(self, stop_revision)
1457
except DivergedBranches:
1461
target.set_revision_history(self.revision_history())
1462
result.tag_conflicts = self.tags.merge_to(target.tags)
1463
result.new_revno, result.new_revid = target.last_revision_info()
1465
result.master_branch = _hook_master
1466
result.local_branch = target
1468
result.master_branch = target
1469
result.local_branch = None
1471
for hook in Branch.hooks['post_push']:
1477
def get_parent(self):
1478
"""See Branch.get_parent."""
1480
assert self.base[-1] == '/'
1481
parent = self._get_parent_location()
1484
# This is an old-format absolute path to a local branch
1485
# turn it into a url
1486
if parent.startswith('/'):
1487
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1489
return urlutils.join(self.base[:-1], parent)
1490
except errors.InvalidURLJoin, e:
1491
raise errors.InaccessibleParent(parent, self.base)
1493
def get_push_location(self):
1494
"""See Branch.get_push_location."""
1495
push_loc = self.get_config().get_user_option('push_location')
1498
def set_push_location(self, location):
1499
"""See Branch.set_push_location."""
1500
self.get_config().set_user_option(
1501
'push_location', location,
1502
store=_mod_config.STORE_LOCATION_NORECURSE)
1505
def set_parent(self, url):
1506
"""See Branch.set_parent."""
1507
# TODO: Maybe delete old location files?
1508
# URLs should never be unicode, even on the local fs,
1509
# FIXUP this and get_parent in a future branch format bump:
1510
# read and rewrite the file, and have the new format code read
1511
# using .get not .get_utf8. RBC 20060125
1513
if isinstance(url, unicode):
1515
url = url.encode('ascii')
1516
except UnicodeEncodeError:
1517
raise bzrlib.errors.InvalidURL(url,
1518
"Urls must be 7-bit ascii, "
1519
"use bzrlib.urlutils.escape")
1520
url = urlutils.relative_url(self.base, url)
1521
self._set_parent_location(url)
1523
def _set_parent_location(self, url):
1525
self.control_files._transport.delete('parent')
1527
assert isinstance(url, str)
1528
self.control_files.put_bytes('parent', url + '\n')
1530
@deprecated_function(zero_nine)
1531
def tree_config(self):
1532
"""DEPRECATED; call get_config instead.
1533
TreeConfig has become part of BranchConfig."""
1534
return TreeConfig(self)
1537
class BzrBranch5(BzrBranch):
1538
"""A format 5 branch. This supports new features over plan branches.
1540
It has support for a master_branch which is the data for bound branches.
1548
super(BzrBranch5, self).__init__(_format=_format,
1549
_control_files=_control_files,
1551
_repository=_repository)
1554
def pull(self, source, overwrite=False, stop_revision=None,
1556
"""Extends branch.pull to be bound branch aware.
1558
:param _run_hooks: Private parameter used to force hook running
1559
off during bound branch double-pushing.
1561
bound_location = self.get_bound_location()
1562
master_branch = None
1563
if bound_location and source.base != bound_location:
1564
# not pulling from master, so we need to update master.
1565
master_branch = self.get_master_branch()
1566
master_branch.lock_write()
1569
# pull from source into master.
1570
master_branch.pull(source, overwrite, stop_revision,
1572
return super(BzrBranch5, self).pull(source, overwrite,
1573
stop_revision, _hook_master=master_branch,
1574
_run_hooks=_run_hooks)
1577
master_branch.unlock()
1580
def push(self, target, overwrite=False, stop_revision=None):
1581
"""Updates branch.push to be bound branch aware."""
1582
bound_location = target.get_bound_location()
1583
master_branch = None
1584
if bound_location and target.base != bound_location:
1585
# not pushing to master, so we need to update master.
1586
master_branch = target.get_master_branch()
1587
master_branch.lock_write()
1590
# push into the master from this branch.
1591
super(BzrBranch5, self).push(master_branch, overwrite,
1592
stop_revision, _run_hooks=False)
1593
# and push into the target branch from this. Note that we push from
1594
# this branch again, because its considered the highest bandwidth
1596
return super(BzrBranch5, self).push(target, overwrite,
1597
stop_revision, _hook_master=master_branch)
1600
master_branch.unlock()
1602
def get_bound_location(self):
1604
return self.control_files.get_utf8('bound').read()[:-1]
1605
except errors.NoSuchFile:
1609
def get_master_branch(self):
1610
"""Return the branch we are bound to.
1612
:return: Either a Branch, or None
1614
This could memoise the branch, but if thats done
1615
it must be revalidated on each new lock.
1616
So for now we just don't memoise it.
1617
# RBC 20060304 review this decision.
1619
bound_loc = self.get_bound_location()
1623
return Branch.open(bound_loc)
1624
except (errors.NotBranchError, errors.ConnectionError), e:
1625
raise errors.BoundBranchConnectionFailure(
1629
def set_bound_location(self, location):
1630
"""Set the target where this branch is bound to.
1632
:param location: URL to the target branch
1635
self.control_files.put_utf8('bound', location+'\n')
1638
self.control_files._transport.delete('bound')
1644
def bind(self, other):
1645
"""Bind this branch to the branch other.
1647
This does not push or pull data between the branches, though it does
1648
check for divergence to raise an error when the branches are not
1649
either the same, or one a prefix of the other. That behaviour may not
1650
be useful, so that check may be removed in future.
1652
:param other: The branch to bind to
1655
# TODO: jam 20051230 Consider checking if the target is bound
1656
# It is debatable whether you should be able to bind to
1657
# a branch which is itself bound.
1658
# Committing is obviously forbidden,
1659
# but binding itself may not be.
1660
# Since we *have* to check at commit time, we don't
1661
# *need* to check here
1663
# we want to raise diverged if:
1664
# last_rev is not in the other_last_rev history, AND
1665
# other_last_rev is not in our history, and do it without pulling
1667
last_rev = self.last_revision()
1668
if last_rev is not None:
1671
other_last_rev = other.last_revision()
1672
if other_last_rev is not None:
1673
# neither branch is new, we have to do some work to
1674
# ascertain diversion.
1675
remote_graph = other.repository.get_revision_graph(
1677
local_graph = self.repository.get_revision_graph(last_rev)
1678
if (last_rev not in remote_graph and
1679
other_last_rev not in local_graph):
1680
raise errors.DivergedBranches(self, other)
1683
self.set_bound_location(other.base)
1687
"""If bound, unbind"""
1688
return self.set_bound_location(None)
1692
"""Synchronise this branch with the master branch if any.
1694
:return: None or the last_revision that was pivoted out during the
1697
master = self.get_master_branch()
1698
if master is not None:
1699
old_tip = self.last_revision()
1700
self.pull(master, overwrite=True)
1701
if old_tip in self.repository.get_ancestry(self.last_revision()):
1707
class BzrBranchExperimental(BzrBranch5):
1708
"""Bzr experimental branch format
1711
- a revision-history file.
1713
- a lock dir guarding the branch itself
1714
- all of this stored in a branch/ subdirectory
1715
- works with shared repositories.
1716
- a tag dictionary in the branch
1718
This format is new in bzr 0.15, but shouldn't be used for real data,
1721
This class acts as it's own BranchFormat.
1724
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1727
def get_format_string(cls):
1728
"""See BranchFormat.get_format_string()."""
1729
return "Bazaar-NG branch format experimental\n"
1732
def get_format_description(cls):
1733
"""See BranchFormat.get_format_description()."""
1734
return "Experimental branch format"
1737
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1739
branch_transport = a_bzrdir.get_branch_transport(cls)
1740
control_files = lockable_files.LockableFiles(branch_transport,
1741
lock_filename, lock_class)
1742
control_files.create_lock()
1743
control_files.lock_write()
1745
for filename, content in utf8_files:
1746
control_files.put_utf8(filename, content)
1748
control_files.unlock()
1751
def initialize(cls, a_bzrdir):
1752
"""Create a branch of this format in a_bzrdir."""
1753
utf8_files = [('format', cls.get_format_string()),
1754
('revision-history', ''),
1755
('branch-name', ''),
1758
cls._initialize_control_files(a_bzrdir, utf8_files,
1759
'lock', lockdir.LockDir)
1760
return cls.open(a_bzrdir, _found=True)
1763
def open(cls, a_bzrdir, _found=False):
1764
"""Return the branch object for a_bzrdir
1766
_found is a private parameter, do not use it. It is used to indicate
1767
if format probing has already be done.
1770
format = BranchFormat.find_format(a_bzrdir)
1771
assert format.__class__ == cls
1772
transport = a_bzrdir.get_branch_transport(None)
1773
control_files = lockable_files.LockableFiles(transport, 'lock',
1775
return cls(_format=cls,
1776
_control_files=control_files,
1778
_repository=a_bzrdir.find_repository())
1781
def is_supported(cls):
1784
def _make_tags(self):
1785
return BasicTags(self)
1788
def supports_tags(cls):
1792
BranchFormat.register_format(BzrBranchExperimental)
1795
class BzrBranch6(BzrBranch5):
1798
def last_revision_info(self):
1799
revision_string = self.control_files.get('last-revision').read()
1800
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1801
revision_id = cache_utf8.get_cached_utf8(revision_id)
1803
return revno, revision_id
1805
def last_revision(self):
1806
"""Return last revision id, or None"""
1807
revision_id = self.last_revision_info()[1]
1808
if revision_id == _mod_revision.NULL_REVISION:
1812
def _write_last_revision_info(self, revno, revision_id):
1813
"""Simply write out the revision id, with no checks.
1815
Use set_last_revision_info to perform this safely.
1817
Does not update the revision_history cache.
1818
Intended to be called by set_last_revision_info and
1819
_write_revision_history.
1821
if revision_id is None:
1822
revision_id = 'null:'
1823
out_string = '%d %s\n' % (revno, revision_id)
1824
self.control_files.put_bytes('last-revision', out_string)
1827
def set_last_revision_info(self, revno, revision_id):
1828
revision_id = osutils.safe_revision_id(revision_id)
1829
if self._get_append_revisions_only():
1830
self._check_history_violation(revision_id)
1831
self._write_last_revision_info(revno, revision_id)
1832
self._clear_cached_state()
1834
def _check_history_violation(self, revision_id):
1835
last_revision = self.last_revision()
1836
if last_revision is None:
1838
if last_revision not in self._lefthand_history(revision_id):
1839
raise errors.AppendRevisionsOnlyViolation(self.base)
1841
def _gen_revision_history(self):
1842
"""Generate the revision history from last revision
1844
history = list(self.repository.iter_reverse_revision_history(
1845
self.last_revision()))
1849
def _write_revision_history(self, history):
1850
"""Factored out of set_revision_history.
1852
This performs the actual writing to disk, with format-specific checks.
1853
It is intended to be called by BzrBranch5.set_revision_history.
1855
if len(history) == 0:
1856
last_revision = 'null:'
1858
if history != self._lefthand_history(history[-1]):
1859
raise errors.NotLefthandHistory(history)
1860
last_revision = history[-1]
1861
if self._get_append_revisions_only():
1862
self._check_history_violation(last_revision)
1863
self._write_last_revision_info(len(history), last_revision)
1866
def append_revision(self, *revision_ids):
1867
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1868
if len(revision_ids) == 0:
1870
prev_revno, prev_revision = self.last_revision_info()
1871
for revision in self.repository.get_revisions(revision_ids):
1872
if prev_revision == _mod_revision.NULL_REVISION:
1873
if revision.parent_ids != []:
1874
raise errors.NotLeftParentDescendant(self, prev_revision,
1875
revision.revision_id)
1877
if revision.parent_ids[0] != prev_revision:
1878
raise errors.NotLeftParentDescendant(self, prev_revision,
1879
revision.revision_id)
1880
prev_revision = revision.revision_id
1881
self.set_last_revision_info(prev_revno + len(revision_ids),
1885
def _set_parent_location(self, url):
1886
"""Set the parent branch"""
1887
self._set_config_location('parent_location', url, make_relative=True)
1890
def _get_parent_location(self):
1891
"""Set the parent branch"""
1892
return self._get_config_location('parent_location')
1894
def set_push_location(self, location):
1895
"""See Branch.set_push_location."""
1896
self._set_config_location('push_location', location)
1898
def set_bound_location(self, location):
1899
"""See Branch.set_push_location."""
1901
config = self.get_config()
1902
if location is None:
1903
if config.get_user_option('bound') != 'True':
1906
config.set_user_option('bound', 'False')
1909
self._set_config_location('bound_location', location,
1911
config.set_user_option('bound', 'True')
1914
def _get_bound_location(self, bound):
1915
"""Return the bound location in the config file.
1917
Return None if the bound parameter does not match"""
1918
config = self.get_config()
1919
config_bound = (config.get_user_option('bound') == 'True')
1920
if config_bound != bound:
1922
return self._get_config_location('bound_location', config=config)
1924
def get_bound_location(self):
1925
"""See Branch.set_push_location."""
1926
return self._get_bound_location(True)
1928
def get_old_bound_location(self):
1929
"""See Branch.get_old_bound_location"""
1930
return self._get_bound_location(False)
1932
def set_append_revisions_only(self, enabled):
1937
self.get_config().set_user_option('append_revisions_only', value)
1939
def _get_append_revisions_only(self):
1940
value = self.get_config().get_user_option('append_revisions_only')
1941
return value == 'True'
1943
def _synchronize_history(self, destination, revision_id):
1944
"""Synchronize last revision and revision history between branches.
1946
This version is most efficient when the destination is also a
1947
BzrBranch6, but works for BzrBranch5, as long as the destination's
1948
repository contains all the lefthand ancestors of the intended
1949
last_revision. If not, set_last_revision_info will fail.
1951
:param destination: The branch to copy the history into
1952
:param revision_id: The revision-id to truncate history at. May
1953
be None to copy complete history.
1955
if revision_id is None:
1956
revno, revision_id = self.last_revision_info()
1958
revno = self.revision_id_to_revno(revision_id)
1959
destination.set_last_revision_info(revno, revision_id)
1961
def _make_tags(self):
1962
return BasicTags(self)
1965
class BranchTestProviderAdapter(object):
1966
"""A tool to generate a suite testing multiple branch formats at once.
1968
This is done by copying the test once for each transport and injecting
1969
the transport_server, transport_readonly_server, and branch_format
1970
classes into each copy. Each copy is also given a new id() to make it
1974
def __init__(self, transport_server, transport_readonly_server, formats):
1975
self._transport_server = transport_server
1976
self._transport_readonly_server = transport_readonly_server
1977
self._formats = formats
1979
def adapt(self, test):
1980
result = TestSuite()
1981
for branch_format, bzrdir_format in self._formats:
1982
new_test = deepcopy(test)
1983
new_test.transport_server = self._transport_server
1984
new_test.transport_readonly_server = self._transport_readonly_server
1985
new_test.bzrdir_format = bzrdir_format
1986
new_test.branch_format = branch_format
1987
def make_new_test_id():
1988
# the format can be either a class or an instance
1989
name = getattr(branch_format, '__name__',
1990
branch_format.__class__.__name__)
1991
new_id = "%s(%s)" % (new_test.id(), name)
1992
return lambda: new_id
1993
new_test.id = make_new_test_id()
1994
result.addTest(new_test)
1998
######################################################################
1999
# results of operations
2002
class _Result(object):
2004
def _show_tag_conficts(self, to_file):
2005
if not getattr(self, 'tag_conflicts', None):
2007
to_file.write('Conflicting tags:\n')
2008
for name, value1, value2 in self.tag_conflicts:
2009
to_file.write(' %s\n' % (name, ))
2012
class PullResult(_Result):
2013
"""Result of a Branch.pull operation.
2015
:ivar old_revno: Revision number before pull.
2016
:ivar new_revno: Revision number after pull.
2017
:ivar old_revid: Tip revision id before pull.
2018
:ivar new_revid: Tip revision id after pull.
2019
:ivar source_branch: Source (local) branch object.
2020
:ivar master_branch: Master branch of the target, or None.
2021
:ivar target_branch: Target/destination branch object.
2025
# DEPRECATED: pull used to return the change in revno
2026
return self.new_revno - self.old_revno
2028
def report(self, to_file):
2029
if self.old_revid == self.new_revid:
2030
to_file.write('No revisions to pull.\n')
2032
to_file.write('Now on revision %d.\n' % self.new_revno)
2033
self._show_tag_conficts(to_file)
2036
class PushResult(_Result):
2037
"""Result of a Branch.push operation.
2039
:ivar old_revno: Revision number before push.
2040
:ivar new_revno: Revision number after push.
2041
:ivar old_revid: Tip revision id before push.
2042
:ivar new_revid: Tip revision id after push.
2043
:ivar source_branch: Source branch object.
2044
:ivar master_branch: Master branch of the target, or None.
2045
:ivar target_branch: Target/destination branch object.
2049
# DEPRECATED: push used to return the change in revno
2050
return self.new_revno - self.old_revno
2052
def report(self, to_file):
2053
"""Write a human-readable description of the result."""
2054
if self.old_revid == self.new_revid:
2055
to_file.write('No new revisions to push.\n')
2057
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2058
self._show_tag_conficts(to_file)
2061
class BranchCheckResult(object):
2062
"""Results of checking branch consistency.
2067
def __init__(self, branch):
2068
self.branch = branch
2070
def report_results(self, verbose):
2071
"""Report the check results via trace.note.
2073
:param verbose: Requests more detailed display of what was checked,
2076
note('checked branch %s format %s',
2078
self.branch._format)
2081
class Converter5to6(object):
2082
"""Perform an in-place upgrade of format 5 to format 6"""
2084
def convert(self, branch):
2085
# Data for 5 and 6 can peacefully coexist.
2086
format = BzrBranchFormat6()
2087
new_branch = format.open(branch.bzrdir, _found=True)
2089
# Copy source data into target
2090
new_branch.set_last_revision_info(*branch.last_revision_info())
2091
new_branch.set_parent(branch.get_parent())
2092
new_branch.set_bound_location(branch.get_bound_location())
2093
new_branch.set_push_location(branch.get_push_location())
2095
# New branch has no tags by default
2096
new_branch.tags._set_tag_dict({})
2098
# Copying done; now update target format
2099
new_branch.control_files.put_utf8('format',
2100
format.get_format_string())
2102
# Clean up old files
2103
new_branch.control_files._transport.delete('revision-history')
2105
branch.set_parent(None)
2108
branch.set_bound_location(None)
added
removed
bzrlib/branch.py
