1
# Copyright (C) 2005, 2006 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 copy import deepcopy
19
from cStringIO import StringIO
20
from unittest import TestSuite
21
from warnings import warn
36
from bzrlib.config import TreeConfig
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
import bzrlib.errors as errors
39
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
40
HistoryMissing, InvalidRevisionId,
41
InvalidRevisionNumber, LockError, NoSuchFile,
42
NoSuchRevision, NoWorkingTree, NotVersionedError,
43
NotBranchError, UninitializableFormat,
44
UnlistableStore, UnlistableBranch,
46
from bzrlib.lockable_files import LockableFiles, TransportLock
47
from bzrlib.symbol_versioning import (deprecated_function,
51
zero_eight, zero_nine,
53
from bzrlib.trace import mutter, note
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
58
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
61
# TODO: Maybe include checks for common corruption of newlines, etc?
63
# TODO: Some operations like log might retrieve the same revisions
64
# repeatedly to calculate deltas. We could perhaps have a weakref
65
# cache in memory to make this faster. In general anything can be
66
# cached in memory between lock and unlock operations. .. nb thats
67
# what the transaction identity map provides
70
######################################################################
74
"""Branch holding a history of revisions.
77
Base directory/url of the branch.
79
# this is really an instance variable - FIXME move it there
83
def __init__(self, *ignored, **ignored_too):
84
raise NotImplementedError('The Branch class is abstract')
87
"""Break a lock if one is present from another instance.
89
Uses the ui factory to ask for confirmation if the lock may be from
92
This will probe the repository for its lock as well.
94
self.control_files.break_lock()
95
self.repository.break_lock()
96
master = self.get_master_branch()
97
if master is not None:
101
@deprecated_method(zero_eight)
102
def open_downlevel(base):
103
"""Open a branch which may be of an old format."""
104
return Branch.open(base, _unsupported=True)
107
def open(base, _unsupported=False):
108
"""Open the branch rooted at base.
110
For instance, if the branch is at URL/.bzr/branch,
111
Branch.open(URL) -> a Branch instance.
113
control = bzrdir.BzrDir.open(base, _unsupported)
114
return control.open_branch(_unsupported)
117
def open_containing(url):
118
"""Open an existing branch which contains url.
120
This probes for a branch at url, and searches upwards from there.
122
Basically we keep looking up until we find the control directory or
123
run into the root. If there isn't one, raises NotBranchError.
124
If there is one and it is either an unrecognised format or an unsupported
125
format, UnknownFormatError or UnsupportedFormatError are raised.
126
If there is one, it is returned, along with the unused portion of url.
128
control, relpath = bzrdir.BzrDir.open_containing(url)
129
return control.open_branch(), relpath
132
@deprecated_function(zero_eight)
133
def initialize(base):
134
"""Create a new working tree and branch, rooted at 'base' (url)
136
NOTE: This will soon be deprecated in favour of creation
139
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
141
@deprecated_function(zero_eight)
142
def setup_caching(self, cache_root):
143
"""Subclasses that care about caching should override this, and set
144
up cached stores located under cache_root.
146
NOTE: This is unused.
150
def get_config(self):
151
return bzrlib.config.BranchConfig(self)
154
return self.get_config().get_nickname()
156
def _set_nick(self, nick):
157
self.get_config().set_user_option('nickname', nick)
159
nick = property(_get_nick, _set_nick)
162
raise NotImplementedError(self.is_locked)
164
def lock_write(self):
165
raise NotImplementedError(self.lock_write)
168
raise NotImplementedError(self.lock_read)
171
raise NotImplementedError(self.unlock)
173
def peek_lock_mode(self):
174
"""Return lock mode for the Branch: 'r', 'w' or None"""
175
raise NotImplementedError(self.peek_lock_mode)
177
def get_physical_lock_status(self):
178
raise NotImplementedError(self.get_physical_lock_status)
180
def abspath(self, name):
181
"""Return absolute filename for something in the branch
183
XXX: Robert Collins 20051017 what is this used for? why is it a branch
184
method and not a tree method.
186
raise NotImplementedError(self.abspath)
188
def bind(self, other):
189
"""Bind the local branch the other branch.
191
:param other: The branch to bind to
194
raise errors.UpgradeRequired(self.base)
197
def fetch(self, from_branch, last_revision=None, pb=None):
198
"""Copy revisions from from_branch into this branch.
200
:param from_branch: Where to copy from.
201
:param last_revision: What revision to stop at (None for at the end
203
:param pb: An optional progress bar to use.
205
Returns the copied revision count and the failed revisions in a tuple:
208
if self.base == from_branch.base:
211
nested_pb = ui.ui_factory.nested_progress_bar()
216
from_branch.lock_read()
218
if last_revision is None:
219
pb.update('get source history')
220
from_history = from_branch.revision_history()
222
last_revision = from_history[-1]
224
# no history in the source branch
225
last_revision = revision.NULL_REVISION
226
return self.repository.fetch(from_branch.repository,
227
revision_id=last_revision,
230
if nested_pb is not None:
234
def get_bound_location(self):
235
"""Return the URL of the branch we are bound to.
237
Older format branches cannot bind, please be sure to use a metadir
242
def get_commit_builder(self, parents, config=None, timestamp=None,
243
timezone=None, committer=None, revprops=None,
245
"""Obtain a CommitBuilder for this branch.
247
:param parents: Revision ids of the parents of the new revision.
248
:param config: Optional configuration to use.
249
:param timestamp: Optional timestamp recorded for commit.
250
:param timezone: Optional timezone for timestamp.
251
:param committer: Optional committer to set for commit.
252
:param revprops: Optional dictionary of revision properties.
253
:param revision_id: Optional revision id.
257
config = self.get_config()
259
return self.repository.get_commit_builder(self, parents, config,
260
timestamp, timezone, committer, revprops, revision_id)
262
def get_master_branch(self):
263
"""Return the branch we are bound to.
265
:return: Either a Branch, or None
269
def get_revision_delta(self, revno):
270
"""Return the delta for one revision.
272
The delta is relative to its mainline predecessor, or the
273
empty tree for revision 1.
275
assert isinstance(revno, int)
276
rh = self.revision_history()
277
if not (1 <= revno <= len(rh)):
278
raise InvalidRevisionNumber(revno)
279
return self.repository.get_revision_delta(rh[revno-1])
281
def get_root_id(self):
282
"""Return the id of this branches root"""
283
raise NotImplementedError(self.get_root_id)
285
def print_file(self, file, revision_id):
286
"""Print `file` to stdout."""
287
raise NotImplementedError(self.print_file)
289
def append_revision(self, *revision_ids):
290
raise NotImplementedError(self.append_revision)
292
def set_revision_history(self, rev_history):
293
raise NotImplementedError(self.set_revision_history)
295
def revision_history(self):
296
"""Return sequence of revision hashes on to this branch."""
297
raise NotImplementedError(self.revision_history)
300
"""Return current revision number for this branch.
302
That is equivalent to the number of revisions committed to
305
return len(self.revision_history())
308
"""Older format branches cannot bind or unbind."""
309
raise errors.UpgradeRequired(self.base)
311
def last_revision(self):
312
"""Return last revision id, or None"""
313
ph = self.revision_history()
319
def missing_revisions(self, other, stop_revision=None):
320
"""Return a list of new revisions that would perfectly fit.
322
If self and other have not diverged, return a list of the revisions
323
present in other, but missing from self.
325
self_history = self.revision_history()
326
self_len = len(self_history)
327
other_history = other.revision_history()
328
other_len = len(other_history)
329
common_index = min(self_len, other_len) -1
330
if common_index >= 0 and \
331
self_history[common_index] != other_history[common_index]:
332
raise DivergedBranches(self, other)
334
if stop_revision is None:
335
stop_revision = other_len
337
assert isinstance(stop_revision, int)
338
if stop_revision > other_len:
339
raise errors.NoSuchRevision(self, stop_revision)
340
return other_history[self_len:stop_revision]
342
def update_revisions(self, other, stop_revision=None):
343
"""Pull in new perfect-fit revisions.
345
:param other: Another Branch to pull from
346
:param stop_revision: Updated until the given revision
349
raise NotImplementedError(self.update_revisions)
351
def revision_id_to_revno(self, revision_id):
352
"""Given a revision id, return its revno"""
353
if revision_id is None:
355
history = self.revision_history()
357
return history.index(revision_id) + 1
359
raise bzrlib.errors.NoSuchRevision(self, revision_id)
361
def get_rev_id(self, revno, history=None):
362
"""Find the revision id of the specified revno."""
366
history = self.revision_history()
367
if revno <= 0 or revno > len(history):
368
raise bzrlib.errors.NoSuchRevision(self, revno)
369
return history[revno - 1]
371
def pull(self, source, overwrite=False, stop_revision=None):
372
raise NotImplementedError(self.pull)
374
def basis_tree(self):
375
"""Return `Tree` object for last revision."""
376
return self.repository.revision_tree(self.last_revision())
378
def rename_one(self, from_rel, to_rel):
381
This can change the directory or the filename or both.
383
raise NotImplementedError(self.rename_one)
385
def move(self, from_paths, to_name):
388
to_name must exist as a versioned directory.
390
If to_name exists and is a directory, the files are moved into
391
it, keeping their old names. If it is a directory,
393
Note that to_name is only the last component of the new name;
394
this doesn't change the directory.
396
This returns a list of (from_path, to_path) pairs for each
399
raise NotImplementedError(self.move)
401
def get_parent(self):
402
"""Return the parent location of the branch.
404
This is the default location for push/pull/missing. The usual
405
pattern is that the user can override it by specifying a
408
raise NotImplementedError(self.get_parent)
410
def get_submit_branch(self):
411
"""Return the submit location of the branch.
413
This is the default location for bundle. The usual
414
pattern is that the user can override it by specifying a
417
return self.get_config().get_user_option('submit_branch')
419
def set_submit_branch(self, location):
420
"""Return the submit location of the branch.
422
This is the default location for bundle. The usual
423
pattern is that the user can override it by specifying a
426
self.get_config().set_user_option('submit_branch', location)
428
def get_push_location(self):
429
"""Return the None or the location to push this branch to."""
430
raise NotImplementedError(self.get_push_location)
432
def set_push_location(self, location):
433
"""Set a new push location for this branch."""
434
raise NotImplementedError(self.set_push_location)
436
def set_parent(self, url):
437
raise NotImplementedError(self.set_parent)
441
"""Synchronise this branch with the master branch if any.
443
:return: None or the last_revision pivoted out during the update.
447
def check_revno(self, revno):
449
Check whether a revno corresponds to any revision.
450
Zero (the NULL revision) is considered valid.
453
self.check_real_revno(revno)
455
def check_real_revno(self, revno):
457
Check whether a revno corresponds to a real revision.
458
Zero (the NULL revision) is considered invalid
460
if revno < 1 or revno > self.revno():
461
raise InvalidRevisionNumber(revno)
464
def clone(self, *args, **kwargs):
465
"""Clone this branch into to_bzrdir preserving all semantic values.
467
revision_id: if not None, the revision history in the new branch will
468
be truncated to end with revision_id.
470
# for API compatibility, until 0.8 releases we provide the old api:
471
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
472
# after 0.8 releases, the *args and **kwargs should be changed:
473
# def clone(self, to_bzrdir, revision_id=None):
474
if (kwargs.get('to_location', None) or
475
kwargs.get('revision', None) or
476
kwargs.get('basis_branch', None) or
477
(len(args) and isinstance(args[0], basestring))):
478
# backwards compatibility api:
479
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
480
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
483
basis_branch = args[2]
485
basis_branch = kwargs.get('basis_branch', None)
487
basis = basis_branch.bzrdir
492
revision_id = args[1]
494
revision_id = kwargs.get('revision', None)
499
# no default to raise if not provided.
500
url = kwargs.get('to_location')
501
return self.bzrdir.clone(url,
502
revision_id=revision_id,
503
basis=basis).open_branch()
505
# generate args by hand
507
revision_id = args[1]
509
revision_id = kwargs.get('revision_id', None)
513
# no default to raise if not provided.
514
to_bzrdir = kwargs.get('to_bzrdir')
515
result = self._format.initialize(to_bzrdir)
516
self.copy_content_into(result, revision_id=revision_id)
520
def sprout(self, to_bzrdir, revision_id=None):
521
"""Create a new line of development from the branch, into to_bzrdir.
523
revision_id: if not None, the revision history in the new branch will
524
be truncated to end with revision_id.
526
result = self._format.initialize(to_bzrdir)
527
self.copy_content_into(result, revision_id=revision_id)
528
result.set_parent(self.bzrdir.root_transport.base)
532
def copy_content_into(self, destination, revision_id=None):
533
"""Copy the content of self into destination.
535
revision_id: if not None, the revision history in the new branch will
536
be truncated to end with revision_id.
538
new_history = self.revision_history()
539
if revision_id is not None:
541
new_history = new_history[:new_history.index(revision_id) + 1]
543
rev = self.repository.get_revision(revision_id)
544
new_history = rev.get_history(self.repository)[1:]
545
destination.set_revision_history(new_history)
547
parent = self.get_parent()
548
except errors.InaccessibleParent, e:
549
mutter('parent was not accessible to copy: %s', e)
552
destination.set_parent(parent)
556
"""Check consistency of the branch.
558
In particular this checks that revisions given in the revision-history
559
do actually match up in the revision graph, and that they're all
560
present in the repository.
562
Callers will typically also want to check the repository.
564
:return: A BranchCheckResult.
566
mainline_parent_id = None
567
for revision_id in self.revision_history():
569
revision = self.repository.get_revision(revision_id)
570
except errors.NoSuchRevision, e:
571
raise errors.BzrCheckError("mainline revision {%s} not in repository"
573
# In general the first entry on the revision history has no parents.
574
# But it's not illegal for it to have parents listed; this can happen
575
# in imports from Arch when the parents weren't reachable.
576
if mainline_parent_id is not None:
577
if mainline_parent_id not in revision.parent_ids:
578
raise errors.BzrCheckError("previous revision {%s} not listed among "
580
% (mainline_parent_id, revision_id))
581
mainline_parent_id = revision_id
582
return BranchCheckResult(self)
584
def create_checkout(self, to_location, revision_id=None,
586
"""Create a checkout of a branch.
588
:param to_location: The url to produce the checkout at
589
:param revision_id: The revision to check out
590
:param lightweight: If True, produce a lightweight checkout, otherwise,
591
produce a bound branch (heavyweight checkout)
592
:return: The tree of the created checkout
595
t = transport.get_transport(to_location)
598
except errors.FileExists:
600
checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
601
BranchReferenceFormat().initialize(checkout, self)
603
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
604
to_location, force_new_tree=False)
605
checkout = checkout_branch.bzrdir
606
checkout_branch.bind(self)
607
if revision_id is not None:
608
rh = checkout_branch.revision_history()
609
new_rh = rh[:rh.index(revision_id) + 1]
610
checkout_branch.set_revision_history(new_rh)
611
return checkout.create_workingtree(revision_id)
614
class BranchFormat(object):
615
"""An encapsulation of the initialization and open routines for a format.
617
Formats provide three things:
618
* An initialization routine,
622
Formats are placed in an dict by their format string for reference
623
during branch opening. Its not required that these be instances, they
624
can be classes themselves with class methods - it simply depends on
625
whether state is needed for a given format or not.
627
Once a format is deprecated, just deprecate the initialize and open
628
methods on the format class. Do not deprecate the object, as the
629
object will be created every time regardless.
632
_default_format = None
633
"""The default format used for new branches."""
636
"""The known formats."""
639
def find_format(klass, a_bzrdir):
640
"""Return the format for the branch object in a_bzrdir."""
642
transport = a_bzrdir.get_branch_transport(None)
643
format_string = transport.get("format").read()
644
return klass._formats[format_string]
646
raise NotBranchError(path=transport.base)
648
raise errors.UnknownFormatError(format=format_string)
651
def get_default_format(klass):
652
"""Return the current default format."""
653
return klass._default_format
655
def get_format_string(self):
656
"""Return the ASCII format string that identifies this format."""
657
raise NotImplementedError(self.get_format_string)
659
def get_format_description(self):
660
"""Return the short format description for this format."""
661
raise NotImplementedError(self.get_format_string)
663
def initialize(self, a_bzrdir):
664
"""Create a branch of this format in a_bzrdir."""
665
raise NotImplementedError(self.initialize)
667
def is_supported(self):
668
"""Is this format supported?
670
Supported formats can be initialized and opened.
671
Unsupported formats may not support initialization or committing or
672
some other features depending on the reason for not being supported.
676
def open(self, a_bzrdir, _found=False):
677
"""Return the branch object for a_bzrdir
679
_found is a private parameter, do not use it. It is used to indicate
680
if format probing has already be done.
682
raise NotImplementedError(self.open)
685
def register_format(klass, format):
686
klass._formats[format.get_format_string()] = format
689
def set_default_format(klass, format):
690
klass._default_format = format
693
def unregister_format(klass, format):
694
assert klass._formats[format.get_format_string()] is format
695
del klass._formats[format.get_format_string()]
698
return self.get_format_string().rstrip()
701
class BzrBranchFormat4(BranchFormat):
702
"""Bzr branch format 4.
705
- a revision-history file.
706
- a branch-lock lock file [ to be shared with the bzrdir ]
709
def get_format_description(self):
710
"""See BranchFormat.get_format_description()."""
711
return "Branch format 4"
713
def initialize(self, a_bzrdir):
714
"""Create a branch of this format in a_bzrdir."""
715
mutter('creating branch in %s', a_bzrdir.transport.base)
716
branch_transport = a_bzrdir.get_branch_transport(self)
717
utf8_files = [('revision-history', ''),
720
control_files = LockableFiles(branch_transport, 'branch-lock',
722
control_files.create_lock()
723
control_files.lock_write()
725
for file, content in utf8_files:
726
control_files.put_utf8(file, content)
728
control_files.unlock()
729
return self.open(a_bzrdir, _found=True)
732
super(BzrBranchFormat4, self).__init__()
733
self._matchingbzrdir = bzrdir.BzrDirFormat6()
735
def open(self, a_bzrdir, _found=False):
736
"""Return the branch object for a_bzrdir
738
_found is a private parameter, do not use it. It is used to indicate
739
if format probing has already be done.
742
# we are being called directly and must probe.
743
raise NotImplementedError
744
return BzrBranch(_format=self,
745
_control_files=a_bzrdir._control_files,
747
_repository=a_bzrdir.open_repository())
750
return "Bazaar-NG branch format 4"
753
class BzrBranchFormat5(BranchFormat):
754
"""Bzr branch format 5.
757
- a revision-history file.
759
- a lock dir guarding the branch itself
760
- all of this stored in a branch/ subdirectory
761
- works with shared repositories.
763
This format is new in bzr 0.8.
766
def get_format_string(self):
767
"""See BranchFormat.get_format_string()."""
768
return "Bazaar-NG branch format 5\n"
770
def get_format_description(self):
771
"""See BranchFormat.get_format_description()."""
772
return "Branch format 5"
774
def initialize(self, a_bzrdir):
775
"""Create a branch of this format in a_bzrdir."""
776
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
777
branch_transport = a_bzrdir.get_branch_transport(self)
778
utf8_files = [('revision-history', ''),
781
control_files = LockableFiles(branch_transport, 'lock', lockdir.LockDir)
782
control_files.create_lock()
783
control_files.lock_write()
784
control_files.put_utf8('format', self.get_format_string())
786
for file, content in utf8_files:
787
control_files.put_utf8(file, content)
789
control_files.unlock()
790
return self.open(a_bzrdir, _found=True, )
793
super(BzrBranchFormat5, self).__init__()
794
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
796
def open(self, a_bzrdir, _found=False):
797
"""Return the branch object for a_bzrdir
799
_found is a private parameter, do not use it. It is used to indicate
800
if format probing has already be done.
803
format = BranchFormat.find_format(a_bzrdir)
804
assert format.__class__ == self.__class__
805
transport = a_bzrdir.get_branch_transport(None)
806
control_files = LockableFiles(transport, 'lock', lockdir.LockDir)
807
return BzrBranch5(_format=self,
808
_control_files=control_files,
810
_repository=a_bzrdir.find_repository())
813
return "Bazaar-NG Metadir branch format 5"
816
class BranchReferenceFormat(BranchFormat):
817
"""Bzr branch reference format.
819
Branch references are used in implementing checkouts, they
820
act as an alias to the real branch which is at some other url.
827
def get_format_string(self):
828
"""See BranchFormat.get_format_string()."""
829
return "Bazaar-NG Branch Reference Format 1\n"
831
def get_format_description(self):
832
"""See BranchFormat.get_format_description()."""
833
return "Checkout reference format 1"
835
def initialize(self, a_bzrdir, target_branch=None):
836
"""Create a branch of this format in a_bzrdir."""
837
if target_branch is None:
838
# this format does not implement branch itself, thus the implicit
839
# creation contract must see it as uninitializable
840
raise errors.UninitializableFormat(self)
841
mutter('creating branch reference in %s', a_bzrdir.transport.base)
842
branch_transport = a_bzrdir.get_branch_transport(self)
843
branch_transport.put_bytes('location',
844
target_branch.bzrdir.root_transport.base)
845
branch_transport.put_bytes('format', self.get_format_string())
846
return self.open(a_bzrdir, _found=True)
849
super(BranchReferenceFormat, self).__init__()
850
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
852
def _make_reference_clone_function(format, a_branch):
853
"""Create a clone() routine for a branch dynamically."""
854
def clone(to_bzrdir, revision_id=None):
855
"""See Branch.clone()."""
856
return format.initialize(to_bzrdir, a_branch)
857
# cannot obey revision_id limits when cloning a reference ...
858
# FIXME RBC 20060210 either nuke revision_id for clone, or
859
# emit some sort of warning/error to the caller ?!
862
def open(self, a_bzrdir, _found=False):
863
"""Return the branch that the branch reference in a_bzrdir points at.
865
_found is a private parameter, do not use it. It is used to indicate
866
if format probing has already be done.
869
format = BranchFormat.find_format(a_bzrdir)
870
assert format.__class__ == self.__class__
871
transport = a_bzrdir.get_branch_transport(None)
872
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
873
result = real_bzrdir.open_branch()
874
# this changes the behaviour of result.clone to create a new reference
875
# rather than a copy of the content of the branch.
876
# I did not use a proxy object because that needs much more extensive
877
# testing, and we are only changing one behaviour at the moment.
878
# If we decide to alter more behaviours - i.e. the implicit nickname
879
# then this should be refactored to introduce a tested proxy branch
880
# and a subclass of that for use in overriding clone() and ....
882
result.clone = self._make_reference_clone_function(result)
886
# formats which have no format string are not discoverable
887
# and not independently creatable, so are not registered.
888
__default_format = BzrBranchFormat5()
889
BranchFormat.register_format(__default_format)
890
BranchFormat.register_format(BranchReferenceFormat())
891
BranchFormat.set_default_format(__default_format)
892
_legacy_formats = [BzrBranchFormat4(),
895
class BzrBranch(Branch):
896
"""A branch stored in the actual filesystem.
898
Note that it's "local" in the context of the filesystem; it doesn't
899
really matter if it's on an nfs/smb/afs/coda/... share, as long as
900
it's writable, and can be accessed via the normal filesystem API.
903
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
904
relax_version_check=DEPRECATED_PARAMETER, _format=None,
905
_control_files=None, a_bzrdir=None, _repository=None):
906
"""Create new branch object at a particular location.
908
transport -- A Transport object, defining how to access files.
910
init -- If True, create new control files in a previously
911
unversioned directory. If False, the branch must already
914
relax_version_check -- If true, the usual check for the branch
915
version is not applied. This is intended only for
916
upgrade/recovery type use; it's not guaranteed that
917
all operations will work on old format branches.
920
self.bzrdir = bzrdir.BzrDir.open(transport.base)
922
self.bzrdir = a_bzrdir
923
self._transport = self.bzrdir.transport.clone('..')
924
self._base = self._transport.base
925
self._format = _format
926
if _control_files is None:
927
raise ValueError('BzrBranch _control_files is None')
928
self.control_files = _control_files
929
if deprecated_passed(init):
930
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
931
"deprecated as of bzr 0.8. Please use Branch.create().",
935
# this is slower than before deprecation, oh well never mind.
937
self._initialize(transport.base)
938
self._check_format(_format)
939
if deprecated_passed(relax_version_check):
940
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
941
"relax_version_check parameter is deprecated as of bzr 0.8. "
942
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
946
if (not relax_version_check
947
and not self._format.is_supported()):
948
raise errors.UnsupportedFormatError(format=fmt)
949
if deprecated_passed(transport):
950
warn("BzrBranch.__init__(transport=XXX...): The transport "
951
"parameter is deprecated as of bzr 0.8. "
952
"Please use Branch.open, or bzrdir.open_branch().",
955
self.repository = _repository
958
return '%s(%r)' % (self.__class__.__name__, self.base)
965
base = property(_get_base, doc="The URL for the root of this branch.")
967
def _finish_transaction(self):
968
"""Exit the current transaction."""
969
return self.control_files._finish_transaction()
971
def get_transaction(self):
972
"""Return the current active transaction.
974
If no transaction is active, this returns a passthrough object
975
for which all data is immediately flushed and no caching happens.
977
# this is an explicit function so that we can do tricky stuff
978
# when the storage in rev_storage is elsewhere.
979
# we probably need to hook the two 'lock a location' and
980
# 'have a transaction' together more delicately, so that
981
# we can have two locks (branch and storage) and one transaction
982
# ... and finishing the transaction unlocks both, but unlocking
983
# does not. - RBC 20051121
984
return self.control_files.get_transaction()
986
def _set_transaction(self, transaction):
987
"""Set a new active transaction."""
988
return self.control_files._set_transaction(transaction)
990
def abspath(self, name):
991
"""See Branch.abspath."""
992
return self.control_files._transport.abspath(name)
994
def _check_format(self, format):
995
"""Identify the branch format if needed.
997
The format is stored as a reference to the format object in
998
self._format for code that needs to check it later.
1000
The format parameter is either None or the branch format class
1001
used to open this branch.
1003
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1006
format = BranchFormat.find_format(self.bzrdir)
1007
self._format = format
1008
mutter("got branch format %s", self._format)
1011
def get_root_id(self):
1012
"""See Branch.get_root_id."""
1013
tree = self.repository.revision_tree(self.last_revision())
1014
return tree.inventory.root.file_id
1016
def is_locked(self):
1017
return self.control_files.is_locked()
1019
def lock_write(self):
1020
self.repository.lock_write()
1022
self.control_files.lock_write()
1024
self.repository.unlock()
1027
def lock_read(self):
1028
self.repository.lock_read()
1030
self.control_files.lock_read()
1032
self.repository.unlock()
1036
# TODO: test for failed two phase locks. This is known broken.
1038
self.control_files.unlock()
1040
self.repository.unlock()
1042
def peek_lock_mode(self):
1043
if self.control_files._lock_count == 0:
1046
return self.control_files._lock_mode
1048
def get_physical_lock_status(self):
1049
return self.control_files.get_physical_lock_status()
1052
def print_file(self, file, revision_id):
1053
"""See Branch.print_file."""
1054
return self.repository.print_file(file, revision_id)
1057
def append_revision(self, *revision_ids):
1058
"""See Branch.append_revision."""
1059
for revision_id in revision_ids:
1060
mutter("add {%s} to revision-history" % revision_id)
1061
rev_history = self.revision_history()
1062
rev_history.extend(revision_ids)
1063
self.set_revision_history(rev_history)
1066
def set_revision_history(self, rev_history):
1067
"""See Branch.set_revision_history."""
1068
self.control_files.put_utf8(
1069
'revision-history', '\n'.join(rev_history))
1070
transaction = self.get_transaction()
1071
history = transaction.map.find_revision_history()
1072
if history is not None:
1073
# update the revision history in the identity map.
1074
history[:] = list(rev_history)
1075
# this call is disabled because revision_history is
1076
# not really an object yet, and the transaction is for objects.
1077
# transaction.register_dirty(history)
1079
transaction.map.add_revision_history(rev_history)
1080
# this call is disabled because revision_history is
1081
# not really an object yet, and the transaction is for objects.
1082
# transaction.register_clean(history)
1085
def revision_history(self):
1086
"""See Branch.revision_history."""
1087
transaction = self.get_transaction()
1088
history = transaction.map.find_revision_history()
1089
if history is not None:
1090
# mutter("cache hit for revision-history in %s", self)
1091
return list(history)
1092
decode_utf8 = cache_utf8.decode
1093
history = [decode_utf8(l.rstrip('\r\n')) for l in
1094
self.control_files.get('revision-history').readlines()]
1095
transaction.map.add_revision_history(history)
1096
# this call is disabled because revision_history is
1097
# not really an object yet, and the transaction is for objects.
1098
# transaction.register_clean(history, precious=True)
1099
return list(history)
1102
def generate_revision_history(self, revision_id, last_rev=None,
1104
"""Create a new revision history that will finish with revision_id.
1106
:param revision_id: the new tip to use.
1107
:param last_rev: The previous last_revision. If not None, then this
1108
must be a ancestory of revision_id, or DivergedBranches is raised.
1109
:param other_branch: The other branch that DivergedBranches should
1110
raise with respect to.
1112
# stop_revision must be a descendant of last_revision
1113
stop_graph = self.repository.get_revision_graph(revision_id)
1114
if last_rev is not None and last_rev not in stop_graph:
1115
# our previous tip is not merged into stop_revision
1116
raise errors.DivergedBranches(self, other_branch)
1117
# make a new revision history from the graph
1118
current_rev_id = revision_id
1120
while current_rev_id not in (None, revision.NULL_REVISION):
1121
new_history.append(current_rev_id)
1122
current_rev_id_parents = stop_graph[current_rev_id]
1124
current_rev_id = current_rev_id_parents[0]
1126
current_rev_id = None
1127
new_history.reverse()
1128
self.set_revision_history(new_history)
1131
def update_revisions(self, other, stop_revision=None):
1132
"""See Branch.update_revisions."""
1135
if stop_revision is None:
1136
stop_revision = other.last_revision()
1137
if stop_revision is None:
1138
# if there are no commits, we're done.
1140
# whats the current last revision, before we fetch [and change it
1142
last_rev = self.last_revision()
1143
# we fetch here regardless of whether we need to so that we pickup
1145
self.fetch(other, stop_revision)
1146
my_ancestry = self.repository.get_ancestry(last_rev)
1147
if stop_revision in my_ancestry:
1148
# last_revision is a descendant of stop_revision
1150
self.generate_revision_history(stop_revision, last_rev=last_rev,
1155
def basis_tree(self):
1156
"""See Branch.basis_tree."""
1157
return self.repository.revision_tree(self.last_revision())
1159
@deprecated_method(zero_eight)
1160
def working_tree(self):
1161
"""Create a Working tree object for this branch."""
1163
from bzrlib.transport.local import LocalTransport
1164
if (self.base.find('://') != -1 or
1165
not isinstance(self._transport, LocalTransport)):
1166
raise NoWorkingTree(self.base)
1167
return self.bzrdir.open_workingtree()
1170
def pull(self, source, overwrite=False, stop_revision=None):
1171
"""See Branch.pull."""
1174
old_count = len(self.revision_history())
1176
self.update_revisions(source, stop_revision)
1177
except DivergedBranches:
1181
self.set_revision_history(source.revision_history())
1182
new_count = len(self.revision_history())
1183
return new_count - old_count
1187
def get_parent(self):
1188
"""See Branch.get_parent."""
1190
_locs = ['parent', 'pull', 'x-pull']
1191
assert self.base[-1] == '/'
1194
parent = self.control_files.get(l).read().strip('\n')
1197
# This is an old-format absolute path to a local branch
1198
# turn it into a url
1199
if parent.startswith('/'):
1200
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1202
return urlutils.join(self.base[:-1], parent)
1203
except errors.InvalidURLJoin, e:
1204
raise errors.InaccessibleParent(parent, self.base)
1207
def get_push_location(self):
1208
"""See Branch.get_push_location."""
1209
push_loc = self.get_config().get_user_option('push_location')
1212
def set_push_location(self, location):
1213
"""See Branch.set_push_location."""
1214
self.get_config().set_user_option('push_location', location,
1218
def set_parent(self, url):
1219
"""See Branch.set_parent."""
1220
# TODO: Maybe delete old location files?
1221
# URLs should never be unicode, even on the local fs,
1222
# FIXUP this and get_parent in a future branch format bump:
1223
# read and rewrite the file, and have the new format code read
1224
# using .get not .get_utf8. RBC 20060125
1226
self.control_files._transport.delete('parent')
1228
if isinstance(url, unicode):
1230
url = url.encode('ascii')
1231
except UnicodeEncodeError:
1232
raise bzrlib.errors.InvalidURL(url,
1233
"Urls must be 7-bit ascii, "
1234
"use bzrlib.urlutils.escape")
1236
url = urlutils.relative_url(self.base, url)
1237
self.control_files.put('parent', StringIO(url + '\n'))
1239
@deprecated_function(zero_nine)
1240
def tree_config(self):
1241
"""DEPRECATED; call get_config instead.
1242
TreeConfig has become part of BranchConfig."""
1243
return TreeConfig(self)
1246
class BzrBranch5(BzrBranch):
1247
"""A format 5 branch. This supports new features over plan branches.
1249
It has support for a master_branch which is the data for bound branches.
1257
super(BzrBranch5, self).__init__(_format=_format,
1258
_control_files=_control_files,
1260
_repository=_repository)
1263
def pull(self, source, overwrite=False, stop_revision=None):
1264
"""Updates branch.pull to be bound branch aware."""
1265
bound_location = self.get_bound_location()
1266
if source.base != bound_location:
1267
# not pulling from master, so we need to update master.
1268
master_branch = self.get_master_branch()
1270
master_branch.pull(source)
1271
source = master_branch
1272
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1274
def get_bound_location(self):
1276
return self.control_files.get_utf8('bound').read()[:-1]
1277
except errors.NoSuchFile:
1281
def get_master_branch(self):
1282
"""Return the branch we are bound to.
1284
:return: Either a Branch, or None
1286
This could memoise the branch, but if thats done
1287
it must be revalidated on each new lock.
1288
So for now we just don't memoise it.
1289
# RBC 20060304 review this decision.
1291
bound_loc = self.get_bound_location()
1295
return Branch.open(bound_loc)
1296
except (errors.NotBranchError, errors.ConnectionError), e:
1297
raise errors.BoundBranchConnectionFailure(
1301
def set_bound_location(self, location):
1302
"""Set the target where this branch is bound to.
1304
:param location: URL to the target branch
1307
self.control_files.put_utf8('bound', location+'\n')
1310
self.control_files._transport.delete('bound')
1316
def bind(self, other):
1317
"""Bind the local branch the other branch.
1319
:param other: The branch to bind to
1322
# TODO: jam 20051230 Consider checking if the target is bound
1323
# It is debatable whether you should be able to bind to
1324
# a branch which is itself bound.
1325
# Committing is obviously forbidden,
1326
# but binding itself may not be.
1327
# Since we *have* to check at commit time, we don't
1328
# *need* to check here
1331
# we are now equal to or a suffix of other.
1333
# Since we have 'pulled' from the remote location,
1334
# now we should try to pull in the opposite direction
1335
# in case the local tree has more revisions than the
1337
# There may be a different check you could do here
1338
# rather than actually trying to install revisions remotely.
1339
# TODO: capture an exception which indicates the remote branch
1341
# If it is up-to-date, this probably should not be a failure
1343
# lock other for write so the revision-history syncing cannot race
1347
# if this does not error, other now has the same last rev we do
1348
# it can only error if the pull from other was concurrent with
1349
# a commit to other from someone else.
1351
# until we ditch revision-history, we need to sync them up:
1352
self.set_revision_history(other.revision_history())
1353
# now other and self are up to date with each other and have the
1354
# same revision-history.
1358
self.set_bound_location(other.base)
1362
"""If bound, unbind"""
1363
return self.set_bound_location(None)
1367
"""Synchronise this branch with the master branch if any.
1369
:return: None or the last_revision that was pivoted out during the
1372
master = self.get_master_branch()
1373
if master is not None:
1374
old_tip = self.last_revision()
1375
self.pull(master, overwrite=True)
1376
if old_tip in self.repository.get_ancestry(self.last_revision()):
1382
class BranchTestProviderAdapter(object):
1383
"""A tool to generate a suite testing multiple branch formats at once.
1385
This is done by copying the test once for each transport and injecting
1386
the transport_server, transport_readonly_server, and branch_format
1387
classes into each copy. Each copy is also given a new id() to make it
1391
def __init__(self, transport_server, transport_readonly_server, formats):
1392
self._transport_server = transport_server
1393
self._transport_readonly_server = transport_readonly_server
1394
self._formats = formats
1396
def adapt(self, test):
1397
result = TestSuite()
1398
for branch_format, bzrdir_format in self._formats:
1399
new_test = deepcopy(test)
1400
new_test.transport_server = self._transport_server
1401
new_test.transport_readonly_server = self._transport_readonly_server
1402
new_test.bzrdir_format = bzrdir_format
1403
new_test.branch_format = branch_format
1404
def make_new_test_id():
1405
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1406
return lambda: new_id
1407
new_test.id = make_new_test_id()
1408
result.addTest(new_test)
1412
class BranchCheckResult(object):
1413
"""Results of checking branch consistency.
1418
def __init__(self, branch):
1419
self.branch = branch
1421
def report_results(self, verbose):
1422
"""Report the check results via trace.note.
1424
:param verbose: Requests more detailed display of what was checked,
1427
note('checked branch %s format %s',
1429
self.branch._format)
1432
######################################################################
1436
@deprecated_function(zero_eight)
1437
def is_control_file(*args, **kwargs):
1438
"""See bzrlib.workingtree.is_control_file."""
1439
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
