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
35
from bzrlib.config import TreeConfig
36
from bzrlib.decorators import needs_read_lock, needs_write_lock
37
import bzrlib.errors as errors
38
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
39
HistoryMissing, InvalidRevisionId,
40
InvalidRevisionNumber, LockError, NoSuchFile,
41
NoSuchRevision, NoWorkingTree, NotVersionedError,
42
NotBranchError, UninitializableFormat,
43
UnlistableStore, UnlistableBranch,
45
from bzrlib.lockable_files import LockableFiles, TransportLock
46
from bzrlib.symbol_versioning import (deprecated_function,
50
zero_eight, zero_nine,
52
from bzrlib.trace import mutter, note
55
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
56
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
57
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
60
# TODO: Maybe include checks for common corruption of newlines, etc?
62
# TODO: Some operations like log might retrieve the same revisions
63
# repeatedly to calculate deltas. We could perhaps have a weakref
64
# cache in memory to make this faster. In general anything can be
65
# cached in memory between lock and unlock operations. .. nb thats
66
# what the transaction identity map provides
69
######################################################################
73
"""Branch holding a history of revisions.
76
Base directory/url of the branch.
78
# this is really an instance variable - FIXME move it there
82
def __init__(self, *ignored, **ignored_too):
83
raise NotImplementedError('The Branch class is abstract')
86
"""Break a lock if one is present from another instance.
88
Uses the ui factory to ask for confirmation if the lock may be from
91
This will probe the repository for its lock as well.
93
self.control_files.break_lock()
94
self.repository.break_lock()
95
master = self.get_master_branch()
96
if master is not None:
100
@deprecated_method(zero_eight)
101
def open_downlevel(base):
102
"""Open a branch which may be of an old format."""
103
return Branch.open(base, _unsupported=True)
106
def open(base, _unsupported=False):
107
"""Open the branch rooted at base.
109
For instance, if the branch is at URL/.bzr/branch,
110
Branch.open(URL) -> a Branch instance.
112
control = bzrdir.BzrDir.open(base, _unsupported)
113
return control.open_branch(_unsupported)
116
def open_containing(url):
117
"""Open an existing branch which contains url.
119
This probes for a branch at url, and searches upwards from there.
121
Basically we keep looking up until we find the control directory or
122
run into the root. If there isn't one, raises NotBranchError.
123
If there is one and it is either an unrecognised format or an unsupported
124
format, UnknownFormatError or UnsupportedFormatError are raised.
125
If there is one, it is returned, along with the unused portion of url.
127
control, relpath = bzrdir.BzrDir.open_containing(url)
128
return control.open_branch(), relpath
131
@deprecated_function(zero_eight)
132
def initialize(base):
133
"""Create a new working tree and branch, rooted at 'base' (url)
135
NOTE: This will soon be deprecated in favour of creation
138
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
140
def setup_caching(self, cache_root):
141
"""Subclasses that care about caching should override this, and set
142
up cached stores located under cache_root.
144
# seems to be unused, 2006-01-13 mbp
145
warn('%s is deprecated' % self.setup_caching)
146
self.cache_root = cache_root
148
def get_config(self):
149
return bzrlib.config.BranchConfig(self)
152
return self.get_config().get_nickname()
154
def _set_nick(self, nick):
155
self.get_config().set_user_option('nickname', nick)
157
nick = property(_get_nick, _set_nick)
160
raise NotImplementedError('is_locked is abstract')
162
def lock_write(self):
163
raise NotImplementedError('lock_write is abstract')
166
raise NotImplementedError('lock_read is abstract')
169
raise NotImplementedError('unlock is abstract')
171
def peek_lock_mode(self):
172
"""Return lock mode for the Branch: 'r', 'w' or None"""
173
raise NotImplementedError(self.peek_lock_mode)
175
def get_physical_lock_status(self):
176
raise NotImplementedError('get_physical_lock_status is abstract')
178
def abspath(self, name):
179
"""Return absolute filename for something in the branch
181
XXX: Robert Collins 20051017 what is this used for? why is it a branch
182
method and not a tree method.
184
raise NotImplementedError('abspath is abstract')
186
def bind(self, other):
187
"""Bind the local branch the other branch.
189
:param other: The branch to bind to
192
raise errors.UpgradeRequired(self.base)
195
def fetch(self, from_branch, last_revision=None, pb=None):
196
"""Copy revisions from from_branch into this branch.
198
:param from_branch: Where to copy from.
199
:param last_revision: What revision to stop at (None for at the end
201
:param pb: An optional progress bar to use.
203
Returns the copied revision count and the failed revisions in a tuple:
206
if self.base == from_branch.base:
209
nested_pb = ui.ui_factory.nested_progress_bar()
214
from_branch.lock_read()
216
if last_revision is None:
217
pb.update('get source history')
218
from_history = from_branch.revision_history()
220
last_revision = from_history[-1]
222
# no history in the source branch
223
last_revision = revision.NULL_REVISION
224
return self.repository.fetch(from_branch.repository,
225
revision_id=last_revision,
228
if nested_pb is not None:
232
def get_bound_location(self):
233
"""Return the URL of the branch we are bound to.
235
Older format branches cannot bind, please be sure to use a metadir
240
def get_commit_builder(self, parents, config=None, timestamp=None,
241
timezone=None, committer=None, revprops=None,
243
"""Obtain a CommitBuilder for this branch.
245
:param parents: Revision ids of the parents of the new revision.
246
:param config: Optional configuration to use.
247
:param timestamp: Optional timestamp recorded for commit.
248
:param timezone: Optional timezone for timestamp.
249
:param committer: Optional committer to set for commit.
250
:param revprops: Optional dictionary of revision properties.
251
:param revision_id: Optional revision id.
255
config = self.get_config()
257
return self.repository.get_commit_builder(self, parents, config,
258
timestamp, timezone, committer, revprops, revision_id)
260
def get_master_branch(self):
261
"""Return the branch we are bound to.
263
:return: Either a Branch, or None
267
def get_revision_delta(self, revno):
268
"""Return the delta for one revision.
270
The delta is relative to its mainline predecessor, or the
271
empty tree for revision 1.
273
assert isinstance(revno, int)
274
rh = self.revision_history()
275
if not (1 <= revno <= len(rh)):
276
raise InvalidRevisionNumber(revno)
277
return self.repository.get_revision_delta(rh[revno-1])
279
def get_root_id(self):
280
"""Return the id of this branches root"""
281
raise NotImplementedError('get_root_id is abstract')
283
def print_file(self, file, revision_id):
284
"""Print `file` to stdout."""
285
raise NotImplementedError('print_file is abstract')
287
def append_revision(self, *revision_ids):
288
raise NotImplementedError('append_revision is abstract')
290
def set_revision_history(self, rev_history):
291
raise NotImplementedError('set_revision_history is abstract')
293
def revision_history(self):
294
"""Return sequence of revision hashes on to this branch."""
295
raise NotImplementedError('revision_history is abstract')
298
"""Return current revision number for this branch.
300
That is equivalent to the number of revisions committed to
303
return len(self.revision_history())
306
"""Older format branches cannot bind or unbind."""
307
raise errors.UpgradeRequired(self.base)
309
def last_revision(self):
310
"""Return last patch hash, or None if no history."""
311
ph = self.revision_history()
317
def missing_revisions(self, other, stop_revision=None):
318
"""Return a list of new revisions that would perfectly fit.
320
If self and other have not diverged, return a list of the revisions
321
present in other, but missing from self.
323
self_history = self.revision_history()
324
self_len = len(self_history)
325
other_history = other.revision_history()
326
other_len = len(other_history)
327
common_index = min(self_len, other_len) -1
328
if common_index >= 0 and \
329
self_history[common_index] != other_history[common_index]:
330
raise DivergedBranches(self, other)
332
if stop_revision is None:
333
stop_revision = other_len
335
assert isinstance(stop_revision, int)
336
if stop_revision > other_len:
337
raise errors.NoSuchRevision(self, stop_revision)
338
return other_history[self_len:stop_revision]
340
def update_revisions(self, other, stop_revision=None):
341
"""Pull in new perfect-fit revisions.
343
:param other: Another Branch to pull from
344
:param stop_revision: Updated until the given revision
347
raise NotImplementedError('update_revisions is abstract')
349
def revision_id_to_revno(self, revision_id):
350
"""Given a revision id, return its revno"""
351
if revision_id is None:
353
history = self.revision_history()
355
return history.index(revision_id) + 1
357
raise bzrlib.errors.NoSuchRevision(self, revision_id)
359
def get_rev_id(self, revno, history=None):
360
"""Find the revision id of the specified revno."""
364
history = self.revision_history()
365
elif revno <= 0 or revno > len(history):
366
raise bzrlib.errors.NoSuchRevision(self, revno)
367
return history[revno - 1]
369
def pull(self, source, overwrite=False, stop_revision=None):
370
raise NotImplementedError('pull is abstract')
372
def basis_tree(self):
373
"""Return `Tree` object for last revision."""
374
return self.repository.revision_tree(self.last_revision())
376
def rename_one(self, from_rel, to_rel):
379
This can change the directory or the filename or both.
381
raise NotImplementedError('rename_one is abstract')
383
def move(self, from_paths, to_name):
386
to_name must exist as a versioned directory.
388
If to_name exists and is a directory, the files are moved into
389
it, keeping their old names. If it is a directory,
391
Note that to_name is only the last component of the new name;
392
this doesn't change the directory.
394
This returns a list of (from_path, to_path) pairs for each
397
raise NotImplementedError('move is abstract')
399
def get_parent(self):
400
"""Return the parent location of the branch.
402
This is the default location for push/pull/missing. The usual
403
pattern is that the user can override it by specifying a
406
raise NotImplementedError('get_parent is abstract')
408
def get_submit_branch(self):
409
"""Return the submit location of the branch.
411
This is the default location for bundle. The usual
412
pattern is that the user can override it by specifying a
415
return self.get_config().get_user_option('submit_branch')
417
def set_submit_branch(self, location):
418
"""Return the submit location of the branch.
420
This is the default location for bundle. The usual
421
pattern is that the user can override it by specifying a
424
self.get_config().set_user_option('submit_branch', location)
426
def get_push_location(self):
427
"""Return the None or the location to push this branch to."""
428
raise NotImplementedError('get_push_location is abstract')
430
def set_push_location(self, location):
431
"""Set a new push location for this branch."""
432
raise NotImplementedError('set_push_location is abstract')
434
def set_parent(self, url):
435
raise NotImplementedError('set_parent is abstract')
439
"""Synchronise this branch with the master branch if any.
441
:return: None or the last_revision pivoted out during the update.
445
def check_revno(self, revno):
447
Check whether a revno corresponds to any revision.
448
Zero (the NULL revision) is considered valid.
451
self.check_real_revno(revno)
453
def check_real_revno(self, revno):
455
Check whether a revno corresponds to a real revision.
456
Zero (the NULL revision) is considered invalid
458
if revno < 1 or revno > self.revno():
459
raise InvalidRevisionNumber(revno)
462
def clone(self, *args, **kwargs):
463
"""Clone this branch into to_bzrdir preserving all semantic values.
465
revision_id: if not None, the revision history in the new branch will
466
be truncated to end with revision_id.
468
# for API compatibility, until 0.8 releases we provide the old api:
469
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
470
# after 0.8 releases, the *args and **kwargs should be changed:
471
# def clone(self, to_bzrdir, revision_id=None):
472
if (kwargs.get('to_location', None) or
473
kwargs.get('revision', None) or
474
kwargs.get('basis_branch', None) or
475
(len(args) and isinstance(args[0], basestring))):
476
# backwards compatibility api:
477
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
478
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
481
basis_branch = args[2]
483
basis_branch = kwargs.get('basis_branch', None)
485
basis = basis_branch.bzrdir
490
revision_id = args[1]
492
revision_id = kwargs.get('revision', None)
497
# no default to raise if not provided.
498
url = kwargs.get('to_location')
499
return self.bzrdir.clone(url,
500
revision_id=revision_id,
501
basis=basis).open_branch()
503
# generate args by hand
505
revision_id = args[1]
507
revision_id = kwargs.get('revision_id', None)
511
# no default to raise if not provided.
512
to_bzrdir = kwargs.get('to_bzrdir')
513
result = self._format.initialize(to_bzrdir)
514
self.copy_content_into(result, revision_id=revision_id)
518
def sprout(self, to_bzrdir, revision_id=None):
519
"""Create a new line of development from the branch, into to_bzrdir.
521
revision_id: if not None, the revision history in the new branch will
522
be truncated to end with revision_id.
524
result = self._format.initialize(to_bzrdir)
525
self.copy_content_into(result, revision_id=revision_id)
526
result.set_parent(self.bzrdir.root_transport.base)
530
def copy_content_into(self, destination, revision_id=None):
531
"""Copy the content of self into destination.
533
revision_id: if not None, the revision history in the new branch will
534
be truncated to end with revision_id.
536
new_history = self.revision_history()
537
if revision_id is not None:
539
new_history = new_history[:new_history.index(revision_id) + 1]
541
rev = self.repository.get_revision(revision_id)
542
new_history = rev.get_history(self.repository)[1:]
543
destination.set_revision_history(new_history)
544
parent = self.get_parent()
546
destination.set_parent(parent)
550
"""Check consistency of the branch.
552
In particular this checks that revisions given in the revision-history
553
do actually match up in the revision graph, and that they're all
554
present in the repository.
556
Callers will typically also want to check the repository.
558
:return: A BranchCheckResult.
560
mainline_parent_id = None
561
for revision_id in self.revision_history():
563
revision = self.repository.get_revision(revision_id)
564
except errors.NoSuchRevision, e:
565
raise errors.BzrCheckError("mainline revision {%s} not in repository"
567
# In general the first entry on the revision history has no parents.
568
# But it's not illegal for it to have parents listed; this can happen
569
# in imports from Arch when the parents weren't reachable.
570
if mainline_parent_id is not None:
571
if mainline_parent_id not in revision.parent_ids:
572
raise errors.BzrCheckError("previous revision {%s} not listed among "
574
% (mainline_parent_id, revision_id))
575
mainline_parent_id = revision_id
576
return BranchCheckResult(self)
579
class BranchFormat(object):
580
"""An encapsulation of the initialization and open routines for a format.
582
Formats provide three things:
583
* An initialization routine,
587
Formats are placed in an dict by their format string for reference
588
during branch opening. Its not required that these be instances, they
589
can be classes themselves with class methods - it simply depends on
590
whether state is needed for a given format or not.
592
Once a format is deprecated, just deprecate the initialize and open
593
methods on the format class. Do not deprecate the object, as the
594
object will be created every time regardless.
597
_default_format = None
598
"""The default format used for new branches."""
601
"""The known formats."""
604
def find_format(klass, a_bzrdir):
605
"""Return the format for the branch object in a_bzrdir."""
607
transport = a_bzrdir.get_branch_transport(None)
608
format_string = transport.get("format").read()
609
return klass._formats[format_string]
611
raise NotBranchError(path=transport.base)
613
raise errors.UnknownFormatError(format=format_string)
616
def get_default_format(klass):
617
"""Return the current default format."""
618
return klass._default_format
620
def get_format_string(self):
621
"""Return the ASCII format string that identifies this format."""
622
raise NotImplementedError(self.get_format_string)
624
def get_format_description(self):
625
"""Return the short format description for this format."""
626
raise NotImplementedError(self.get_format_string)
628
def initialize(self, a_bzrdir):
629
"""Create a branch of this format in a_bzrdir."""
630
raise NotImplementedError(self.initialize)
632
def is_supported(self):
633
"""Is this format supported?
635
Supported formats can be initialized and opened.
636
Unsupported formats may not support initialization or committing or
637
some other features depending on the reason for not being supported.
641
def open(self, a_bzrdir, _found=False):
642
"""Return the branch object for a_bzrdir
644
_found is a private parameter, do not use it. It is used to indicate
645
if format probing has already be done.
647
raise NotImplementedError(self.open)
650
def register_format(klass, format):
651
klass._formats[format.get_format_string()] = format
654
def set_default_format(klass, format):
655
klass._default_format = format
658
def unregister_format(klass, format):
659
assert klass._formats[format.get_format_string()] is format
660
del klass._formats[format.get_format_string()]
663
return self.get_format_string().rstrip()
666
class BzrBranchFormat4(BranchFormat):
667
"""Bzr branch format 4.
670
- a revision-history file.
671
- a branch-lock lock file [ to be shared with the bzrdir ]
674
def get_format_description(self):
675
"""See BranchFormat.get_format_description()."""
676
return "Branch format 4"
678
def initialize(self, a_bzrdir):
679
"""Create a branch of this format in a_bzrdir."""
680
mutter('creating branch in %s', a_bzrdir.transport.base)
681
branch_transport = a_bzrdir.get_branch_transport(self)
682
utf8_files = [('revision-history', ''),
685
control_files = LockableFiles(branch_transport, 'branch-lock',
687
control_files.create_lock()
688
control_files.lock_write()
690
for file, content in utf8_files:
691
control_files.put_utf8(file, content)
693
control_files.unlock()
694
return self.open(a_bzrdir, _found=True)
697
super(BzrBranchFormat4, self).__init__()
698
self._matchingbzrdir = bzrdir.BzrDirFormat6()
700
def open(self, a_bzrdir, _found=False):
701
"""Return the branch object for a_bzrdir
703
_found is a private parameter, do not use it. It is used to indicate
704
if format probing has already be done.
707
# we are being called directly and must probe.
708
raise NotImplementedError
709
return BzrBranch(_format=self,
710
_control_files=a_bzrdir._control_files,
712
_repository=a_bzrdir.open_repository())
715
return "Bazaar-NG branch format 4"
718
class BzrBranchFormat5(BranchFormat):
719
"""Bzr branch format 5.
722
- a revision-history file.
724
- a lock dir guarding the branch itself
725
- all of this stored in a branch/ subdirectory
726
- works with shared repositories.
728
This format is new in bzr 0.8.
731
def get_format_string(self):
732
"""See BranchFormat.get_format_string()."""
733
return "Bazaar-NG branch format 5\n"
735
def get_format_description(self):
736
"""See BranchFormat.get_format_description()."""
737
return "Branch format 5"
739
def initialize(self, a_bzrdir):
740
"""Create a branch of this format in a_bzrdir."""
741
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
742
branch_transport = a_bzrdir.get_branch_transport(self)
743
utf8_files = [('revision-history', ''),
746
control_files = LockableFiles(branch_transport, 'lock', lockdir.LockDir)
747
control_files.create_lock()
748
control_files.lock_write()
749
control_files.put_utf8('format', self.get_format_string())
751
for file, content in utf8_files:
752
control_files.put_utf8(file, content)
754
control_files.unlock()
755
return self.open(a_bzrdir, _found=True, )
758
super(BzrBranchFormat5, self).__init__()
759
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
761
def open(self, a_bzrdir, _found=False):
762
"""Return the branch object for a_bzrdir
764
_found is a private parameter, do not use it. It is used to indicate
765
if format probing has already be done.
768
format = BranchFormat.find_format(a_bzrdir)
769
assert format.__class__ == self.__class__
770
transport = a_bzrdir.get_branch_transport(None)
771
control_files = LockableFiles(transport, 'lock', lockdir.LockDir)
772
return BzrBranch5(_format=self,
773
_control_files=control_files,
775
_repository=a_bzrdir.find_repository())
778
return "Bazaar-NG Metadir branch format 5"
781
class BranchReferenceFormat(BranchFormat):
782
"""Bzr branch reference format.
784
Branch references are used in implementing checkouts, they
785
act as an alias to the real branch which is at some other url.
792
def get_format_string(self):
793
"""See BranchFormat.get_format_string()."""
794
return "Bazaar-NG Branch Reference Format 1\n"
796
def get_format_description(self):
797
"""See BranchFormat.get_format_description()."""
798
return "Checkout reference format 1"
800
def initialize(self, a_bzrdir, target_branch=None):
801
"""Create a branch of this format in a_bzrdir."""
802
if target_branch is None:
803
# this format does not implement branch itself, thus the implicit
804
# creation contract must see it as uninitializable
805
raise errors.UninitializableFormat(self)
806
mutter('creating branch reference in %s', a_bzrdir.transport.base)
807
branch_transport = a_bzrdir.get_branch_transport(self)
808
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
809
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
810
branch_transport.put('format', StringIO(self.get_format_string()))
811
return self.open(a_bzrdir, _found=True)
814
super(BranchReferenceFormat, self).__init__()
815
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
817
def _make_reference_clone_function(format, a_branch):
818
"""Create a clone() routine for a branch dynamically."""
819
def clone(to_bzrdir, revision_id=None):
820
"""See Branch.clone()."""
821
return format.initialize(to_bzrdir, a_branch)
822
# cannot obey revision_id limits when cloning a reference ...
823
# FIXME RBC 20060210 either nuke revision_id for clone, or
824
# emit some sort of warning/error to the caller ?!
827
def open(self, a_bzrdir, _found=False):
828
"""Return the branch that the branch reference in a_bzrdir points at.
830
_found is a private parameter, do not use it. It is used to indicate
831
if format probing has already be done.
834
format = BranchFormat.find_format(a_bzrdir)
835
assert format.__class__ == self.__class__
836
transport = a_bzrdir.get_branch_transport(None)
837
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
838
result = real_bzrdir.open_branch()
839
# this changes the behaviour of result.clone to create a new reference
840
# rather than a copy of the content of the branch.
841
# I did not use a proxy object because that needs much more extensive
842
# testing, and we are only changing one behaviour at the moment.
843
# If we decide to alter more behaviours - i.e. the implicit nickname
844
# then this should be refactored to introduce a tested proxy branch
845
# and a subclass of that for use in overriding clone() and ....
847
result.clone = self._make_reference_clone_function(result)
851
# formats which have no format string are not discoverable
852
# and not independently creatable, so are not registered.
853
__default_format = BzrBranchFormat5()
854
BranchFormat.register_format(__default_format)
855
BranchFormat.register_format(BranchReferenceFormat())
856
BranchFormat.set_default_format(__default_format)
857
_legacy_formats = [BzrBranchFormat4(),
860
class BzrBranch(Branch):
861
"""A branch stored in the actual filesystem.
863
Note that it's "local" in the context of the filesystem; it doesn't
864
really matter if it's on an nfs/smb/afs/coda/... share, as long as
865
it's writable, and can be accessed via the normal filesystem API.
868
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
869
relax_version_check=DEPRECATED_PARAMETER, _format=None,
870
_control_files=None, a_bzrdir=None, _repository=None):
871
"""Create new branch object at a particular location.
873
transport -- A Transport object, defining how to access files.
875
init -- If True, create new control files in a previously
876
unversioned directory. If False, the branch must already
879
relax_version_check -- If true, the usual check for the branch
880
version is not applied. This is intended only for
881
upgrade/recovery type use; it's not guaranteed that
882
all operations will work on old format branches.
885
self.bzrdir = bzrdir.BzrDir.open(transport.base)
887
self.bzrdir = a_bzrdir
888
self._transport = self.bzrdir.transport.clone('..')
889
self._base = self._transport.base
890
self._format = _format
891
if _control_files is None:
892
raise ValueError('BzrBranch _control_files is None')
893
self.control_files = _control_files
894
if deprecated_passed(init):
895
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
896
"deprecated as of bzr 0.8. Please use Branch.create().",
900
# this is slower than before deprecation, oh well never mind.
902
self._initialize(transport.base)
903
self._check_format(_format)
904
if deprecated_passed(relax_version_check):
905
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
906
"relax_version_check parameter is deprecated as of bzr 0.8. "
907
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
911
if (not relax_version_check
912
and not self._format.is_supported()):
913
raise errors.UnsupportedFormatError(format=fmt)
914
if deprecated_passed(transport):
915
warn("BzrBranch.__init__(transport=XXX...): The transport "
916
"parameter is deprecated as of bzr 0.8. "
917
"Please use Branch.open, or bzrdir.open_branch().",
920
self.repository = _repository
923
return '%s(%r)' % (self.__class__.__name__, self.base)
928
# TODO: It might be best to do this somewhere else,
929
# but it is nice for a Branch object to automatically
930
# cache it's information.
931
# Alternatively, we could have the Transport objects cache requests
932
# See the earlier discussion about how major objects (like Branch)
933
# should never expect their __del__ function to run.
934
# XXX: cache_root seems to be unused, 2006-01-13 mbp
935
if hasattr(self, 'cache_root') and self.cache_root is not None:
937
osutils.rmtree(self.cache_root)
940
self.cache_root = None
945
base = property(_get_base, doc="The URL for the root of this branch.")
947
def _finish_transaction(self):
948
"""Exit the current transaction."""
949
return self.control_files._finish_transaction()
951
def get_transaction(self):
952
"""Return the current active transaction.
954
If no transaction is active, this returns a passthrough object
955
for which all data is immediately flushed and no caching happens.
957
# this is an explicit function so that we can do tricky stuff
958
# when the storage in rev_storage is elsewhere.
959
# we probably need to hook the two 'lock a location' and
960
# 'have a transaction' together more delicately, so that
961
# we can have two locks (branch and storage) and one transaction
962
# ... and finishing the transaction unlocks both, but unlocking
963
# does not. - RBC 20051121
964
return self.control_files.get_transaction()
966
def _set_transaction(self, transaction):
967
"""Set a new active transaction."""
968
return self.control_files._set_transaction(transaction)
970
def abspath(self, name):
971
"""See Branch.abspath."""
972
return self.control_files._transport.abspath(name)
974
def _check_format(self, format):
975
"""Identify the branch format if needed.
977
The format is stored as a reference to the format object in
978
self._format for code that needs to check it later.
980
The format parameter is either None or the branch format class
981
used to open this branch.
983
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
986
format = BranchFormat.find_format(self.bzrdir)
987
self._format = format
988
mutter("got branch format %s", self._format)
991
def get_root_id(self):
992
"""See Branch.get_root_id."""
993
tree = self.repository.revision_tree(self.last_revision())
994
return tree.inventory.root.file_id
997
return self.control_files.is_locked()
999
def lock_write(self):
1000
self.repository.lock_write()
1002
self.control_files.lock_write()
1004
self.repository.unlock()
1007
def lock_read(self):
1008
self.repository.lock_read()
1010
self.control_files.lock_read()
1012
self.repository.unlock()
1016
# TODO: test for failed two phase locks. This is known broken.
1018
self.control_files.unlock()
1020
self.repository.unlock()
1022
def peek_lock_mode(self):
1023
if self.control_files._lock_count == 0:
1026
return self.control_files._lock_mode
1028
def get_physical_lock_status(self):
1029
return self.control_files.get_physical_lock_status()
1032
def print_file(self, file, revision_id):
1033
"""See Branch.print_file."""
1034
return self.repository.print_file(file, revision_id)
1037
def append_revision(self, *revision_ids):
1038
"""See Branch.append_revision."""
1039
for revision_id in revision_ids:
1040
mutter("add {%s} to revision-history" % revision_id)
1041
rev_history = self.revision_history()
1042
rev_history.extend(revision_ids)
1043
self.set_revision_history(rev_history)
1046
def set_revision_history(self, rev_history):
1047
"""See Branch.set_revision_history."""
1048
self.control_files.put_utf8(
1049
'revision-history', '\n'.join(rev_history))
1050
transaction = self.get_transaction()
1051
history = transaction.map.find_revision_history()
1052
if history is not None:
1053
# update the revision history in the identity map.
1054
history[:] = list(rev_history)
1055
# this call is disabled because revision_history is
1056
# not really an object yet, and the transaction is for objects.
1057
# transaction.register_dirty(history)
1059
transaction.map.add_revision_history(rev_history)
1060
# this call is disabled because revision_history is
1061
# not really an object yet, and the transaction is for objects.
1062
# transaction.register_clean(history)
1065
def revision_history(self):
1066
"""See Branch.revision_history."""
1067
transaction = self.get_transaction()
1068
history = transaction.map.find_revision_history()
1069
if history is not None:
1070
mutter("cache hit for revision-history in %s", self)
1071
return list(history)
1072
decode_utf8 = cache_utf8.decode
1073
history = [decode_utf8(l.rstrip('\r\n')) for l in
1074
self.control_files.get('revision-history').readlines()]
1075
transaction.map.add_revision_history(history)
1076
# this call is disabled because revision_history is
1077
# not really an object yet, and the transaction is for objects.
1078
# transaction.register_clean(history, precious=True)
1079
return list(history)
1082
def generate_revision_history(self, revision_id, last_rev=None,
1084
"""Create a new revision history that will finish with revision_id.
1086
:param revision_id: the new tip to use.
1087
:param last_rev: The previous last_revision. If not None, then this
1088
must be a ancestory of revision_id, or DivergedBranches is raised.
1089
:param other_branch: The other branch that DivergedBranches should
1090
raise with respect to.
1092
# stop_revision must be a descendant of last_revision
1093
stop_graph = self.repository.get_revision_graph(revision_id)
1094
if last_rev is not None and last_rev not in stop_graph:
1095
# our previous tip is not merged into stop_revision
1096
raise errors.DivergedBranches(self, other_branch)
1097
# make a new revision history from the graph
1098
current_rev_id = revision_id
1100
while current_rev_id not in (None, revision.NULL_REVISION):
1101
new_history.append(current_rev_id)
1102
current_rev_id_parents = stop_graph[current_rev_id]
1104
current_rev_id = current_rev_id_parents[0]
1106
current_rev_id = None
1107
new_history.reverse()
1108
self.set_revision_history(new_history)
1111
def update_revisions(self, other, stop_revision=None):
1112
"""See Branch.update_revisions."""
1115
if stop_revision is None:
1116
stop_revision = other.last_revision()
1117
if stop_revision is None:
1118
# if there are no commits, we're done.
1120
# whats the current last revision, before we fetch [and change it
1122
last_rev = self.last_revision()
1123
# we fetch here regardless of whether we need to so that we pickup
1125
self.fetch(other, stop_revision)
1126
my_ancestry = self.repository.get_ancestry(last_rev)
1127
if stop_revision in my_ancestry:
1128
# last_revision is a descendant of stop_revision
1130
self.generate_revision_history(stop_revision, last_rev=last_rev,
1135
def basis_tree(self):
1136
"""See Branch.basis_tree."""
1137
return self.repository.revision_tree(self.last_revision())
1139
@deprecated_method(zero_eight)
1140
def working_tree(self):
1141
"""Create a Working tree object for this branch."""
1143
from bzrlib.transport.local import LocalTransport
1144
if (self.base.find('://') != -1 or
1145
not isinstance(self._transport, LocalTransport)):
1146
raise NoWorkingTree(self.base)
1147
return self.bzrdir.open_workingtree()
1150
def pull(self, source, overwrite=False, stop_revision=None):
1151
"""See Branch.pull."""
1154
old_count = len(self.revision_history())
1156
self.update_revisions(source,stop_revision)
1157
except DivergedBranches:
1161
self.set_revision_history(source.revision_history())
1162
new_count = len(self.revision_history())
1163
return new_count - old_count
1167
def get_parent(self):
1168
"""See Branch.get_parent."""
1170
_locs = ['parent', 'pull', 'x-pull']
1171
assert self.base[-1] == '/'
1174
parent = self.control_files.get(l).read().strip('\n')
1177
# This is an old-format absolute path to a local branch
1178
# turn it into a url
1179
if parent.startswith('/'):
1180
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1181
return urlutils.join(self.base[:-1], parent)
1184
def get_push_location(self):
1185
"""See Branch.get_push_location."""
1186
push_loc = self.get_config().get_user_option('push_location')
1189
def set_push_location(self, location):
1190
"""See Branch.set_push_location."""
1191
self.get_config().set_user_option('push_location', location,
1195
def set_parent(self, url):
1196
"""See Branch.set_parent."""
1197
# TODO: Maybe delete old location files?
1198
# URLs should never be unicode, even on the local fs,
1199
# FIXUP this and get_parent in a future branch format bump:
1200
# read and rewrite the file, and have the new format code read
1201
# using .get not .get_utf8. RBC 20060125
1203
self.control_files._transport.delete('parent')
1205
if isinstance(url, unicode):
1207
url = url.encode('ascii')
1208
except UnicodeEncodeError:
1209
raise bzrlib.errors.InvalidURL(url,
1210
"Urls must be 7-bit ascii, "
1211
"use bzrlib.urlutils.escape")
1213
url = urlutils.relative_url(self.base, url)
1214
self.control_files.put('parent', url + '\n')
1216
@deprecated_function(zero_nine)
1217
def tree_config(self):
1218
"""DEPRECATED; call get_config instead.
1219
TreeConfig has become part of BranchConfig."""
1220
return TreeConfig(self)
1223
class BzrBranch5(BzrBranch):
1224
"""A format 5 branch. This supports new features over plan branches.
1226
It has support for a master_branch which is the data for bound branches.
1234
super(BzrBranch5, self).__init__(_format=_format,
1235
_control_files=_control_files,
1237
_repository=_repository)
1240
def pull(self, source, overwrite=False, stop_revision=None):
1241
"""Updates branch.pull to be bound branch aware."""
1242
bound_location = self.get_bound_location()
1243
if source.base != bound_location:
1244
# not pulling from master, so we need to update master.
1245
master_branch = self.get_master_branch()
1247
master_branch.pull(source)
1248
source = master_branch
1249
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1251
def get_bound_location(self):
1253
return self.control_files.get_utf8('bound').read()[:-1]
1254
except errors.NoSuchFile:
1258
def get_master_branch(self):
1259
"""Return the branch we are bound to.
1261
:return: Either a Branch, or None
1263
This could memoise the branch, but if thats done
1264
it must be revalidated on each new lock.
1265
So for now we just don't memoise it.
1266
# RBC 20060304 review this decision.
1268
bound_loc = self.get_bound_location()
1272
return Branch.open(bound_loc)
1273
except (errors.NotBranchError, errors.ConnectionError), e:
1274
raise errors.BoundBranchConnectionFailure(
1278
def set_bound_location(self, location):
1279
"""Set the target where this branch is bound to.
1281
:param location: URL to the target branch
1284
self.control_files.put_utf8('bound', location+'\n')
1287
self.control_files._transport.delete('bound')
1293
def bind(self, other):
1294
"""Bind the local branch the other branch.
1296
:param other: The branch to bind to
1299
# TODO: jam 20051230 Consider checking if the target is bound
1300
# It is debatable whether you should be able to bind to
1301
# a branch which is itself bound.
1302
# Committing is obviously forbidden,
1303
# but binding itself may not be.
1304
# Since we *have* to check at commit time, we don't
1305
# *need* to check here
1308
# we are now equal to or a suffix of other.
1310
# Since we have 'pulled' from the remote location,
1311
# now we should try to pull in the opposite direction
1312
# in case the local tree has more revisions than the
1314
# There may be a different check you could do here
1315
# rather than actually trying to install revisions remotely.
1316
# TODO: capture an exception which indicates the remote branch
1318
# If it is up-to-date, this probably should not be a failure
1320
# lock other for write so the revision-history syncing cannot race
1324
# if this does not error, other now has the same last rev we do
1325
# it can only error if the pull from other was concurrent with
1326
# a commit to other from someone else.
1328
# until we ditch revision-history, we need to sync them up:
1329
self.set_revision_history(other.revision_history())
1330
# now other and self are up to date with each other and have the
1331
# same revision-history.
1335
self.set_bound_location(other.base)
1339
"""If bound, unbind"""
1340
return self.set_bound_location(None)
1344
"""Synchronise this branch with the master branch if any.
1346
:return: None or the last_revision that was pivoted out during the
1349
master = self.get_master_branch()
1350
if master is not None:
1351
old_tip = self.last_revision()
1352
self.pull(master, overwrite=True)
1353
if old_tip in self.repository.get_ancestry(self.last_revision()):
1359
class BranchTestProviderAdapter(object):
1360
"""A tool to generate a suite testing multiple branch formats at once.
1362
This is done by copying the test once for each transport and injecting
1363
the transport_server, transport_readonly_server, and branch_format
1364
classes into each copy. Each copy is also given a new id() to make it
1368
def __init__(self, transport_server, transport_readonly_server, formats):
1369
self._transport_server = transport_server
1370
self._transport_readonly_server = transport_readonly_server
1371
self._formats = formats
1373
def adapt(self, test):
1374
result = TestSuite()
1375
for branch_format, bzrdir_format in self._formats:
1376
new_test = deepcopy(test)
1377
new_test.transport_server = self._transport_server
1378
new_test.transport_readonly_server = self._transport_readonly_server
1379
new_test.bzrdir_format = bzrdir_format
1380
new_test.branch_format = branch_format
1381
def make_new_test_id():
1382
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1383
return lambda: new_id
1384
new_test.id = make_new_test_id()
1385
result.addTest(new_test)
1389
class BranchCheckResult(object):
1390
"""Results of checking branch consistency.
1395
def __init__(self, branch):
1396
self.branch = branch
1398
def report_results(self, verbose):
1399
"""Report the check results via trace.note.
1401
:param verbose: Requests more detailed display of what was checked,
1404
note('checked branch %s format %s',
1406
self.branch._format)
1409
######################################################################
1413
@deprecated_function(zero_eight)
1414
def is_control_file(*args, **kwargs):
1415
"""See bzrlib.workingtree.is_control_file."""
1416
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
