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, *args, **kwargs):
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
# for API compatibility, until 0.8 releases we provide the old api:
601
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
602
# after 0.8 releases, the *args and **kwargs should be changed:
603
# def clone(self, to_bzrdir, revision_id=None):
604
if (kwargs.get('to_location', None) or
605
kwargs.get('revision', None) or
606
kwargs.get('basis_branch', None) or
607
(len(args) and isinstance(args[0], basestring))):
608
# backwards compatibility api:
609
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
610
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
613
basis_branch = args[2]
615
basis_branch = kwargs.get('basis_branch', None)
617
basis = basis_branch.bzrdir
622
revision_id = args[1]
624
revision_id = kwargs.get('revision', None)
629
# no default to raise if not provided.
630
url = kwargs.get('to_location')
631
return self.bzrdir.clone(url,
632
revision_id=revision_id,
633
basis=basis).open_branch()
635
# generate args by hand
637
revision_id = args[1]
639
revision_id = kwargs.get('revision_id', None)
643
# no default to raise if not provided.
644
to_bzrdir = kwargs.get('to_bzrdir')
645
result = self._format.initialize(to_bzrdir)
646
self.copy_content_into(result, revision_id=revision_id)
650
def sprout(self, to_bzrdir, revision_id=None):
651
"""Create a new line of development from the branch, into to_bzrdir.
653
revision_id: if not None, the revision history in the new branch will
654
be truncated to end with revision_id.
656
result = self._format.initialize(to_bzrdir)
657
self.copy_content_into(result, revision_id=revision_id)
658
result.set_parent(self.bzrdir.root_transport.base)
661
def _synchronize_history(self, destination, revision_id):
662
"""Synchronize last revision and revision history between branches.
664
This version is most efficient when the destination is also a
665
BzrBranch5, but works for BzrBranch6 as long as the revision
666
history is the true lefthand parent history, and all of the revisions
667
are in the destination's repository. If not, set_revision_history
670
:param destination: The branch to copy the history into
671
:param revision_id: The revision-id to truncate history at. May
672
be None to copy complete history.
674
new_history = self.revision_history()
675
if revision_id is not None:
676
revision_id = osutils.safe_revision_id(revision_id)
678
new_history = new_history[:new_history.index(revision_id) + 1]
680
rev = self.repository.get_revision(revision_id)
681
new_history = rev.get_history(self.repository)[1:]
682
destination.set_revision_history(new_history)
685
def copy_content_into(self, destination, revision_id=None):
686
"""Copy the content of self into destination.
688
revision_id: if not None, the revision history in the new branch will
689
be truncated to end with revision_id.
691
self._synchronize_history(destination, revision_id)
693
parent = self.get_parent()
694
except errors.InaccessibleParent, e:
695
mutter('parent was not accessible to copy: %s', e)
698
destination.set_parent(parent)
699
self.tags.merge_to(destination.tags)
703
"""Check consistency of the branch.
705
In particular this checks that revisions given in the revision-history
706
do actually match up in the revision graph, and that they're all
707
present in the repository.
709
Callers will typically also want to check the repository.
711
:return: A BranchCheckResult.
713
mainline_parent_id = None
714
for revision_id in self.revision_history():
716
revision = self.repository.get_revision(revision_id)
717
except errors.NoSuchRevision, e:
718
raise errors.BzrCheckError("mainline revision {%s} not in repository"
720
# In general the first entry on the revision history has no parents.
721
# But it's not illegal for it to have parents listed; this can happen
722
# in imports from Arch when the parents weren't reachable.
723
if mainline_parent_id is not None:
724
if mainline_parent_id not in revision.parent_ids:
725
raise errors.BzrCheckError("previous revision {%s} not listed among "
727
% (mainline_parent_id, revision_id))
728
mainline_parent_id = revision_id
729
return BranchCheckResult(self)
731
def _get_checkout_format(self):
732
"""Return the most suitable metadir for a checkout of this branch.
733
Weaves are used if this branch's repostory uses weaves.
735
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
736
from bzrlib.repofmt import weaverepo
737
format = bzrdir.BzrDirMetaFormat1()
738
format.repository_format = weaverepo.RepositoryFormat7()
740
format = self.repository.bzrdir.checkout_metadir()
741
format.set_branch_format(self._format)
744
def create_checkout(self, to_location, revision_id=None,
746
"""Create a checkout of a branch.
748
:param to_location: The url to produce the checkout at
749
:param revision_id: The revision to check out
750
:param lightweight: If True, produce a lightweight checkout, otherwise,
751
produce a bound branch (heavyweight checkout)
752
:return: The tree of the created checkout
754
t = transport.get_transport(to_location)
757
except errors.FileExists:
760
format = self._get_checkout_format()
761
checkout = format.initialize_on_transport(t)
762
BranchReferenceFormat().initialize(checkout, self)
764
format = self._get_checkout_format()
765
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
766
to_location, force_new_tree=False, format=format)
767
checkout = checkout_branch.bzrdir
768
checkout_branch.bind(self)
769
# pull up to the specified revision_id to set the initial
770
# branch tip correctly, and seed it with history.
771
checkout_branch.pull(self, stop_revision=revision_id)
772
tree = checkout.create_workingtree(revision_id)
773
basis_tree = tree.basis_tree()
774
basis_tree.lock_read()
776
for path, file_id in basis_tree.iter_references():
777
reference_parent = self.reference_parent(file_id, path)
778
reference_parent.create_checkout(tree.abspath(path),
779
basis_tree.get_reference_revision(file_id, path),
785
def reference_parent(self, file_id, path):
786
"""Return the parent branch for a tree-reference file_id
787
:param file_id: The file_id of the tree reference
788
:param path: The path of the file_id in the tree
789
:return: A branch associated with the file_id
791
# FIXME should provide multiple branches, based on config
792
return Branch.open(self.bzrdir.root_transport.clone(path).base)
794
def supports_tags(self):
795
return self._format.supports_tags()
798
class BranchFormat(object):
799
"""An encapsulation of the initialization and open routines for a format.
801
Formats provide three things:
802
* An initialization routine,
806
Formats are placed in an dict by their format string for reference
807
during branch opening. Its not required that these be instances, they
808
can be classes themselves with class methods - it simply depends on
809
whether state is needed for a given format or not.
811
Once a format is deprecated, just deprecate the initialize and open
812
methods on the format class. Do not deprecate the object, as the
813
object will be created every time regardless.
816
_default_format = None
817
"""The default format used for new branches."""
820
"""The known formats."""
823
def find_format(klass, a_bzrdir):
824
"""Return the format for the branch object in a_bzrdir."""
826
transport = a_bzrdir.get_branch_transport(None)
827
format_string = transport.get("format").read()
828
return klass._formats[format_string]
830
raise NotBranchError(path=transport.base)
832
raise errors.UnknownFormatError(format=format_string)
835
def get_default_format(klass):
836
"""Return the current default format."""
837
return klass._default_format
839
def get_format_string(self):
840
"""Return the ASCII format string that identifies this format."""
841
raise NotImplementedError(self.get_format_string)
843
def get_format_description(self):
844
"""Return the short format description for this format."""
845
raise NotImplementedError(self.get_format_description)
847
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
849
"""Initialize a branch in a bzrdir, with specified files
851
:param a_bzrdir: The bzrdir to initialize the branch in
852
:param utf8_files: The files to create as a list of
853
(filename, content) tuples
854
:param set_format: If True, set the format with
855
self.get_format_string. (BzrBranch4 has its format set
857
:return: a branch in this format
859
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
860
branch_transport = a_bzrdir.get_branch_transport(self)
862
'metadir': ('lock', lockdir.LockDir),
863
'branch4': ('branch-lock', lockable_files.TransportLock),
865
lock_name, lock_class = lock_map[lock_type]
866
control_files = lockable_files.LockableFiles(branch_transport,
867
lock_name, lock_class)
868
control_files.create_lock()
869
control_files.lock_write()
871
control_files.put_utf8('format', self.get_format_string())
873
for file, content in utf8_files:
874
control_files.put_utf8(file, content)
876
control_files.unlock()
877
return self.open(a_bzrdir, _found=True)
879
def initialize(self, a_bzrdir):
880
"""Create a branch of this format in a_bzrdir."""
881
raise NotImplementedError(self.initialize)
883
def is_supported(self):
884
"""Is this format supported?
886
Supported formats can be initialized and opened.
887
Unsupported formats may not support initialization or committing or
888
some other features depending on the reason for not being supported.
892
def open(self, a_bzrdir, _found=False):
893
"""Return the branch object for a_bzrdir
895
_found is a private parameter, do not use it. It is used to indicate
896
if format probing has already be done.
898
raise NotImplementedError(self.open)
901
def register_format(klass, format):
902
klass._formats[format.get_format_string()] = format
905
def set_default_format(klass, format):
906
klass._default_format = format
909
def unregister_format(klass, format):
910
assert klass._formats[format.get_format_string()] is format
911
del klass._formats[format.get_format_string()]
914
return self.get_format_string().rstrip()
916
def supports_tags(self):
917
"""True if this format supports tags stored in the branch"""
918
return False # by default
920
# XXX: Probably doesn't really belong here -- mbp 20070212
921
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
923
branch_transport = a_bzrdir.get_branch_transport(self)
924
control_files = lockable_files.LockableFiles(branch_transport,
925
lock_filename, lock_class)
926
control_files.create_lock()
927
control_files.lock_write()
929
for filename, content in utf8_files:
930
control_files.put_utf8(filename, content)
932
control_files.unlock()
935
class BranchHooks(dict):
936
"""A dictionary mapping hook name to a list of callables for branch hooks.
938
e.g. ['set_rh'] Is the list of items to be called when the
939
set_revision_history function is invoked.
943
"""Create the default hooks.
945
These are all empty initially, because by default nothing should get
949
# Introduced in 0.15:
950
# invoked whenever the revision history has been set
951
# with set_revision_history. The api signature is
952
# (branch, revision_history), and the branch will
955
# invoked after a push operation completes.
956
# the api signature is
958
# containing the members
959
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
960
# where local is the local branch or None, master is the target
961
# master branch, and the rest should be self explanatory. The source
962
# is read locked and the target branches write locked. Source will
963
# be the local low-latency branch.
964
self['post_push'] = []
965
# invoked after a pull operation completes.
966
# the api signature is
968
# containing the members
969
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
970
# where local is the local branch or None, master is the target
971
# master branch, and the rest should be self explanatory. The source
972
# is read locked and the target branches write locked. The local
973
# branch is the low-latency branch.
974
self['post_pull'] = []
975
# invoked after a commit operation completes.
976
# the api signature is
977
# (local, master, old_revno, old_revid, new_revno, new_revid)
978
# old_revid is NULL_REVISION for the first commit to a branch.
979
self['post_commit'] = []
980
# invoked after a uncommit operation completes.
981
# the api signature is
982
# (local, master, old_revno, old_revid, new_revno, new_revid) where
983
# local is the local branch or None, master is the target branch,
984
# and an empty branch recieves new_revno of 0, new_revid of None.
985
self['post_uncommit'] = []
987
def install_hook(self, hook_name, a_callable):
988
"""Install a_callable in to the hook hook_name.
990
:param hook_name: A hook name. See the __init__ method of BranchHooks
991
for the complete list of hooks.
992
:param a_callable: The callable to be invoked when the hook triggers.
993
The exact signature will depend on the hook - see the __init__
994
method of BranchHooks for details on each hook.
997
self[hook_name].append(a_callable)
999
raise errors.UnknownHook('branch', hook_name)
1002
# install the default hooks into the Branch class.
1003
Branch.hooks = BranchHooks()
1006
class BzrBranchFormat4(BranchFormat):
1007
"""Bzr branch format 4.
1010
- a revision-history file.
1011
- a branch-lock lock file [ to be shared with the bzrdir ]
1014
def get_format_description(self):
1015
"""See BranchFormat.get_format_description()."""
1016
return "Branch format 4"
1018
def initialize(self, a_bzrdir):
1019
"""Create a branch of this format in a_bzrdir."""
1020
utf8_files = [('revision-history', ''),
1021
('branch-name', ''),
1023
return self._initialize_helper(a_bzrdir, utf8_files,
1024
lock_type='branch4', set_format=False)
1027
super(BzrBranchFormat4, self).__init__()
1028
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1030
def open(self, a_bzrdir, _found=False):
1031
"""Return the branch object for a_bzrdir
1033
_found is a private parameter, do not use it. It is used to indicate
1034
if format probing has already be done.
1037
# we are being called directly and must probe.
1038
raise NotImplementedError
1039
return BzrBranch(_format=self,
1040
_control_files=a_bzrdir._control_files,
1042
_repository=a_bzrdir.open_repository())
1045
return "Bazaar-NG branch format 4"
1048
class BzrBranchFormat5(BranchFormat):
1049
"""Bzr branch format 5.
1052
- a revision-history file.
1054
- a lock dir guarding the branch itself
1055
- all of this stored in a branch/ subdirectory
1056
- works with shared repositories.
1058
This format is new in bzr 0.8.
1061
def get_format_string(self):
1062
"""See BranchFormat.get_format_string()."""
1063
return "Bazaar-NG branch format 5\n"
1065
def get_format_description(self):
1066
"""See BranchFormat.get_format_description()."""
1067
return "Branch format 5"
1069
def initialize(self, a_bzrdir):
1070
"""Create a branch of this format in a_bzrdir."""
1071
utf8_files = [('revision-history', ''),
1072
('branch-name', ''),
1074
return self._initialize_helper(a_bzrdir, utf8_files)
1077
super(BzrBranchFormat5, self).__init__()
1078
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
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 BzrBranch5(_format=self,
1093
_control_files=control_files,
1095
_repository=a_bzrdir.find_repository())
1098
class BzrBranchFormat6(BzrBranchFormat5):
1099
"""Branch format with last-revision
1101
Unlike previous formats, this has no explicit revision history. Instead,
1102
this just stores the last-revision, and the left-hand history leading
1103
up to there is the history.
1105
This format was introduced in bzr 0.15
1108
def get_format_string(self):
1109
"""See BranchFormat.get_format_string()."""
1110
return "Bazaar Branch Format 6 (bzr 0.15)\n"
1112
def get_format_description(self):
1113
"""See BranchFormat.get_format_description()."""
1114
return "Branch format 6"
1116
def initialize(self, a_bzrdir):
1117
"""Create a branch of this format in a_bzrdir."""
1118
utf8_files = [('last-revision', '0 null:\n'),
1119
('branch-name', ''),
1120
('branch.conf', ''),
1123
return self._initialize_helper(a_bzrdir, utf8_files)
1125
def open(self, a_bzrdir, _found=False):
1126
"""Return the branch object for a_bzrdir
1128
_found is a private parameter, do not use it. It is used to indicate
1129
if format probing has already be done.
1132
format = BranchFormat.find_format(a_bzrdir)
1133
assert format.__class__ == self.__class__
1134
transport = a_bzrdir.get_branch_transport(None)
1135
control_files = lockable_files.LockableFiles(transport, 'lock',
1137
return BzrBranch6(_format=self,
1138
_control_files=control_files,
1140
_repository=a_bzrdir.find_repository())
1142
def supports_tags(self):
1146
class BranchReferenceFormat(BranchFormat):
1147
"""Bzr branch reference format.
1149
Branch references are used in implementing checkouts, they
1150
act as an alias to the real branch which is at some other url.
1157
def get_format_string(self):
1158
"""See BranchFormat.get_format_string()."""
1159
return "Bazaar-NG Branch Reference Format 1\n"
1161
def get_format_description(self):
1162
"""See BranchFormat.get_format_description()."""
1163
return "Checkout reference format 1"
1165
def initialize(self, a_bzrdir, target_branch=None):
1166
"""Create a branch of this format in a_bzrdir."""
1167
if target_branch is None:
1168
# this format does not implement branch itself, thus the implicit
1169
# creation contract must see it as uninitializable
1170
raise errors.UninitializableFormat(self)
1171
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1172
branch_transport = a_bzrdir.get_branch_transport(self)
1173
branch_transport.put_bytes('location',
1174
target_branch.bzrdir.root_transport.base)
1175
branch_transport.put_bytes('format', self.get_format_string())
1176
return self.open(a_bzrdir, _found=True)
1179
super(BranchReferenceFormat, self).__init__()
1180
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1182
def _make_reference_clone_function(format, a_branch):
1183
"""Create a clone() routine for a branch dynamically."""
1184
def clone(to_bzrdir, revision_id=None):
1185
"""See Branch.clone()."""
1186
return format.initialize(to_bzrdir, a_branch)
1187
# cannot obey revision_id limits when cloning a reference ...
1188
# FIXME RBC 20060210 either nuke revision_id for clone, or
1189
# emit some sort of warning/error to the caller ?!
1192
def open(self, a_bzrdir, _found=False):
1193
"""Return the branch that the branch reference in a_bzrdir points at.
1195
_found is a private parameter, do not use it. It is used to indicate
1196
if format probing has already be done.
1199
format = BranchFormat.find_format(a_bzrdir)
1200
assert format.__class__ == self.__class__
1201
transport = a_bzrdir.get_branch_transport(None)
1202
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1203
result = real_bzrdir.open_branch()
1204
# this changes the behaviour of result.clone to create a new reference
1205
# rather than a copy of the content of the branch.
1206
# I did not use a proxy object because that needs much more extensive
1207
# testing, and we are only changing one behaviour at the moment.
1208
# If we decide to alter more behaviours - i.e. the implicit nickname
1209
# then this should be refactored to introduce a tested proxy branch
1210
# and a subclass of that for use in overriding clone() and ....
1212
result.clone = self._make_reference_clone_function(result)
1216
# formats which have no format string are not discoverable
1217
# and not independently creatable, so are not registered.
1218
__default_format = BzrBranchFormat5()
1219
BranchFormat.register_format(__default_format)
1220
BranchFormat.register_format(BranchReferenceFormat())
1221
BranchFormat.register_format(BzrBranchFormat6())
1222
BranchFormat.set_default_format(__default_format)
1223
_legacy_formats = [BzrBranchFormat4(),
1226
class BzrBranch(Branch):
1227
"""A branch stored in the actual filesystem.
1229
Note that it's "local" in the context of the filesystem; it doesn't
1230
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1231
it's writable, and can be accessed via the normal filesystem API.
1234
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
1235
relax_version_check=DEPRECATED_PARAMETER, _format=None,
1236
_control_files=None, a_bzrdir=None, _repository=None):
1237
"""Create new branch object at a particular location.
1239
transport -- A Transport object, defining how to access files.
1241
init -- If True, create new control files in a previously
1242
unversioned directory. If False, the branch must already
1245
relax_version_check -- If true, the usual check for the branch
1246
version is not applied. This is intended only for
1247
upgrade/recovery type use; it's not guaranteed that
1248
all operations will work on old format branches.
1250
Branch.__init__(self)
1251
if a_bzrdir is None:
1252
self.bzrdir = bzrdir.BzrDir.open(transport.base)
1254
self.bzrdir = a_bzrdir
1255
# self._transport used to point to the directory containing the
1256
# control directory, but was not used - now it's just the transport
1257
# for the branch control files. mbp 20070212
1258
self._base = self.bzrdir.transport.clone('..').base
1259
self._format = _format
1260
if _control_files is None:
1261
raise ValueError('BzrBranch _control_files is None')
1262
self.control_files = _control_files
1263
self._transport = _control_files._transport
1264
if deprecated_passed(init):
1265
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
1266
"deprecated as of bzr 0.8. Please use Branch.create().",
1270
# this is slower than before deprecation, oh well never mind.
1271
# -> its deprecated.
1272
self._initialize(transport.base)
1273
self._check_format(_format)
1274
if deprecated_passed(relax_version_check):
1275
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1276
"relax_version_check parameter is deprecated as of bzr 0.8. "
1277
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1281
if (not relax_version_check
1282
and not self._format.is_supported()):
1283
raise errors.UnsupportedFormatError(format=fmt)
1284
if deprecated_passed(transport):
1285
warn("BzrBranch.__init__(transport=XXX...): The transport "
1286
"parameter is deprecated as of bzr 0.8. "
1287
"Please use Branch.open, or bzrdir.open_branch().",
1290
self.repository = _repository
1293
return '%s(%r)' % (self.__class__.__name__, self.base)
1297
def _get_base(self):
1298
"""Returns the directory containing the control directory."""
1301
base = property(_get_base, doc="The URL for the root of this branch.")
1303
def abspath(self, name):
1304
"""See Branch.abspath."""
1305
return self.control_files._transport.abspath(name)
1307
def _check_format(self, format):
1308
"""Identify the branch format if needed.
1310
The format is stored as a reference to the format object in
1311
self._format for code that needs to check it later.
1313
The format parameter is either None or the branch format class
1314
used to open this branch.
1316
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1319
format = BranchFormat.find_format(self.bzrdir)
1320
self._format = format
1321
mutter("got branch format %s", self._format)
1324
def get_root_id(self):
1325
"""See Branch.get_root_id."""
1326
tree = self.repository.revision_tree(self.last_revision())
1327
return tree.inventory.root.file_id
1329
def is_locked(self):
1330
return self.control_files.is_locked()
1332
def lock_write(self):
1333
self.repository.lock_write()
1335
self.control_files.lock_write()
1337
self.repository.unlock()
1340
def lock_read(self):
1341
self.repository.lock_read()
1343
self.control_files.lock_read()
1345
self.repository.unlock()
1349
# TODO: test for failed two phase locks. This is known broken.
1351
self.control_files.unlock()
1353
self.repository.unlock()
1354
if not self.control_files.is_locked():
1355
# we just released the lock
1356
self._clear_cached_state()
1358
def peek_lock_mode(self):
1359
if self.control_files._lock_count == 0:
1362
return self.control_files._lock_mode
1364
def get_physical_lock_status(self):
1365
return self.control_files.get_physical_lock_status()
1368
def print_file(self, file, revision_id):
1369
"""See Branch.print_file."""
1370
return self.repository.print_file(file, revision_id)
1373
def append_revision(self, *revision_ids):
1374
"""See Branch.append_revision."""
1375
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1376
for revision_id in revision_ids:
1377
_mod_revision.check_not_reserved_id(revision_id)
1378
mutter("add {%s} to revision-history" % revision_id)
1379
rev_history = self.revision_history()
1380
rev_history.extend(revision_ids)
1381
self.set_revision_history(rev_history)
1383
def _write_revision_history(self, history):
1384
"""Factored out of set_revision_history.
1386
This performs the actual writing to disk.
1387
It is intended to be called by BzrBranch5.set_revision_history."""
1388
self.control_files.put_bytes(
1389
'revision-history', '\n'.join(history))
1392
def set_revision_history(self, rev_history):
1393
"""See Branch.set_revision_history."""
1394
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1395
self._write_revision_history(rev_history)
1396
self._cache_revision_history(rev_history)
1397
for hook in Branch.hooks['set_rh']:
1398
hook(self, rev_history)
1401
def set_last_revision_info(self, revno, revision_id):
1402
revision_id = osutils.safe_revision_id(revision_id)
1403
history = self._lefthand_history(revision_id)
1404
assert len(history) == revno, '%d != %d' % (len(history), revno)
1405
self.set_revision_history(history)
1407
def _gen_revision_history(self):
1408
history = self.control_files.get('revision-history').read().split('\n')
1409
if history[-1:] == ['']:
1410
# There shouldn't be a trailing newline, but just in case.
1414
def _lefthand_history(self, revision_id, last_rev=None,
1416
# stop_revision must be a descendant of last_revision
1417
stop_graph = self.repository.get_revision_graph(revision_id)
1418
if last_rev is not None and last_rev not in stop_graph:
1419
# our previous tip is not merged into stop_revision
1420
raise errors.DivergedBranches(self, other_branch)
1421
# make a new revision history from the graph
1422
current_rev_id = revision_id
1424
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1425
new_history.append(current_rev_id)
1426
current_rev_id_parents = stop_graph[current_rev_id]
1428
current_rev_id = current_rev_id_parents[0]
1430
current_rev_id = None
1431
new_history.reverse()
1435
def generate_revision_history(self, revision_id, last_rev=None,
1437
"""Create a new revision history that will finish with revision_id.
1439
:param revision_id: the new tip to use.
1440
:param last_rev: The previous last_revision. If not None, then this
1441
must be a ancestory of revision_id, or DivergedBranches is raised.
1442
:param other_branch: The other branch that DivergedBranches should
1443
raise with respect to.
1445
revision_id = osutils.safe_revision_id(revision_id)
1446
self.set_revision_history(self._lefthand_history(revision_id,
1447
last_rev, other_branch))
1450
def update_revisions(self, other, stop_revision=None):
1451
"""See Branch.update_revisions."""
1454
if stop_revision is None:
1455
stop_revision = other.last_revision()
1456
if stop_revision is None:
1457
# if there are no commits, we're done.
1460
stop_revision = osutils.safe_revision_id(stop_revision)
1461
# whats the current last revision, before we fetch [and change it
1463
last_rev = self.last_revision()
1464
# we fetch here regardless of whether we need to so that we pickup
1466
self.fetch(other, stop_revision)
1467
my_ancestry = self.repository.get_ancestry(last_rev)
1468
if stop_revision in my_ancestry:
1469
# last_revision is a descendant of stop_revision
1471
self.generate_revision_history(stop_revision, last_rev=last_rev,
1476
def basis_tree(self):
1477
"""See Branch.basis_tree."""
1478
return self.repository.revision_tree(self.last_revision())
1480
@deprecated_method(zero_eight)
1481
def working_tree(self):
1482
"""Create a Working tree object for this branch."""
1484
from bzrlib.transport.local import LocalTransport
1485
if (self.base.find('://') != -1 or
1486
not isinstance(self._transport, LocalTransport)):
1487
raise NoWorkingTree(self.base)
1488
return self.bzrdir.open_workingtree()
1491
def pull(self, source, overwrite=False, stop_revision=None,
1492
_hook_master=None, _run_hooks=True):
1495
:param _hook_master: Private parameter - set the branch to
1496
be supplied as the master to push hooks.
1497
:param _run_hooks: Private parameter - allow disabling of
1498
hooks, used when pushing to a master branch.
1500
result = PullResult()
1501
result.source_branch = source
1502
result.target_branch = self
1505
result.old_revno, result.old_revid = self.last_revision_info()
1507
self.update_revisions(source, stop_revision)
1508
except DivergedBranches:
1512
if stop_revision is None:
1513
stop_revision = source.last_revision()
1514
self.generate_revision_history(stop_revision)
1515
result.tag_conflicts = source.tags.merge_to(self.tags)
1516
result.new_revno, result.new_revid = self.last_revision_info()
1518
result.master_branch = _hook_master
1519
result.local_branch = self
1521
result.master_branch = self
1522
result.local_branch = None
1524
for hook in Branch.hooks['post_pull']:
1530
def _get_parent_location(self):
1531
_locs = ['parent', 'pull', 'x-pull']
1534
return self.control_files.get(l).read().strip('\n')
1540
def push(self, target, overwrite=False, stop_revision=None,
1541
_hook_master=None, _run_hooks=True):
1544
:param _hook_master: Private parameter - set the branch to
1545
be supplied as the master to push hooks.
1546
:param _run_hooks: Private parameter - allow disabling of
1547
hooks, used when pushing to a master branch.
1549
result = PushResult()
1550
result.source_branch = self
1551
result.target_branch = target
1554
result.old_revno, result.old_revid = target.last_revision_info()
1556
target.update_revisions(self, stop_revision)
1557
except DivergedBranches:
1561
target.set_revision_history(self.revision_history())
1562
result.tag_conflicts = self.tags.merge_to(target.tags)
1563
result.new_revno, result.new_revid = target.last_revision_info()
1565
result.master_branch = _hook_master
1566
result.local_branch = target
1568
result.master_branch = target
1569
result.local_branch = None
1571
for hook in Branch.hooks['post_push']:
1577
def get_parent(self):
1578
"""See Branch.get_parent."""
1580
assert self.base[-1] == '/'
1581
parent = self._get_parent_location()
1584
# This is an old-format absolute path to a local branch
1585
# turn it into a url
1586
if parent.startswith('/'):
1587
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1589
return urlutils.join(self.base[:-1], parent)
1590
except errors.InvalidURLJoin, e:
1591
raise errors.InaccessibleParent(parent, self.base)
1593
def get_push_location(self):
1594
"""See Branch.get_push_location."""
1595
push_loc = self.get_config().get_user_option('push_location')
1598
def set_push_location(self, location):
1599
"""See Branch.set_push_location."""
1600
self.get_config().set_user_option(
1601
'push_location', location,
1602
store=_mod_config.STORE_LOCATION_NORECURSE)
1605
def set_parent(self, url):
1606
"""See Branch.set_parent."""
1607
# TODO: Maybe delete old location files?
1608
# URLs should never be unicode, even on the local fs,
1609
# FIXUP this and get_parent in a future branch format bump:
1610
# read and rewrite the file, and have the new format code read
1611
# using .get not .get_utf8. RBC 20060125
1613
if isinstance(url, unicode):
1615
url = url.encode('ascii')
1616
except UnicodeEncodeError:
1617
raise bzrlib.errors.InvalidURL(url,
1618
"Urls must be 7-bit ascii, "
1619
"use bzrlib.urlutils.escape")
1620
url = urlutils.relative_url(self.base, url)
1621
self._set_parent_location(url)
1623
def _set_parent_location(self, url):
1625
self.control_files._transport.delete('parent')
1627
assert isinstance(url, str)
1628
self.control_files.put_bytes('parent', url + '\n')
1630
@deprecated_function(zero_nine)
1631
def tree_config(self):
1632
"""DEPRECATED; call get_config instead.
1633
TreeConfig has become part of BranchConfig."""
1634
return TreeConfig(self)
1637
class BzrBranch5(BzrBranch):
1638
"""A format 5 branch. This supports new features over plan branches.
1640
It has support for a master_branch which is the data for bound branches.
1648
super(BzrBranch5, self).__init__(_format=_format,
1649
_control_files=_control_files,
1651
_repository=_repository)
1654
def pull(self, source, overwrite=False, stop_revision=None,
1656
"""Extends branch.pull to be bound branch aware.
1658
:param _run_hooks: Private parameter used to force hook running
1659
off during bound branch double-pushing.
1661
bound_location = self.get_bound_location()
1662
master_branch = None
1663
if bound_location and source.base != bound_location:
1664
# not pulling from master, so we need to update master.
1665
master_branch = self.get_master_branch()
1666
master_branch.lock_write()
1669
# pull from source into master.
1670
master_branch.pull(source, overwrite, stop_revision,
1672
return super(BzrBranch5, self).pull(source, overwrite,
1673
stop_revision, _hook_master=master_branch,
1674
_run_hooks=_run_hooks)
1677
master_branch.unlock()
1680
def push(self, target, overwrite=False, stop_revision=None):
1681
"""Updates branch.push to be bound branch aware."""
1682
bound_location = target.get_bound_location()
1683
master_branch = None
1684
if bound_location and target.base != bound_location:
1685
# not pushing to master, so we need to update master.
1686
master_branch = target.get_master_branch()
1687
master_branch.lock_write()
1690
# push into the master from this branch.
1691
super(BzrBranch5, self).push(master_branch, overwrite,
1692
stop_revision, _run_hooks=False)
1693
# and push into the target branch from this. Note that we push from
1694
# this branch again, because its considered the highest bandwidth
1696
return super(BzrBranch5, self).push(target, overwrite,
1697
stop_revision, _hook_master=master_branch)
1700
master_branch.unlock()
1702
def get_bound_location(self):
1704
return self.control_files.get_utf8('bound').read()[:-1]
1705
except errors.NoSuchFile:
1709
def get_master_branch(self):
1710
"""Return the branch we are bound to.
1712
:return: Either a Branch, or None
1714
This could memoise the branch, but if thats done
1715
it must be revalidated on each new lock.
1716
So for now we just don't memoise it.
1717
# RBC 20060304 review this decision.
1719
bound_loc = self.get_bound_location()
1723
return Branch.open(bound_loc)
1724
except (errors.NotBranchError, errors.ConnectionError), e:
1725
raise errors.BoundBranchConnectionFailure(
1729
def set_bound_location(self, location):
1730
"""Set the target where this branch is bound to.
1732
:param location: URL to the target branch
1735
self.control_files.put_utf8('bound', location+'\n')
1738
self.control_files._transport.delete('bound')
1744
def bind(self, other):
1745
"""Bind this branch to the branch other.
1747
This does not push or pull data between the branches, though it does
1748
check for divergence to raise an error when the branches are not
1749
either the same, or one a prefix of the other. That behaviour may not
1750
be useful, so that check may be removed in future.
1752
:param other: The branch to bind to
1755
# TODO: jam 20051230 Consider checking if the target is bound
1756
# It is debatable whether you should be able to bind to
1757
# a branch which is itself bound.
1758
# Committing is obviously forbidden,
1759
# but binding itself may not be.
1760
# Since we *have* to check at commit time, we don't
1761
# *need* to check here
1763
# we want to raise diverged if:
1764
# last_rev is not in the other_last_rev history, AND
1765
# other_last_rev is not in our history, and do it without pulling
1767
last_rev = self.last_revision()
1768
if last_rev is not None:
1771
other_last_rev = other.last_revision()
1772
if other_last_rev is not None:
1773
# neither branch is new, we have to do some work to
1774
# ascertain diversion.
1775
remote_graph = other.repository.get_revision_graph(
1777
local_graph = self.repository.get_revision_graph(last_rev)
1778
if (last_rev not in remote_graph and
1779
other_last_rev not in local_graph):
1780
raise errors.DivergedBranches(self, other)
1783
self.set_bound_location(other.base)
1787
"""If bound, unbind"""
1788
return self.set_bound_location(None)
1792
"""Synchronise this branch with the master branch if any.
1794
:return: None or the last_revision that was pivoted out during the
1797
master = self.get_master_branch()
1798
if master is not None:
1799
old_tip = self.last_revision()
1800
self.pull(master, overwrite=True)
1801
if old_tip in self.repository.get_ancestry(self.last_revision()):
1807
class BzrBranchExperimental(BzrBranch5):
1808
"""Bzr experimental branch format
1811
- a revision-history file.
1813
- a lock dir guarding the branch itself
1814
- all of this stored in a branch/ subdirectory
1815
- works with shared repositories.
1816
- a tag dictionary in the branch
1818
This format is new in bzr 0.15, but shouldn't be used for real data,
1821
This class acts as it's own BranchFormat.
1824
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1827
def get_format_string(cls):
1828
"""See BranchFormat.get_format_string()."""
1829
return "Bazaar-NG branch format experimental\n"
1832
def get_format_description(cls):
1833
"""See BranchFormat.get_format_description()."""
1834
return "Experimental branch format"
1837
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1839
branch_transport = a_bzrdir.get_branch_transport(cls)
1840
control_files = lockable_files.LockableFiles(branch_transport,
1841
lock_filename, lock_class)
1842
control_files.create_lock()
1843
control_files.lock_write()
1845
for filename, content in utf8_files:
1846
control_files.put_utf8(filename, content)
1848
control_files.unlock()
1851
def initialize(cls, a_bzrdir):
1852
"""Create a branch of this format in a_bzrdir."""
1853
utf8_files = [('format', cls.get_format_string()),
1854
('revision-history', ''),
1855
('branch-name', ''),
1858
cls._initialize_control_files(a_bzrdir, utf8_files,
1859
'lock', lockdir.LockDir)
1860
return cls.open(a_bzrdir, _found=True)
1863
def open(cls, a_bzrdir, _found=False):
1864
"""Return the branch object for a_bzrdir
1866
_found is a private parameter, do not use it. It is used to indicate
1867
if format probing has already be done.
1870
format = BranchFormat.find_format(a_bzrdir)
1871
assert format.__class__ == cls
1872
transport = a_bzrdir.get_branch_transport(None)
1873
control_files = lockable_files.LockableFiles(transport, 'lock',
1875
return cls(_format=cls,
1876
_control_files=control_files,
1878
_repository=a_bzrdir.find_repository())
1881
def is_supported(cls):
1884
def _make_tags(self):
1885
return BasicTags(self)
1888
def supports_tags(cls):
1892
BranchFormat.register_format(BzrBranchExperimental)
1895
class BzrBranch6(BzrBranch5):
1898
def last_revision_info(self):
1899
revision_string = self.control_files.get('last-revision').read()
1900
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1901
revision_id = cache_utf8.get_cached_utf8(revision_id)
1903
return revno, revision_id
1905
def last_revision(self):
1906
"""Return last revision id, or None"""
1907
revision_id = self.last_revision_info()[1]
1908
if revision_id == _mod_revision.NULL_REVISION:
1912
def _write_last_revision_info(self, revno, revision_id):
1913
"""Simply write out the revision id, with no checks.
1915
Use set_last_revision_info to perform this safely.
1917
Does not update the revision_history cache.
1918
Intended to be called by set_last_revision_info and
1919
_write_revision_history.
1921
if revision_id is None:
1922
revision_id = 'null:'
1923
out_string = '%d %s\n' % (revno, revision_id)
1924
self.control_files.put_bytes('last-revision', out_string)
1927
def set_last_revision_info(self, revno, revision_id):
1928
revision_id = osutils.safe_revision_id(revision_id)
1929
if self._get_append_revisions_only():
1930
self._check_history_violation(revision_id)
1931
self._write_last_revision_info(revno, revision_id)
1932
self._clear_cached_state()
1934
def _check_history_violation(self, revision_id):
1935
last_revision = self.last_revision()
1936
if last_revision is None:
1938
if last_revision not in self._lefthand_history(revision_id):
1939
raise errors.AppendRevisionsOnlyViolation(self.base)
1941
def _gen_revision_history(self):
1942
"""Generate the revision history from last revision
1944
history = list(self.repository.iter_reverse_revision_history(
1945
self.last_revision()))
1949
def _write_revision_history(self, history):
1950
"""Factored out of set_revision_history.
1952
This performs the actual writing to disk, with format-specific checks.
1953
It is intended to be called by BzrBranch5.set_revision_history.
1955
if len(history) == 0:
1956
last_revision = 'null:'
1958
if history != self._lefthand_history(history[-1]):
1959
raise errors.NotLefthandHistory(history)
1960
last_revision = history[-1]
1961
if self._get_append_revisions_only():
1962
self._check_history_violation(last_revision)
1963
self._write_last_revision_info(len(history), last_revision)
1966
def append_revision(self, *revision_ids):
1967
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1968
if len(revision_ids) == 0:
1970
prev_revno, prev_revision = self.last_revision_info()
1971
for revision in self.repository.get_revisions(revision_ids):
1972
if prev_revision == _mod_revision.NULL_REVISION:
1973
if revision.parent_ids != []:
1974
raise errors.NotLeftParentDescendant(self, prev_revision,
1975
revision.revision_id)
1977
if revision.parent_ids[0] != prev_revision:
1978
raise errors.NotLeftParentDescendant(self, prev_revision,
1979
revision.revision_id)
1980
prev_revision = revision.revision_id
1981
self.set_last_revision_info(prev_revno + len(revision_ids),
1985
def _set_parent_location(self, url):
1986
"""Set the parent branch"""
1987
self._set_config_location('parent_location', url, make_relative=True)
1990
def _get_parent_location(self):
1991
"""Set the parent branch"""
1992
return self._get_config_location('parent_location')
1994
def set_push_location(self, location):
1995
"""See Branch.set_push_location."""
1996
self._set_config_location('push_location', location)
1998
def set_bound_location(self, location):
1999
"""See Branch.set_push_location."""
2001
config = self.get_config()
2002
if location is None:
2003
if config.get_user_option('bound') != 'True':
2006
config.set_user_option('bound', 'False')
2009
self._set_config_location('bound_location', location,
2011
config.set_user_option('bound', 'True')
2014
def _get_bound_location(self, bound):
2015
"""Return the bound location in the config file.
2017
Return None if the bound parameter does not match"""
2018
config = self.get_config()
2019
config_bound = (config.get_user_option('bound') == 'True')
2020
if config_bound != bound:
2022
return self._get_config_location('bound_location', config=config)
2024
def get_bound_location(self):
2025
"""See Branch.set_push_location."""
2026
return self._get_bound_location(True)
2028
def get_old_bound_location(self):
2029
"""See Branch.get_old_bound_location"""
2030
return self._get_bound_location(False)
2032
def set_append_revisions_only(self, enabled):
2037
self.get_config().set_user_option('append_revisions_only', value)
2039
def _get_append_revisions_only(self):
2040
value = self.get_config().get_user_option('append_revisions_only')
2041
return value == 'True'
2043
def _synchronize_history(self, destination, revision_id):
2044
"""Synchronize last revision and revision history between branches.
2046
This version is most efficient when the destination is also a
2047
BzrBranch6, but works for BzrBranch5, as long as the destination's
2048
repository contains all the lefthand ancestors of the intended
2049
last_revision. If not, set_last_revision_info will fail.
2051
:param destination: The branch to copy the history into
2052
:param revision_id: The revision-id to truncate history at. May
2053
be None to copy complete history.
2055
if revision_id is None:
2056
revno, revision_id = self.last_revision_info()
2058
revno = self.revision_id_to_revno(revision_id)
2059
destination.set_last_revision_info(revno, revision_id)
2061
def _make_tags(self):
2062
return BasicTags(self)
2065
class BranchTestProviderAdapter(object):
2066
"""A tool to generate a suite testing multiple branch formats at once.
2068
This is done by copying the test once for each transport and injecting
2069
the transport_server, transport_readonly_server, and branch_format
2070
classes into each copy. Each copy is also given a new id() to make it
2074
def __init__(self, transport_server, transport_readonly_server, formats):
2075
self._transport_server = transport_server
2076
self._transport_readonly_server = transport_readonly_server
2077
self._formats = formats
2079
def adapt(self, test):
2080
result = TestSuite()
2081
for branch_format, bzrdir_format in self._formats:
2082
new_test = deepcopy(test)
2083
new_test.transport_server = self._transport_server
2084
new_test.transport_readonly_server = self._transport_readonly_server
2085
new_test.bzrdir_format = bzrdir_format
2086
new_test.branch_format = branch_format
2087
def make_new_test_id():
2088
# the format can be either a class or an instance
2089
name = getattr(branch_format, '__name__',
2090
branch_format.__class__.__name__)
2091
new_id = "%s(%s)" % (new_test.id(), name)
2092
return lambda: new_id
2093
new_test.id = make_new_test_id()
2094
result.addTest(new_test)
2098
######################################################################
2099
# results of operations
2102
class _Result(object):
2104
def _show_tag_conficts(self, to_file):
2105
if not getattr(self, 'tag_conflicts', None):
2107
to_file.write('Conflicting tags:\n')
2108
for name, value1, value2 in self.tag_conflicts:
2109
to_file.write(' %s\n' % (name, ))
2112
class PullResult(_Result):
2113
"""Result of a Branch.pull operation.
2115
:ivar old_revno: Revision number before pull.
2116
:ivar new_revno: Revision number after pull.
2117
:ivar old_revid: Tip revision id before pull.
2118
:ivar new_revid: Tip revision id after pull.
2119
:ivar source_branch: Source (local) branch object.
2120
:ivar master_branch: Master branch of the target, or None.
2121
:ivar target_branch: Target/destination branch object.
2125
# DEPRECATED: pull used to return the change in revno
2126
return self.new_revno - self.old_revno
2128
def report(self, to_file):
2129
if self.old_revid == self.new_revid:
2130
to_file.write('No revisions to pull.\n')
2132
to_file.write('Now on revision %d.\n' % self.new_revno)
2133
self._show_tag_conficts(to_file)
2136
class PushResult(_Result):
2137
"""Result of a Branch.push operation.
2139
:ivar old_revno: Revision number before push.
2140
:ivar new_revno: Revision number after push.
2141
:ivar old_revid: Tip revision id before push.
2142
:ivar new_revid: Tip revision id after push.
2143
:ivar source_branch: Source branch object.
2144
:ivar master_branch: Master branch of the target, or None.
2145
:ivar target_branch: Target/destination branch object.
2149
# DEPRECATED: push used to return the change in revno
2150
return self.new_revno - self.old_revno
2152
def report(self, to_file):
2153
"""Write a human-readable description of the result."""
2154
if self.old_revid == self.new_revid:
2155
to_file.write('No new revisions to push.\n')
2157
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2158
self._show_tag_conficts(to_file)
2161
class BranchCheckResult(object):
2162
"""Results of checking branch consistency.
2167
def __init__(self, branch):
2168
self.branch = branch
2170
def report_results(self, verbose):
2171
"""Report the check results via trace.note.
2173
:param verbose: Requests more detailed display of what was checked,
2176
note('checked branch %s format %s',
2178
self.branch._format)
2181
class Converter5to6(object):
2182
"""Perform an in-place upgrade of format 5 to format 6"""
2184
def convert(self, branch):
2185
# Data for 5 and 6 can peacefully coexist.
2186
format = BzrBranchFormat6()
2187
new_branch = format.open(branch.bzrdir, _found=True)
2189
# Copy source data into target
2190
new_branch.set_last_revision_info(*branch.last_revision_info())
2191
new_branch.set_parent(branch.get_parent())
2192
new_branch.set_bound_location(branch.get_bound_location())
2193
new_branch.set_push_location(branch.get_push_location())
2195
# New branch has no tags by default
2196
new_branch.tags._set_tag_dict({})
2198
# Copying done; now update target format
2199
new_branch.control_files.put_utf8('format',
2200
format.get_format_string())
2202
# Clean up old files
2203
new_branch.control_files._transport.delete('revision-history')
2205
branch.set_parent(None)
2208
branch.set_bound_location(None)
added
removed
bzrlib/branch.py
