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")
336
>>> br1.missing_revisions(br2)
338
>>> br2.missing_revisions(br1)
340
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
342
>>> br1.missing_revisions(br2)
344
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
346
>>> br1.missing_revisions(br2)
348
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
350
>>> br1.missing_revisions(br2)
351
Traceback (most recent call last):
352
DivergedBranches: These branches have diverged. Try merge.
354
self_history = self.revision_history()
355
self_len = len(self_history)
356
other_history = other.revision_history()
357
other_len = len(other_history)
358
common_index = min(self_len, other_len) -1
359
if common_index >= 0 and \
360
self_history[common_index] != other_history[common_index]:
361
raise DivergedBranches(self, other)
363
if stop_revision is None:
364
stop_revision = other_len
366
assert isinstance(stop_revision, int)
367
if stop_revision > other_len:
368
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
369
return other_history[self_len:stop_revision]
371
def update_revisions(self, other, stop_revision=None):
372
"""Pull in new perfect-fit revisions.
374
:param other: Another Branch to pull from
375
:param stop_revision: Updated until the given revision
378
raise NotImplementedError('update_revisions is abstract')
380
def revision_id_to_revno(self, revision_id):
381
"""Given a revision id, return its revno"""
382
if revision_id is None:
384
history = self.revision_history()
386
return history.index(revision_id) + 1
388
raise bzrlib.errors.NoSuchRevision(self, revision_id)
390
def get_rev_id(self, revno, history=None):
391
"""Find the revision id of the specified revno."""
395
history = self.revision_history()
396
elif revno <= 0 or revno > len(history):
397
raise bzrlib.errors.NoSuchRevision(self, revno)
398
return history[revno - 1]
400
def pull(self, source, overwrite=False, stop_revision=None):
401
raise NotImplementedError('pull is abstract')
403
def basis_tree(self):
404
"""Return `Tree` object for last revision.
406
If there are no revisions yet, return an `EmptyTree`.
408
return self.repository.revision_tree(self.last_revision())
410
def rename_one(self, from_rel, to_rel):
413
This can change the directory or the filename or both.
415
raise NotImplementedError('rename_one is abstract')
417
def move(self, from_paths, to_name):
420
to_name must exist as a versioned directory.
422
If to_name exists and is a directory, the files are moved into
423
it, keeping their old names. If it is a directory,
425
Note that to_name is only the last component of the new name;
426
this doesn't change the directory.
428
This returns a list of (from_path, to_path) pairs for each
431
raise NotImplementedError('move is abstract')
433
def get_parent(self):
434
"""Return the parent location of the branch.
436
This is the default location for push/pull/missing. The usual
437
pattern is that the user can override it by specifying a
440
raise NotImplementedError('get_parent is abstract')
442
def get_push_location(self):
443
"""Return the None or the location to push this branch to."""
444
raise NotImplementedError('get_push_location is abstract')
446
def set_push_location(self, location):
447
"""Set a new push location for this branch."""
448
raise NotImplementedError('set_push_location is abstract')
450
def set_parent(self, url):
451
raise NotImplementedError('set_parent is abstract')
455
"""Synchronise this branch with the master branch if any.
457
:return: None or the last_revision pivoted out during the update.
461
def check_revno(self, revno):
463
Check whether a revno corresponds to any revision.
464
Zero (the NULL revision) is considered valid.
467
self.check_real_revno(revno)
469
def check_real_revno(self, revno):
471
Check whether a revno corresponds to a real revision.
472
Zero (the NULL revision) is considered invalid
474
if revno < 1 or revno > self.revno():
475
raise InvalidRevisionNumber(revno)
478
def clone(self, *args, **kwargs):
479
"""Clone this branch into to_bzrdir preserving all semantic values.
481
revision_id: if not None, the revision history in the new branch will
482
be truncated to end with revision_id.
484
# for API compatibility, until 0.8 releases we provide the old api:
485
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
486
# after 0.8 releases, the *args and **kwargs should be changed:
487
# def clone(self, to_bzrdir, revision_id=None):
488
if (kwargs.get('to_location', None) or
489
kwargs.get('revision', None) or
490
kwargs.get('basis_branch', None) or
491
(len(args) and isinstance(args[0], basestring))):
492
# backwards compatibility api:
493
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
494
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
497
basis_branch = args[2]
499
basis_branch = kwargs.get('basis_branch', None)
501
basis = basis_branch.bzrdir
506
revision_id = args[1]
508
revision_id = kwargs.get('revision', None)
513
# no default to raise if not provided.
514
url = kwargs.get('to_location')
515
return self.bzrdir.clone(url,
516
revision_id=revision_id,
517
basis=basis).open_branch()
519
# generate args by hand
521
revision_id = args[1]
523
revision_id = kwargs.get('revision_id', None)
527
# no default to raise if not provided.
528
to_bzrdir = kwargs.get('to_bzrdir')
529
result = self._format.initialize(to_bzrdir)
530
self.copy_content_into(result, revision_id=revision_id)
534
def sprout(self, to_bzrdir, revision_id=None):
535
"""Create a new line of development from the branch, into to_bzrdir.
537
revision_id: if not None, the revision history in the new branch will
538
be truncated to end with revision_id.
540
result = self._format.initialize(to_bzrdir)
541
self.copy_content_into(result, revision_id=revision_id)
542
result.set_parent(self.bzrdir.root_transport.base)
546
def copy_content_into(self, destination, revision_id=None):
547
"""Copy the content of self into destination.
549
revision_id: if not None, the revision history in the new branch will
550
be truncated to end with revision_id.
552
new_history = self.revision_history()
553
if revision_id is not None:
555
new_history = new_history[:new_history.index(revision_id) + 1]
557
rev = self.repository.get_revision(revision_id)
558
new_history = rev.get_history(self.repository)[1:]
559
destination.set_revision_history(new_history)
560
parent = self.get_parent()
562
destination.set_parent(parent)
566
"""Check consistency of the branch.
568
In particular this checks that revisions given in the revision-history
569
do actually match up in the revision graph, and that they're all
570
present in the repository.
572
:return: A BranchCheckResult.
574
mainline_parent_id = None
575
for revision_id in self.revision_history():
577
revision = self.repository.get_revision(revision_id)
578
except errors.NoSuchRevision, e:
579
raise BzrCheckError("mainline revision {%s} not in repository"
581
# In general the first entry on the revision history has no parents.
582
# But it's not illegal for it to have parents listed; this can happen
583
# in imports from Arch when the parents weren't reachable.
584
if mainline_parent_id is not None:
585
if mainline_parent_id not in revision.parent_ids:
586
raise BzrCheckError("previous revision {%s} not listed among "
588
% (mainline_parent_id, revision_id))
589
mainline_parent_id = revision_id
590
return BranchCheckResult(self)
593
class BranchFormat(object):
594
"""An encapsulation of the initialization and open routines for a format.
596
Formats provide three things:
597
* An initialization routine,
601
Formats are placed in an dict by their format string for reference
602
during branch opening. Its not required that these be instances, they
603
can be classes themselves with class methods - it simply depends on
604
whether state is needed for a given format or not.
606
Once a format is deprecated, just deprecate the initialize and open
607
methods on the format class. Do not deprecate the object, as the
608
object will be created every time regardless.
611
_default_format = None
612
"""The default format used for new branches."""
615
"""The known formats."""
618
def find_format(klass, a_bzrdir):
619
"""Return the format for the branch object in a_bzrdir."""
621
transport = a_bzrdir.get_branch_transport(None)
622
format_string = transport.get("format").read()
623
return klass._formats[format_string]
625
raise NotBranchError(path=transport.base)
627
raise errors.UnknownFormatError(format_string)
630
def get_default_format(klass):
631
"""Return the current default format."""
632
return klass._default_format
634
def get_format_string(self):
635
"""Return the ASCII format string that identifies this format."""
636
raise NotImplementedError(self.get_format_string)
638
def get_format_description(self):
639
"""Return the short format description for this format."""
640
raise NotImplementedError(self.get_format_string)
642
def initialize(self, a_bzrdir):
643
"""Create a branch of this format in a_bzrdir."""
644
raise NotImplementedError(self.initialize)
646
def is_supported(self):
647
"""Is this format supported?
649
Supported formats can be initialized and opened.
650
Unsupported formats may not support initialization or committing or
651
some other features depending on the reason for not being supported.
655
def open(self, a_bzrdir, _found=False):
656
"""Return the branch object for a_bzrdir
658
_found is a private parameter, do not use it. It is used to indicate
659
if format probing has already be done.
661
raise NotImplementedError(self.open)
664
def register_format(klass, format):
665
klass._formats[format.get_format_string()] = format
668
def set_default_format(klass, format):
669
klass._default_format = format
672
def unregister_format(klass, format):
673
assert klass._formats[format.get_format_string()] is format
674
del klass._formats[format.get_format_string()]
677
return self.get_format_string().rstrip()
680
class BzrBranchFormat4(BranchFormat):
681
"""Bzr branch format 4.
684
- a revision-history file.
685
- a branch-lock lock file [ to be shared with the bzrdir ]
688
def get_format_description(self):
689
"""See BranchFormat.get_format_description()."""
690
return "Branch format 4"
692
def initialize(self, a_bzrdir):
693
"""Create a branch of this format in a_bzrdir."""
694
mutter('creating branch in %s', a_bzrdir.transport.base)
695
branch_transport = a_bzrdir.get_branch_transport(self)
696
utf8_files = [('revision-history', ''),
699
control_files = LockableFiles(branch_transport, 'branch-lock',
701
control_files.create_lock()
702
control_files.lock_write()
704
for file, content in utf8_files:
705
control_files.put_utf8(file, content)
707
control_files.unlock()
708
return self.open(a_bzrdir, _found=True)
711
super(BzrBranchFormat4, self).__init__()
712
self._matchingbzrdir = bzrdir.BzrDirFormat6()
714
def open(self, a_bzrdir, _found=False):
715
"""Return the branch object for a_bzrdir
717
_found is a private parameter, do not use it. It is used to indicate
718
if format probing has already be done.
721
# we are being called directly and must probe.
722
raise NotImplementedError
723
return BzrBranch(_format=self,
724
_control_files=a_bzrdir._control_files,
726
_repository=a_bzrdir.open_repository())
729
return "Bazaar-NG branch format 4"
732
class BzrBranchFormat5(BranchFormat):
733
"""Bzr branch format 5.
736
- a revision-history file.
738
- a lock dir guarding the branch itself
739
- all of this stored in a branch/ subdirectory
740
- works with shared repositories.
742
This format is new in bzr 0.8.
745
def get_format_string(self):
746
"""See BranchFormat.get_format_string()."""
747
return "Bazaar-NG branch format 5\n"
749
def get_format_description(self):
750
"""See BranchFormat.get_format_description()."""
751
return "Branch format 5"
753
def initialize(self, a_bzrdir):
754
"""Create a branch of this format in a_bzrdir."""
755
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
756
branch_transport = a_bzrdir.get_branch_transport(self)
757
utf8_files = [('revision-history', ''),
760
control_files = LockableFiles(branch_transport, 'lock', LockDir)
761
control_files.create_lock()
762
control_files.lock_write()
763
control_files.put_utf8('format', self.get_format_string())
765
for file, content in utf8_files:
766
control_files.put_utf8(file, content)
768
control_files.unlock()
769
return self.open(a_bzrdir, _found=True, )
772
super(BzrBranchFormat5, self).__init__()
773
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
775
def open(self, a_bzrdir, _found=False):
776
"""Return the branch object for a_bzrdir
778
_found is a private parameter, do not use it. It is used to indicate
779
if format probing has already be done.
782
format = BranchFormat.find_format(a_bzrdir)
783
assert format.__class__ == self.__class__
784
transport = a_bzrdir.get_branch_transport(None)
785
control_files = LockableFiles(transport, 'lock', LockDir)
786
return BzrBranch5(_format=self,
787
_control_files=control_files,
789
_repository=a_bzrdir.find_repository())
792
return "Bazaar-NG Metadir branch format 5"
795
class BranchReferenceFormat(BranchFormat):
796
"""Bzr branch reference format.
798
Branch references are used in implementing checkouts, they
799
act as an alias to the real branch which is at some other url.
806
def get_format_string(self):
807
"""See BranchFormat.get_format_string()."""
808
return "Bazaar-NG Branch Reference Format 1\n"
810
def get_format_description(self):
811
"""See BranchFormat.get_format_description()."""
812
return "Checkout reference format 1"
814
def initialize(self, a_bzrdir, target_branch=None):
815
"""Create a branch of this format in a_bzrdir."""
816
if target_branch is None:
817
# this format does not implement branch itself, thus the implicit
818
# creation contract must see it as uninitializable
819
raise errors.UninitializableFormat(self)
820
mutter('creating branch reference in %s', a_bzrdir.transport.base)
821
branch_transport = a_bzrdir.get_branch_transport(self)
822
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
823
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
824
branch_transport.put('format', StringIO(self.get_format_string()))
825
return self.open(a_bzrdir, _found=True)
828
super(BranchReferenceFormat, self).__init__()
829
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
831
def _make_reference_clone_function(format, a_branch):
832
"""Create a clone() routine for a branch dynamically."""
833
def clone(to_bzrdir, revision_id=None):
834
"""See Branch.clone()."""
835
return format.initialize(to_bzrdir, a_branch)
836
# cannot obey revision_id limits when cloning a reference ...
837
# FIXME RBC 20060210 either nuke revision_id for clone, or
838
# emit some sort of warning/error to the caller ?!
841
def open(self, a_bzrdir, _found=False):
842
"""Return the branch that the branch reference in a_bzrdir points at.
844
_found is a private parameter, do not use it. It is used to indicate
845
if format probing has already be done.
848
format = BranchFormat.find_format(a_bzrdir)
849
assert format.__class__ == self.__class__
850
transport = a_bzrdir.get_branch_transport(None)
851
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
852
result = real_bzrdir.open_branch()
853
# this changes the behaviour of result.clone to create a new reference
854
# rather than a copy of the content of the branch.
855
# I did not use a proxy object because that needs much more extensive
856
# testing, and we are only changing one behaviour at the moment.
857
# If we decide to alter more behaviours - i.e. the implicit nickname
858
# then this should be refactored to introduce a tested proxy branch
859
# and a subclass of that for use in overriding clone() and ....
861
result.clone = self._make_reference_clone_function(result)
865
# formats which have no format string are not discoverable
866
# and not independently creatable, so are not registered.
867
__default_format = BzrBranchFormat5()
868
BranchFormat.register_format(__default_format)
869
BranchFormat.register_format(BranchReferenceFormat())
870
BranchFormat.set_default_format(__default_format)
871
_legacy_formats = [BzrBranchFormat4(),
874
class BzrBranch(Branch):
875
"""A branch stored in the actual filesystem.
877
Note that it's "local" in the context of the filesystem; it doesn't
878
really matter if it's on an nfs/smb/afs/coda/... share, as long as
879
it's writable, and can be accessed via the normal filesystem API.
882
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
883
relax_version_check=DEPRECATED_PARAMETER, _format=None,
884
_control_files=None, a_bzrdir=None, _repository=None):
885
"""Create new branch object at a particular location.
887
transport -- A Transport object, defining how to access files.
889
init -- If True, create new control files in a previously
890
unversioned directory. If False, the branch must already
893
relax_version_check -- If true, the usual check for the branch
894
version is not applied. This is intended only for
895
upgrade/recovery type use; it's not guaranteed that
896
all operations will work on old format branches.
899
self.bzrdir = bzrdir.BzrDir.open(transport.base)
901
self.bzrdir = a_bzrdir
902
self._transport = self.bzrdir.transport.clone('..')
903
self._base = self._transport.base
904
self._format = _format
905
if _control_files is None:
906
raise BzrBadParameterMissing('_control_files')
907
self.control_files = _control_files
908
if deprecated_passed(init):
909
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
910
"deprecated as of bzr 0.8. Please use Branch.create().",
914
# this is slower than before deprecation, oh well never mind.
916
self._initialize(transport.base)
917
self._check_format(_format)
918
if deprecated_passed(relax_version_check):
919
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
920
"relax_version_check parameter is deprecated as of bzr 0.8. "
921
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
925
if (not relax_version_check
926
and not self._format.is_supported()):
927
raise errors.UnsupportedFormatError(
928
'sorry, branch format %r not supported' % fmt,
929
['use a different bzr version',
930
'or remove the .bzr directory'
931
' and "bzr init" again'])
932
if deprecated_passed(transport):
933
warn("BzrBranch.__init__(transport=XXX...): The transport "
934
"parameter is deprecated as of bzr 0.8. "
935
"Please use Branch.open, or bzrdir.open_branch().",
938
self.repository = _repository
941
return '%s(%r)' % (self.__class__.__name__, self.base)
946
# TODO: It might be best to do this somewhere else,
947
# but it is nice for a Branch object to automatically
948
# cache it's information.
949
# Alternatively, we could have the Transport objects cache requests
950
# See the earlier discussion about how major objects (like Branch)
951
# should never expect their __del__ function to run.
952
# XXX: cache_root seems to be unused, 2006-01-13 mbp
953
if hasattr(self, 'cache_root') and self.cache_root is not None:
955
rmtree(self.cache_root)
958
self.cache_root = None
963
base = property(_get_base, doc="The URL for the root of this branch.")
965
def _finish_transaction(self):
966
"""Exit the current transaction."""
967
return self.control_files._finish_transaction()
969
def get_transaction(self):
970
"""Return the current active transaction.
972
If no transaction is active, this returns a passthrough object
973
for which all data is immediately flushed and no caching happens.
975
# this is an explicit function so that we can do tricky stuff
976
# when the storage in rev_storage is elsewhere.
977
# we probably need to hook the two 'lock a location' and
978
# 'have a transaction' together more delicately, so that
979
# we can have two locks (branch and storage) and one transaction
980
# ... and finishing the transaction unlocks both, but unlocking
981
# does not. - RBC 20051121
982
return self.control_files.get_transaction()
984
def _set_transaction(self, transaction):
985
"""Set a new active transaction."""
986
return self.control_files._set_transaction(transaction)
988
def abspath(self, name):
989
"""See Branch.abspath."""
990
return self.control_files._transport.abspath(name)
992
def _check_format(self, format):
993
"""Identify the branch format if needed.
995
The format is stored as a reference to the format object in
996
self._format for code that needs to check it later.
998
The format parameter is either None or the branch format class
999
used to open this branch.
1001
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1004
format = BzrBranchFormat.find_format(self.bzrdir)
1005
self._format = format
1006
mutter("got branch format %s", self._format)
1009
def get_root_id(self):
1010
"""See Branch.get_root_id."""
1011
tree = self.repository.revision_tree(self.last_revision())
1012
return tree.inventory.root.file_id
1014
def is_locked(self):
1015
return self.control_files.is_locked()
1017
def lock_write(self):
1018
# TODO: test for failed two phase locks. This is known broken.
1019
self.control_files.lock_write()
1020
self.repository.lock_write()
1022
def lock_read(self):
1023
# TODO: test for failed two phase locks. This is known broken.
1024
self.control_files.lock_read()
1025
self.repository.lock_read()
1028
# TODO: test for failed two phase locks. This is known broken.
1030
self.repository.unlock()
1032
self.control_files.unlock()
1034
def peek_lock_mode(self):
1035
if self.control_files._lock_count == 0:
1038
return self.control_files._lock_mode
1040
def get_physical_lock_status(self):
1041
return self.control_files.get_physical_lock_status()
1044
def print_file(self, file, revision_id):
1045
"""See Branch.print_file."""
1046
return self.repository.print_file(file, revision_id)
1049
def append_revision(self, *revision_ids):
1050
"""See Branch.append_revision."""
1051
for revision_id in revision_ids:
1052
mutter("add {%s} to revision-history" % revision_id)
1053
rev_history = self.revision_history()
1054
rev_history.extend(revision_ids)
1055
self.set_revision_history(rev_history)
1058
def set_revision_history(self, rev_history):
1059
"""See Branch.set_revision_history."""
1060
self.control_files.put_utf8(
1061
'revision-history', '\n'.join(rev_history))
1062
transaction = self.get_transaction()
1063
history = transaction.map.find_revision_history()
1064
if history is not None:
1065
# update the revision history in the identity map.
1066
history[:] = list(rev_history)
1067
# this call is disabled because revision_history is
1068
# not really an object yet, and the transaction is for objects.
1069
# transaction.register_dirty(history)
1071
transaction.map.add_revision_history(rev_history)
1072
# this call is disabled because revision_history is
1073
# not really an object yet, and the transaction is for objects.
1074
# transaction.register_clean(history)
1076
def get_revision_delta(self, revno):
1077
"""Return the delta for one revision.
1079
The delta is relative to its mainline predecessor, or the
1080
empty tree for revision 1.
1082
assert isinstance(revno, int)
1083
rh = self.revision_history()
1084
if not (1 <= revno <= len(rh)):
1085
raise InvalidRevisionNumber(revno)
1087
# revno is 1-based; list is 0-based
1089
new_tree = self.repository.revision_tree(rh[revno-1])
1091
old_tree = EmptyTree()
1093
old_tree = self.repository.revision_tree(rh[revno-2])
1094
return compare_trees(old_tree, new_tree)
1097
def revision_history(self):
1098
"""See Branch.revision_history."""
1099
transaction = self.get_transaction()
1100
history = transaction.map.find_revision_history()
1101
if history is not None:
1102
mutter("cache hit for revision-history in %s", self)
1103
return list(history)
1104
history = [l.rstrip('\r\n') for l in
1105
self.control_files.get_utf8('revision-history').readlines()]
1106
transaction.map.add_revision_history(history)
1107
# this call is disabled because revision_history is
1108
# not really an object yet, and the transaction is for objects.
1109
# transaction.register_clean(history, precious=True)
1110
return list(history)
1113
def update_revisions(self, other, stop_revision=None):
1114
"""See Branch.update_revisions."""
1117
if stop_revision is None:
1118
stop_revision = other.last_revision()
1119
if stop_revision is None:
1120
# if there are no commits, we're done.
1122
# whats the current last revision, before we fetch [and change it
1124
last_rev = self.last_revision()
1125
# we fetch here regardless of whether we need to so that we pickup
1127
self.fetch(other, stop_revision)
1128
my_ancestry = self.repository.get_ancestry(last_rev)
1129
if stop_revision in my_ancestry:
1130
# last_revision is a descendant of stop_revision
1132
# stop_revision must be a descendant of last_revision
1133
stop_graph = self.repository.get_revision_graph(stop_revision)
1134
if last_rev is not None and last_rev not in stop_graph:
1135
# our previous tip is not merged into stop_revision
1136
raise errors.DivergedBranches(self, other)
1137
# make a new revision history from the graph
1138
current_rev_id = stop_revision
1140
while current_rev_id not in (None, NULL_REVISION):
1141
new_history.append(current_rev_id)
1142
current_rev_id_parents = stop_graph[current_rev_id]
1144
current_rev_id = current_rev_id_parents[0]
1146
current_rev_id = None
1147
new_history.reverse()
1148
self.set_revision_history(new_history)
1152
def basis_tree(self):
1153
"""See Branch.basis_tree."""
1154
return self.repository.revision_tree(self.last_revision())
1156
@deprecated_method(zero_eight)
1157
def working_tree(self):
1158
"""Create a Working tree object for this branch."""
1159
from bzrlib.workingtree import WorkingTree
1160
from bzrlib.transport.local import LocalTransport
1161
if (self.base.find('://') != -1 or
1162
not isinstance(self._transport, LocalTransport)):
1163
raise NoWorkingTree(self.base)
1164
return self.bzrdir.open_workingtree()
1167
def pull(self, source, overwrite=False, stop_revision=None):
1168
"""See Branch.pull."""
1171
old_count = len(self.revision_history())
1173
self.update_revisions(source,stop_revision)
1174
except DivergedBranches:
1178
self.set_revision_history(source.revision_history())
1179
new_count = len(self.revision_history())
1180
return new_count - old_count
1184
def get_parent(self):
1185
"""See Branch.get_parent."""
1187
_locs = ['parent', 'pull', 'x-pull']
1188
assert self.base[-1] == '/'
1191
parent = self.control_files.get(l).read().strip('\n')
1194
# This is an old-format absolute path to a local branch
1195
# turn it into a url
1196
if parent.startswith('/'):
1197
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1198
return urlutils.join(self.base[:-1], parent)
1201
def get_push_location(self):
1202
"""See Branch.get_push_location."""
1203
config = bzrlib.config.BranchConfig(self)
1204
push_loc = config.get_user_option('push_location')
1207
def set_push_location(self, location):
1208
"""See Branch.set_push_location."""
1209
config = bzrlib.config.LocationConfig(self.base)
1210
config.set_user_option('push_location', location)
1213
def set_parent(self, url):
1214
"""See Branch.set_parent."""
1215
# TODO: Maybe delete old location files?
1216
# URLs should never be unicode, even on the local fs,
1217
# FIXUP this and get_parent in a future branch format bump:
1218
# read and rewrite the file, and have the new format code read
1219
# using .get not .get_utf8. RBC 20060125
1221
self.control_files._transport.delete('parent')
1223
if isinstance(url, unicode):
1225
url = url.encode('ascii')
1226
except UnicodeEncodeError:
1227
raise bzrlib.errors.InvalidURL(url,
1228
"Urls must be 7-bit ascii, "
1229
"use bzrlib.urlutils.escape")
1231
url = urlutils.relative_url(self.base, url)
1232
self.control_files.put('parent', url + '\n')
1234
def tree_config(self):
1235
return TreeConfig(self)
1238
class BzrBranch5(BzrBranch):
1239
"""A format 5 branch. This supports new features over plan branches.
1241
It has support for a master_branch which is the data for bound branches.
1249
super(BzrBranch5, self).__init__(_format=_format,
1250
_control_files=_control_files,
1252
_repository=_repository)
1255
def pull(self, source, overwrite=False, stop_revision=None):
1256
"""Updates branch.pull to be bound branch aware."""
1257
bound_location = self.get_bound_location()
1258
if source.base != bound_location:
1259
# not pulling from master, so we need to update master.
1260
master_branch = self.get_master_branch()
1262
master_branch.pull(source)
1263
source = master_branch
1264
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1266
def get_bound_location(self):
1268
return self.control_files.get_utf8('bound').read()[:-1]
1269
except errors.NoSuchFile:
1273
def get_master_branch(self):
1274
"""Return the branch we are bound to.
1276
:return: Either a Branch, or None
1278
This could memoise the branch, but if thats done
1279
it must be revalidated on each new lock.
1280
So for now we just don't memoise it.
1281
# RBC 20060304 review this decision.
1283
bound_loc = self.get_bound_location()
1287
return Branch.open(bound_loc)
1288
except (errors.NotBranchError, errors.ConnectionError), e:
1289
raise errors.BoundBranchConnectionFailure(
1293
def set_bound_location(self, location):
1294
"""Set the target where this branch is bound to.
1296
:param location: URL to the target branch
1299
self.control_files.put_utf8('bound', location+'\n')
1302
self.control_files._transport.delete('bound')
1308
def bind(self, other):
1309
"""Bind the local branch the other branch.
1311
:param other: The branch to bind to
1314
# TODO: jam 20051230 Consider checking if the target is bound
1315
# It is debatable whether you should be able to bind to
1316
# a branch which is itself bound.
1317
# Committing is obviously forbidden,
1318
# but binding itself may not be.
1319
# Since we *have* to check at commit time, we don't
1320
# *need* to check here
1323
# we are now equal to or a suffix of other.
1325
# Since we have 'pulled' from the remote location,
1326
# now we should try to pull in the opposite direction
1327
# in case the local tree has more revisions than the
1329
# There may be a different check you could do here
1330
# rather than actually trying to install revisions remotely.
1331
# TODO: capture an exception which indicates the remote branch
1333
# If it is up-to-date, this probably should not be a failure
1335
# lock other for write so the revision-history syncing cannot race
1339
# if this does not error, other now has the same last rev we do
1340
# it can only error if the pull from other was concurrent with
1341
# a commit to other from someone else.
1343
# until we ditch revision-history, we need to sync them up:
1344
self.set_revision_history(other.revision_history())
1345
# now other and self are up to date with each other and have the
1346
# same revision-history.
1350
self.set_bound_location(other.base)
1354
"""If bound, unbind"""
1355
return self.set_bound_location(None)
1359
"""Synchronise this branch with the master branch if any.
1361
:return: None or the last_revision that was pivoted out during the
1364
master = self.get_master_branch()
1365
if master is not None:
1366
old_tip = self.last_revision()
1367
self.pull(master, overwrite=True)
1368
if old_tip in self.repository.get_ancestry(self.last_revision()):
1374
class BranchTestProviderAdapter(object):
1375
"""A tool to generate a suite testing multiple branch formats at once.
1377
This is done by copying the test once for each transport and injecting
1378
the transport_server, transport_readonly_server, and branch_format
1379
classes into each copy. Each copy is also given a new id() to make it
1383
def __init__(self, transport_server, transport_readonly_server, formats):
1384
self._transport_server = transport_server
1385
self._transport_readonly_server = transport_readonly_server
1386
self._formats = formats
1388
def adapt(self, test):
1389
result = TestSuite()
1390
for branch_format, bzrdir_format in self._formats:
1391
new_test = deepcopy(test)
1392
new_test.transport_server = self._transport_server
1393
new_test.transport_readonly_server = self._transport_readonly_server
1394
new_test.bzrdir_format = bzrdir_format
1395
new_test.branch_format = branch_format
1396
def make_new_test_id():
1397
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1398
return lambda: new_id
1399
new_test.id = make_new_test_id()
1400
result.addTest(new_test)
1404
class BranchCheckResult(object):
1405
"""Results of checking branch consistency.
1410
def __init__(self, branch):
1411
self.branch = branch
1413
def report_results(self, verbose):
1414
"""Report the check results via trace.note.
1416
:param verbose: Requests more detailed display of what was checked,
1419
note('checked branch %s format %s',
1421
self.branch._format)
1424
######################################################################
1428
@deprecated_function(zero_eight)
1429
def ScratchBranch(*args, **kwargs):
1430
"""See bzrlib.bzrdir.ScratchDir."""
1431
d = ScratchDir(*args, **kwargs)
1432
return d.open_branch()
1435
@deprecated_function(zero_eight)
1436
def is_control_file(*args, **kwargs):
1437
"""See bzrlib.workingtree.is_control_file."""
1438
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
