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 (Revision, is_ancestor, get_intervening_revisions)
61
from bzrlib.store import copy_all
62
from bzrlib.symbol_versioning import *
63
import bzrlib.transactions as transactions
64
from bzrlib.transport import Transport, get_transport
65
from bzrlib.tree import EmptyTree, RevisionTree
70
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
71
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
72
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
75
# TODO: Maybe include checks for common corruption of newlines, etc?
77
# TODO: Some operations like log might retrieve the same revisions
78
# repeatedly to calculate deltas. We could perhaps have a weakref
79
# cache in memory to make this faster. In general anything can be
80
# cached in memory between lock and unlock operations. .. nb thats
81
# what the transaction identity map provides
84
######################################################################
88
"""Branch holding a history of revisions.
91
Base directory/url of the branch.
93
# this is really an instance variable - FIXME move it there
99
"""Construct the current default format branch in a_bzrdir.
101
This creates the current default BzrDir format, and if that
102
supports multiple Branch formats, then the default Branch format
105
print "not usable until we have repositories"
106
raise NotImplementedError("not usable right now")
107
return bzrdir.BzrDir.create(base)
109
def __init__(self, *ignored, **ignored_too):
110
raise NotImplementedError('The Branch class is abstract')
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
# imported here to prevent scope creep as this is going.
152
from bzrlib.workingtree import WorkingTree
153
return WorkingTree.create_standalone(safe_unicode(base)).branch
155
def setup_caching(self, cache_root):
156
"""Subclasses that care about caching should override this, and set
157
up cached stores located under cache_root.
159
# seems to be unused, 2006-01-13 mbp
160
warn('%s is deprecated' % self.setup_caching)
161
self.cache_root = cache_root
164
cfg = self.tree_config()
165
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
167
def _set_nick(self, nick):
168
cfg = self.tree_config()
169
cfg.set_option(nick, "nickname")
170
assert cfg.get_option("nickname") == nick
172
nick = property(_get_nick, _set_nick)
174
def lock_write(self):
175
raise NotImplementedError('lock_write is abstract')
178
raise NotImplementedError('lock_read is abstract')
181
raise NotImplementedError('unlock is abstract')
183
def peek_lock_mode(self):
184
"""Return lock mode for the Branch: 'r', 'w' or None"""
185
raise NotImplementedError(self.peek_lock_mode)
187
def abspath(self, name):
188
"""Return absolute filename for something in the branch
190
XXX: Robert Collins 20051017 what is this used for? why is it a branch
191
method and not a tree method.
193
raise NotImplementedError('abspath is abstract')
195
def get_root_id(self):
196
"""Return the id of this branches root"""
197
raise NotImplementedError('get_root_id is abstract')
199
def print_file(self, file, revision_id):
200
"""Print `file` to stdout."""
201
raise NotImplementedError('print_file is abstract')
203
def append_revision(self, *revision_ids):
204
raise NotImplementedError('append_revision is abstract')
206
def set_revision_history(self, rev_history):
207
raise NotImplementedError('set_revision_history is abstract')
209
def revision_history(self):
210
"""Return sequence of revision hashes on to this branch."""
211
raise NotImplementedError('revision_history is abstract')
214
"""Return current revision number for this branch.
216
That is equivalent to the number of revisions committed to
219
return len(self.revision_history())
221
def last_revision(self):
222
"""Return last patch hash, or None if no history."""
223
ph = self.revision_history()
229
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
230
"""Return a list of new revisions that would perfectly fit.
232
If self and other have not diverged, return a list of the revisions
233
present in other, but missing from self.
235
>>> from bzrlib.workingtree import WorkingTree
236
>>> bzrlib.trace.silent = True
237
>>> d1 = bzrdir.ScratchDir()
238
>>> br1 = d1.open_branch()
239
>>> wt1 = WorkingTree(br1.base, br1)
240
>>> d2 = bzrdir.ScratchDir()
241
>>> br2 = d2.open_branch()
242
>>> wt2 = WorkingTree(br2.base, br2)
243
>>> br1.missing_revisions(br2)
245
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
246
>>> br1.missing_revisions(br2)
248
>>> br2.missing_revisions(br1)
250
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
251
>>> br1.missing_revisions(br2)
253
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
254
>>> br1.missing_revisions(br2)
256
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
257
>>> br1.missing_revisions(br2)
258
Traceback (most recent call last):
259
DivergedBranches: These branches have diverged. Try merge.
261
self_history = self.revision_history()
262
self_len = len(self_history)
263
other_history = other.revision_history()
264
other_len = len(other_history)
265
common_index = min(self_len, other_len) -1
266
if common_index >= 0 and \
267
self_history[common_index] != other_history[common_index]:
268
raise DivergedBranches(self, other)
270
if stop_revision is None:
271
stop_revision = other_len
273
assert isinstance(stop_revision, int)
274
if stop_revision > other_len:
275
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
276
return other_history[self_len:stop_revision]
278
def update_revisions(self, other, stop_revision=None):
279
"""Pull in new perfect-fit revisions."""
280
raise NotImplementedError('update_revisions is abstract')
282
def pullable_revisions(self, other, stop_revision):
283
raise NotImplementedError('pullable_revisions is abstract')
285
def revision_id_to_revno(self, revision_id):
286
"""Given a revision id, return its revno"""
287
if revision_id is None:
289
history = self.revision_history()
291
return history.index(revision_id) + 1
293
raise bzrlib.errors.NoSuchRevision(self, revision_id)
295
def get_rev_id(self, revno, history=None):
296
"""Find the revision id of the specified revno."""
300
history = self.revision_history()
301
elif revno <= 0 or revno > len(history):
302
raise bzrlib.errors.NoSuchRevision(self, revno)
303
return history[revno - 1]
305
def pull(self, source, overwrite=False):
306
raise NotImplementedError('pull is abstract')
308
def basis_tree(self):
309
"""Return `Tree` object for last revision.
311
If there are no revisions yet, return an `EmptyTree`.
313
return self.repository.revision_tree(self.last_revision())
315
def rename_one(self, from_rel, to_rel):
318
This can change the directory or the filename or both.
320
raise NotImplementedError('rename_one is abstract')
322
def move(self, from_paths, to_name):
325
to_name must exist as a versioned directory.
327
If to_name exists and is a directory, the files are moved into
328
it, keeping their old names. If it is a directory,
330
Note that to_name is only the last component of the new name;
331
this doesn't change the directory.
333
This returns a list of (from_path, to_path) pairs for each
336
raise NotImplementedError('move is abstract')
338
def get_parent(self):
339
"""Return the parent location of the branch.
341
This is the default location for push/pull/missing. The usual
342
pattern is that the user can override it by specifying a
345
raise NotImplementedError('get_parent is abstract')
347
def get_push_location(self):
348
"""Return the None or the location to push this branch to."""
349
raise NotImplementedError('get_push_location is abstract')
351
def set_push_location(self, location):
352
"""Set a new push location for this branch."""
353
raise NotImplementedError('set_push_location is abstract')
355
def set_parent(self, url):
356
raise NotImplementedError('set_parent is abstract')
358
def check_revno(self, revno):
360
Check whether a revno corresponds to any revision.
361
Zero (the NULL revision) is considered valid.
364
self.check_real_revno(revno)
366
def check_real_revno(self, revno):
368
Check whether a revno corresponds to a real revision.
369
Zero (the NULL revision) is considered invalid
371
if revno < 1 or revno > self.revno():
372
raise InvalidRevisionNumber(revno)
374
def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
375
"""Copy this branch into the existing directory to_location.
377
Returns the newly created branch object.
380
If not None, only revisions up to this point will be copied.
381
The head of the new branch will be that revision. Must be a
384
to_location -- The destination directory; must either exist and be
385
empty, or not exist, in which case it is created.
388
A local branch to copy revisions from, related to this branch.
389
This is used when branching from a remote (slow) branch, and we have
390
a local branch that might contain some relevant revisions.
393
Branch type of destination branch
395
from bzrlib.workingtree import WorkingTree
396
assert isinstance(to_location, basestring)
397
segments = to_location.split('/')
398
if segments and segments[-1] not in ('', '.'):
399
parent = '/'.join(segments[:-1])
400
t = get_transport(parent)
402
t.mkdir(segments[-1])
403
except errors.FileExists:
405
if to_branch_format is None:
407
br_to = bzrdir.BzrDir.create_branch_and_repo(to_location)
409
br_to = to_branch_format.initialize(to_location)
410
mutter("copy branch from %s to %s", self, br_to)
412
revision = self.last_revision()
413
if basis_branch is not None:
414
basis_branch.repository.push_stores(br_to.repository,
416
br_to.update_revisions(self, stop_revision=revision)
417
br_to.set_parent(self.base)
422
class BranchFormat(object):
423
"""An encapsulation of the initialization and open routines for a format.
425
Formats provide three things:
426
* An initialization routine,
430
Formats are placed in an dict by their format string for reference
431
during branch opening. Its not required that these be instances, they
432
can be classes themselves with class methods - it simply depends on
433
whether state is needed for a given format or not.
435
Once a format is deprecated, just deprecate the initialize and open
436
methods on the format class. Do not deprecate the object, as the
437
object will be created every time regardless.
440
_default_format = None
441
"""The default format used for new branches."""
444
"""The known formats."""
447
def find_format(klass, a_bzrdir):
448
"""Return the format for the branch object in a_bzrdir."""
450
transport = a_bzrdir.get_branch_transport(None)
451
format_string = transport.get("format").read()
452
return klass._formats[format_string]
454
raise NotBranchError(path=transport.base)
456
raise errors.UnknownFormatError(format_string)
459
def get_default_format(klass):
460
"""Return the current default format."""
461
return klass._default_format
463
def get_format_string(self):
464
"""Return the ASCII format string that identifies this format."""
465
raise NotImplementedError(self.get_format_string)
467
def _find_modes(self, t):
468
"""Determine the appropriate modes for files and directories.
470
FIXME: When this merges into, or from storage,
471
this code becomes delgatable to a LockableFiles instance.
473
For now its cribbed and returns (dir_mode, file_mode)
477
except errors.TransportNotPossible:
481
dir_mode = st.st_mode & 07777
482
# Remove the sticky and execute bits for files
483
file_mode = dir_mode & ~07111
484
if not BzrBranch._set_dir_mode:
486
if not BzrBranch._set_file_mode:
488
return dir_mode, file_mode
490
def initialize(self, a_bzrdir):
491
"""Create a branch of this format in a_bzrdir."""
492
raise NotImplementedError(self.initialized)
494
def is_supported(self):
495
"""Is this format supported?
497
Supported formats can be initialized and opened.
498
Unsupported formats may not support initialization or committing or
499
some other features depending on the reason for not being supported.
503
def open(self, a_bzrdir, _found=False):
504
"""Return the branch object for a_bzrdir
506
_found is a private parameter, do not use it. It is used to indicate
507
if format probing has already be done.
509
raise NotImplementedError(self.open)
512
def register_format(klass, format):
513
klass._formats[format.get_format_string()] = format
516
def set_default_format(klass, format):
517
klass._default_format = format
520
def unregister_format(klass, format):
521
assert klass._formats[format.get_format_string()] is format
522
del klass._formats[format.get_format_string()]
525
class BzrBranchFormat4(BranchFormat):
526
"""Bzr branch format 4.
529
- a revision-history file.
530
- a branch-lock lock file [ to be shared with the bzrdir ]
533
def initialize(self, a_bzrdir):
534
"""Create a branch of this format in a_bzrdir."""
535
mutter('creating branch in %s', a_bzrdir.transport.base)
536
branch_transport = a_bzrdir.get_branch_transport(self)
537
utf8_files = [('revision-history', ''),
540
control_files = LockableFiles(branch_transport, 'branch-lock')
541
control_files.lock_write()
543
for file, content in utf8_files:
544
control_files.put_utf8(file, content)
546
control_files.unlock()
547
return self.open(a_bzrdir, _found=True)
550
super(BzrBranchFormat4, self).__init__()
551
self._matchingbzrdir = bzrdir.BzrDirFormat6()
553
def open(self, a_bzrdir, _found=False):
554
"""Return the branch object for a_bzrdir
556
_found is a private parameter, do not use it. It is used to indicate
557
if format probing has already be done.
560
# we are being called directly and must probe.
561
raise NotImplementedError
562
transport = a_bzrdir.get_branch_transport(self)
563
control_files = LockableFiles(transport, 'branch-lock')
564
return BzrBranch(_format=self,
565
_control_files=control_files,
569
class BzrBranchFormat5(BranchFormat):
570
"""Bzr branch format 5.
573
- a revision-history file.
578
def get_format_string(self):
579
"""See BranchFormat.get_format_string()."""
580
return "Bazaar-NG branch format 5\n"
582
def initialize(self, a_bzrdir):
583
"""Create a branch of this format in a_bzrdir."""
584
mutter('creating branch in %s', a_bzrdir.transport.base)
585
branch_transport = a_bzrdir.get_branch_transport(self)
587
utf8_files = [('revision-history', ''),
591
branch_transport.put(lock_file, StringIO()) # TODO get the file mode from the bzrdir lock files., mode=file_mode)
592
control_files = LockableFiles(branch_transport, 'lock')
593
control_files.lock_write()
594
control_files.put_utf8('format', self.get_format_string())
596
for file, content in utf8_files:
597
control_files.put_utf8(file, content)
599
control_files.unlock()
600
return self.open(a_bzrdir, _found=True, )
603
super(BzrBranchFormat5, self).__init__()
604
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
606
def open(self, a_bzrdir, _found=False):
607
"""Return the branch object for a_bzrdir
609
_found is a private parameter, do not use it. It is used to indicate
610
if format probing has already be done.
613
format = BranchFormat.find_format(a_bzrdir)
614
assert format.__class__ == self.__class__
615
transport = a_bzrdir.get_branch_transport(None)
616
control_files = LockableFiles(transport, 'lock')
617
return BzrBranch(_format=self,
618
_control_files=control_files,
622
# formats which have no format string are not discoverable
623
# and not independently creatable, so are not registered.
624
__default_format = BzrBranchFormat5()
625
BranchFormat.register_format(__default_format)
626
BranchFormat.set_default_format(__default_format)
627
_legacy_formats = [BzrBranchFormat4(),
630
class BzrBranch(Branch):
631
"""A branch stored in the actual filesystem.
633
Note that it's "local" in the context of the filesystem; it doesn't
634
really matter if it's on an nfs/smb/afs/coda/... share, as long as
635
it's writable, and can be accessed via the normal filesystem API.
638
# We actually expect this class to be somewhat short-lived; part of its
639
# purpose is to try to isolate what bits of the branch logic are tied to
640
# filesystem access, so that in a later step, we can extricate them to
641
# a separarte ("storage") class.
642
_inventory_weave = None
644
# Map some sort of prefix into a namespace
645
# stuff like "revno:10", "revid:", etc.
646
# This should match a prefix with a function which accepts
647
REVISION_NAMESPACES = {}
649
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
650
relax_version_check=DEPRECATED_PARAMETER, _format=None,
651
_control_files=None, a_bzrdir=None):
652
"""Create new branch object at a particular location.
654
transport -- A Transport object, defining how to access files.
656
init -- If True, create new control files in a previously
657
unversioned directory. If False, the branch must already
660
relax_version_check -- If true, the usual check for the branch
661
version is not applied. This is intended only for
662
upgrade/recovery type use; it's not guaranteed that
663
all operations will work on old format branches.
666
self.bzrdir = bzrdir.BzrDir.open(transport.base)
668
self.bzrdir = a_bzrdir
669
self._transport = self.bzrdir.transport.clone('..')
670
self._base = self._transport.base
671
self._format = _format
672
if _control_files is None:
673
raise BzrBadParameterMissing('_control_files')
674
self.control_files = _control_files
675
if deprecated_passed(init):
676
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
677
"deprecated as of bzr 0.8. Please use Branch.create().",
681
# this is slower than before deprecation, oh well never mind.
683
self._initialize(transport.base)
684
self._check_format(_format)
685
if deprecated_passed(relax_version_check):
686
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
687
"relax_version_check parameter is deprecated as of bzr 0.8. "
688
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
692
if (not relax_version_check
693
and not self._format.is_supported()):
694
raise errors.UnsupportedFormatError(
695
'sorry, branch format %r not supported' % fmt,
696
['use a different bzr version',
697
'or remove the .bzr directory'
698
' and "bzr init" again'])
699
if deprecated_passed(transport):
700
warn("BzrBranch.__init__(transport=XXX...): The transport "
701
"parameter is deprecated as of bzr 0.8. "
702
"Please use Branch.open, or bzrdir.open_branch().",
705
# TODO change this to search upwards if needed.
706
self.repository = self.bzrdir.open_repository()
709
return '%s(%r)' % (self.__class__.__name__, self.base)
714
# TODO: It might be best to do this somewhere else,
715
# but it is nice for a Branch object to automatically
716
# cache it's information.
717
# Alternatively, we could have the Transport objects cache requests
718
# See the earlier discussion about how major objects (like Branch)
719
# should never expect their __del__ function to run.
720
# XXX: cache_root seems to be unused, 2006-01-13 mbp
721
if hasattr(self, 'cache_root') and self.cache_root is not None:
723
shutil.rmtree(self.cache_root)
726
self.cache_root = None
731
base = property(_get_base, doc="The URL for the root of this branch.")
733
def _finish_transaction(self):
734
"""Exit the current transaction."""
735
return self.control_files._finish_transaction()
737
def get_transaction(self):
738
"""Return the current active transaction.
740
If no transaction is active, this returns a passthrough object
741
for which all data is immediately flushed and no caching happens.
743
# this is an explicit function so that we can do tricky stuff
744
# when the storage in rev_storage is elsewhere.
745
# we probably need to hook the two 'lock a location' and
746
# 'have a transaction' together more delicately, so that
747
# we can have two locks (branch and storage) and one transaction
748
# ... and finishing the transaction unlocks both, but unlocking
749
# does not. - RBC 20051121
750
return self.control_files.get_transaction()
752
def _set_transaction(self, transaction):
753
"""Set a new active transaction."""
754
return self.control_files._set_transaction(transaction)
756
def abspath(self, name):
757
"""See Branch.abspath."""
758
return self.control_files._transport.abspath(name)
760
def _check_format(self, format):
761
"""Identify the branch format if needed.
763
The format is stored as a reference to the format object in
764
self._format for code that needs to check it later.
766
The format parameter is either None or the branch format class
767
used to open this branch.
769
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
772
format = BzrBranchFormat.find_format(self.bzrdir)
773
self._format = format
774
mutter("got branch format %s", self._format)
777
def get_root_id(self):
778
"""See Branch.get_root_id."""
779
tree = self.repository.revision_tree(self.last_revision())
780
return tree.inventory.root.file_id
782
def lock_write(self):
783
# TODO: test for failed two phase locks. This is known broken.
784
self.control_files.lock_write()
785
self.repository.lock_write()
788
# TODO: test for failed two phase locks. This is known broken.
789
self.control_files.lock_read()
790
self.repository.lock_read()
793
# TODO: test for failed two phase locks. This is known broken.
794
self.repository.unlock()
795
self.control_files.unlock()
797
def peek_lock_mode(self):
798
if self.control_files._lock_count == 0:
801
return self.control_files._lock_mode
804
def print_file(self, file, revision_id):
805
"""See Branch.print_file."""
806
return self.repository.print_file(file, revision_id)
809
def append_revision(self, *revision_ids):
810
"""See Branch.append_revision."""
811
for revision_id in revision_ids:
812
mutter("add {%s} to revision-history" % revision_id)
813
rev_history = self.revision_history()
814
rev_history.extend(revision_ids)
815
self.set_revision_history(rev_history)
818
def set_revision_history(self, rev_history):
819
"""See Branch.set_revision_history."""
820
self.control_files.put_utf8(
821
'revision-history', '\n'.join(rev_history))
823
def get_revision_delta(self, revno):
824
"""Return the delta for one revision.
826
The delta is relative to its mainline predecessor, or the
827
empty tree for revision 1.
829
assert isinstance(revno, int)
830
rh = self.revision_history()
831
if not (1 <= revno <= len(rh)):
832
raise InvalidRevisionNumber(revno)
834
# revno is 1-based; list is 0-based
836
new_tree = self.repository.revision_tree(rh[revno-1])
838
old_tree = EmptyTree()
840
old_tree = self.repository.revision_tree(rh[revno-2])
841
return compare_trees(old_tree, new_tree)
844
def revision_history(self):
845
"""See Branch.revision_history."""
846
# FIXME are transactions bound to control files ? RBC 20051121
847
transaction = self.get_transaction()
848
history = transaction.map.find_revision_history()
849
if history is not None:
850
mutter("cache hit for revision-history in %s", self)
852
history = [l.rstrip('\r\n') for l in
853
self.control_files.get_utf8('revision-history').readlines()]
854
transaction.map.add_revision_history(history)
855
# this call is disabled because revision_history is
856
# not really an object yet, and the transaction is for objects.
857
# transaction.register_clean(history, precious=True)
860
def update_revisions(self, other, stop_revision=None):
861
"""See Branch.update_revisions."""
862
from bzrlib.fetch import greedy_fetch
863
if stop_revision is None:
864
stop_revision = other.last_revision()
865
### Should this be checking is_ancestor instead of revision_history?
866
if (stop_revision is not None and
867
stop_revision in self.revision_history()):
869
greedy_fetch(to_branch=self, from_branch=other,
870
revision=stop_revision)
871
pullable_revs = self.pullable_revisions(other, stop_revision)
872
if len(pullable_revs) > 0:
873
self.append_revision(*pullable_revs)
875
def pullable_revisions(self, other, stop_revision):
876
"""See Branch.pullable_revisions."""
877
other_revno = other.revision_id_to_revno(stop_revision)
879
return self.missing_revisions(other, other_revno)
880
except DivergedBranches, e:
882
pullable_revs = get_intervening_revisions(self.last_revision(),
885
assert self.last_revision() not in pullable_revs
887
except bzrlib.errors.NotAncestor:
888
if is_ancestor(self.last_revision(), stop_revision, self):
893
def basis_tree(self):
894
"""See Branch.basis_tree."""
895
return self.repository.revision_tree(self.last_revision())
897
@deprecated_method(zero_eight)
898
def working_tree(self):
899
"""Create a Working tree object for this branch."""
900
from bzrlib.workingtree import WorkingTree
901
from bzrlib.transport.local import LocalTransport
902
if (self.base.find('://') != -1 or
903
not isinstance(self._transport, LocalTransport)):
904
raise NoWorkingTree(self.base)
905
return WorkingTree(self.base, branch=self)
908
def pull(self, source, overwrite=False):
909
"""See Branch.pull."""
912
old_count = len(self.revision_history())
914
self.update_revisions(source)
915
except DivergedBranches:
919
self.set_revision_history(source.revision_history())
920
new_count = len(self.revision_history())
921
return new_count - old_count
925
def get_parent(self):
926
"""See Branch.get_parent."""
928
_locs = ['parent', 'pull', 'x-pull']
931
return self.control_files.get_utf8(l).read().strip('\n')
936
def get_push_location(self):
937
"""See Branch.get_push_location."""
938
config = bzrlib.config.BranchConfig(self)
939
push_loc = config.get_user_option('push_location')
942
def set_push_location(self, location):
943
"""See Branch.set_push_location."""
944
config = bzrlib.config.LocationConfig(self.base)
945
config.set_user_option('push_location', location)
948
def set_parent(self, url):
949
"""See Branch.set_parent."""
950
# TODO: Maybe delete old location files?
951
# URLs should never be unicode, even on the local fs,
952
# FIXUP this and get_parent in a future branch format bump:
953
# read and rewrite the file, and have the new format code read
954
# using .get not .get_utf8. RBC 20060125
955
self.control_files.put_utf8('parent', url + '\n')
957
def tree_config(self):
958
return TreeConfig(self)
960
def _get_truncated_history(self, revision_id):
961
history = self.revision_history()
962
if revision_id is None:
965
idx = history.index(revision_id)
967
raise InvalidRevisionId(revision_id=revision, branch=self)
968
return history[:idx+1]
971
def _clone_weave(self, to_location, revision=None, basis_branch=None):
973
from bzrlib.workingtree import WorkingTree
974
assert isinstance(to_location, basestring)
975
if basis_branch is not None:
976
note("basis_branch is not supported for fast weave copy yet.")
978
history = self._get_truncated_history(revision)
979
if not bzrlib.osutils.lexists(to_location):
980
os.mkdir(to_location)
981
bzrdir_to = self.bzrdir._format.initialize(to_location)
982
self.repository.clone(bzrdir_to)
983
branch_to = bzrdir_to.create_branch()
984
mutter("copy branch from %s to %s", self, branch_to)
986
# FIXME duplicate code with base .clone().
987
# .. would template method be useful here? RBC 20051207
988
branch_to.set_parent(self.base)
989
branch_to.append_revision(*history)
990
WorkingTree.create(branch_to, branch_to.base)
994
def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
995
print "FIXME: clone via create and fetch is probably faster when versioned file comes in."
996
if (to_branch_type is None
997
and self.repository.weave_store.listable()
998
and self.repository.revision_store.listable()):
999
return self._clone_weave(to_location, revision, basis_branch)
1001
return Branch.clone(self, to_location, revision, basis_branch, to_branch_type)
1004
class BranchTestProviderAdapter(object):
1005
"""A tool to generate a suite testing multiple branch formats at once.
1007
This is done by copying the test once for each transport and injecting
1008
the transport_server, transport_readonly_server, and branch_format
1009
classes into each copy. Each copy is also given a new id() to make it
1013
def __init__(self, transport_server, transport_readonly_server, formats):
1014
self._transport_server = transport_server
1015
self._transport_readonly_server = transport_readonly_server
1016
self._formats = formats
1018
def adapt(self, test):
1019
result = TestSuite()
1020
for branch_format, bzrdir_format in self._formats:
1021
new_test = deepcopy(test)
1022
new_test.transport_server = self._transport_server
1023
new_test.transport_readonly_server = self._transport_readonly_server
1024
new_test.bzrdir_format = bzrdir_format
1025
new_test.branch_format = branch_format
1026
def make_new_test_id():
1027
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1028
return lambda: new_id
1029
new_test.id = make_new_test_id()
1030
result.addTest(new_test)
1034
######################################################################
1038
@deprecated_function(zero_eight)
1039
def ScratchBranch(*args, **kwargs):
1040
"""See bzrlib.bzrdir.ScratchDir."""
1041
d = ScratchDir(*args, **kwargs)
1042
return d.open_branch()
1045
@deprecated_function(zero_eight)
1046
def is_control_file(*args, **kwargs):
1047
"""See bzrlib.workingtree.is_control_file."""
1048
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
