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.repository import Repository
51
from bzrlib.revision import (
56
from bzrlib.store import copy_all
57
from bzrlib.symbol_versioning import *
58
from bzrlib.textui import show_status
59
from bzrlib.trace import mutter, note
60
import bzrlib.transactions as transactions
61
from bzrlib.transport import Transport, get_transport
62
from bzrlib.tree import EmptyTree, RevisionTree
64
import bzrlib.urlutils as urlutils
68
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
69
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
70
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
73
# TODO: Maybe include checks for common corruption of newlines, etc?
75
# TODO: Some operations like log might retrieve the same revisions
76
# repeatedly to calculate deltas. We could perhaps have a weakref
77
# cache in memory to make this faster. In general anything can be
78
# cached in memory between lock and unlock operations. .. nb thats
79
# what the transaction identity map provides
82
######################################################################
86
"""Branch holding a history of revisions.
89
Base directory/url of the branch.
91
# this is really an instance variable - FIXME move it there
95
def __init__(self, *ignored, **ignored_too):
96
raise NotImplementedError('The Branch class is abstract')
99
"""Break a lock if one is present from another instance.
101
Uses the ui factory to ask for confirmation if the lock may be from
104
This will probe the repository for its lock as well.
106
self.control_files.break_lock()
107
self.repository.break_lock()
108
master = self.get_master_branch()
109
if master is not None:
113
@deprecated_method(zero_eight)
114
def open_downlevel(base):
115
"""Open a branch which may be of an old format."""
116
return Branch.open(base, _unsupported=True)
119
def open(base, _unsupported=False):
120
"""Open the repository rooted at base.
122
For instance, if the repository is at URL/.bzr/repository,
123
Repository.open(URL) -> a Repository instance.
125
control = bzrdir.BzrDir.open(base, _unsupported)
126
return control.open_branch(_unsupported)
129
def open_containing(url):
130
"""Open an existing branch which contains url.
132
This probes for a branch at url, and searches upwards from there.
134
Basically we keep looking up until we find the control directory or
135
run into the root. If there isn't one, raises NotBranchError.
136
If there is one and it is either an unrecognised format or an unsupported
137
format, UnknownFormatError or UnsupportedFormatError are raised.
138
If there is one, it is returned, along with the unused portion of url.
140
control, relpath = bzrdir.BzrDir.open_containing(url)
141
return control.open_branch(), relpath
144
@deprecated_function(zero_eight)
145
def initialize(base):
146
"""Create a new working tree and branch, rooted at 'base' (url)
148
NOTE: This will soon be deprecated in favour of creation
151
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
153
def setup_caching(self, cache_root):
154
"""Subclasses that care about caching should override this, and set
155
up cached stores located under cache_root.
157
# seems to be unused, 2006-01-13 mbp
158
warn('%s is deprecated' % self.setup_caching)
159
self.cache_root = cache_root
162
cfg = self.tree_config()
163
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
165
def _set_nick(self, nick):
166
cfg = self.tree_config()
167
cfg.set_option(nick, "nickname")
168
assert cfg.get_option("nickname") == nick
170
nick = property(_get_nick, _set_nick)
173
raise NotImplementedError('is_locked is abstract')
175
def lock_write(self):
176
raise NotImplementedError('lock_write is abstract')
179
raise NotImplementedError('lock_read is abstract')
182
raise NotImplementedError('unlock is abstract')
184
def peek_lock_mode(self):
185
"""Return lock mode for the Branch: 'r', 'w' or None"""
186
raise NotImplementedError(self.peek_lock_mode)
188
def get_physical_lock_status(self):
189
raise NotImplementedError('get_physical_lock_status is abstract')
191
def abspath(self, name):
192
"""Return absolute filename for something in the branch
194
XXX: Robert Collins 20051017 what is this used for? why is it a branch
195
method and not a tree method.
197
raise NotImplementedError('abspath is abstract')
199
def bind(self, other):
200
"""Bind the local branch the other branch.
202
:param other: The branch to bind to
205
raise errors.UpgradeRequired(self.base)
208
def fetch(self, from_branch, last_revision=None, pb=None):
209
"""Copy revisions from from_branch into this branch.
211
:param from_branch: Where to copy from.
212
:param last_revision: What revision to stop at (None for at the end
214
:param pb: An optional progress bar to use.
216
Returns the copied revision count and the failed revisions in a tuple:
219
if self.base == from_branch.base:
222
nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
227
from_branch.lock_read()
229
if last_revision is None:
230
pb.update('get source history')
231
from_history = from_branch.revision_history()
233
last_revision = from_history[-1]
235
# no history in the source branch
236
last_revision = NULL_REVISION
237
return self.repository.fetch(from_branch.repository,
238
revision_id=last_revision,
241
if nested_pb is not None:
245
def get_bound_location(self):
246
"""Return the URL of the branch we are bound to.
248
Older format branches cannot bind, please be sure to use a metadir
253
def get_commit_builder(self, parents, config=None, timestamp=None,
254
timezone=None, committer=None, revprops=None,
256
"""Obtain a CommitBuilder for this branch.
258
:param parents: Revision ids of the parents of the new revision.
259
:param config: Optional configuration to use.
260
:param timestamp: Optional timestamp recorded for commit.
261
:param timezone: Optional timezone for timestamp.
262
:param committer: Optional committer to set for commit.
263
:param revprops: Optional dictionary of revision properties.
264
:param revision_id: Optional revision id.
268
config = bzrlib.config.BranchConfig(self)
270
return self.repository.get_commit_builder(self, parents, config,
271
timestamp, timezone, committer, revprops, revision_id)
273
def get_master_branch(self):
274
"""Return the branch we are bound to.
276
:return: Either a Branch, or None
280
def get_root_id(self):
281
"""Return the id of this branches root"""
282
raise NotImplementedError('get_root_id is abstract')
284
def print_file(self, file, revision_id):
285
"""Print `file` to stdout."""
286
raise NotImplementedError('print_file is abstract')
288
def append_revision(self, *revision_ids):
289
raise NotImplementedError('append_revision is abstract')
291
def set_revision_history(self, rev_history):
292
raise NotImplementedError('set_revision_history is abstract')
294
def revision_history(self):
295
"""Return sequence of revision hashes on to this branch."""
296
raise NotImplementedError('revision_history is abstract')
299
"""Return current revision number for this branch.
301
That is equivalent to the number of revisions committed to
304
return len(self.revision_history())
307
"""Older format branches cannot bind or unbind."""
308
raise errors.UpgradeRequired(self.base)
310
def last_revision(self):
311
"""Return last patch hash, or None if no history."""
312
ph = self.revision_history()
318
def missing_revisions(self, other, stop_revision=None):
319
"""Return a list of new revisions that would perfectly fit.
321
If self and other have not diverged, return a list of the revisions
322
present in other, but missing from self.
324
>>> from bzrlib.workingtree import WorkingTree
325
>>> bzrlib.trace.silent = True
326
>>> d1 = bzrdir.ScratchDir()
327
>>> br1 = d1.open_branch()
328
>>> wt1 = d1.open_workingtree()
329
>>> d2 = bzrdir.ScratchDir()
330
>>> br2 = d2.open_branch()
331
>>> wt2 = d2.open_workingtree()
332
>>> br1.missing_revisions(br2)
334
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
335
>>> br1.missing_revisions(br2)
337
>>> br2.missing_revisions(br1)
339
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
340
>>> br1.missing_revisions(br2)
342
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
343
>>> br1.missing_revisions(br2)
345
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
346
>>> br1.missing_revisions(br2)
347
Traceback (most recent call last):
348
DivergedBranches: These branches have diverged. Try merge.
350
self_history = self.revision_history()
351
self_len = len(self_history)
352
other_history = other.revision_history()
353
other_len = len(other_history)
354
common_index = min(self_len, other_len) -1
355
if common_index >= 0 and \
356
self_history[common_index] != other_history[common_index]:
357
raise DivergedBranches(self, other)
359
if stop_revision is None:
360
stop_revision = other_len
362
assert isinstance(stop_revision, int)
363
if stop_revision > other_len:
364
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
365
return other_history[self_len:stop_revision]
367
def update_revisions(self, other, stop_revision=None):
368
"""Pull in new perfect-fit revisions.
370
:param other: Another Branch to pull from
371
:param stop_revision: Updated until the given revision
374
raise NotImplementedError('update_revisions is abstract')
376
def revision_id_to_revno(self, revision_id):
377
"""Given a revision id, return its revno"""
378
if revision_id is None:
380
history = self.revision_history()
382
return history.index(revision_id) + 1
384
raise bzrlib.errors.NoSuchRevision(self, revision_id)
386
def get_rev_id(self, revno, history=None):
387
"""Find the revision id of the specified revno."""
391
history = self.revision_history()
392
elif revno <= 0 or revno > len(history):
393
raise bzrlib.errors.NoSuchRevision(self, revno)
394
return history[revno - 1]
396
def pull(self, source, overwrite=False, stop_revision=None):
397
raise NotImplementedError('pull is abstract')
399
def basis_tree(self):
400
"""Return `Tree` object for last revision.
402
If there are no revisions yet, return an `EmptyTree`.
404
return self.repository.revision_tree(self.last_revision())
406
def rename_one(self, from_rel, to_rel):
409
This can change the directory or the filename or both.
411
raise NotImplementedError('rename_one is abstract')
413
def move(self, from_paths, to_name):
416
to_name must exist as a versioned directory.
418
If to_name exists and is a directory, the files are moved into
419
it, keeping their old names. If it is a directory,
421
Note that to_name is only the last component of the new name;
422
this doesn't change the directory.
424
This returns a list of (from_path, to_path) pairs for each
427
raise NotImplementedError('move is abstract')
429
def get_parent(self):
430
"""Return the parent location of the branch.
432
This is the default location for push/pull/missing. The usual
433
pattern is that the user can override it by specifying a
436
raise NotImplementedError('get_parent is abstract')
438
def get_push_location(self):
439
"""Return the None or the location to push this branch to."""
440
raise NotImplementedError('get_push_location is abstract')
442
def set_push_location(self, location):
443
"""Set a new push location for this branch."""
444
raise NotImplementedError('set_push_location is abstract')
446
def set_parent(self, url):
447
raise NotImplementedError('set_parent is abstract')
451
"""Synchronise this branch with the master branch if any.
453
:return: None or the last_revision pivoted out during the update.
457
def check_revno(self, revno):
459
Check whether a revno corresponds to any revision.
460
Zero (the NULL revision) is considered valid.
463
self.check_real_revno(revno)
465
def check_real_revno(self, revno):
467
Check whether a revno corresponds to a real revision.
468
Zero (the NULL revision) is considered invalid
470
if revno < 1 or revno > self.revno():
471
raise InvalidRevisionNumber(revno)
474
def clone(self, *args, **kwargs):
475
"""Clone this branch into to_bzrdir preserving all semantic values.
477
revision_id: if not None, the revision history in the new branch will
478
be truncated to end with revision_id.
480
# for API compatability, until 0.8 releases we provide the old api:
481
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
482
# after 0.8 releases, the *args and **kwargs should be changed:
483
# def clone(self, to_bzrdir, revision_id=None):
484
if (kwargs.get('to_location', None) or
485
kwargs.get('revision', None) or
486
kwargs.get('basis_branch', None) or
487
(len(args) and isinstance(args[0], basestring))):
488
# backwards compatability api:
489
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
490
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
493
basis_branch = args[2]
495
basis_branch = kwargs.get('basis_branch', None)
497
basis = basis_branch.bzrdir
502
revision_id = args[1]
504
revision_id = kwargs.get('revision', None)
509
# no default to raise if not provided.
510
url = kwargs.get('to_location')
511
return self.bzrdir.clone(url,
512
revision_id=revision_id,
513
basis=basis).open_branch()
515
# generate args by hand
517
revision_id = args[1]
519
revision_id = kwargs.get('revision_id', None)
523
# no default to raise if not provided.
524
to_bzrdir = kwargs.get('to_bzrdir')
525
result = self._format.initialize(to_bzrdir)
526
self.copy_content_into(result, revision_id=revision_id)
530
def sprout(self, to_bzrdir, revision_id=None):
531
"""Create a new line of development from the branch, into to_bzrdir.
533
revision_id: if not None, the revision history in the new branch will
534
be truncated to end with revision_id.
536
result = self._format.initialize(to_bzrdir)
537
self.copy_content_into(result, revision_id=revision_id)
538
result.set_parent(self.bzrdir.root_transport.base)
542
def copy_content_into(self, destination, revision_id=None):
543
"""Copy the content of self into destination.
545
revision_id: if not None, the revision history in the new branch will
546
be truncated to end with revision_id.
548
new_history = self.revision_history()
549
if revision_id is not None:
551
new_history = new_history[:new_history.index(revision_id) + 1]
553
rev = self.repository.get_revision(revision_id)
554
new_history = rev.get_history(self.repository)[1:]
555
destination.set_revision_history(new_history)
556
parent = self.get_parent()
558
destination.set_parent(parent)
561
class BranchFormat(object):
562
"""An encapsulation of the initialization and open routines for a format.
564
Formats provide three things:
565
* An initialization routine,
569
Formats are placed in an dict by their format string for reference
570
during branch opening. Its not required that these be instances, they
571
can be classes themselves with class methods - it simply depends on
572
whether state is needed for a given format or not.
574
Once a format is deprecated, just deprecate the initialize and open
575
methods on the format class. Do not deprecate the object, as the
576
object will be created every time regardless.
579
_default_format = None
580
"""The default format used for new branches."""
583
"""The known formats."""
586
def find_format(klass, a_bzrdir):
587
"""Return the format for the branch object in a_bzrdir."""
589
transport = a_bzrdir.get_branch_transport(None)
590
format_string = transport.get("format").read()
591
return klass._formats[format_string]
593
raise NotBranchError(path=transport.base)
595
raise errors.UnknownFormatError(format_string)
598
def get_default_format(klass):
599
"""Return the current default format."""
600
return klass._default_format
602
def get_format_string(self):
603
"""Return the ASCII format string that identifies this format."""
604
raise NotImplementedError(self.get_format_string)
606
def get_format_description(self):
607
"""Return the short format description for this format."""
608
raise NotImplementedError(self.get_format_string)
610
def initialize(self, a_bzrdir):
611
"""Create a branch of this format in a_bzrdir."""
612
raise NotImplementedError(self.initialized)
614
def is_supported(self):
615
"""Is this format supported?
617
Supported formats can be initialized and opened.
618
Unsupported formats may not support initialization or committing or
619
some other features depending on the reason for not being supported.
623
def open(self, a_bzrdir, _found=False):
624
"""Return the branch object for a_bzrdir
626
_found is a private parameter, do not use it. It is used to indicate
627
if format probing has already be done.
629
raise NotImplementedError(self.open)
632
def register_format(klass, format):
633
klass._formats[format.get_format_string()] = format
636
def set_default_format(klass, format):
637
klass._default_format = format
640
def unregister_format(klass, format):
641
assert klass._formats[format.get_format_string()] is format
642
del klass._formats[format.get_format_string()]
645
return self.get_format_string().rstrip()
648
class BzrBranchFormat4(BranchFormat):
649
"""Bzr branch format 4.
652
- a revision-history file.
653
- a branch-lock lock file [ to be shared with the bzrdir ]
656
def get_format_description(self):
657
"""See BranchFormat.get_format_description()."""
658
return "Branch format 4"
660
def initialize(self, a_bzrdir):
661
"""Create a branch of this format in a_bzrdir."""
662
mutter('creating branch in %s', a_bzrdir.transport.base)
663
branch_transport = a_bzrdir.get_branch_transport(self)
664
utf8_files = [('revision-history', ''),
667
control_files = LockableFiles(branch_transport, 'branch-lock',
669
control_files.create_lock()
670
control_files.lock_write()
672
for file, content in utf8_files:
673
control_files.put_utf8(file, content)
675
control_files.unlock()
676
return self.open(a_bzrdir, _found=True)
679
super(BzrBranchFormat4, self).__init__()
680
self._matchingbzrdir = bzrdir.BzrDirFormat6()
682
def open(self, a_bzrdir, _found=False):
683
"""Return the branch object for a_bzrdir
685
_found is a private parameter, do not use it. It is used to indicate
686
if format probing has already be done.
689
# we are being called directly and must probe.
690
raise NotImplementedError
691
return BzrBranch(_format=self,
692
_control_files=a_bzrdir._control_files,
694
_repository=a_bzrdir.open_repository())
697
return "Bazaar-NG branch format 4"
700
class BzrBranchFormat5(BranchFormat):
701
"""Bzr branch format 5.
704
- a revision-history file.
706
- a lock dir guarding the branch itself
707
- all of this stored in a branch/ subdirectory
708
- works with shared repositories.
710
This format is new in bzr 0.8.
713
def get_format_string(self):
714
"""See BranchFormat.get_format_string()."""
715
return "Bazaar-NG branch format 5\n"
717
def get_format_description(self):
718
"""See BranchFormat.get_format_description()."""
719
return "Branch format 5"
721
def initialize(self, a_bzrdir):
722
"""Create a branch of this format in a_bzrdir."""
723
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
724
branch_transport = a_bzrdir.get_branch_transport(self)
725
utf8_files = [('revision-history', ''),
728
control_files = LockableFiles(branch_transport, 'lock', LockDir)
729
control_files.create_lock()
730
control_files.lock_write()
731
control_files.put_utf8('format', self.get_format_string())
733
for file, content in utf8_files:
734
control_files.put_utf8(file, content)
736
control_files.unlock()
737
return self.open(a_bzrdir, _found=True, )
740
super(BzrBranchFormat5, self).__init__()
741
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
743
def open(self, a_bzrdir, _found=False):
744
"""Return the branch object for a_bzrdir
746
_found is a private parameter, do not use it. It is used to indicate
747
if format probing has already be done.
750
format = BranchFormat.find_format(a_bzrdir)
751
assert format.__class__ == self.__class__
752
transport = a_bzrdir.get_branch_transport(None)
753
control_files = LockableFiles(transport, 'lock', LockDir)
754
return BzrBranch5(_format=self,
755
_control_files=control_files,
757
_repository=a_bzrdir.find_repository())
760
return "Bazaar-NG Metadir branch format 5"
763
class BranchReferenceFormat(BranchFormat):
764
"""Bzr branch reference format.
766
Branch references are used in implementing checkouts, they
767
act as an alias to the real branch which is at some other url.
774
def get_format_string(self):
775
"""See BranchFormat.get_format_string()."""
776
return "Bazaar-NG Branch Reference Format 1\n"
778
def get_format_description(self):
779
"""See BranchFormat.get_format_description()."""
780
return "Checkout reference format 1"
782
def initialize(self, a_bzrdir, target_branch=None):
783
"""Create a branch of this format in a_bzrdir."""
784
if target_branch is None:
785
# this format does not implement branch itself, thus the implicit
786
# creation contract must see it as uninitializable
787
raise errors.UninitializableFormat(self)
788
mutter('creating branch reference in %s', a_bzrdir.transport.base)
789
branch_transport = a_bzrdir.get_branch_transport(self)
790
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
791
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
792
branch_transport.put('format', StringIO(self.get_format_string()))
793
return self.open(a_bzrdir, _found=True)
796
super(BranchReferenceFormat, self).__init__()
797
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
799
def _make_reference_clone_function(format, a_branch):
800
"""Create a clone() routine for a branch dynamically."""
801
def clone(to_bzrdir, revision_id=None):
802
"""See Branch.clone()."""
803
return format.initialize(to_bzrdir, a_branch)
804
# cannot obey revision_id limits when cloning a reference ...
805
# FIXME RBC 20060210 either nuke revision_id for clone, or
806
# emit some sort of warning/error to the caller ?!
809
def open(self, a_bzrdir, _found=False):
810
"""Return the branch that the branch reference in a_bzrdir points at.
812
_found is a private parameter, do not use it. It is used to indicate
813
if format probing has already be done.
816
format = BranchFormat.find_format(a_bzrdir)
817
assert format.__class__ == self.__class__
818
transport = a_bzrdir.get_branch_transport(None)
819
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
820
result = real_bzrdir.open_branch()
821
# this changes the behaviour of result.clone to create a new reference
822
# rather than a copy of the content of the branch.
823
# I did not use a proxy object because that needs much more extensive
824
# testing, and we are only changing one behaviour at the moment.
825
# If we decide to alter more behaviours - i.e. the implicit nickname
826
# then this should be refactored to introduce a tested proxy branch
827
# and a subclass of that for use in overriding clone() and ....
829
result.clone = self._make_reference_clone_function(result)
833
# formats which have no format string are not discoverable
834
# and not independently creatable, so are not registered.
835
__default_format = BzrBranchFormat5()
836
BranchFormat.register_format(__default_format)
837
BranchFormat.register_format(BranchReferenceFormat())
838
BranchFormat.set_default_format(__default_format)
839
_legacy_formats = [BzrBranchFormat4(),
842
class BzrBranch(Branch):
843
"""A branch stored in the actual filesystem.
845
Note that it's "local" in the context of the filesystem; it doesn't
846
really matter if it's on an nfs/smb/afs/coda/... share, as long as
847
it's writable, and can be accessed via the normal filesystem API.
850
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
851
relax_version_check=DEPRECATED_PARAMETER, _format=None,
852
_control_files=None, a_bzrdir=None, _repository=None):
853
"""Create new branch object at a particular location.
855
transport -- A Transport object, defining how to access files.
857
init -- If True, create new control files in a previously
858
unversioned directory. If False, the branch must already
861
relax_version_check -- If true, the usual check for the branch
862
version is not applied. This is intended only for
863
upgrade/recovery type use; it's not guaranteed that
864
all operations will work on old format branches.
867
self.bzrdir = bzrdir.BzrDir.open(transport.base)
869
self.bzrdir = a_bzrdir
870
self._transport = self.bzrdir.transport.clone('..')
871
self._base = self._transport.base
872
self._format = _format
873
if _control_files is None:
874
raise BzrBadParameterMissing('_control_files')
875
self.control_files = _control_files
876
if deprecated_passed(init):
877
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
878
"deprecated as of bzr 0.8. Please use Branch.create().",
882
# this is slower than before deprecation, oh well never mind.
884
self._initialize(transport.base)
885
self._check_format(_format)
886
if deprecated_passed(relax_version_check):
887
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
888
"relax_version_check parameter is deprecated as of bzr 0.8. "
889
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
893
if (not relax_version_check
894
and not self._format.is_supported()):
895
raise errors.UnsupportedFormatError(
896
'sorry, branch format %r not supported' % fmt,
897
['use a different bzr version',
898
'or remove the .bzr directory'
899
' and "bzr init" again'])
900
if deprecated_passed(transport):
901
warn("BzrBranch.__init__(transport=XXX...): The transport "
902
"parameter is deprecated as of bzr 0.8. "
903
"Please use Branch.open, or bzrdir.open_branch().",
906
self.repository = _repository
909
return '%s(%r)' % (self.__class__.__name__, self.base)
914
# TODO: It might be best to do this somewhere else,
915
# but it is nice for a Branch object to automatically
916
# cache it's information.
917
# Alternatively, we could have the Transport objects cache requests
918
# See the earlier discussion about how major objects (like Branch)
919
# should never expect their __del__ function to run.
920
# XXX: cache_root seems to be unused, 2006-01-13 mbp
921
if hasattr(self, 'cache_root') and self.cache_root is not None:
923
rmtree(self.cache_root)
926
self.cache_root = None
931
base = property(_get_base, doc="The URL for the root of this branch.")
933
def _finish_transaction(self):
934
"""Exit the current transaction."""
935
return self.control_files._finish_transaction()
937
def get_transaction(self):
938
"""Return the current active transaction.
940
If no transaction is active, this returns a passthrough object
941
for which all data is immediately flushed and no caching happens.
943
# this is an explicit function so that we can do tricky stuff
944
# when the storage in rev_storage is elsewhere.
945
# we probably need to hook the two 'lock a location' and
946
# 'have a transaction' together more delicately, so that
947
# we can have two locks (branch and storage) and one transaction
948
# ... and finishing the transaction unlocks both, but unlocking
949
# does not. - RBC 20051121
950
return self.control_files.get_transaction()
952
def _set_transaction(self, transaction):
953
"""Set a new active transaction."""
954
return self.control_files._set_transaction(transaction)
956
def abspath(self, name):
957
"""See Branch.abspath."""
958
return self.control_files._transport.abspath(name)
960
def _check_format(self, format):
961
"""Identify the branch format if needed.
963
The format is stored as a reference to the format object in
964
self._format for code that needs to check it later.
966
The format parameter is either None or the branch format class
967
used to open this branch.
969
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
972
format = BzrBranchFormat.find_format(self.bzrdir)
973
self._format = format
974
mutter("got branch format %s", self._format)
977
def get_root_id(self):
978
"""See Branch.get_root_id."""
979
tree = self.repository.revision_tree(self.last_revision())
980
return tree.inventory.root.file_id
983
return self.control_files.is_locked()
985
def lock_write(self):
986
# TODO: test for failed two phase locks. This is known broken.
987
self.control_files.lock_write()
988
self.repository.lock_write()
991
# TODO: test for failed two phase locks. This is known broken.
992
self.control_files.lock_read()
993
self.repository.lock_read()
996
# TODO: test for failed two phase locks. This is known broken.
998
self.repository.unlock()
1000
self.control_files.unlock()
1002
def peek_lock_mode(self):
1003
if self.control_files._lock_count == 0:
1006
return self.control_files._lock_mode
1008
def get_physical_lock_status(self):
1009
return self.control_files.get_physical_lock_status()
1012
def print_file(self, file, revision_id):
1013
"""See Branch.print_file."""
1014
return self.repository.print_file(file, revision_id)
1017
def append_revision(self, *revision_ids):
1018
"""See Branch.append_revision."""
1019
for revision_id in revision_ids:
1020
mutter("add {%s} to revision-history" % revision_id)
1021
rev_history = self.revision_history()
1022
rev_history.extend(revision_ids)
1023
self.set_revision_history(rev_history)
1026
def set_revision_history(self, rev_history):
1027
"""See Branch.set_revision_history."""
1028
self.control_files.put_utf8(
1029
'revision-history', '\n'.join(rev_history))
1030
transaction = self.get_transaction()
1031
history = transaction.map.find_revision_history()
1032
if history is not None:
1033
# update the revision history in the identity map.
1034
history[:] = list(rev_history)
1035
# this call is disabled because revision_history is
1036
# not really an object yet, and the transaction is for objects.
1037
# transaction.register_dirty(history)
1039
transaction.map.add_revision_history(rev_history)
1040
# this call is disabled because revision_history is
1041
# not really an object yet, and the transaction is for objects.
1042
# transaction.register_clean(history)
1044
def get_revision_delta(self, revno):
1045
"""Return the delta for one revision.
1047
The delta is relative to its mainline predecessor, or the
1048
empty tree for revision 1.
1050
assert isinstance(revno, int)
1051
rh = self.revision_history()
1052
if not (1 <= revno <= len(rh)):
1053
raise InvalidRevisionNumber(revno)
1055
# revno is 1-based; list is 0-based
1057
new_tree = self.repository.revision_tree(rh[revno-1])
1059
old_tree = EmptyTree()
1061
old_tree = self.repository.revision_tree(rh[revno-2])
1062
return compare_trees(old_tree, new_tree)
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
history = [l.rstrip('\r\n') for l in
1073
self.control_files.get_utf8('revision-history').readlines()]
1074
transaction.map.add_revision_history(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_clean(history, precious=True)
1078
return list(history)
1081
def update_revisions(self, other, stop_revision=None):
1082
"""See Branch.update_revisions."""
1085
if stop_revision is None:
1086
stop_revision = other.last_revision()
1087
if stop_revision is None:
1088
# if there are no commits, we're done.
1090
# whats the current last revision, before we fetch [and change it
1092
last_rev = self.last_revision()
1093
# we fetch here regardless of whether we need to so that we pickup
1095
self.fetch(other, stop_revision)
1096
my_ancestry = self.repository.get_ancestry(last_rev)
1097
if stop_revision in my_ancestry:
1098
# last_revision is a descendant of stop_revision
1100
# stop_revision must be a descendant of last_revision
1101
stop_graph = self.repository.get_revision_graph(stop_revision)
1102
if last_rev is not None and last_rev not in stop_graph:
1103
# our previous tip is not merged into stop_revision
1104
raise errors.DivergedBranches(self, other)
1105
# make a new revision history from the graph
1106
current_rev_id = stop_revision
1108
while current_rev_id not in (None, NULL_REVISION):
1109
new_history.append(current_rev_id)
1110
current_rev_id_parents = stop_graph[current_rev_id]
1112
current_rev_id = current_rev_id_parents[0]
1114
current_rev_id = None
1115
new_history.reverse()
1116
self.set_revision_history(new_history)
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']
1156
assert self.base[-1] == '/'
1159
return urlutils.join(self.base[:-1],
1160
self.control_files.get(l).read().strip('\n'))
1165
def get_push_location(self):
1166
"""See Branch.get_push_location."""
1167
config = bzrlib.config.BranchConfig(self)
1168
push_loc = config.get_user_option('push_location')
1171
def set_push_location(self, location):
1172
"""See Branch.set_push_location."""
1173
config = bzrlib.config.LocationConfig(self.base)
1174
config.set_user_option('push_location', location)
1177
def set_parent(self, url):
1178
"""See Branch.set_parent."""
1179
# TODO: Maybe delete old location files?
1180
# URLs should never be unicode, even on the local fs,
1181
# FIXUP this and get_parent in a future branch format bump:
1182
# read and rewrite the file, and have the new format code read
1183
# using .get not .get_utf8. RBC 20060125
1185
self.control_files._transport.delete('parent')
1187
if isinstance(url, unicode):
1189
url = url.encode('ascii')
1190
except UnicodeEncodeError:
1191
raise bzrlib.errors.InvalidURL(url,
1192
"Urls must be 7-bit ascii, "
1193
"use bzrlib.urlutils.escape")
1195
url = urlutils.relative_url(self.base, url)
1196
self.control_files.put('parent', url + '\n')
1198
def tree_config(self):
1199
return TreeConfig(self)
1202
class BzrBranch5(BzrBranch):
1203
"""A format 5 branch. This supports new features over plan branches.
1205
It has support for a master_branch which is the data for bound branches.
1213
super(BzrBranch5, self).__init__(_format=_format,
1214
_control_files=_control_files,
1216
_repository=_repository)
1219
def pull(self, source, overwrite=False, stop_revision=None):
1220
"""Updates branch.pull to be bound branch aware."""
1221
bound_location = self.get_bound_location()
1222
if source.base != bound_location:
1223
# not pulling from master, so we need to update master.
1224
master_branch = self.get_master_branch()
1226
master_branch.pull(source)
1227
source = master_branch
1228
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1230
def get_bound_location(self):
1232
return self.control_files.get_utf8('bound').read()[:-1]
1233
except errors.NoSuchFile:
1237
def get_master_branch(self):
1238
"""Return the branch we are bound to.
1240
:return: Either a Branch, or None
1242
This could memoise the branch, but if thats done
1243
it must be revalidated on each new lock.
1244
So for now we just dont memoise it.
1245
# RBC 20060304 review this decision.
1247
bound_loc = self.get_bound_location()
1251
return Branch.open(bound_loc)
1252
except (errors.NotBranchError, errors.ConnectionError), e:
1253
raise errors.BoundBranchConnectionFailure(
1257
def set_bound_location(self, location):
1258
"""Set the target where this branch is bound to.
1260
:param location: URL to the target branch
1263
self.control_files.put_utf8('bound', location+'\n')
1266
self.control_files._transport.delete('bound')
1272
def bind(self, other):
1273
"""Bind the local branch the other branch.
1275
:param other: The branch to bind to
1278
# TODO: jam 20051230 Consider checking if the target is bound
1279
# It is debatable whether you should be able to bind to
1280
# a branch which is itself bound.
1281
# Committing is obviously forbidden,
1282
# but binding itself may not be.
1283
# Since we *have* to check at commit time, we don't
1284
# *need* to check here
1287
# we are now equal to or a suffix of other.
1289
# Since we have 'pulled' from the remote location,
1290
# now we should try to pull in the opposite direction
1291
# in case the local tree has more revisions than the
1293
# There may be a different check you could do here
1294
# rather than actually trying to install revisions remotely.
1295
# TODO: capture an exception which indicates the remote branch
1297
# If it is up-to-date, this probably should not be a failure
1299
# lock other for write so the revision-history syncing cannot race
1303
# if this does not error, other now has the same last rev we do
1304
# it can only error if the pull from other was concurrent with
1305
# a commit to other from someone else.
1307
# until we ditch revision-history, we need to sync them up:
1308
self.set_revision_history(other.revision_history())
1309
# now other and self are up to date with each other and have the
1310
# same revision-history.
1314
self.set_bound_location(other.base)
1318
"""If bound, unbind"""
1319
return self.set_bound_location(None)
1323
"""Synchronise this branch with the master branch if any.
1325
:return: None or the last_revision that was pivoted out during the
1328
master = self.get_master_branch()
1329
if master is not None:
1330
old_tip = self.last_revision()
1331
self.pull(master, overwrite=True)
1332
if old_tip in self.repository.get_ancestry(self.last_revision()):
1338
class BranchTestProviderAdapter(object):
1339
"""A tool to generate a suite testing multiple branch formats at once.
1341
This is done by copying the test once for each transport and injecting
1342
the transport_server, transport_readonly_server, and branch_format
1343
classes into each copy. Each copy is also given a new id() to make it
1347
def __init__(self, transport_server, transport_readonly_server, formats):
1348
self._transport_server = transport_server
1349
self._transport_readonly_server = transport_readonly_server
1350
self._formats = formats
1352
def adapt(self, test):
1353
result = TestSuite()
1354
for branch_format, bzrdir_format in self._formats:
1355
new_test = deepcopy(test)
1356
new_test.transport_server = self._transport_server
1357
new_test.transport_readonly_server = self._transport_readonly_server
1358
new_test.bzrdir_format = bzrdir_format
1359
new_test.branch_format = branch_format
1360
def make_new_test_id():
1361
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1362
return lambda: new_id
1363
new_test.id = make_new_test_id()
1364
result.addTest(new_test)
1368
######################################################################
1372
@deprecated_function(zero_eight)
1373
def ScratchBranch(*args, **kwargs):
1374
"""See bzrlib.bzrdir.ScratchDir."""
1375
d = ScratchDir(*args, **kwargs)
1376
return d.open_branch()
1379
@deprecated_function(zero_eight)
1380
def is_control_file(*args, **kwargs):
1381
"""See bzrlib.workingtree.is_control_file."""
1382
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
