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
self.repository = self.bzrdir.open_repository()
708
return '%s(%r)' % (self.__class__.__name__, self.base)
713
# TODO: It might be best to do this somewhere else,
714
# but it is nice for a Branch object to automatically
715
# cache it's information.
716
# Alternatively, we could have the Transport objects cache requests
717
# See the earlier discussion about how major objects (like Branch)
718
# should never expect their __del__ function to run.
719
# XXX: cache_root seems to be unused, 2006-01-13 mbp
720
if hasattr(self, 'cache_root') and self.cache_root is not None:
722
shutil.rmtree(self.cache_root)
725
self.cache_root = None
730
base = property(_get_base, doc="The URL for the root of this branch.")
732
def _finish_transaction(self):
733
"""Exit the current transaction."""
734
return self.control_files._finish_transaction()
736
def get_transaction(self):
737
"""Return the current active transaction.
739
If no transaction is active, this returns a passthrough object
740
for which all data is immediately flushed and no caching happens.
742
# this is an explicit function so that we can do tricky stuff
743
# when the storage in rev_storage is elsewhere.
744
# we probably need to hook the two 'lock a location' and
745
# 'have a transaction' together more delicately, so that
746
# we can have two locks (branch and storage) and one transaction
747
# ... and finishing the transaction unlocks both, but unlocking
748
# does not. - RBC 20051121
749
return self.control_files.get_transaction()
751
def _set_transaction(self, transaction):
752
"""Set a new active transaction."""
753
return self.control_files._set_transaction(transaction)
755
def abspath(self, name):
756
"""See Branch.abspath."""
757
return self.control_files._transport.abspath(name)
759
def _check_format(self, format):
760
"""Identify the branch format if needed.
762
The format is stored as a reference to the format object in
763
self._format for code that needs to check it later.
765
The format parameter is either None or the branch format class
766
used to open this branch.
768
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
771
format = BzrBranchFormat.find_format(self.bzrdir)
772
self._format = format
773
mutter("got branch format %s", self._format)
776
def get_root_id(self):
777
"""See Branch.get_root_id."""
778
tree = self.repository.revision_tree(self.last_revision())
779
return tree.inventory.root.file_id
781
def lock_write(self):
782
# TODO: test for failed two phase locks. This is known broken.
783
self.control_files.lock_write()
784
self.repository.lock_write()
787
# TODO: test for failed two phase locks. This is known broken.
788
self.control_files.lock_read()
789
self.repository.lock_read()
792
# TODO: test for failed two phase locks. This is known broken.
793
self.repository.unlock()
794
self.control_files.unlock()
796
def peek_lock_mode(self):
797
if self.control_files._lock_count == 0:
800
return self.control_files._lock_mode
803
def print_file(self, file, revision_id):
804
"""See Branch.print_file."""
805
return self.repository.print_file(file, revision_id)
808
def append_revision(self, *revision_ids):
809
"""See Branch.append_revision."""
810
for revision_id in revision_ids:
811
mutter("add {%s} to revision-history" % revision_id)
812
rev_history = self.revision_history()
813
rev_history.extend(revision_ids)
814
self.set_revision_history(rev_history)
817
def set_revision_history(self, rev_history):
818
"""See Branch.set_revision_history."""
819
self.control_files.put_utf8(
820
'revision-history', '\n'.join(rev_history))
822
def get_revision_delta(self, revno):
823
"""Return the delta for one revision.
825
The delta is relative to its mainline predecessor, or the
826
empty tree for revision 1.
828
assert isinstance(revno, int)
829
rh = self.revision_history()
830
if not (1 <= revno <= len(rh)):
831
raise InvalidRevisionNumber(revno)
833
# revno is 1-based; list is 0-based
835
new_tree = self.repository.revision_tree(rh[revno-1])
837
old_tree = EmptyTree()
839
old_tree = self.repository.revision_tree(rh[revno-2])
840
return compare_trees(old_tree, new_tree)
843
def revision_history(self):
844
"""See Branch.revision_history."""
845
# FIXME are transactions bound to control files ? RBC 20051121
846
transaction = self.get_transaction()
847
history = transaction.map.find_revision_history()
848
if history is not None:
849
mutter("cache hit for revision-history in %s", self)
851
history = [l.rstrip('\r\n') for l in
852
self.control_files.get_utf8('revision-history').readlines()]
853
transaction.map.add_revision_history(history)
854
# this call is disabled because revision_history is
855
# not really an object yet, and the transaction is for objects.
856
# transaction.register_clean(history, precious=True)
859
def update_revisions(self, other, stop_revision=None):
860
"""See Branch.update_revisions."""
861
from bzrlib.fetch import greedy_fetch
862
if stop_revision is None:
863
stop_revision = other.last_revision()
864
### Should this be checking is_ancestor instead of revision_history?
865
if (stop_revision is not None and
866
stop_revision in self.revision_history()):
868
greedy_fetch(to_branch=self, from_branch=other,
869
revision=stop_revision)
870
pullable_revs = self.pullable_revisions(other, stop_revision)
871
if len(pullable_revs) > 0:
872
self.append_revision(*pullable_revs)
874
def pullable_revisions(self, other, stop_revision):
875
"""See Branch.pullable_revisions."""
876
other_revno = other.revision_id_to_revno(stop_revision)
878
return self.missing_revisions(other, other_revno)
879
except DivergedBranches, e:
881
pullable_revs = get_intervening_revisions(self.last_revision(),
884
assert self.last_revision() not in pullable_revs
886
except bzrlib.errors.NotAncestor:
887
if is_ancestor(self.last_revision(), stop_revision, self):
892
def basis_tree(self):
893
"""See Branch.basis_tree."""
894
return self.repository.revision_tree(self.last_revision())
896
@deprecated_method(zero_eight)
897
def working_tree(self):
898
"""Create a Working tree object for this branch."""
899
from bzrlib.workingtree import WorkingTree
900
from bzrlib.transport.local import LocalTransport
901
if (self.base.find('://') != -1 or
902
not isinstance(self._transport, LocalTransport)):
903
raise NoWorkingTree(self.base)
904
return WorkingTree(self.base, branch=self)
907
def pull(self, source, overwrite=False):
908
"""See Branch.pull."""
911
old_count = len(self.revision_history())
913
self.update_revisions(source)
914
except DivergedBranches:
918
self.set_revision_history(source.revision_history())
919
new_count = len(self.revision_history())
920
return new_count - old_count
924
def get_parent(self):
925
"""See Branch.get_parent."""
927
_locs = ['parent', 'pull', 'x-pull']
930
return self.control_files.get_utf8(l).read().strip('\n')
935
def get_push_location(self):
936
"""See Branch.get_push_location."""
937
config = bzrlib.config.BranchConfig(self)
938
push_loc = config.get_user_option('push_location')
941
def set_push_location(self, location):
942
"""See Branch.set_push_location."""
943
config = bzrlib.config.LocationConfig(self.base)
944
config.set_user_option('push_location', location)
947
def set_parent(self, url):
948
"""See Branch.set_parent."""
949
# TODO: Maybe delete old location files?
950
# URLs should never be unicode, even on the local fs,
951
# FIXUP this and get_parent in a future branch format bump:
952
# read and rewrite the file, and have the new format code read
953
# using .get not .get_utf8. RBC 20060125
954
self.control_files.put_utf8('parent', url + '\n')
956
def tree_config(self):
957
return TreeConfig(self)
959
def _get_truncated_history(self, revision_id):
960
history = self.revision_history()
961
if revision_id is None:
964
idx = history.index(revision_id)
966
raise InvalidRevisionId(revision_id=revision, branch=self)
967
return history[:idx+1]
970
def _clone_weave(self, to_location, revision=None, basis_branch=None):
972
from bzrlib.workingtree import WorkingTree
973
assert isinstance(to_location, basestring)
974
if basis_branch is not None:
975
note("basis_branch is not supported for fast weave copy yet.")
977
history = self._get_truncated_history(revision)
978
if not bzrlib.osutils.lexists(to_location):
979
os.mkdir(to_location)
980
bzrdir_to = self.bzrdir._format.initialize(to_location)
981
self.repository.clone(bzrdir_to)
982
branch_to = bzrdir_to.create_branch()
983
mutter("copy branch from %s to %s", self, branch_to)
985
# FIXME duplicate code with base .clone().
986
# .. would template method be useful here? RBC 20051207
987
branch_to.set_parent(self.base)
988
branch_to.append_revision(*history)
989
WorkingTree.create(branch_to, branch_to.base)
993
def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
994
print "FIXME: clone via create and fetch is probably faster when versioned file comes in."
995
if (to_branch_type is None
996
and self.repository.weave_store.listable()
997
and self.repository.revision_store.listable()):
998
return self._clone_weave(to_location, revision, basis_branch)
1000
return Branch.clone(self, to_location, revision, basis_branch, to_branch_type)
1003
class BranchTestProviderAdapter(object):
1004
"""A tool to generate a suite testing multiple branch formats at once.
1006
This is done by copying the test once for each transport and injecting
1007
the transport_server, transport_readonly_server, and branch_format
1008
classes into each copy. Each copy is also given a new id() to make it
1012
def __init__(self, transport_server, transport_readonly_server, formats):
1013
self._transport_server = transport_server
1014
self._transport_readonly_server = transport_readonly_server
1015
self._formats = formats
1017
def adapt(self, test):
1018
result = TestSuite()
1019
for branch_format, bzrdir_format in self._formats:
1020
new_test = deepcopy(test)
1021
new_test.transport_server = self._transport_server
1022
new_test.transport_readonly_server = self._transport_readonly_server
1023
new_test.bzrdir_format = bzrdir_format
1024
new_test.branch_format = branch_format
1025
def make_new_test_id():
1026
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1027
return lambda: new_id
1028
new_test.id = make_new_test_id()
1029
result.addTest(new_test)
1033
######################################################################
1037
@deprecated_function(zero_eight)
1038
def ScratchBranch(*args, **kwargs):
1039
"""See bzrlib.bzrdir.ScratchDir."""
1040
d = ScratchDir(*args, **kwargs)
1041
return d.open_branch()
1044
@deprecated_function(zero_eight)
1045
def is_control_file(*args, **kwargs):
1046
"""See bzrlib.workingtree.is_control_file."""
1047
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
