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
24
from unittest import TestSuite
25
from warnings import warn
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.config import TreeConfig
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
31
from bzrlib.delta import compare_trees
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError,
36
UninitializableFormat,
38
UnlistableBranch, NoSuchFile, NotVersionedError,
40
import bzrlib.inventory as inventory
41
from bzrlib.inventory import Inventory
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.lockdir import LockDir
44
from bzrlib.osutils import (isdir, quotefn,
45
rename, splitpath, sha_file,
46
file_kind, abspath, normpath, pathjoin,
50
from bzrlib.textui import show_status
51
from bzrlib.trace import mutter, note
52
from bzrlib.tree import EmptyTree, RevisionTree
53
from bzrlib.repository import Repository
54
from bzrlib.revision import (
55
get_intervening_revisions,
60
from bzrlib.store import copy_all
61
from bzrlib.symbol_versioning import *
62
import bzrlib.transactions as transactions
63
from bzrlib.transport import Transport, get_transport
64
from bzrlib.tree import EmptyTree, RevisionTree
69
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
70
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
71
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
74
# TODO: Maybe include checks for common corruption of newlines, etc?
76
# TODO: Some operations like log might retrieve the same revisions
77
# repeatedly to calculate deltas. We could perhaps have a weakref
78
# cache in memory to make this faster. In general anything can be
79
# cached in memory between lock and unlock operations. .. nb thats
80
# what the transaction identity map provides
83
######################################################################
87
"""Branch holding a history of revisions.
90
Base directory/url of the branch.
92
# this is really an instance variable - FIXME move it there
96
def __init__(self, *ignored, **ignored_too):
97
raise NotImplementedError('The Branch class is abstract')
100
"""Break a lock if one is present from another instance.
102
Uses the ui factory to ask for confirmation if the lock may be from
105
This will probe the repository for its lock as well.
107
self.control_files.break_lock()
108
self.repository.break_lock()
109
master = self.get_master_branch()
110
if master is not None:
114
@deprecated_method(zero_eight)
115
def open_downlevel(base):
116
"""Open a branch which may be of an old format."""
117
return Branch.open(base, _unsupported=True)
120
def open(base, _unsupported=False):
121
"""Open the repository rooted at base.
123
For instance, if the repository is at URL/.bzr/repository,
124
Repository.open(URL) -> a Repository instance.
126
control = bzrdir.BzrDir.open(base, _unsupported)
127
return control.open_branch(_unsupported)
130
def open_containing(url):
131
"""Open an existing branch which contains url.
133
This probes for a branch at url, and searches upwards from there.
135
Basically we keep looking up until we find the control directory or
136
run into the root. If there isn't one, raises NotBranchError.
137
If there is one and it is either an unrecognised format or an unsupported
138
format, UnknownFormatError or UnsupportedFormatError are raised.
139
If there is one, it is returned, along with the unused portion of url.
141
control, relpath = bzrdir.BzrDir.open_containing(url)
142
return control.open_branch(), relpath
145
@deprecated_function(zero_eight)
146
def initialize(base):
147
"""Create a new working tree and branch, rooted at 'base' (url)
149
NOTE: This will soon be deprecated in favour of creation
152
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
154
def setup_caching(self, cache_root):
155
"""Subclasses that care about caching should override this, and set
156
up cached stores located under cache_root.
158
# seems to be unused, 2006-01-13 mbp
159
warn('%s is deprecated' % self.setup_caching)
160
self.cache_root = cache_root
163
cfg = self.tree_config()
164
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
166
def _set_nick(self, nick):
167
cfg = self.tree_config()
168
cfg.set_option(nick, "nickname")
169
assert cfg.get_option("nickname") == nick
171
nick = property(_get_nick, _set_nick)
174
raise NotImplementedError('is_locked is abstract')
176
def lock_write(self):
177
raise NotImplementedError('lock_write is abstract')
180
raise NotImplementedError('lock_read is abstract')
183
raise NotImplementedError('unlock is abstract')
185
def peek_lock_mode(self):
186
"""Return lock mode for the Branch: 'r', 'w' or None"""
187
raise NotImplementedError(self.peek_lock_mode)
189
def get_physical_lock_status(self):
190
raise NotImplementedError('get_physical_lock_status is abstract')
192
def abspath(self, name):
193
"""Return absolute filename for something in the branch
195
XXX: Robert Collins 20051017 what is this used for? why is it a branch
196
method and not a tree method.
198
raise NotImplementedError('abspath is abstract')
200
def bind(self, other):
201
"""Bind the local branch the other branch.
203
:param other: The branch to bind to
206
raise errors.UpgradeRequired(self.base)
209
def fetch(self, from_branch, last_revision=None, pb=None):
210
"""Copy revisions from from_branch into this branch.
212
:param from_branch: Where to copy from.
213
:param last_revision: What revision to stop at (None for at the end
215
:param pb: An optional progress bar to use.
217
Returns the copied revision count and the failed revisions in a tuple:
220
if self.base == from_branch.base:
223
nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
228
from_branch.lock_read()
230
if last_revision is None:
231
pb.update('get source history')
232
from_history = from_branch.revision_history()
234
last_revision = from_history[-1]
236
# no history in the source branch
237
last_revision = NULL_REVISION
238
return self.repository.fetch(from_branch.repository,
239
revision_id=last_revision,
242
if nested_pb is not None:
246
def get_bound_location(self):
247
"""Return the URL of the branch we are bound to.
249
Older format branches cannot bind, please be sure to use a metadir
254
def get_master_branch(self):
255
"""Return the branch we are bound to.
257
:return: Either a Branch, or None
261
def get_root_id(self):
262
"""Return the id of this branches root"""
263
raise NotImplementedError('get_root_id is abstract')
265
def print_file(self, file, revision_id):
266
"""Print `file` to stdout."""
267
raise NotImplementedError('print_file is abstract')
269
def append_revision(self, *revision_ids):
270
raise NotImplementedError('append_revision is abstract')
272
def set_revision_history(self, rev_history):
273
raise NotImplementedError('set_revision_history is abstract')
275
def revision_history(self):
276
"""Return sequence of revision hashes on to this branch."""
277
raise NotImplementedError('revision_history is abstract')
280
"""Return current revision number for this branch.
282
That is equivalent to the number of revisions committed to
285
return len(self.revision_history())
288
"""Older format branches cannot bind or unbind."""
289
raise errors.UpgradeRequired(self.base)
291
def last_revision(self):
292
"""Return last patch hash, or None if no history."""
293
ph = self.revision_history()
299
def missing_revisions(self, other, stop_revision=None):
300
"""Return a list of new revisions that would perfectly fit.
302
If self and other have not diverged, return a list of the revisions
303
present in other, but missing from self.
305
>>> from bzrlib.workingtree import WorkingTree
306
>>> bzrlib.trace.silent = True
307
>>> d1 = bzrdir.ScratchDir()
308
>>> br1 = d1.open_branch()
309
>>> wt1 = d1.open_workingtree()
310
>>> d2 = bzrdir.ScratchDir()
311
>>> br2 = d2.open_branch()
312
>>> wt2 = d2.open_workingtree()
313
>>> br1.missing_revisions(br2)
315
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
316
>>> br1.missing_revisions(br2)
318
>>> br2.missing_revisions(br1)
320
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
321
>>> br1.missing_revisions(br2)
323
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
324
>>> br1.missing_revisions(br2)
326
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
327
>>> br1.missing_revisions(br2)
328
Traceback (most recent call last):
329
DivergedBranches: These branches have diverged. Try merge.
331
self_history = self.revision_history()
332
self_len = len(self_history)
333
other_history = other.revision_history()
334
other_len = len(other_history)
335
common_index = min(self_len, other_len) -1
336
if common_index >= 0 and \
337
self_history[common_index] != other_history[common_index]:
338
raise DivergedBranches(self, other)
340
if stop_revision is None:
341
stop_revision = other_len
343
assert isinstance(stop_revision, int)
344
if stop_revision > other_len:
345
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
346
return other_history[self_len:stop_revision]
348
def update_revisions(self, other, stop_revision=None):
349
"""Pull in new perfect-fit revisions.
351
:param other: Another Branch to pull from
352
:param stop_revision: Updated until the given revision
355
raise NotImplementedError('update_revisions is abstract')
357
def revision_id_to_revno(self, revision_id):
358
"""Given a revision id, return its revno"""
359
if revision_id is None:
361
history = self.revision_history()
363
return history.index(revision_id) + 1
365
raise bzrlib.errors.NoSuchRevision(self, revision_id)
367
def get_rev_id(self, revno, history=None):
368
"""Find the revision id of the specified revno."""
372
history = self.revision_history()
373
elif revno <= 0 or revno > len(history):
374
raise bzrlib.errors.NoSuchRevision(self, revno)
375
return history[revno - 1]
377
def pull(self, source, overwrite=False, stop_revision=None):
378
raise NotImplementedError('pull is abstract')
380
def basis_tree(self):
381
"""Return `Tree` object for last revision.
383
If there are no revisions yet, return an `EmptyTree`.
385
return self.repository.revision_tree(self.last_revision())
387
def rename_one(self, from_rel, to_rel):
390
This can change the directory or the filename or both.
392
raise NotImplementedError('rename_one is abstract')
394
def move(self, from_paths, to_name):
397
to_name must exist as a versioned directory.
399
If to_name exists and is a directory, the files are moved into
400
it, keeping their old names. If it is a directory,
402
Note that to_name is only the last component of the new name;
403
this doesn't change the directory.
405
This returns a list of (from_path, to_path) pairs for each
408
raise NotImplementedError('move is abstract')
410
def get_parent(self):
411
"""Return the parent location of the branch.
413
This is the default location for push/pull/missing. The usual
414
pattern is that the user can override it by specifying a
417
raise NotImplementedError('get_parent is abstract')
419
def get_push_location(self):
420
"""Return the None or the location to push this branch to."""
421
raise NotImplementedError('get_push_location is abstract')
423
def set_push_location(self, location):
424
"""Set a new push location for this branch."""
425
raise NotImplementedError('set_push_location is abstract')
427
def set_parent(self, url):
428
raise NotImplementedError('set_parent is abstract')
432
"""Synchronise this branch with the master branch if any.
434
:return: None or the last_revision pivoted out during the update.
438
def check_revno(self, revno):
440
Check whether a revno corresponds to any revision.
441
Zero (the NULL revision) is considered valid.
444
self.check_real_revno(revno)
446
def check_real_revno(self, revno):
448
Check whether a revno corresponds to a real revision.
449
Zero (the NULL revision) is considered invalid
451
if revno < 1 or revno > self.revno():
452
raise InvalidRevisionNumber(revno)
455
def clone(self, *args, **kwargs):
456
"""Clone this branch into to_bzrdir preserving all semantic values.
458
revision_id: if not None, the revision history in the new branch will
459
be truncated to end with revision_id.
461
# for API compatability, until 0.8 releases we provide the old api:
462
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
463
# after 0.8 releases, the *args and **kwargs should be changed:
464
# def clone(self, to_bzrdir, revision_id=None):
465
if (kwargs.get('to_location', None) or
466
kwargs.get('revision', None) or
467
kwargs.get('basis_branch', None) or
468
(len(args) and isinstance(args[0], basestring))):
469
# backwards compatability api:
470
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
471
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
474
basis_branch = args[2]
476
basis_branch = kwargs.get('basis_branch', None)
478
basis = basis_branch.bzrdir
483
revision_id = args[1]
485
revision_id = kwargs.get('revision', None)
490
# no default to raise if not provided.
491
url = kwargs.get('to_location')
492
return self.bzrdir.clone(url,
493
revision_id=revision_id,
494
basis=basis).open_branch()
496
# generate args by hand
498
revision_id = args[1]
500
revision_id = kwargs.get('revision_id', None)
504
# no default to raise if not provided.
505
to_bzrdir = kwargs.get('to_bzrdir')
506
result = self._format.initialize(to_bzrdir)
507
self.copy_content_into(result, revision_id=revision_id)
511
def sprout(self, to_bzrdir, revision_id=None):
512
"""Create a new line of development from the branch, into to_bzrdir.
514
revision_id: if not None, the revision history in the new branch will
515
be truncated to end with revision_id.
517
result = self._format.initialize(to_bzrdir)
518
self.copy_content_into(result, revision_id=revision_id)
519
result.set_parent(self.bzrdir.root_transport.base)
523
def copy_content_into(self, destination, revision_id=None):
524
"""Copy the content of self into destination.
526
revision_id: if not None, the revision history in the new branch will
527
be truncated to end with revision_id.
529
new_history = self.revision_history()
530
if revision_id is not None:
532
new_history = new_history[:new_history.index(revision_id) + 1]
534
rev = self.repository.get_revision(revision_id)
535
new_history = rev.get_history(self.repository)[1:]
536
destination.set_revision_history(new_history)
537
parent = self.get_parent()
539
destination.set_parent(parent)
542
class BranchFormat(object):
543
"""An encapsulation of the initialization and open routines for a format.
545
Formats provide three things:
546
* An initialization routine,
550
Formats are placed in an dict by their format string for reference
551
during branch opening. Its not required that these be instances, they
552
can be classes themselves with class methods - it simply depends on
553
whether state is needed for a given format or not.
555
Once a format is deprecated, just deprecate the initialize and open
556
methods on the format class. Do not deprecate the object, as the
557
object will be created every time regardless.
560
_default_format = None
561
"""The default format used for new branches."""
564
"""The known formats."""
567
def find_format(klass, a_bzrdir):
568
"""Return the format for the branch object in a_bzrdir."""
570
transport = a_bzrdir.get_branch_transport(None)
571
format_string = transport.get("format").read()
572
return klass._formats[format_string]
574
raise NotBranchError(path=transport.base)
576
raise errors.UnknownFormatError(format_string)
579
def get_default_format(klass):
580
"""Return the current default format."""
581
return klass._default_format
583
def get_format_string(self):
584
"""Return the ASCII format string that identifies this format."""
585
raise NotImplementedError(self.get_format_string)
587
def get_format_description(self):
588
"""Return the short format description for this format."""
589
raise NotImplementedError(self.get_format_string)
591
def initialize(self, a_bzrdir):
592
"""Create a branch of this format in a_bzrdir."""
593
raise NotImplementedError(self.initialized)
595
def is_supported(self):
596
"""Is this format supported?
598
Supported formats can be initialized and opened.
599
Unsupported formats may not support initialization or committing or
600
some other features depending on the reason for not being supported.
604
def open(self, a_bzrdir, _found=False):
605
"""Return the branch object for a_bzrdir
607
_found is a private parameter, do not use it. It is used to indicate
608
if format probing has already be done.
610
raise NotImplementedError(self.open)
613
def register_format(klass, format):
614
klass._formats[format.get_format_string()] = format
617
def set_default_format(klass, format):
618
klass._default_format = format
621
def unregister_format(klass, format):
622
assert klass._formats[format.get_format_string()] is format
623
del klass._formats[format.get_format_string()]
626
return self.get_format_string().rstrip()
629
class BzrBranchFormat4(BranchFormat):
630
"""Bzr branch format 4.
633
- a revision-history file.
634
- a branch-lock lock file [ to be shared with the bzrdir ]
637
def get_format_description(self):
638
"""See BranchFormat.get_format_description()."""
639
return "Branch format 4"
641
def initialize(self, a_bzrdir):
642
"""Create a branch of this format in a_bzrdir."""
643
mutter('creating branch in %s', a_bzrdir.transport.base)
644
branch_transport = a_bzrdir.get_branch_transport(self)
645
utf8_files = [('revision-history', ''),
648
control_files = LockableFiles(branch_transport, 'branch-lock',
650
control_files.create_lock()
651
control_files.lock_write()
653
for file, content in utf8_files:
654
control_files.put_utf8(file, content)
656
control_files.unlock()
657
return self.open(a_bzrdir, _found=True)
660
super(BzrBranchFormat4, self).__init__()
661
self._matchingbzrdir = bzrdir.BzrDirFormat6()
663
def open(self, a_bzrdir, _found=False):
664
"""Return the branch object for a_bzrdir
666
_found is a private parameter, do not use it. It is used to indicate
667
if format probing has already be done.
670
# we are being called directly and must probe.
671
raise NotImplementedError
672
return BzrBranch(_format=self,
673
_control_files=a_bzrdir._control_files,
675
_repository=a_bzrdir.open_repository())
678
return "Bazaar-NG branch format 4"
681
class BzrBranchFormat5(BranchFormat):
682
"""Bzr branch format 5.
685
- a revision-history file.
687
- a lock dir guarding the branch itself
688
- all of this stored in a branch/ subdirectory
689
- works with shared repositories.
691
This format is new in bzr 0.8.
694
def get_format_string(self):
695
"""See BranchFormat.get_format_string()."""
696
return "Bazaar-NG branch format 5\n"
698
def get_format_description(self):
699
"""See BranchFormat.get_format_description()."""
700
return "Branch format 5"
702
def initialize(self, a_bzrdir):
703
"""Create a branch of this format in a_bzrdir."""
704
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
705
branch_transport = a_bzrdir.get_branch_transport(self)
706
utf8_files = [('revision-history', ''),
709
control_files = LockableFiles(branch_transport, 'lock', LockDir)
710
control_files.create_lock()
711
control_files.lock_write()
712
control_files.put_utf8('format', self.get_format_string())
714
for file, content in utf8_files:
715
control_files.put_utf8(file, content)
717
control_files.unlock()
718
return self.open(a_bzrdir, _found=True, )
721
super(BzrBranchFormat5, self).__init__()
722
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
724
def open(self, a_bzrdir, _found=False):
725
"""Return the branch object for a_bzrdir
727
_found is a private parameter, do not use it. It is used to indicate
728
if format probing has already be done.
731
format = BranchFormat.find_format(a_bzrdir)
732
assert format.__class__ == self.__class__
733
transport = a_bzrdir.get_branch_transport(None)
734
control_files = LockableFiles(transport, 'lock', LockDir)
735
return BzrBranch5(_format=self,
736
_control_files=control_files,
738
_repository=a_bzrdir.find_repository())
741
return "Bazaar-NG Metadir branch format 5"
744
class BranchReferenceFormat(BranchFormat):
745
"""Bzr branch reference format.
747
Branch references are used in implementing checkouts, they
748
act as an alias to the real branch which is at some other url.
755
def get_format_string(self):
756
"""See BranchFormat.get_format_string()."""
757
return "Bazaar-NG Branch Reference Format 1\n"
759
def get_format_description(self):
760
"""See BranchFormat.get_format_description()."""
761
return "Checkout reference format 1"
763
def initialize(self, a_bzrdir, target_branch=None):
764
"""Create a branch of this format in a_bzrdir."""
765
if target_branch is None:
766
# this format does not implement branch itself, thus the implicit
767
# creation contract must see it as uninitializable
768
raise errors.UninitializableFormat(self)
769
mutter('creating branch reference in %s', a_bzrdir.transport.base)
770
branch_transport = a_bzrdir.get_branch_transport(self)
771
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
772
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
773
branch_transport.put('format', StringIO(self.get_format_string()))
774
return self.open(a_bzrdir, _found=True)
777
super(BranchReferenceFormat, self).__init__()
778
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
780
def _make_reference_clone_function(format, a_branch):
781
"""Create a clone() routine for a branch dynamically."""
782
def clone(to_bzrdir, revision_id=None):
783
"""See Branch.clone()."""
784
return format.initialize(to_bzrdir, a_branch)
785
# cannot obey revision_id limits when cloning a reference ...
786
# FIXME RBC 20060210 either nuke revision_id for clone, or
787
# emit some sort of warning/error to the caller ?!
790
def open(self, a_bzrdir, _found=False):
791
"""Return the branch that the branch reference in a_bzrdir points at.
793
_found is a private parameter, do not use it. It is used to indicate
794
if format probing has already be done.
797
format = BranchFormat.find_format(a_bzrdir)
798
assert format.__class__ == self.__class__
799
transport = a_bzrdir.get_branch_transport(None)
800
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
801
result = real_bzrdir.open_branch()
802
# this changes the behaviour of result.clone to create a new reference
803
# rather than a copy of the content of the branch.
804
# I did not use a proxy object because that needs much more extensive
805
# testing, and we are only changing one behaviour at the moment.
806
# If we decide to alter more behaviours - i.e. the implicit nickname
807
# then this should be refactored to introduce a tested proxy branch
808
# and a subclass of that for use in overriding clone() and ....
810
result.clone = self._make_reference_clone_function(result)
814
# formats which have no format string are not discoverable
815
# and not independently creatable, so are not registered.
816
__default_format = BzrBranchFormat5()
817
BranchFormat.register_format(__default_format)
818
BranchFormat.register_format(BranchReferenceFormat())
819
BranchFormat.set_default_format(__default_format)
820
_legacy_formats = [BzrBranchFormat4(),
823
class BzrBranch(Branch):
824
"""A branch stored in the actual filesystem.
826
Note that it's "local" in the context of the filesystem; it doesn't
827
really matter if it's on an nfs/smb/afs/coda/... share, as long as
828
it's writable, and can be accessed via the normal filesystem API.
831
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
832
relax_version_check=DEPRECATED_PARAMETER, _format=None,
833
_control_files=None, a_bzrdir=None, _repository=None):
834
"""Create new branch object at a particular location.
836
transport -- A Transport object, defining how to access files.
838
init -- If True, create new control files in a previously
839
unversioned directory. If False, the branch must already
842
relax_version_check -- If true, the usual check for the branch
843
version is not applied. This is intended only for
844
upgrade/recovery type use; it's not guaranteed that
845
all operations will work on old format branches.
848
self.bzrdir = bzrdir.BzrDir.open(transport.base)
850
self.bzrdir = a_bzrdir
851
self._transport = self.bzrdir.transport.clone('..')
852
self._base = self._transport.base
853
self._format = _format
854
if _control_files is None:
855
raise BzrBadParameterMissing('_control_files')
856
self.control_files = _control_files
857
if deprecated_passed(init):
858
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
859
"deprecated as of bzr 0.8. Please use Branch.create().",
863
# this is slower than before deprecation, oh well never mind.
865
self._initialize(transport.base)
866
self._check_format(_format)
867
if deprecated_passed(relax_version_check):
868
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
869
"relax_version_check parameter is deprecated as of bzr 0.8. "
870
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
874
if (not relax_version_check
875
and not self._format.is_supported()):
876
raise errors.UnsupportedFormatError(
877
'sorry, branch format %r not supported' % fmt,
878
['use a different bzr version',
879
'or remove the .bzr directory'
880
' and "bzr init" again'])
881
if deprecated_passed(transport):
882
warn("BzrBranch.__init__(transport=XXX...): The transport "
883
"parameter is deprecated as of bzr 0.8. "
884
"Please use Branch.open, or bzrdir.open_branch().",
887
self.repository = _repository
890
return '%s(%r)' % (self.__class__.__name__, self.base)
895
# TODO: It might be best to do this somewhere else,
896
# but it is nice for a Branch object to automatically
897
# cache it's information.
898
# Alternatively, we could have the Transport objects cache requests
899
# See the earlier discussion about how major objects (like Branch)
900
# should never expect their __del__ function to run.
901
# XXX: cache_root seems to be unused, 2006-01-13 mbp
902
if hasattr(self, 'cache_root') and self.cache_root is not None:
904
rmtree(self.cache_root)
907
self.cache_root = None
912
base = property(_get_base, doc="The URL for the root of this branch.")
914
def _finish_transaction(self):
915
"""Exit the current transaction."""
916
return self.control_files._finish_transaction()
918
def get_transaction(self):
919
"""Return the current active transaction.
921
If no transaction is active, this returns a passthrough object
922
for which all data is immediately flushed and no caching happens.
924
# this is an explicit function so that we can do tricky stuff
925
# when the storage in rev_storage is elsewhere.
926
# we probably need to hook the two 'lock a location' and
927
# 'have a transaction' together more delicately, so that
928
# we can have two locks (branch and storage) and one transaction
929
# ... and finishing the transaction unlocks both, but unlocking
930
# does not. - RBC 20051121
931
return self.control_files.get_transaction()
933
def _set_transaction(self, transaction):
934
"""Set a new active transaction."""
935
return self.control_files._set_transaction(transaction)
937
def abspath(self, name):
938
"""See Branch.abspath."""
939
return self.control_files._transport.abspath(name)
941
def _check_format(self, format):
942
"""Identify the branch format if needed.
944
The format is stored as a reference to the format object in
945
self._format for code that needs to check it later.
947
The format parameter is either None or the branch format class
948
used to open this branch.
950
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
953
format = BzrBranchFormat.find_format(self.bzrdir)
954
self._format = format
955
mutter("got branch format %s", self._format)
958
def get_root_id(self):
959
"""See Branch.get_root_id."""
960
tree = self.repository.revision_tree(self.last_revision())
961
return tree.inventory.root.file_id
964
return self.control_files.is_locked()
966
def lock_write(self):
967
# TODO: test for failed two phase locks. This is known broken.
968
self.control_files.lock_write()
969
self.repository.lock_write()
972
# TODO: test for failed two phase locks. This is known broken.
973
self.control_files.lock_read()
974
self.repository.lock_read()
977
# TODO: test for failed two phase locks. This is known broken.
979
self.repository.unlock()
981
self.control_files.unlock()
983
def peek_lock_mode(self):
984
if self.control_files._lock_count == 0:
987
return self.control_files._lock_mode
989
def get_physical_lock_status(self):
990
return self.control_files.get_physical_lock_status()
993
def print_file(self, file, revision_id):
994
"""See Branch.print_file."""
995
return self.repository.print_file(file, revision_id)
998
def append_revision(self, *revision_ids):
999
"""See Branch.append_revision."""
1000
for revision_id in revision_ids:
1001
mutter("add {%s} to revision-history" % revision_id)
1002
rev_history = self.revision_history()
1003
rev_history.extend(revision_ids)
1004
self.set_revision_history(rev_history)
1007
def set_revision_history(self, rev_history):
1008
"""See Branch.set_revision_history."""
1009
self.control_files.put_utf8(
1010
'revision-history', '\n'.join(rev_history))
1011
transaction = self.get_transaction()
1012
history = transaction.map.find_revision_history()
1013
if history is not None:
1014
# update the revision history in the identity map.
1015
history[:] = list(rev_history)
1016
# this call is disabled because revision_history is
1017
# not really an object yet, and the transaction is for objects.
1018
# transaction.register_dirty(history)
1020
transaction.map.add_revision_history(rev_history)
1021
# this call is disabled because revision_history is
1022
# not really an object yet, and the transaction is for objects.
1023
# transaction.register_clean(history)
1025
def get_revision_delta(self, revno):
1026
"""Return the delta for one revision.
1028
The delta is relative to its mainline predecessor, or the
1029
empty tree for revision 1.
1031
assert isinstance(revno, int)
1032
rh = self.revision_history()
1033
if not (1 <= revno <= len(rh)):
1034
raise InvalidRevisionNumber(revno)
1036
# revno is 1-based; list is 0-based
1038
new_tree = self.repository.revision_tree(rh[revno-1])
1040
old_tree = EmptyTree()
1042
old_tree = self.repository.revision_tree(rh[revno-2])
1043
return compare_trees(old_tree, new_tree)
1046
def revision_history(self):
1047
"""See Branch.revision_history."""
1048
transaction = self.get_transaction()
1049
history = transaction.map.find_revision_history()
1050
if history is not None:
1051
mutter("cache hit for revision-history in %s", self)
1052
return list(history)
1053
history = [l.rstrip('\r\n') for l in
1054
self.control_files.get_utf8('revision-history').readlines()]
1055
transaction.map.add_revision_history(history)
1056
# this call is disabled because revision_history is
1057
# not really an object yet, and the transaction is for objects.
1058
# transaction.register_clean(history, precious=True)
1059
return list(history)
1062
def update_revisions(self, other, stop_revision=None):
1063
"""See Branch.update_revisions."""
1066
if stop_revision is None:
1067
stop_revision = other.last_revision()
1068
if stop_revision is None:
1069
# if there are no commits, we're done.
1071
# whats the current last revision, before we fetch [and change it
1073
last_rev = self.last_revision()
1074
# we fetch here regardless of whether we need to so that we pickup
1076
self.fetch(other, stop_revision)
1077
my_ancestry = self.repository.get_ancestry(last_rev)
1078
if stop_revision in my_ancestry:
1079
# last_revision is a descendant of stop_revision
1081
# stop_revision must be a descendant of last_revision
1082
stop_graph = self.repository.get_revision_graph(stop_revision)
1083
if last_rev is not None and last_rev not in stop_graph:
1084
# our previous tip is not merged into stop_revision
1085
raise errors.DivergedBranches(self, other)
1086
# make a new revision history from the graph
1087
current_rev_id = stop_revision
1089
while current_rev_id not in (None, NULL_REVISION):
1090
new_history.append(current_rev_id)
1091
current_rev_id_parents = stop_graph[current_rev_id]
1093
current_rev_id = current_rev_id_parents[0]
1095
current_rev_id = None
1096
new_history.reverse()
1097
self.set_revision_history(new_history)
1101
@deprecated_method(zero_eight)
1102
def pullable_revisions(self, other, stop_revision):
1103
"""Please use bzrlib.missing instead."""
1104
other_revno = other.revision_id_to_revno(stop_revision)
1106
return self.missing_revisions(other, other_revno)
1107
except DivergedBranches, e:
1109
pullable_revs = get_intervening_revisions(self.last_revision(),
1112
assert self.last_revision() not in pullable_revs
1113
return pullable_revs
1114
except bzrlib.errors.NotAncestor:
1115
if is_ancestor(self.last_revision(), stop_revision, self):
1120
def basis_tree(self):
1121
"""See Branch.basis_tree."""
1122
return self.repository.revision_tree(self.last_revision())
1124
@deprecated_method(zero_eight)
1125
def working_tree(self):
1126
"""Create a Working tree object for this branch."""
1127
from bzrlib.workingtree import WorkingTree
1128
from bzrlib.transport.local import LocalTransport
1129
if (self.base.find('://') != -1 or
1130
not isinstance(self._transport, LocalTransport)):
1131
raise NoWorkingTree(self.base)
1132
return self.bzrdir.open_workingtree()
1135
def pull(self, source, overwrite=False, stop_revision=None):
1136
"""See Branch.pull."""
1139
old_count = len(self.revision_history())
1141
self.update_revisions(source,stop_revision)
1142
except DivergedBranches:
1146
self.set_revision_history(source.revision_history())
1147
new_count = len(self.revision_history())
1148
return new_count - old_count
1152
def get_parent(self):
1153
"""See Branch.get_parent."""
1155
_locs = ['parent', 'pull', 'x-pull']
1158
return self.control_files.get_utf8(l).read().strip('\n')
1163
def get_push_location(self):
1164
"""See Branch.get_push_location."""
1165
config = bzrlib.config.BranchConfig(self)
1166
push_loc = config.get_user_option('push_location')
1169
def set_push_location(self, location):
1170
"""See Branch.set_push_location."""
1171
config = bzrlib.config.LocationConfig(self.base)
1172
config.set_user_option('push_location', location)
1175
def set_parent(self, url):
1176
"""See Branch.set_parent."""
1177
# TODO: Maybe delete old location files?
1178
# URLs should never be unicode, even on the local fs,
1179
# FIXUP this and get_parent in a future branch format bump:
1180
# read and rewrite the file, and have the new format code read
1181
# using .get not .get_utf8. RBC 20060125
1183
self.control_files._transport.delete('parent')
1185
self.control_files.put_utf8('parent', url + '\n')
1187
def tree_config(self):
1188
return TreeConfig(self)
1191
class BzrBranch5(BzrBranch):
1192
"""A format 5 branch. This supports new features over plan branches.
1194
It has support for a master_branch which is the data for bound branches.
1202
super(BzrBranch5, self).__init__(_format=_format,
1203
_control_files=_control_files,
1205
_repository=_repository)
1208
def pull(self, source, overwrite=False, stop_revision=None):
1209
"""Updates branch.pull to be bound branch aware."""
1210
bound_location = self.get_bound_location()
1211
if source.base != bound_location:
1212
# not pulling from master, so we need to update master.
1213
master_branch = self.get_master_branch()
1215
master_branch.pull(source)
1216
source = master_branch
1217
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1219
def get_bound_location(self):
1221
return self.control_files.get_utf8('bound').read()[:-1]
1222
except errors.NoSuchFile:
1226
def get_master_branch(self):
1227
"""Return the branch we are bound to.
1229
:return: Either a Branch, or None
1231
This could memoise the branch, but if thats done
1232
it must be revalidated on each new lock.
1233
So for now we just dont memoise it.
1234
# RBC 20060304 review this decision.
1236
bound_loc = self.get_bound_location()
1240
return Branch.open(bound_loc)
1241
except (errors.NotBranchError, errors.ConnectionError), e:
1242
raise errors.BoundBranchConnectionFailure(
1246
def set_bound_location(self, location):
1247
"""Set the target where this branch is bound to.
1249
:param location: URL to the target branch
1252
self.control_files.put_utf8('bound', location+'\n')
1255
self.control_files._transport.delete('bound')
1261
def bind(self, other):
1262
"""Bind the local branch the other branch.
1264
:param other: The branch to bind to
1267
# TODO: jam 20051230 Consider checking if the target is bound
1268
# It is debatable whether you should be able to bind to
1269
# a branch which is itself bound.
1270
# Committing is obviously forbidden,
1271
# but binding itself may not be.
1272
# Since we *have* to check at commit time, we don't
1273
# *need* to check here
1276
# we are now equal to or a suffix of other.
1278
# Since we have 'pulled' from the remote location,
1279
# now we should try to pull in the opposite direction
1280
# in case the local tree has more revisions than the
1282
# There may be a different check you could do here
1283
# rather than actually trying to install revisions remotely.
1284
# TODO: capture an exception which indicates the remote branch
1286
# If it is up-to-date, this probably should not be a failure
1288
# lock other for write so the revision-history syncing cannot race
1292
# if this does not error, other now has the same last rev we do
1293
# it can only error if the pull from other was concurrent with
1294
# a commit to other from someone else.
1296
# until we ditch revision-history, we need to sync them up:
1297
self.set_revision_history(other.revision_history())
1298
# now other and self are up to date with each other and have the
1299
# same revision-history.
1303
self.set_bound_location(other.base)
1307
"""If bound, unbind"""
1308
return self.set_bound_location(None)
1312
"""Synchronise this branch with the master branch if any.
1314
:return: None or the last_revision that was pivoted out during the
1317
master = self.get_master_branch()
1318
if master is not None:
1319
old_tip = self.last_revision()
1320
self.pull(master, overwrite=True)
1321
if old_tip in self.repository.get_ancestry(self.last_revision()):
1327
class BranchTestProviderAdapter(object):
1328
"""A tool to generate a suite testing multiple branch formats at once.
1330
This is done by copying the test once for each transport and injecting
1331
the transport_server, transport_readonly_server, and branch_format
1332
classes into each copy. Each copy is also given a new id() to make it
1336
def __init__(self, transport_server, transport_readonly_server, formats):
1337
self._transport_server = transport_server
1338
self._transport_readonly_server = transport_readonly_server
1339
self._formats = formats
1341
def adapt(self, test):
1342
result = TestSuite()
1343
for branch_format, bzrdir_format in self._formats:
1344
new_test = deepcopy(test)
1345
new_test.transport_server = self._transport_server
1346
new_test.transport_readonly_server = self._transport_readonly_server
1347
new_test.bzrdir_format = bzrdir_format
1348
new_test.branch_format = branch_format
1349
def make_new_test_id():
1350
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1351
return lambda: new_id
1352
new_test.id = make_new_test_id()
1353
result.addTest(new_test)
1357
######################################################################
1361
@deprecated_function(zero_eight)
1362
def ScratchBranch(*args, **kwargs):
1363
"""See bzrlib.bzrdir.ScratchDir."""
1364
d = ScratchDir(*args, **kwargs)
1365
return d.open_branch()
1368
@deprecated_function(zero_eight)
1369
def is_control_file(*args, **kwargs):
1370
"""See bzrlib.workingtree.is_control_file."""
1371
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
