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
24
import bzrlib.bzrdir as bzrdir
25
from bzrlib.config import TreeConfig
26
from bzrlib.decorators import needs_read_lock, needs_write_lock
27
from bzrlib.delta import compare_trees
28
import bzrlib.errors as errors
29
from bzrlib.errors import (InvalidRevisionNumber,
34
from bzrlib.lockable_files import LockableFiles, TransportLock
35
from bzrlib.lockdir import LockDir
36
from bzrlib.osutils import (
39
from bzrlib.revision import (
42
from bzrlib.symbol_versioning import (deprecated_function,
48
from bzrlib.trace import mutter, note
49
from bzrlib.tree import EmptyTree
50
import bzrlib.ui as ui
51
import bzrlib.urlutils as urlutils
54
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
55
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
56
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
59
# TODO: Maybe include checks for common corruption of newlines, etc?
61
# TODO: Some operations like log might retrieve the same revisions
62
# repeatedly to calculate deltas. We could perhaps have a weakref
63
# cache in memory to make this faster. In general anything can be
64
# cached in memory between lock and unlock operations. .. nb thats
65
# what the transaction identity map provides
68
######################################################################
72
"""Branch holding a history of revisions.
75
Base directory/url of the branch.
77
# this is really an instance variable - FIXME move it there
81
def __init__(self, *ignored, **ignored_too):
82
raise NotImplementedError('The Branch class is abstract')
85
"""Break a lock if one is present from another instance.
87
Uses the ui factory to ask for confirmation if the lock may be from
90
This will probe the repository for its lock as well.
92
self.control_files.break_lock()
93
self.repository.break_lock()
94
master = self.get_master_branch()
95
if master is not None:
99
@deprecated_method(zero_eight)
100
def open_downlevel(base):
101
"""Open a branch which may be of an old format."""
102
return Branch.open(base, _unsupported=True)
105
def open(base, _unsupported=False):
106
"""Open the repository rooted at base.
108
For instance, if the repository is at URL/.bzr/repository,
109
Repository.open(URL) -> a Repository instance.
111
control = bzrdir.BzrDir.open(base, _unsupported)
112
return control.open_branch(_unsupported)
115
def open_containing(url):
116
"""Open an existing branch which contains url.
118
This probes for a branch at url, and searches upwards from there.
120
Basically we keep looking up until we find the control directory or
121
run into the root. If there isn't one, raises NotBranchError.
122
If there is one and it is either an unrecognised format or an unsupported
123
format, UnknownFormatError or UnsupportedFormatError are raised.
124
If there is one, it is returned, along with the unused portion of url.
126
control, relpath = bzrdir.BzrDir.open_containing(url)
127
return control.open_branch(), relpath
130
@deprecated_function(zero_eight)
131
def initialize(base):
132
"""Create a new working tree and branch, rooted at 'base' (url)
134
NOTE: This will soon be deprecated in favour of creation
137
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
139
def setup_caching(self, cache_root):
140
"""Subclasses that care about caching should override this, and set
141
up cached stores located under cache_root.
143
# seems to be unused, 2006-01-13 mbp
144
warn('%s is deprecated' % self.setup_caching)
145
self.cache_root = cache_root
148
cfg = self.tree_config()
149
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
151
def _set_nick(self, nick):
152
cfg = self.tree_config()
153
cfg.set_option(nick, "nickname")
154
assert cfg.get_option("nickname") == nick
156
nick = property(_get_nick, _set_nick)
159
raise NotImplementedError('is_locked is abstract')
161
def lock_write(self):
162
raise NotImplementedError('lock_write is abstract')
165
raise NotImplementedError('lock_read is abstract')
168
raise NotImplementedError('unlock is abstract')
170
def peek_lock_mode(self):
171
"""Return lock mode for the Branch: 'r', 'w' or None"""
172
raise NotImplementedError(self.peek_lock_mode)
174
def get_physical_lock_status(self):
175
raise NotImplementedError('get_physical_lock_status is abstract')
177
def abspath(self, name):
178
"""Return absolute filename for something in the branch
180
XXX: Robert Collins 20051017 what is this used for? why is it a branch
181
method and not a tree method.
183
raise NotImplementedError('abspath is abstract')
185
def bind(self, other):
186
"""Bind the local branch the other branch.
188
:param other: The branch to bind to
191
raise errors.UpgradeRequired(self.base)
194
def fetch(self, from_branch, last_revision=None, pb=None):
195
"""Copy revisions from from_branch into this branch.
197
:param from_branch: Where to copy from.
198
:param last_revision: What revision to stop at (None for at the end
200
:param pb: An optional progress bar to use.
202
Returns the copied revision count and the failed revisions in a tuple:
205
if self.base == from_branch.base:
208
nested_pb = ui.ui_factory.nested_progress_bar()
213
from_branch.lock_read()
215
if last_revision is None:
216
pb.update('get source history')
217
from_history = from_branch.revision_history()
219
last_revision = from_history[-1]
221
# no history in the source branch
222
last_revision = NULL_REVISION
223
return self.repository.fetch(from_branch.repository,
224
revision_id=last_revision,
227
if nested_pb is not None:
231
def get_bound_location(self):
232
"""Return the URL of the branch we are bound to.
234
Older format branches cannot bind, please be sure to use a metadir
239
def get_commit_builder(self, parents, config=None, timestamp=None,
240
timezone=None, committer=None, revprops=None,
242
"""Obtain a CommitBuilder for this branch.
244
:param parents: Revision ids of the parents of the new revision.
245
:param config: Optional configuration to use.
246
:param timestamp: Optional timestamp recorded for commit.
247
:param timezone: Optional timezone for timestamp.
248
:param committer: Optional committer to set for commit.
249
:param revprops: Optional dictionary of revision properties.
250
:param revision_id: Optional revision id.
254
config = bzrlib.config.BranchConfig(self)
256
return self.repository.get_commit_builder(self, parents, config,
257
timestamp, timezone, committer, revprops, revision_id)
259
def get_master_branch(self):
260
"""Return the branch we are bound to.
262
:return: Either a Branch, or None
266
def get_root_id(self):
267
"""Return the id of this branches root"""
268
raise NotImplementedError('get_root_id is abstract')
270
def print_file(self, file, revision_id):
271
"""Print `file` to stdout."""
272
raise NotImplementedError('print_file is abstract')
274
def append_revision(self, *revision_ids):
275
raise NotImplementedError('append_revision is abstract')
277
def set_revision_history(self, rev_history):
278
raise NotImplementedError('set_revision_history is abstract')
280
def revision_history(self):
281
"""Return sequence of revision hashes on to this branch."""
282
raise NotImplementedError('revision_history is abstract')
285
"""Return current revision number for this branch.
287
That is equivalent to the number of revisions committed to
290
return len(self.revision_history())
293
"""Older format branches cannot bind or unbind."""
294
raise errors.UpgradeRequired(self.base)
296
def last_revision(self):
297
"""Return last patch hash, or None if no history."""
298
ph = self.revision_history()
304
def missing_revisions(self, other, stop_revision=None):
305
"""Return a list of new revisions that would perfectly fit.
307
If self and other have not diverged, return a list of the revisions
308
present in other, but missing from self.
310
>>> from bzrlib.workingtree import WorkingTree
311
>>> bzrlib.trace.silent = True
312
>>> d1 = bzrdir.ScratchDir()
313
>>> br1 = d1.open_branch()
314
>>> wt1 = d1.open_workingtree()
315
>>> d2 = bzrdir.ScratchDir()
316
>>> br2 = d2.open_branch()
317
>>> wt2 = d2.open_workingtree()
318
>>> br1.missing_revisions(br2)
320
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
321
>>> br1.missing_revisions(br2)
323
>>> br2.missing_revisions(br1)
325
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
326
>>> br1.missing_revisions(br2)
328
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
329
>>> br1.missing_revisions(br2)
331
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
332
>>> br1.missing_revisions(br2)
333
Traceback (most recent call last):
334
DivergedBranches: These branches have diverged. Try merge.
336
self_history = self.revision_history()
337
self_len = len(self_history)
338
other_history = other.revision_history()
339
other_len = len(other_history)
340
common_index = min(self_len, other_len) -1
341
if common_index >= 0 and \
342
self_history[common_index] != other_history[common_index]:
343
raise DivergedBranches(self, other)
345
if stop_revision is None:
346
stop_revision = other_len
348
assert isinstance(stop_revision, int)
349
if stop_revision > other_len:
350
raise errors.NoSuchRevision(self, stop_revision)
351
return other_history[self_len:stop_revision]
353
def update_revisions(self, other, stop_revision=None):
354
"""Pull in new perfect-fit revisions.
356
:param other: Another Branch to pull from
357
:param stop_revision: Updated until the given revision
360
raise NotImplementedError('update_revisions is abstract')
362
def revision_id_to_revno(self, revision_id):
363
"""Given a revision id, return its revno"""
364
if revision_id is None:
366
history = self.revision_history()
368
return history.index(revision_id) + 1
370
raise bzrlib.errors.NoSuchRevision(self, revision_id)
372
def get_rev_id(self, revno, history=None):
373
"""Find the revision id of the specified revno."""
377
history = self.revision_history()
378
elif revno <= 0 or revno > len(history):
379
raise bzrlib.errors.NoSuchRevision(self, revno)
380
return history[revno - 1]
382
def pull(self, source, overwrite=False, stop_revision=None):
383
raise NotImplementedError('pull is abstract')
385
def basis_tree(self):
386
"""Return `Tree` object for last revision.
388
If there are no revisions yet, return an `EmptyTree`.
390
return self.repository.revision_tree(self.last_revision())
392
def rename_one(self, from_rel, to_rel):
395
This can change the directory or the filename or both.
397
raise NotImplementedError('rename_one is abstract')
399
def move(self, from_paths, to_name):
402
to_name must exist as a versioned directory.
404
If to_name exists and is a directory, the files are moved into
405
it, keeping their old names. If it is a directory,
407
Note that to_name is only the last component of the new name;
408
this doesn't change the directory.
410
This returns a list of (from_path, to_path) pairs for each
413
raise NotImplementedError('move is abstract')
415
def get_parent(self):
416
"""Return the parent location of the branch.
418
This is the default location for push/pull/missing. The usual
419
pattern is that the user can override it by specifying a
422
raise NotImplementedError('get_parent is abstract')
424
def get_push_location(self):
425
"""Return the None or the location to push this branch to."""
426
raise NotImplementedError('get_push_location is abstract')
428
def set_push_location(self, location):
429
"""Set a new push location for this branch."""
430
raise NotImplementedError('set_push_location is abstract')
432
def set_parent(self, url):
433
raise NotImplementedError('set_parent is abstract')
437
"""Synchronise this branch with the master branch if any.
439
:return: None or the last_revision pivoted out during the update.
443
def check_revno(self, revno):
445
Check whether a revno corresponds to any revision.
446
Zero (the NULL revision) is considered valid.
449
self.check_real_revno(revno)
451
def check_real_revno(self, revno):
453
Check whether a revno corresponds to a real revision.
454
Zero (the NULL revision) is considered invalid
456
if revno < 1 or revno > self.revno():
457
raise InvalidRevisionNumber(revno)
460
def clone(self, *args, **kwargs):
461
"""Clone this branch into to_bzrdir preserving all semantic values.
463
revision_id: if not None, the revision history in the new branch will
464
be truncated to end with revision_id.
466
# for API compatibility, until 0.8 releases we provide the old api:
467
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
468
# after 0.8 releases, the *args and **kwargs should be changed:
469
# def clone(self, to_bzrdir, revision_id=None):
470
if (kwargs.get('to_location', None) or
471
kwargs.get('revision', None) or
472
kwargs.get('basis_branch', None) or
473
(len(args) and isinstance(args[0], basestring))):
474
# backwards compatibility api:
475
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
476
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
479
basis_branch = args[2]
481
basis_branch = kwargs.get('basis_branch', None)
483
basis = basis_branch.bzrdir
488
revision_id = args[1]
490
revision_id = kwargs.get('revision', None)
495
# no default to raise if not provided.
496
url = kwargs.get('to_location')
497
return self.bzrdir.clone(url,
498
revision_id=revision_id,
499
basis=basis).open_branch()
501
# generate args by hand
503
revision_id = args[1]
505
revision_id = kwargs.get('revision_id', None)
509
# no default to raise if not provided.
510
to_bzrdir = kwargs.get('to_bzrdir')
511
result = self._format.initialize(to_bzrdir)
512
self.copy_content_into(result, revision_id=revision_id)
516
def sprout(self, to_bzrdir, revision_id=None):
517
"""Create a new line of development from the branch, into to_bzrdir.
519
revision_id: if not None, the revision history in the new branch will
520
be truncated to end with revision_id.
522
result = self._format.initialize(to_bzrdir)
523
self.copy_content_into(result, revision_id=revision_id)
524
result.set_parent(self.bzrdir.root_transport.base)
528
def copy_content_into(self, destination, revision_id=None):
529
"""Copy the content of self into destination.
531
revision_id: if not None, the revision history in the new branch will
532
be truncated to end with revision_id.
534
new_history = self.revision_history()
535
if revision_id is not None:
537
new_history = new_history[:new_history.index(revision_id) + 1]
539
rev = self.repository.get_revision(revision_id)
540
new_history = rev.get_history(self.repository)[1:]
541
destination.set_revision_history(new_history)
542
parent = self.get_parent()
544
destination.set_parent(parent)
548
"""Check consistency of the branch.
550
In particular this checks that revisions given in the revision-history
551
do actually match up in the revision graph, and that they're all
552
present in the repository.
554
Callers will typically also want to check the repository.
556
:return: A BranchCheckResult.
558
mainline_parent_id = None
559
for revision_id in self.revision_history():
561
revision = self.repository.get_revision(revision_id)
562
except errors.NoSuchRevision, e:
563
raise errors.BzrCheckError("mainline revision {%s} not in repository"
565
# In general the first entry on the revision history has no parents.
566
# But it's not illegal for it to have parents listed; this can happen
567
# in imports from Arch when the parents weren't reachable.
568
if mainline_parent_id is not None:
569
if mainline_parent_id not in revision.parent_ids:
570
raise errors.BzrCheckError("previous revision {%s} not listed among "
572
% (mainline_parent_id, revision_id))
573
mainline_parent_id = revision_id
574
return BranchCheckResult(self)
577
class BranchFormat(object):
578
"""An encapsulation of the initialization and open routines for a format.
580
Formats provide three things:
581
* An initialization routine,
585
Formats are placed in an dict by their format string for reference
586
during branch opening. Its not required that these be instances, they
587
can be classes themselves with class methods - it simply depends on
588
whether state is needed for a given format or not.
590
Once a format is deprecated, just deprecate the initialize and open
591
methods on the format class. Do not deprecate the object, as the
592
object will be created every time regardless.
595
_default_format = None
596
"""The default format used for new branches."""
599
"""The known formats."""
602
def find_format(klass, a_bzrdir):
603
"""Return the format for the branch object in a_bzrdir."""
605
transport = a_bzrdir.get_branch_transport(None)
606
format_string = transport.get("format").read()
607
return klass._formats[format_string]
609
raise NotBranchError(path=transport.base)
611
raise errors.UnknownFormatError(format_string)
614
def get_default_format(klass):
615
"""Return the current default format."""
616
return klass._default_format
618
def get_format_string(self):
619
"""Return the ASCII format string that identifies this format."""
620
raise NotImplementedError(self.get_format_string)
622
def get_format_description(self):
623
"""Return the short format description for this format."""
624
raise NotImplementedError(self.get_format_string)
626
def initialize(self, a_bzrdir):
627
"""Create a branch of this format in a_bzrdir."""
628
raise NotImplementedError(self.initialize)
630
def is_supported(self):
631
"""Is this format supported?
633
Supported formats can be initialized and opened.
634
Unsupported formats may not support initialization or committing or
635
some other features depending on the reason for not being supported.
639
def open(self, a_bzrdir, _found=False):
640
"""Return the branch object for a_bzrdir
642
_found is a private parameter, do not use it. It is used to indicate
643
if format probing has already be done.
645
raise NotImplementedError(self.open)
648
def register_format(klass, format):
649
klass._formats[format.get_format_string()] = format
652
def set_default_format(klass, format):
653
klass._default_format = format
656
def unregister_format(klass, format):
657
assert klass._formats[format.get_format_string()] is format
658
del klass._formats[format.get_format_string()]
661
return self.get_format_string().rstrip()
664
class BzrBranchFormat4(BranchFormat):
665
"""Bzr branch format 4.
668
- a revision-history file.
669
- a branch-lock lock file [ to be shared with the bzrdir ]
672
def get_format_description(self):
673
"""See BranchFormat.get_format_description()."""
674
return "Branch format 4"
676
def initialize(self, a_bzrdir):
677
"""Create a branch of this format in a_bzrdir."""
678
mutter('creating branch in %s', a_bzrdir.transport.base)
679
branch_transport = a_bzrdir.get_branch_transport(self)
680
utf8_files = [('revision-history', ''),
683
control_files = LockableFiles(branch_transport, 'branch-lock',
685
control_files.create_lock()
686
control_files.lock_write()
688
for file, content in utf8_files:
689
control_files.put_utf8(file, content)
691
control_files.unlock()
692
return self.open(a_bzrdir, _found=True)
695
super(BzrBranchFormat4, self).__init__()
696
self._matchingbzrdir = bzrdir.BzrDirFormat6()
698
def open(self, a_bzrdir, _found=False):
699
"""Return the branch object for a_bzrdir
701
_found is a private parameter, do not use it. It is used to indicate
702
if format probing has already be done.
705
# we are being called directly and must probe.
706
raise NotImplementedError
707
return BzrBranch(_format=self,
708
_control_files=a_bzrdir._control_files,
710
_repository=a_bzrdir.open_repository())
713
return "Bazaar-NG branch format 4"
716
class BzrBranchFormat5(BranchFormat):
717
"""Bzr branch format 5.
720
- a revision-history file.
722
- a lock dir guarding the branch itself
723
- all of this stored in a branch/ subdirectory
724
- works with shared repositories.
726
This format is new in bzr 0.8.
729
def get_format_string(self):
730
"""See BranchFormat.get_format_string()."""
731
return "Bazaar-NG branch format 5\n"
733
def get_format_description(self):
734
"""See BranchFormat.get_format_description()."""
735
return "Branch format 5"
737
def initialize(self, a_bzrdir):
738
"""Create a branch of this format in a_bzrdir."""
739
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
740
branch_transport = a_bzrdir.get_branch_transport(self)
741
utf8_files = [('revision-history', ''),
744
control_files = LockableFiles(branch_transport, 'lock', LockDir)
745
control_files.create_lock()
746
control_files.lock_write()
747
control_files.put_utf8('format', self.get_format_string())
749
for file, content in utf8_files:
750
control_files.put_utf8(file, content)
752
control_files.unlock()
753
return self.open(a_bzrdir, _found=True, )
756
super(BzrBranchFormat5, self).__init__()
757
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
759
def open(self, a_bzrdir, _found=False):
760
"""Return the branch object for a_bzrdir
762
_found is a private parameter, do not use it. It is used to indicate
763
if format probing has already be done.
766
format = BranchFormat.find_format(a_bzrdir)
767
assert format.__class__ == self.__class__
768
transport = a_bzrdir.get_branch_transport(None)
769
control_files = LockableFiles(transport, 'lock', LockDir)
770
return BzrBranch5(_format=self,
771
_control_files=control_files,
773
_repository=a_bzrdir.find_repository())
776
return "Bazaar-NG Metadir branch format 5"
779
class BranchReferenceFormat(BranchFormat):
780
"""Bzr branch reference format.
782
Branch references are used in implementing checkouts, they
783
act as an alias to the real branch which is at some other url.
790
def get_format_string(self):
791
"""See BranchFormat.get_format_string()."""
792
return "Bazaar-NG Branch Reference Format 1\n"
794
def get_format_description(self):
795
"""See BranchFormat.get_format_description()."""
796
return "Checkout reference format 1"
798
def initialize(self, a_bzrdir, target_branch=None):
799
"""Create a branch of this format in a_bzrdir."""
800
if target_branch is None:
801
# this format does not implement branch itself, thus the implicit
802
# creation contract must see it as uninitializable
803
raise errors.UninitializableFormat(self)
804
mutter('creating branch reference in %s', a_bzrdir.transport.base)
805
branch_transport = a_bzrdir.get_branch_transport(self)
806
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
807
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
808
branch_transport.put('format', StringIO(self.get_format_string()))
809
return self.open(a_bzrdir, _found=True)
812
super(BranchReferenceFormat, self).__init__()
813
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
815
def _make_reference_clone_function(format, a_branch):
816
"""Create a clone() routine for a branch dynamically."""
817
def clone(to_bzrdir, revision_id=None):
818
"""See Branch.clone()."""
819
return format.initialize(to_bzrdir, a_branch)
820
# cannot obey revision_id limits when cloning a reference ...
821
# FIXME RBC 20060210 either nuke revision_id for clone, or
822
# emit some sort of warning/error to the caller ?!
825
def open(self, a_bzrdir, _found=False):
826
"""Return the branch that the branch reference in a_bzrdir points at.
828
_found is a private parameter, do not use it. It is used to indicate
829
if format probing has already be done.
832
format = BranchFormat.find_format(a_bzrdir)
833
assert format.__class__ == self.__class__
834
transport = a_bzrdir.get_branch_transport(None)
835
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
836
result = real_bzrdir.open_branch()
837
# this changes the behaviour of result.clone to create a new reference
838
# rather than a copy of the content of the branch.
839
# I did not use a proxy object because that needs much more extensive
840
# testing, and we are only changing one behaviour at the moment.
841
# If we decide to alter more behaviours - i.e. the implicit nickname
842
# then this should be refactored to introduce a tested proxy branch
843
# and a subclass of that for use in overriding clone() and ....
845
result.clone = self._make_reference_clone_function(result)
849
# formats which have no format string are not discoverable
850
# and not independently creatable, so are not registered.
851
__default_format = BzrBranchFormat5()
852
BranchFormat.register_format(__default_format)
853
BranchFormat.register_format(BranchReferenceFormat())
854
BranchFormat.set_default_format(__default_format)
855
_legacy_formats = [BzrBranchFormat4(),
858
class BzrBranch(Branch):
859
"""A branch stored in the actual filesystem.
861
Note that it's "local" in the context of the filesystem; it doesn't
862
really matter if it's on an nfs/smb/afs/coda/... share, as long as
863
it's writable, and can be accessed via the normal filesystem API.
866
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
867
relax_version_check=DEPRECATED_PARAMETER, _format=None,
868
_control_files=None, a_bzrdir=None, _repository=None):
869
"""Create new branch object at a particular location.
871
transport -- A Transport object, defining how to access files.
873
init -- If True, create new control files in a previously
874
unversioned directory. If False, the branch must already
877
relax_version_check -- If true, the usual check for the branch
878
version is not applied. This is intended only for
879
upgrade/recovery type use; it's not guaranteed that
880
all operations will work on old format branches.
883
self.bzrdir = bzrdir.BzrDir.open(transport.base)
885
self.bzrdir = a_bzrdir
886
self._transport = self.bzrdir.transport.clone('..')
887
self._base = self._transport.base
888
self._format = _format
889
if _control_files is None:
890
raise ValueError('BzrBranch _control_files is None')
891
self.control_files = _control_files
892
if deprecated_passed(init):
893
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
894
"deprecated as of bzr 0.8. Please use Branch.create().",
898
# this is slower than before deprecation, oh well never mind.
900
self._initialize(transport.base)
901
self._check_format(_format)
902
if deprecated_passed(relax_version_check):
903
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
904
"relax_version_check parameter is deprecated as of bzr 0.8. "
905
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
909
if (not relax_version_check
910
and not self._format.is_supported()):
911
raise errors.UnsupportedFormatError(
912
'sorry, branch format %r not supported' % self._format,
913
['use a different bzr version',
914
'or remove the .bzr directory'
915
' and "bzr init" again'])
916
if deprecated_passed(transport):
917
warn("BzrBranch.__init__(transport=XXX...): The transport "
918
"parameter is deprecated as of bzr 0.8. "
919
"Please use Branch.open, or bzrdir.open_branch().",
922
self.repository = _repository
925
return '%s(%r)' % (self.__class__.__name__, self.base)
930
# TODO: It might be best to do this somewhere else,
931
# but it is nice for a Branch object to automatically
932
# cache it's information.
933
# Alternatively, we could have the Transport objects cache requests
934
# See the earlier discussion about how major objects (like Branch)
935
# should never expect their __del__ function to run.
936
# XXX: cache_root seems to be unused, 2006-01-13 mbp
937
if hasattr(self, 'cache_root') and self.cache_root is not None:
939
rmtree(self.cache_root)
942
self.cache_root = None
947
base = property(_get_base, doc="The URL for the root of this branch.")
949
def _finish_transaction(self):
950
"""Exit the current transaction."""
951
return self.control_files._finish_transaction()
953
def get_transaction(self):
954
"""Return the current active transaction.
956
If no transaction is active, this returns a passthrough object
957
for which all data is immediately flushed and no caching happens.
959
# this is an explicit function so that we can do tricky stuff
960
# when the storage in rev_storage is elsewhere.
961
# we probably need to hook the two 'lock a location' and
962
# 'have a transaction' together more delicately, so that
963
# we can have two locks (branch and storage) and one transaction
964
# ... and finishing the transaction unlocks both, but unlocking
965
# does not. - RBC 20051121
966
return self.control_files.get_transaction()
968
def _set_transaction(self, transaction):
969
"""Set a new active transaction."""
970
return self.control_files._set_transaction(transaction)
972
def abspath(self, name):
973
"""See Branch.abspath."""
974
return self.control_files._transport.abspath(name)
976
def _check_format(self, format):
977
"""Identify the branch format if needed.
979
The format is stored as a reference to the format object in
980
self._format for code that needs to check it later.
982
The format parameter is either None or the branch format class
983
used to open this branch.
985
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
988
format = BranchFormat.find_format(self.bzrdir)
989
self._format = format
990
mutter("got branch format %s", self._format)
993
def get_root_id(self):
994
"""See Branch.get_root_id."""
995
tree = self.repository.revision_tree(self.last_revision())
996
return tree.inventory.root.file_id
999
return self.control_files.is_locked()
1001
def lock_write(self):
1002
# TODO: test for failed two phase locks. This is known broken.
1003
self.control_files.lock_write()
1004
self.repository.lock_write()
1006
def lock_read(self):
1007
# TODO: test for failed two phase locks. This is known broken.
1008
self.control_files.lock_read()
1009
self.repository.lock_read()
1012
# TODO: test for failed two phase locks. This is known broken.
1014
self.repository.unlock()
1016
self.control_files.unlock()
1018
def peek_lock_mode(self):
1019
if self.control_files._lock_count == 0:
1022
return self.control_files._lock_mode
1024
def get_physical_lock_status(self):
1025
return self.control_files.get_physical_lock_status()
1028
def print_file(self, file, revision_id):
1029
"""See Branch.print_file."""
1030
return self.repository.print_file(file, revision_id)
1033
def append_revision(self, *revision_ids):
1034
"""See Branch.append_revision."""
1035
for revision_id in revision_ids:
1036
mutter("add {%s} to revision-history" % revision_id)
1037
rev_history = self.revision_history()
1038
rev_history.extend(revision_ids)
1039
self.set_revision_history(rev_history)
1042
def set_revision_history(self, rev_history):
1043
"""See Branch.set_revision_history."""
1044
self.control_files.put_utf8(
1045
'revision-history', '\n'.join(rev_history))
1046
transaction = self.get_transaction()
1047
history = transaction.map.find_revision_history()
1048
if history is not None:
1049
# update the revision history in the identity map.
1050
history[:] = list(rev_history)
1051
# this call is disabled because revision_history is
1052
# not really an object yet, and the transaction is for objects.
1053
# transaction.register_dirty(history)
1055
transaction.map.add_revision_history(rev_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)
1060
def get_revision_delta(self, revno):
1061
"""Return the delta for one revision.
1063
The delta is relative to its mainline predecessor, or the
1064
empty tree for revision 1.
1066
assert isinstance(revno, int)
1067
rh = self.revision_history()
1068
if not (1 <= revno <= len(rh)):
1069
raise InvalidRevisionNumber(revno)
1071
# revno is 1-based; list is 0-based
1073
new_tree = self.repository.revision_tree(rh[revno-1])
1075
old_tree = EmptyTree()
1077
old_tree = self.repository.revision_tree(rh[revno-2])
1078
return compare_trees(old_tree, new_tree)
1081
def revision_history(self):
1082
"""See Branch.revision_history."""
1083
transaction = self.get_transaction()
1084
history = transaction.map.find_revision_history()
1085
if history is not None:
1086
mutter("cache hit for revision-history in %s", self)
1087
return list(history)
1088
history = [l.rstrip('\r\n') for l in
1089
self.control_files.get_utf8('revision-history').readlines()]
1090
transaction.map.add_revision_history(history)
1091
# this call is disabled because revision_history is
1092
# not really an object yet, and the transaction is for objects.
1093
# transaction.register_clean(history, precious=True)
1094
return list(history)
1097
def update_revisions(self, other, stop_revision=None):
1098
"""See Branch.update_revisions."""
1101
if stop_revision is None:
1102
stop_revision = other.last_revision()
1103
if stop_revision is None:
1104
# if there are no commits, we're done.
1106
# whats the current last revision, before we fetch [and change it
1108
last_rev = self.last_revision()
1109
# we fetch here regardless of whether we need to so that we pickup
1111
self.fetch(other, stop_revision)
1112
my_ancestry = self.repository.get_ancestry(last_rev)
1113
if stop_revision in my_ancestry:
1114
# last_revision is a descendant of stop_revision
1116
# stop_revision must be a descendant of last_revision
1117
stop_graph = self.repository.get_revision_graph(stop_revision)
1118
if last_rev is not None and last_rev not in stop_graph:
1119
# our previous tip is not merged into stop_revision
1120
raise errors.DivergedBranches(self, other)
1121
# make a new revision history from the graph
1122
current_rev_id = stop_revision
1124
while current_rev_id not in (None, NULL_REVISION):
1125
new_history.append(current_rev_id)
1126
current_rev_id_parents = stop_graph[current_rev_id]
1128
current_rev_id = current_rev_id_parents[0]
1130
current_rev_id = None
1131
new_history.reverse()
1132
self.set_revision_history(new_history)
1136
def basis_tree(self):
1137
"""See Branch.basis_tree."""
1138
return self.repository.revision_tree(self.last_revision())
1140
@deprecated_method(zero_eight)
1141
def working_tree(self):
1142
"""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."""
1169
_locs = ['parent', 'pull', 'x-pull']
1170
assert self.base[-1] == '/'
1173
return urlutils.join(self.base[:-1],
1174
self.control_files.get(l).read().strip('\n'))
1179
def get_push_location(self):
1180
"""See Branch.get_push_location."""
1181
config = bzrlib.config.BranchConfig(self)
1182
push_loc = config.get_user_option('push_location')
1185
def set_push_location(self, location):
1186
"""See Branch.set_push_location."""
1187
config = bzrlib.config.LocationConfig(self.base)
1188
config.set_user_option('push_location', location)
1191
def set_parent(self, url):
1192
"""See Branch.set_parent."""
1193
# TODO: Maybe delete old location files?
1194
# URLs should never be unicode, even on the local fs,
1195
# FIXUP this and get_parent in a future branch format bump:
1196
# read and rewrite the file, and have the new format code read
1197
# using .get not .get_utf8. RBC 20060125
1199
self.control_files._transport.delete('parent')
1201
if isinstance(url, unicode):
1203
url = url.encode('ascii')
1204
except UnicodeEncodeError:
1205
raise bzrlib.errors.InvalidURL(url,
1206
"Urls must be 7-bit ascii, "
1207
"use bzrlib.urlutils.escape")
1209
url = urlutils.relative_url(self.base, url)
1210
self.control_files.put('parent', url + '\n')
1212
def tree_config(self):
1213
return TreeConfig(self)
1216
class BzrBranch5(BzrBranch):
1217
"""A format 5 branch. This supports new features over plan branches.
1219
It has support for a master_branch which is the data for bound branches.
1227
super(BzrBranch5, self).__init__(_format=_format,
1228
_control_files=_control_files,
1230
_repository=_repository)
1233
def pull(self, source, overwrite=False, stop_revision=None):
1234
"""Updates branch.pull to be bound branch aware."""
1235
bound_location = self.get_bound_location()
1236
if source.base != bound_location:
1237
# not pulling from master, so we need to update master.
1238
master_branch = self.get_master_branch()
1240
master_branch.pull(source)
1241
source = master_branch
1242
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1244
def get_bound_location(self):
1246
return self.control_files.get_utf8('bound').read()[:-1]
1247
except errors.NoSuchFile:
1251
def get_master_branch(self):
1252
"""Return the branch we are bound to.
1254
:return: Either a Branch, or None
1256
This could memoise the branch, but if thats done
1257
it must be revalidated on each new lock.
1258
So for now we just don't memoise it.
1259
# RBC 20060304 review this decision.
1261
bound_loc = self.get_bound_location()
1265
return Branch.open(bound_loc)
1266
except (errors.NotBranchError, errors.ConnectionError), e:
1267
raise errors.BoundBranchConnectionFailure(
1271
def set_bound_location(self, location):
1272
"""Set the target where this branch is bound to.
1274
:param location: URL to the target branch
1277
self.control_files.put_utf8('bound', location+'\n')
1280
self.control_files._transport.delete('bound')
1286
def bind(self, other):
1287
"""Bind the local branch the other branch.
1289
:param other: The branch to bind to
1292
# TODO: jam 20051230 Consider checking if the target is bound
1293
# It is debatable whether you should be able to bind to
1294
# a branch which is itself bound.
1295
# Committing is obviously forbidden,
1296
# but binding itself may not be.
1297
# Since we *have* to check at commit time, we don't
1298
# *need* to check here
1301
# we are now equal to or a suffix of other.
1303
# Since we have 'pulled' from the remote location,
1304
# now we should try to pull in the opposite direction
1305
# in case the local tree has more revisions than the
1307
# There may be a different check you could do here
1308
# rather than actually trying to install revisions remotely.
1309
# TODO: capture an exception which indicates the remote branch
1311
# If it is up-to-date, this probably should not be a failure
1313
# lock other for write so the revision-history syncing cannot race
1317
# if this does not error, other now has the same last rev we do
1318
# it can only error if the pull from other was concurrent with
1319
# a commit to other from someone else.
1321
# until we ditch revision-history, we need to sync them up:
1322
self.set_revision_history(other.revision_history())
1323
# now other and self are up to date with each other and have the
1324
# same revision-history.
1328
self.set_bound_location(other.base)
1332
"""If bound, unbind"""
1333
return self.set_bound_location(None)
1337
"""Synchronise this branch with the master branch if any.
1339
:return: None or the last_revision that was pivoted out during the
1342
master = self.get_master_branch()
1343
if master is not None:
1344
old_tip = self.last_revision()
1345
self.pull(master, overwrite=True)
1346
if old_tip in self.repository.get_ancestry(self.last_revision()):
1352
class BranchTestProviderAdapter(object):
1353
"""A tool to generate a suite testing multiple branch formats at once.
1355
This is done by copying the test once for each transport and injecting
1356
the transport_server, transport_readonly_server, and branch_format
1357
classes into each copy. Each copy is also given a new id() to make it
1361
def __init__(self, transport_server, transport_readonly_server, formats):
1362
self._transport_server = transport_server
1363
self._transport_readonly_server = transport_readonly_server
1364
self._formats = formats
1366
def adapt(self, test):
1367
result = TestSuite()
1368
for branch_format, bzrdir_format in self._formats:
1369
new_test = deepcopy(test)
1370
new_test.transport_server = self._transport_server
1371
new_test.transport_readonly_server = self._transport_readonly_server
1372
new_test.bzrdir_format = bzrdir_format
1373
new_test.branch_format = branch_format
1374
def make_new_test_id():
1375
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1376
return lambda: new_id
1377
new_test.id = make_new_test_id()
1378
result.addTest(new_test)
1382
class BranchCheckResult(object):
1383
"""Results of checking branch consistency.
1388
def __init__(self, branch):
1389
self.branch = branch
1391
def report_results(self, verbose):
1392
"""Report the check results via trace.note.
1394
:param verbose: Requests more detailed display of what was checked,
1397
note('checked branch %s format %s',
1399
self.branch._format)
1402
######################################################################
1406
@deprecated_function(zero_eight)
1407
def is_control_file(*args, **kwargs):
1408
"""See bzrlib.workingtree.is_control_file."""
1409
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
