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
27
import xml.sax.saxutils
29
raise ImportError("We were unable to import 'xml.sax.saxutils',"
30
" most likely you have an xml.pyc or xml.pyo file"
31
" lying around in your bzrlib directory."
36
import bzrlib.bzrdir as bzrdir
37
from bzrlib.config import TreeConfig
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
from bzrlib.delta import compare_trees
40
import bzrlib.errors as errors
41
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
42
NoSuchRevision, HistoryMissing, NotBranchError,
43
DivergedBranches, LockError,
44
UninitializableFormat,
46
UnlistableBranch, NoSuchFile, NotVersionedError,
48
import bzrlib.inventory as inventory
49
from bzrlib.inventory import Inventory
50
from bzrlib.lockable_files import LockableFiles
51
from bzrlib.osutils import (isdir, quotefn,
52
rename, splitpath, sha_file,
53
file_kind, abspath, normpath, pathjoin,
56
from bzrlib.textui import show_status
57
from bzrlib.trace import mutter, note
58
from bzrlib.tree import EmptyTree, RevisionTree
59
from bzrlib.repository import Repository
60
from bzrlib.revision import (
61
get_intervening_revisions,
66
from bzrlib.store import copy_all
67
from bzrlib.symbol_versioning import *
68
import bzrlib.transactions as transactions
69
from bzrlib.transport import Transport, get_transport
70
from bzrlib.tree import EmptyTree, RevisionTree
75
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
76
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
77
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
80
# TODO: Maybe include checks for common corruption of newlines, etc?
82
# TODO: Some operations like log might retrieve the same revisions
83
# repeatedly to calculate deltas. We could perhaps have a weakref
84
# cache in memory to make this faster. In general anything can be
85
# cached in memory between lock and unlock operations. .. nb thats
86
# what the transaction identity map provides
89
######################################################################
93
"""Branch holding a history of revisions.
96
Base directory/url of the branch.
98
# this is really an instance variable - FIXME move it there
102
def __init__(self, *ignored, **ignored_too):
103
raise NotImplementedError('The Branch class is abstract')
106
@deprecated_method(zero_eight)
107
def open_downlevel(base):
108
"""Open a branch which may be of an old format."""
109
return Branch.open(base, _unsupported=True)
112
def open(base, _unsupported=False):
113
"""Open the repository rooted at base.
115
For instance, if the repository is at URL/.bzr/repository,
116
Repository.open(URL) -> a Repository instance.
118
control = bzrdir.BzrDir.open(base, _unsupported)
119
return control.open_branch(_unsupported)
122
def open_containing(url):
123
"""Open an existing branch which contains url.
125
This probes for a branch at url, and searches upwards from there.
127
Basically we keep looking up until we find the control directory or
128
run into the root. If there isn't one, raises NotBranchError.
129
If there is one and it is either an unrecognised format or an unsupported
130
format, UnknownFormatError or UnsupportedFormatError are raised.
131
If there is one, it is returned, along with the unused portion of url.
133
control, relpath = bzrdir.BzrDir.open_containing(url)
134
return control.open_branch(), relpath
137
@deprecated_function(zero_eight)
138
def initialize(base):
139
"""Create a new working tree and branch, rooted at 'base' (url)
141
NOTE: This will soon be deprecated in favour of creation
144
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
146
def setup_caching(self, cache_root):
147
"""Subclasses that care about caching should override this, and set
148
up cached stores located under cache_root.
150
# seems to be unused, 2006-01-13 mbp
151
warn('%s is deprecated' % self.setup_caching)
152
self.cache_root = cache_root
155
cfg = self.tree_config()
156
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
158
def _set_nick(self, nick):
159
cfg = self.tree_config()
160
cfg.set_option(nick, "nickname")
161
assert cfg.get_option("nickname") == nick
163
nick = property(_get_nick, _set_nick)
165
def lock_write(self):
166
raise NotImplementedError('lock_write is abstract')
169
raise NotImplementedError('lock_read is abstract')
172
raise NotImplementedError('unlock is abstract')
174
def peek_lock_mode(self):
175
"""Return lock mode for the Branch: 'r', 'w' or None"""
176
raise NotImplementedError(self.peek_lock_mode)
178
def abspath(self, name):
179
"""Return absolute filename for something in the branch
181
XXX: Robert Collins 20051017 what is this used for? why is it a branch
182
method and not a tree method.
184
raise NotImplementedError('abspath is abstract')
187
def fetch(self, from_branch, last_revision=None, pb=None):
188
"""Copy revisions from from_branch into this branch.
190
:param from_branch: Where to copy from.
191
:param last_revision: What revision to stop at (None for at the end
193
:param pb: An optional progress bar to use.
195
Returns the copied revision count and the failed revisions in a tuple:
198
if self.base == from_branch.base:
199
raise Exception("can't fetch from a branch to itself %s, %s" %
200
(self.base, to_branch.base))
202
pb = bzrlib.ui.ui_factory.progress_bar()
204
from_branch.lock_read()
206
if last_revision is None:
207
pb.update('get source history')
208
from_history = from_branch.revision_history()
210
last_revision = from_history[-1]
212
# no history in the source branch
213
last_revision = NULL_REVISION
214
return self.repository.fetch(from_branch.repository,
215
revision_id=last_revision,
220
def get_root_id(self):
221
"""Return the id of this branches root"""
222
raise NotImplementedError('get_root_id is abstract')
224
def print_file(self, file, revision_id):
225
"""Print `file` to stdout."""
226
raise NotImplementedError('print_file is abstract')
228
def append_revision(self, *revision_ids):
229
raise NotImplementedError('append_revision is abstract')
231
def set_revision_history(self, rev_history):
232
raise NotImplementedError('set_revision_history is abstract')
234
def revision_history(self):
235
"""Return sequence of revision hashes on to this branch."""
236
raise NotImplementedError('revision_history is abstract')
239
"""Return current revision number for this branch.
241
That is equivalent to the number of revisions committed to
244
return len(self.revision_history())
246
def last_revision(self):
247
"""Return last patch hash, or None if no history."""
248
ph = self.revision_history()
254
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
255
"""Return a list of new revisions that would perfectly fit.
257
If self and other have not diverged, return a list of the revisions
258
present in other, but missing from self.
260
>>> from bzrlib.workingtree import WorkingTree
261
>>> bzrlib.trace.silent = True
262
>>> d1 = bzrdir.ScratchDir()
263
>>> br1 = d1.open_branch()
264
>>> wt1 = d1.open_workingtree()
265
>>> d2 = bzrdir.ScratchDir()
266
>>> br2 = d2.open_branch()
267
>>> wt2 = d2.open_workingtree()
268
>>> br1.missing_revisions(br2)
270
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
271
>>> br1.missing_revisions(br2)
273
>>> br2.missing_revisions(br1)
275
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
276
>>> br1.missing_revisions(br2)
278
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
279
>>> br1.missing_revisions(br2)
281
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
282
>>> br1.missing_revisions(br2)
283
Traceback (most recent call last):
284
DivergedBranches: These branches have diverged. Try merge.
286
self_history = self.revision_history()
287
self_len = len(self_history)
288
other_history = other.revision_history()
289
other_len = len(other_history)
290
common_index = min(self_len, other_len) -1
291
if common_index >= 0 and \
292
self_history[common_index] != other_history[common_index]:
293
raise DivergedBranches(self, other)
295
if stop_revision is None:
296
stop_revision = other_len
298
assert isinstance(stop_revision, int)
299
if stop_revision > other_len:
300
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
301
return other_history[self_len:stop_revision]
303
def update_revisions(self, other, stop_revision=None):
304
"""Pull in new perfect-fit revisions."""
305
raise NotImplementedError('update_revisions is abstract')
307
def pullable_revisions(self, other, stop_revision):
308
raise NotImplementedError('pullable_revisions is abstract')
310
def revision_id_to_revno(self, revision_id):
311
"""Given a revision id, return its revno"""
312
if revision_id is None:
314
history = self.revision_history()
316
return history.index(revision_id) + 1
318
raise bzrlib.errors.NoSuchRevision(self, revision_id)
320
def get_rev_id(self, revno, history=None):
321
"""Find the revision id of the specified revno."""
325
history = self.revision_history()
326
elif revno <= 0 or revno > len(history):
327
raise bzrlib.errors.NoSuchRevision(self, revno)
328
return history[revno - 1]
330
def pull(self, source, overwrite=False, stop_revision=None):
331
raise NotImplementedError('pull is abstract')
333
def basis_tree(self):
334
"""Return `Tree` object for last revision.
336
If there are no revisions yet, return an `EmptyTree`.
338
return self.repository.revision_tree(self.last_revision())
340
def rename_one(self, from_rel, to_rel):
343
This can change the directory or the filename or both.
345
raise NotImplementedError('rename_one is abstract')
347
def move(self, from_paths, to_name):
350
to_name must exist as a versioned directory.
352
If to_name exists and is a directory, the files are moved into
353
it, keeping their old names. If it is a directory,
355
Note that to_name is only the last component of the new name;
356
this doesn't change the directory.
358
This returns a list of (from_path, to_path) pairs for each
361
raise NotImplementedError('move is abstract')
363
def get_parent(self):
364
"""Return the parent location of the branch.
366
This is the default location for push/pull/missing. The usual
367
pattern is that the user can override it by specifying a
370
raise NotImplementedError('get_parent is abstract')
372
def get_push_location(self):
373
"""Return the None or the location to push this branch to."""
374
raise NotImplementedError('get_push_location is abstract')
376
def set_push_location(self, location):
377
"""Set a new push location for this branch."""
378
raise NotImplementedError('set_push_location is abstract')
380
def set_parent(self, url):
381
raise NotImplementedError('set_parent is abstract')
383
def check_revno(self, revno):
385
Check whether a revno corresponds to any revision.
386
Zero (the NULL revision) is considered valid.
389
self.check_real_revno(revno)
391
def check_real_revno(self, revno):
393
Check whether a revno corresponds to a real revision.
394
Zero (the NULL revision) is considered invalid
396
if revno < 1 or revno > self.revno():
397
raise InvalidRevisionNumber(revno)
400
def clone(self, *args, **kwargs):
401
"""Clone this branch into to_bzrdir preserving all semantic values.
403
revision_id: if not None, the revision history in the new branch will
404
be truncated to end with revision_id.
406
# for API compatability, until 0.8 releases we provide the old api:
407
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
408
# after 0.8 releases, the *args and **kwargs should be changed:
409
# def clone(self, to_bzrdir, revision_id=None):
410
if (kwargs.get('to_location', None) or
411
kwargs.get('revision', None) or
412
kwargs.get('basis_branch', None) or
413
(len(args) and isinstance(args[0], basestring))):
414
# backwards compatability api:
415
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
416
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
419
basis_branch = args[2]
421
basis_branch = kwargs.get('basis_branch', None)
423
basis = basis_branch.bzrdir
428
revision_id = args[1]
430
revision_id = kwargs.get('revision', None)
435
# no default to raise if not provided.
436
url = kwargs.get('to_location')
437
return self.bzrdir.clone(url,
438
revision_id=revision_id,
439
basis=basis).open_branch()
441
# generate args by hand
443
revision_id = args[1]
445
revision_id = kwargs.get('revision_id', None)
449
# no default to raise if not provided.
450
to_bzrdir = kwargs.get('to_bzrdir')
451
result = self._format.initialize(to_bzrdir)
452
self.copy_content_into(result, revision_id=revision_id)
456
def sprout(self, to_bzrdir, revision_id=None):
457
"""Create a new line of development from the branch, into to_bzrdir.
459
revision_id: if not None, the revision history in the new branch will
460
be truncated to end with revision_id.
462
result = self._format.initialize(to_bzrdir)
463
self.copy_content_into(result, revision_id=revision_id)
464
result.set_parent(self.bzrdir.root_transport.base)
468
def copy_content_into(self, destination, revision_id=None):
469
"""Copy the content of self into destination.
471
revision_id: if not None, the revision history in the new branch will
472
be truncated to end with revision_id.
474
new_history = self.revision_history()
475
if revision_id is not None:
477
new_history = new_history[:new_history.index(revision_id) + 1]
479
rev = self.repository.get_revision(revision_id)
480
new_history = rev.get_history(self.repository)[1:]
481
destination.set_revision_history(new_history)
482
parent = self.get_parent()
484
destination.set_parent(parent)
487
class BranchFormat(object):
488
"""An encapsulation of the initialization and open routines for a format.
490
Formats provide three things:
491
* An initialization routine,
495
Formats are placed in an dict by their format string for reference
496
during branch opening. Its not required that these be instances, they
497
can be classes themselves with class methods - it simply depends on
498
whether state is needed for a given format or not.
500
Once a format is deprecated, just deprecate the initialize and open
501
methods on the format class. Do not deprecate the object, as the
502
object will be created every time regardless.
505
_default_format = None
506
"""The default format used for new branches."""
509
"""The known formats."""
512
def find_format(klass, a_bzrdir):
513
"""Return the format for the branch object in a_bzrdir."""
515
transport = a_bzrdir.get_branch_transport(None)
516
format_string = transport.get("format").read()
517
return klass._formats[format_string]
519
raise NotBranchError(path=transport.base)
521
raise errors.UnknownFormatError(format_string)
524
def get_default_format(klass):
525
"""Return the current default format."""
526
return klass._default_format
528
def get_format_string(self):
529
"""Return the ASCII format string that identifies this format."""
530
raise NotImplementedError(self.get_format_string)
532
def initialize(self, a_bzrdir):
533
"""Create a branch of this format in a_bzrdir."""
534
raise NotImplementedError(self.initialized)
536
def is_supported(self):
537
"""Is this format supported?
539
Supported formats can be initialized and opened.
540
Unsupported formats may not support initialization or committing or
541
some other features depending on the reason for not being supported.
545
def open(self, a_bzrdir, _found=False):
546
"""Return the branch object for a_bzrdir
548
_found is a private parameter, do not use it. It is used to indicate
549
if format probing has already be done.
551
raise NotImplementedError(self.open)
554
def register_format(klass, format):
555
klass._formats[format.get_format_string()] = format
558
def set_default_format(klass, format):
559
klass._default_format = format
562
def unregister_format(klass, format):
563
assert klass._formats[format.get_format_string()] is format
564
del klass._formats[format.get_format_string()]
567
class BzrBranchFormat4(BranchFormat):
568
"""Bzr branch format 4.
571
- a revision-history file.
572
- a branch-lock lock file [ to be shared with the bzrdir ]
575
def initialize(self, a_bzrdir):
576
"""Create a branch of this format in a_bzrdir."""
577
mutter('creating branch in %s', a_bzrdir.transport.base)
578
branch_transport = a_bzrdir.get_branch_transport(self)
579
utf8_files = [('revision-history', ''),
582
control_files = LockableFiles(branch_transport, 'branch-lock')
583
control_files.lock_write()
585
for file, content in utf8_files:
586
control_files.put_utf8(file, content)
588
control_files.unlock()
589
return self.open(a_bzrdir, _found=True)
592
super(BzrBranchFormat4, self).__init__()
593
self._matchingbzrdir = bzrdir.BzrDirFormat6()
595
def open(self, a_bzrdir, _found=False):
596
"""Return the branch object for a_bzrdir
598
_found is a private parameter, do not use it. It is used to indicate
599
if format probing has already be done.
602
# we are being called directly and must probe.
603
raise NotImplementedError
604
return BzrBranch(_format=self,
605
_control_files=a_bzrdir._control_files,
607
_repository=a_bzrdir.open_repository())
610
class BzrBranchFormat5(BranchFormat):
611
"""Bzr branch format 5.
614
- a revision-history file.
617
- works with shared repositories.
620
def get_format_string(self):
621
"""See BranchFormat.get_format_string()."""
622
return "Bazaar-NG branch format 5\n"
624
def initialize(self, a_bzrdir):
625
"""Create a branch of this format in a_bzrdir."""
626
mutter('creating branch in %s', a_bzrdir.transport.base)
627
branch_transport = a_bzrdir.get_branch_transport(self)
629
utf8_files = [('revision-history', ''),
633
branch_transport.put(lock_file, StringIO()) # TODO get the file mode from the bzrdir lock files., mode=file_mode)
634
control_files = LockableFiles(branch_transport, 'lock')
635
control_files.lock_write()
636
control_files.put_utf8('format', self.get_format_string())
638
for file, content in utf8_files:
639
control_files.put_utf8(file, content)
641
control_files.unlock()
642
return self.open(a_bzrdir, _found=True, )
645
super(BzrBranchFormat5, self).__init__()
646
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
648
def open(self, a_bzrdir, _found=False):
649
"""Return the branch object for a_bzrdir
651
_found is a private parameter, do not use it. It is used to indicate
652
if format probing has already be done.
655
format = BranchFormat.find_format(a_bzrdir)
656
assert format.__class__ == self.__class__
657
transport = a_bzrdir.get_branch_transport(None)
658
control_files = LockableFiles(transport, 'lock')
659
return BzrBranch(_format=self,
660
_control_files=control_files,
662
_repository=a_bzrdir.find_repository())
665
class BranchReferenceFormat(BranchFormat):
666
"""Bzr branch reference format.
668
Branch references are used in implementing checkouts, they
669
act as an alias to the real branch which is at some other url.
676
def get_format_string(self):
677
"""See BranchFormat.get_format_string()."""
678
return "Bazaar-NG Branch Reference Format 1\n"
680
def initialize(self, a_bzrdir, target_branch=None):
681
"""Create a branch of this format in a_bzrdir."""
682
if target_branch is None:
683
# this format does not implement branch itself, thus the implicit
684
# creation contract must see it as uninitializable
685
raise errors.UninitializableFormat(self)
686
mutter('creating branch reference in %s', a_bzrdir.transport.base)
687
branch_transport = a_bzrdir.get_branch_transport(self)
688
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
689
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
690
branch_transport.put('format', StringIO(self.get_format_string()))
691
return self.open(a_bzrdir, _found=True)
694
super(BranchReferenceFormat, self).__init__()
695
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
697
def _make_reference_clone_function(format, a_branch):
698
"""Create a clone() routine for a branch dynamically."""
699
def clone(to_bzrdir, revision_id=None):
700
"""See Branch.clone()."""
701
return format.initialize(to_bzrdir, a_branch)
702
# cannot obey revision_id limits when cloning a reference ...
703
# FIXME RBC 20060210 either nuke revision_id for clone, or
704
# emit some sort of warning/error to the caller ?!
707
def open(self, a_bzrdir, _found=False):
708
"""Return the branch that the branch reference in a_bzrdir points at.
710
_found is a private parameter, do not use it. It is used to indicate
711
if format probing has already be done.
714
format = BranchFormat.find_format(a_bzrdir)
715
assert format.__class__ == self.__class__
716
transport = a_bzrdir.get_branch_transport(None)
717
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
718
result = real_bzrdir.open_branch()
719
# this changes the behaviour of result.clone to create a new reference
720
# rather than a copy of the content of the branch.
721
# I did not use a proxy object because that needs much more extensive
722
# testing, and we are only changing one behaviour at the moment.
723
# If we decide to alter more behaviours - i.e. the implicit nickname
724
# then this should be refactored to introduce a tested proxy branch
725
# and a subclass of that for use in overriding clone() and ....
727
result.clone = self._make_reference_clone_function(result)
731
# formats which have no format string are not discoverable
732
# and not independently creatable, so are not registered.
733
__default_format = BzrBranchFormat5()
734
BranchFormat.register_format(__default_format)
735
BranchFormat.register_format(BranchReferenceFormat())
736
BranchFormat.set_default_format(__default_format)
737
_legacy_formats = [BzrBranchFormat4(),
740
class BzrBranch(Branch):
741
"""A branch stored in the actual filesystem.
743
Note that it's "local" in the context of the filesystem; it doesn't
744
really matter if it's on an nfs/smb/afs/coda/... share, as long as
745
it's writable, and can be accessed via the normal filesystem API.
747
# We actually expect this class to be somewhat short-lived; part of its
748
# purpose is to try to isolate what bits of the branch logic are tied to
749
# filesystem access, so that in a later step, we can extricate them to
750
# a separarte ("storage") class.
751
_inventory_weave = None
753
# Map some sort of prefix into a namespace
754
# stuff like "revno:10", "revid:", etc.
755
# This should match a prefix with a function which accepts
756
REVISION_NAMESPACES = {}
758
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
759
relax_version_check=DEPRECATED_PARAMETER, _format=None,
760
_control_files=None, a_bzrdir=None, _repository=None):
761
"""Create new branch object at a particular location.
763
transport -- A Transport object, defining how to access files.
765
init -- If True, create new control files in a previously
766
unversioned directory. If False, the branch must already
769
relax_version_check -- If true, the usual check for the branch
770
version is not applied. This is intended only for
771
upgrade/recovery type use; it's not guaranteed that
772
all operations will work on old format branches.
775
self.bzrdir = bzrdir.BzrDir.open(transport.base)
777
self.bzrdir = a_bzrdir
778
self._transport = self.bzrdir.transport.clone('..')
779
self._base = self._transport.base
780
self._format = _format
781
if _control_files is None:
782
raise BzrBadParameterMissing('_control_files')
783
self.control_files = _control_files
784
if deprecated_passed(init):
785
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
786
"deprecated as of bzr 0.8. Please use Branch.create().",
790
# this is slower than before deprecation, oh well never mind.
792
self._initialize(transport.base)
793
self._check_format(_format)
794
if deprecated_passed(relax_version_check):
795
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
796
"relax_version_check parameter is deprecated as of bzr 0.8. "
797
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
801
if (not relax_version_check
802
and not self._format.is_supported()):
803
raise errors.UnsupportedFormatError(
804
'sorry, branch format %r not supported' % fmt,
805
['use a different bzr version',
806
'or remove the .bzr directory'
807
' and "bzr init" again'])
808
if deprecated_passed(transport):
809
warn("BzrBranch.__init__(transport=XXX...): The transport "
810
"parameter is deprecated as of bzr 0.8. "
811
"Please use Branch.open, or bzrdir.open_branch().",
814
self.repository = _repository
817
return '%s(%r)' % (self.__class__.__name__, self.base)
822
# TODO: It might be best to do this somewhere else,
823
# but it is nice for a Branch object to automatically
824
# cache it's information.
825
# Alternatively, we could have the Transport objects cache requests
826
# See the earlier discussion about how major objects (like Branch)
827
# should never expect their __del__ function to run.
828
# XXX: cache_root seems to be unused, 2006-01-13 mbp
829
if hasattr(self, 'cache_root') and self.cache_root is not None:
831
shutil.rmtree(self.cache_root)
834
self.cache_root = None
839
base = property(_get_base, doc="The URL for the root of this branch.")
841
def _finish_transaction(self):
842
"""Exit the current transaction."""
843
return self.control_files._finish_transaction()
845
def get_transaction(self):
846
"""Return the current active transaction.
848
If no transaction is active, this returns a passthrough object
849
for which all data is immediately flushed and no caching happens.
851
# this is an explicit function so that we can do tricky stuff
852
# when the storage in rev_storage is elsewhere.
853
# we probably need to hook the two 'lock a location' and
854
# 'have a transaction' together more delicately, so that
855
# we can have two locks (branch and storage) and one transaction
856
# ... and finishing the transaction unlocks both, but unlocking
857
# does not. - RBC 20051121
858
return self.control_files.get_transaction()
860
def _set_transaction(self, transaction):
861
"""Set a new active transaction."""
862
return self.control_files._set_transaction(transaction)
864
def abspath(self, name):
865
"""See Branch.abspath."""
866
return self.control_files._transport.abspath(name)
868
def _check_format(self, format):
869
"""Identify the branch format if needed.
871
The format is stored as a reference to the format object in
872
self._format for code that needs to check it later.
874
The format parameter is either None or the branch format class
875
used to open this branch.
877
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
880
format = BzrBranchFormat.find_format(self.bzrdir)
881
self._format = format
882
mutter("got branch format %s", self._format)
885
def get_root_id(self):
886
"""See Branch.get_root_id."""
887
tree = self.repository.revision_tree(self.last_revision())
888
return tree.inventory.root.file_id
890
def lock_write(self):
891
# TODO: test for failed two phase locks. This is known broken.
892
self.control_files.lock_write()
893
self.repository.lock_write()
896
# TODO: test for failed two phase locks. This is known broken.
897
self.control_files.lock_read()
898
self.repository.lock_read()
901
# TODO: test for failed two phase locks. This is known broken.
902
self.repository.unlock()
903
self.control_files.unlock()
905
def peek_lock_mode(self):
906
if self.control_files._lock_count == 0:
909
return self.control_files._lock_mode
912
def print_file(self, file, revision_id):
913
"""See Branch.print_file."""
914
return self.repository.print_file(file, revision_id)
917
def append_revision(self, *revision_ids):
918
"""See Branch.append_revision."""
919
for revision_id in revision_ids:
920
mutter("add {%s} to revision-history" % revision_id)
921
rev_history = self.revision_history()
922
rev_history.extend(revision_ids)
923
self.set_revision_history(rev_history)
926
def set_revision_history(self, rev_history):
927
"""See Branch.set_revision_history."""
928
self.control_files.put_utf8(
929
'revision-history', '\n'.join(rev_history))
931
def get_revision_delta(self, revno):
932
"""Return the delta for one revision.
934
The delta is relative to its mainline predecessor, or the
935
empty tree for revision 1.
937
assert isinstance(revno, int)
938
rh = self.revision_history()
939
if not (1 <= revno <= len(rh)):
940
raise InvalidRevisionNumber(revno)
942
# revno is 1-based; list is 0-based
944
new_tree = self.repository.revision_tree(rh[revno-1])
946
old_tree = EmptyTree()
948
old_tree = self.repository.revision_tree(rh[revno-2])
949
return compare_trees(old_tree, new_tree)
952
def revision_history(self):
953
"""See Branch.revision_history."""
954
# FIXME are transactions bound to control files ? RBC 20051121
955
transaction = self.get_transaction()
956
history = transaction.map.find_revision_history()
957
if history is not None:
958
mutter("cache hit for revision-history in %s", self)
960
history = [l.rstrip('\r\n') for l in
961
self.control_files.get_utf8('revision-history').readlines()]
962
transaction.map.add_revision_history(history)
963
# this call is disabled because revision_history is
964
# not really an object yet, and the transaction is for objects.
965
# transaction.register_clean(history, precious=True)
968
def update_revisions(self, other, stop_revision=None):
969
"""See Branch.update_revisions."""
970
if stop_revision is None:
971
stop_revision = other.last_revision()
972
### Should this be checking is_ancestor instead of revision_history?
973
if (stop_revision is not None and
974
stop_revision in self.revision_history()):
976
self.fetch(other, stop_revision)
977
pullable_revs = self.pullable_revisions(other, stop_revision)
978
if len(pullable_revs) > 0:
979
self.append_revision(*pullable_revs)
981
def pullable_revisions(self, other, stop_revision):
982
"""See Branch.pullable_revisions."""
983
other_revno = other.revision_id_to_revno(stop_revision)
985
return self.missing_revisions(other, other_revno)
986
except DivergedBranches, e:
988
pullable_revs = get_intervening_revisions(self.last_revision(),
991
assert self.last_revision() not in pullable_revs
993
except bzrlib.errors.NotAncestor:
994
if is_ancestor(self.last_revision(), stop_revision, self):
999
def basis_tree(self):
1000
"""See Branch.basis_tree."""
1001
return self.repository.revision_tree(self.last_revision())
1003
@deprecated_method(zero_eight)
1004
def working_tree(self):
1005
"""Create a Working tree object for this branch."""
1006
from bzrlib.workingtree import WorkingTree
1007
from bzrlib.transport.local import LocalTransport
1008
if (self.base.find('://') != -1 or
1009
not isinstance(self._transport, LocalTransport)):
1010
raise NoWorkingTree(self.base)
1011
return self.bzrdir.open_workingtree()
1014
def pull(self, source, overwrite=False, stop_revision=None):
1015
"""See Branch.pull."""
1018
old_count = len(self.revision_history())
1020
self.update_revisions(source,stop_revision)
1021
except DivergedBranches:
1025
self.set_revision_history(source.revision_history())
1026
new_count = len(self.revision_history())
1027
return new_count - old_count
1031
def get_parent(self):
1032
"""See Branch.get_parent."""
1034
_locs = ['parent', 'pull', 'x-pull']
1037
return self.control_files.get_utf8(l).read().strip('\n')
1042
def get_push_location(self):
1043
"""See Branch.get_push_location."""
1044
config = bzrlib.config.BranchConfig(self)
1045
push_loc = config.get_user_option('push_location')
1048
def set_push_location(self, location):
1049
"""See Branch.set_push_location."""
1050
config = bzrlib.config.LocationConfig(self.base)
1051
config.set_user_option('push_location', location)
1054
def set_parent(self, url):
1055
"""See Branch.set_parent."""
1056
# TODO: Maybe delete old location files?
1057
# URLs should never be unicode, even on the local fs,
1058
# FIXUP this and get_parent in a future branch format bump:
1059
# read and rewrite the file, and have the new format code read
1060
# using .get not .get_utf8. RBC 20060125
1061
self.control_files.put_utf8('parent', url + '\n')
1063
def tree_config(self):
1064
return TreeConfig(self)
1066
def _get_truncated_history(self, revision_id):
1067
history = self.revision_history()
1068
if revision_id is None:
1071
idx = history.index(revision_id)
1073
raise InvalidRevisionId(revision_id=revision, branch=self)
1074
return history[:idx+1]
1077
def _clone_weave(self, to_location, revision=None, basis_branch=None):
1079
from bzrlib.workingtree import WorkingTree
1080
assert isinstance(to_location, basestring)
1081
if basis_branch is not None:
1082
note("basis_branch is not supported for fast weave copy yet.")
1084
history = self._get_truncated_history(revision)
1085
if not bzrlib.osutils.lexists(to_location):
1086
os.mkdir(to_location)
1087
bzrdir_to = self.bzrdir._format.initialize(to_location)
1088
self.repository.clone(bzrdir_to)
1089
branch_to = bzrdir_to.create_branch()
1090
mutter("copy branch from %s to %s", self, branch_to)
1092
# FIXME duplicate code with base .clone().
1093
# .. would template method be useful here? RBC 20051207
1094
branch_to.set_parent(self.base)
1095
branch_to.append_revision(*history)
1096
WorkingTree.create(branch_to, branch_to.base)
1101
class BranchTestProviderAdapter(object):
1102
"""A tool to generate a suite testing multiple branch formats at once.
1104
This is done by copying the test once for each transport and injecting
1105
the transport_server, transport_readonly_server, and branch_format
1106
classes into each copy. Each copy is also given a new id() to make it
1110
def __init__(self, transport_server, transport_readonly_server, formats):
1111
self._transport_server = transport_server
1112
self._transport_readonly_server = transport_readonly_server
1113
self._formats = formats
1115
def adapt(self, test):
1116
result = TestSuite()
1117
for branch_format, bzrdir_format in self._formats:
1118
new_test = deepcopy(test)
1119
new_test.transport_server = self._transport_server
1120
new_test.transport_readonly_server = self._transport_readonly_server
1121
new_test.bzrdir_format = bzrdir_format
1122
new_test.branch_format = branch_format
1123
def make_new_test_id():
1124
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1125
return lambda: new_id
1126
new_test.id = make_new_test_id()
1127
result.addTest(new_test)
1131
######################################################################
1135
@deprecated_function(zero_eight)
1136
def ScratchBranch(*args, **kwargs):
1137
"""See bzrlib.bzrdir.ScratchDir."""
1138
d = ScratchDir(*args, **kwargs)
1139
return d.open_branch()
1142
@deprecated_function(zero_eight)
1143
def is_control_file(*args, **kwargs):
1144
"""See bzrlib.workingtree.is_control_file."""
1145
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
