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 cStringIO import StringIO
20
from bzrlib.lazy_import import lazy_import
21
lazy_import(globals(), """
22
from copy import deepcopy
23
from unittest import TestSuite
24
from warnings import warn
30
config as _mod_config,
35
revision as _mod_revision,
41
from bzrlib.config import BranchConfig, TreeConfig
42
from bzrlib.lockable_files import LockableFiles, TransportLock
45
from bzrlib.decorators import needs_read_lock, needs_write_lock
46
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
47
HistoryMissing, InvalidRevisionId,
48
InvalidRevisionNumber, LockError, NoSuchFile,
49
NoSuchRevision, NoWorkingTree, NotVersionedError,
50
NotBranchError, UninitializableFormat,
51
UnlistableStore, UnlistableBranch,
53
from bzrlib.symbol_versioning import (deprecated_function,
57
zero_eight, zero_nine,
59
from bzrlib.trace import mutter, note
62
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
63
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
64
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
67
# TODO: Maybe include checks for common corruption of newlines, etc?
69
# TODO: Some operations like log might retrieve the same revisions
70
# repeatedly to calculate deltas. We could perhaps have a weakref
71
# cache in memory to make this faster. In general anything can be
72
# cached in memory between lock and unlock operations. .. nb thats
73
# what the transaction identity map provides
76
######################################################################
80
"""Branch holding a history of revisions.
83
Base directory/url of the branch.
85
hooks: An instance of BranchHooks.
87
# this is really an instance variable - FIXME move it there
91
def __init__(self, *ignored, **ignored_too):
92
raise NotImplementedError('The Branch class is abstract')
95
"""Break a lock if one is present from another instance.
97
Uses the ui factory to ask for confirmation if the lock may be from
100
This will probe the repository for its lock as well.
102
self.control_files.break_lock()
103
self.repository.break_lock()
104
master = self.get_master_branch()
105
if master is not None:
109
@deprecated_method(zero_eight)
110
def open_downlevel(base):
111
"""Open a branch which may be of an old format."""
112
return Branch.open(base, _unsupported=True)
115
def open(base, _unsupported=False):
116
"""Open the branch rooted at base.
118
For instance, if the branch is at URL/.bzr/branch,
119
Branch.open(URL) -> a Branch instance.
121
control = bzrdir.BzrDir.open(base, _unsupported)
122
return control.open_branch(_unsupported)
125
def open_containing(url):
126
"""Open an existing branch which contains url.
128
This probes for a branch at url, and searches upwards from there.
130
Basically we keep looking up until we find the control directory or
131
run into the root. If there isn't one, raises NotBranchError.
132
If there is one and it is either an unrecognised format or an unsupported
133
format, UnknownFormatError or UnsupportedFormatError are raised.
134
If there is one, it is returned, along with the unused portion of url.
136
control, relpath = bzrdir.BzrDir.open_containing(url)
137
return control.open_branch(), relpath
140
@deprecated_function(zero_eight)
141
def initialize(base):
142
"""Create a new working tree and branch, rooted at 'base' (url)
144
NOTE: This will soon be deprecated in favour of creation
147
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
149
@deprecated_function(zero_eight)
150
def setup_caching(self, cache_root):
151
"""Subclasses that care about caching should override this, and set
152
up cached stores located under cache_root.
154
NOTE: This is unused.
158
def get_config(self):
159
return BranchConfig(self)
162
return self.get_config().get_nickname()
164
def _set_nick(self, nick):
165
self.get_config().set_user_option('nickname', nick)
167
nick = property(_get_nick, _set_nick)
170
raise NotImplementedError(self.is_locked)
172
def lock_write(self):
173
raise NotImplementedError(self.lock_write)
176
raise NotImplementedError(self.lock_read)
179
raise NotImplementedError(self.unlock)
181
def peek_lock_mode(self):
182
"""Return lock mode for the Branch: 'r', 'w' or None"""
183
raise NotImplementedError(self.peek_lock_mode)
185
def get_physical_lock_status(self):
186
raise NotImplementedError(self.get_physical_lock_status)
188
def abspath(self, name):
189
"""Return absolute filename for something in the branch
191
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
method and not a tree method.
194
raise NotImplementedError(self.abspath)
196
def bind(self, other):
197
"""Bind the local branch the other branch.
199
:param other: The branch to bind to
202
raise errors.UpgradeRequired(self.base)
205
def fetch(self, from_branch, last_revision=None, pb=None):
206
"""Copy revisions from from_branch into this branch.
208
:param from_branch: Where to copy from.
209
:param last_revision: What revision to stop at (None for at the end
211
:param pb: An optional progress bar to use.
213
Returns the copied revision count and the failed revisions in a tuple:
216
if self.base == from_branch.base:
219
nested_pb = ui.ui_factory.nested_progress_bar()
224
from_branch.lock_read()
226
if last_revision is None:
227
pb.update('get source history')
228
from_history = from_branch.revision_history()
230
last_revision = from_history[-1]
232
# no history in the source branch
233
last_revision = _mod_revision.NULL_REVISION
234
return self.repository.fetch(from_branch.repository,
235
revision_id=last_revision,
238
if nested_pb is not None:
242
def get_bound_location(self):
243
"""Return the URL of the branch we are bound to.
245
Older format branches cannot bind, please be sure to use a metadir
250
def get_commit_builder(self, parents, config=None, timestamp=None,
251
timezone=None, committer=None, revprops=None,
253
"""Obtain a CommitBuilder for this branch.
255
:param parents: Revision ids of the parents of the new revision.
256
:param config: Optional configuration to use.
257
:param timestamp: Optional timestamp recorded for commit.
258
:param timezone: Optional timezone for timestamp.
259
:param committer: Optional committer to set for commit.
260
:param revprops: Optional dictionary of revision properties.
261
:param revision_id: Optional revision id.
265
config = self.get_config()
267
return self.repository.get_commit_builder(self, parents, config,
268
timestamp, timezone, committer, revprops, revision_id)
270
def get_master_branch(self):
271
"""Return the branch we are bound to.
273
:return: Either a Branch, or None
277
def get_revision_delta(self, revno):
278
"""Return the delta for one revision.
280
The delta is relative to its mainline predecessor, or the
281
empty tree for revision 1.
283
assert isinstance(revno, int)
284
rh = self.revision_history()
285
if not (1 <= revno <= len(rh)):
286
raise InvalidRevisionNumber(revno)
287
return self.repository.get_revision_delta(rh[revno-1])
289
def get_root_id(self):
290
"""Return the id of this branches root"""
291
raise NotImplementedError(self.get_root_id)
293
def print_file(self, file, revision_id):
294
"""Print `file` to stdout."""
295
raise NotImplementedError(self.print_file)
297
def append_revision(self, *revision_ids):
298
raise NotImplementedError(self.append_revision)
300
def set_revision_history(self, rev_history):
301
raise NotImplementedError(self.set_revision_history)
303
def revision_history(self):
304
"""Return sequence of revision hashes on to this branch."""
305
raise NotImplementedError(self.revision_history)
308
"""Return current revision number for this branch.
310
That is equivalent to the number of revisions committed to
313
return len(self.revision_history())
316
"""Older format branches cannot bind or unbind."""
317
raise errors.UpgradeRequired(self.base)
319
def last_revision(self):
320
"""Return last revision id, or None"""
321
ph = self.revision_history()
327
def missing_revisions(self, other, stop_revision=None):
328
"""Return a list of new revisions that would perfectly fit.
330
If self and other have not diverged, return a list of the revisions
331
present in other, but missing from self.
333
self_history = self.revision_history()
334
self_len = len(self_history)
335
other_history = other.revision_history()
336
other_len = len(other_history)
337
common_index = min(self_len, other_len) -1
338
if common_index >= 0 and \
339
self_history[common_index] != other_history[common_index]:
340
raise DivergedBranches(self, other)
342
if stop_revision is None:
343
stop_revision = other_len
345
assert isinstance(stop_revision, int)
346
if stop_revision > other_len:
347
raise errors.NoSuchRevision(self, stop_revision)
348
return other_history[self_len:stop_revision]
350
def update_revisions(self, other, stop_revision=None):
351
"""Pull in new perfect-fit revisions.
353
:param other: Another Branch to pull from
354
:param stop_revision: Updated until the given revision
357
raise NotImplementedError(self.update_revisions)
359
def revision_id_to_revno(self, revision_id):
360
"""Given a revision id, return its revno"""
361
if revision_id is None:
363
revision_id = osutils.safe_revision_id(revision_id)
364
history = self.revision_history()
366
return history.index(revision_id) + 1
368
raise bzrlib.errors.NoSuchRevision(self, revision_id)
370
def get_rev_id(self, revno, history=None):
371
"""Find the revision id of the specified revno."""
375
history = self.revision_history()
376
if revno <= 0 or revno > len(history):
377
raise bzrlib.errors.NoSuchRevision(self, revno)
378
return history[revno - 1]
380
def pull(self, source, overwrite=False, stop_revision=None):
381
raise NotImplementedError(self.pull)
383
def basis_tree(self):
384
"""Return `Tree` object for last revision."""
385
return self.repository.revision_tree(self.last_revision())
387
def rename_one(self, from_rel, to_rel):
390
This can change the directory or the filename or both.
392
raise NotImplementedError(self.rename_one)
394
def move(self, from_paths, to_name):
397
to_name must exist as a versioned directory.
399
If to_name exists and is a directory, the files are moved into
400
it, keeping their old names. If it is a directory,
402
Note that to_name is only the last component of the new name;
403
this doesn't change the directory.
405
This returns a list of (from_path, to_path) pairs for each
408
raise NotImplementedError(self.move)
410
def get_parent(self):
411
"""Return the parent location of the branch.
413
This is the default location for push/pull/missing. The usual
414
pattern is that the user can override it by specifying a
417
raise NotImplementedError(self.get_parent)
419
def get_submit_branch(self):
420
"""Return the submit location of the branch.
422
This is the default location for bundle. The usual
423
pattern is that the user can override it by specifying a
426
return self.get_config().get_user_option('submit_branch')
428
def set_submit_branch(self, location):
429
"""Return the submit location of the branch.
431
This is the default location for bundle. The usual
432
pattern is that the user can override it by specifying a
435
self.get_config().set_user_option('submit_branch', location)
437
def get_push_location(self):
438
"""Return the None or the location to push this branch to."""
439
raise NotImplementedError(self.get_push_location)
441
def set_push_location(self, location):
442
"""Set a new push location for this branch."""
443
raise NotImplementedError(self.set_push_location)
445
def set_parent(self, url):
446
raise NotImplementedError(self.set_parent)
450
"""Synchronise this branch with the master branch if any.
452
:return: None or the last_revision pivoted out during the update.
456
def check_revno(self, revno):
458
Check whether a revno corresponds to any revision.
459
Zero (the NULL revision) is considered valid.
462
self.check_real_revno(revno)
464
def check_real_revno(self, revno):
466
Check whether a revno corresponds to a real revision.
467
Zero (the NULL revision) is considered invalid
469
if revno < 1 or revno > self.revno():
470
raise InvalidRevisionNumber(revno)
473
def clone(self, *args, **kwargs):
474
"""Clone this branch into to_bzrdir preserving all semantic values.
476
revision_id: if not None, the revision history in the new branch will
477
be truncated to end with revision_id.
479
# for API compatibility, until 0.8 releases we provide the old api:
480
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
481
# after 0.8 releases, the *args and **kwargs should be changed:
482
# def clone(self, to_bzrdir, revision_id=None):
483
if (kwargs.get('to_location', None) or
484
kwargs.get('revision', None) or
485
kwargs.get('basis_branch', None) or
486
(len(args) and isinstance(args[0], basestring))):
487
# backwards compatibility api:
488
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
489
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
492
basis_branch = args[2]
494
basis_branch = kwargs.get('basis_branch', None)
496
basis = basis_branch.bzrdir
501
revision_id = args[1]
503
revision_id = kwargs.get('revision', None)
508
# no default to raise if not provided.
509
url = kwargs.get('to_location')
510
return self.bzrdir.clone(url,
511
revision_id=revision_id,
512
basis=basis).open_branch()
514
# generate args by hand
516
revision_id = args[1]
518
revision_id = kwargs.get('revision_id', None)
522
# no default to raise if not provided.
523
to_bzrdir = kwargs.get('to_bzrdir')
524
result = self._format.initialize(to_bzrdir)
525
self.copy_content_into(result, revision_id=revision_id)
529
def sprout(self, to_bzrdir, revision_id=None):
530
"""Create a new line of development from the branch, into to_bzrdir.
532
revision_id: if not None, the revision history in the new branch will
533
be truncated to end with revision_id.
535
result = self._format.initialize(to_bzrdir)
536
self.copy_content_into(result, revision_id=revision_id)
537
result.set_parent(self.bzrdir.root_transport.base)
541
def copy_content_into(self, destination, revision_id=None):
542
"""Copy the content of self into destination.
544
revision_id: if not None, the revision history in the new branch will
545
be truncated to end with revision_id.
547
new_history = self.revision_history()
548
if revision_id is not None:
549
revision_id = osutils.safe_revision_id(revision_id)
551
new_history = new_history[:new_history.index(revision_id) + 1]
553
rev = self.repository.get_revision(revision_id)
554
new_history = rev.get_history(self.repository)[1:]
555
destination.set_revision_history(new_history)
557
parent = self.get_parent()
558
except errors.InaccessibleParent, e:
559
mutter('parent was not accessible to copy: %s', e)
562
destination.set_parent(parent)
566
"""Check consistency of the branch.
568
In particular this checks that revisions given in the revision-history
569
do actually match up in the revision graph, and that they're all
570
present in the repository.
572
Callers will typically also want to check the repository.
574
:return: A BranchCheckResult.
576
mainline_parent_id = None
577
for revision_id in self.revision_history():
579
revision = self.repository.get_revision(revision_id)
580
except errors.NoSuchRevision, e:
581
raise errors.BzrCheckError("mainline revision {%s} not in repository"
583
# In general the first entry on the revision history has no parents.
584
# But it's not illegal for it to have parents listed; this can happen
585
# in imports from Arch when the parents weren't reachable.
586
if mainline_parent_id is not None:
587
if mainline_parent_id not in revision.parent_ids:
588
raise errors.BzrCheckError("previous revision {%s} not listed among "
590
% (mainline_parent_id, revision_id))
591
mainline_parent_id = revision_id
592
return BranchCheckResult(self)
594
def _get_checkout_format(self):
595
"""Return the most suitable metadir for a checkout of this branch.
596
Weaves are used if this branch's repostory uses weaves.
598
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
599
from bzrlib import repository
600
format = bzrdir.BzrDirMetaFormat1()
601
format.repository_format = repository.RepositoryFormat7()
603
format = self.repository.bzrdir.cloning_metadir()
606
def create_checkout(self, to_location, revision_id=None,
608
"""Create a checkout of a branch.
610
:param to_location: The url to produce the checkout at
611
:param revision_id: The revision to check out
612
:param lightweight: If True, produce a lightweight checkout, otherwise,
613
produce a bound branch (heavyweight checkout)
614
:return: The tree of the created checkout
616
t = transport.get_transport(to_location)
619
except errors.FileExists:
622
checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
623
BranchReferenceFormat().initialize(checkout, self)
625
format = self._get_checkout_format()
626
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
627
to_location, force_new_tree=False, format=format)
628
checkout = checkout_branch.bzrdir
629
checkout_branch.bind(self)
630
# pull up to the specified revision_id to set the initial
631
# branch tip correctly, and seed it with history.
632
checkout_branch.pull(self, stop_revision=revision_id)
633
return checkout.create_workingtree(revision_id)
636
class BranchFormat(object):
637
"""An encapsulation of the initialization and open routines for a format.
639
Formats provide three things:
640
* An initialization routine,
644
Formats are placed in an dict by their format string for reference
645
during branch opening. Its not required that these be instances, they
646
can be classes themselves with class methods - it simply depends on
647
whether state is needed for a given format or not.
649
Once a format is deprecated, just deprecate the initialize and open
650
methods on the format class. Do not deprecate the object, as the
651
object will be created every time regardless.
654
_default_format = None
655
"""The default format used for new branches."""
658
"""The known formats."""
661
def find_format(klass, a_bzrdir):
662
"""Return the format for the branch object in a_bzrdir."""
664
transport = a_bzrdir.get_branch_transport(None)
665
format_string = transport.get("format").read()
666
return klass._formats[format_string]
668
raise NotBranchError(path=transport.base)
670
raise errors.UnknownFormatError(format=format_string)
673
def get_default_format(klass):
674
"""Return the current default format."""
675
return klass._default_format
677
def get_format_string(self):
678
"""Return the ASCII format string that identifies this format."""
679
raise NotImplementedError(self.get_format_string)
681
def get_format_description(self):
682
"""Return the short format description for this format."""
683
raise NotImplementedError(self.get_format_string)
685
def initialize(self, a_bzrdir):
686
"""Create a branch of this format in a_bzrdir."""
687
raise NotImplementedError(self.initialize)
689
def is_supported(self):
690
"""Is this format supported?
692
Supported formats can be initialized and opened.
693
Unsupported formats may not support initialization or committing or
694
some other features depending on the reason for not being supported.
698
def open(self, a_bzrdir, _found=False):
699
"""Return the branch object for a_bzrdir
701
_found is a private parameter, do not use it. It is used to indicate
702
if format probing has already be done.
704
raise NotImplementedError(self.open)
707
def register_format(klass, format):
708
klass._formats[format.get_format_string()] = format
711
def set_default_format(klass, format):
712
klass._default_format = format
715
def unregister_format(klass, format):
716
assert klass._formats[format.get_format_string()] is format
717
del klass._formats[format.get_format_string()]
720
return self.get_format_string().rstrip()
723
class BranchHooks(dict):
724
"""A dictionary mapping hook name to a list of callables for branch hooks.
726
e.g. ['set_rh'] Is the list of items to be called when the
727
set_revision_history function is invoked.
731
"""Create the default hooks.
733
These are all empty initially, because by default nothing should get
737
# invoked whenever the revision history has been set
738
# with set_revision_history. The api signature is
739
# (branch, revision_history), and the branch will
740
# be write-locked. Introduced in 0.15.
743
def install_hook(self, hook_name, a_callable):
744
"""Install a_callable in to the hook hook_name.
746
:param hook_name: A hook name. See the __init__ method of BranchHooks
747
for the complete list of hooks.
748
:param a_callable: The callable to be invoked when the hook triggers.
749
The exact signature will depend on the hook - see the __init__
750
method of BranchHooks for details on each hook.
753
self[hook_name].append(a_callable)
755
raise errors.UnknownHook('branch', hook_name)
758
# install the default hooks into the Branch class.
759
Branch.hooks = BranchHooks()
762
class BzrBranchFormat4(BranchFormat):
763
"""Bzr branch format 4.
766
- a revision-history file.
767
- a branch-lock lock file [ to be shared with the bzrdir ]
770
def get_format_description(self):
771
"""See BranchFormat.get_format_description()."""
772
return "Branch format 4"
774
def initialize(self, a_bzrdir):
775
"""Create a branch of this format in a_bzrdir."""
776
mutter('creating branch in %s', a_bzrdir.transport.base)
777
branch_transport = a_bzrdir.get_branch_transport(self)
778
utf8_files = [('revision-history', ''),
781
control_files = lockable_files.LockableFiles(branch_transport,
782
'branch-lock', lockable_files.TransportLock)
783
control_files.create_lock()
784
control_files.lock_write()
786
for file, content in utf8_files:
787
control_files.put_utf8(file, content)
789
control_files.unlock()
790
return self.open(a_bzrdir, _found=True)
793
super(BzrBranchFormat4, self).__init__()
794
self._matchingbzrdir = bzrdir.BzrDirFormat6()
796
def open(self, a_bzrdir, _found=False):
797
"""Return the branch object for a_bzrdir
799
_found is a private parameter, do not use it. It is used to indicate
800
if format probing has already be done.
803
# we are being called directly and must probe.
804
raise NotImplementedError
805
return BzrBranch(_format=self,
806
_control_files=a_bzrdir._control_files,
808
_repository=a_bzrdir.open_repository())
811
return "Bazaar-NG branch format 4"
814
class BzrBranchFormat5(BranchFormat):
815
"""Bzr branch format 5.
818
- a revision-history file.
820
- a lock dir guarding the branch itself
821
- all of this stored in a branch/ subdirectory
822
- works with shared repositories.
824
This format is new in bzr 0.8.
827
def get_format_string(self):
828
"""See BranchFormat.get_format_string()."""
829
return "Bazaar-NG branch format 5\n"
831
def get_format_description(self):
832
"""See BranchFormat.get_format_description()."""
833
return "Branch format 5"
835
def initialize(self, a_bzrdir):
836
"""Create a branch of this format in a_bzrdir."""
837
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
838
branch_transport = a_bzrdir.get_branch_transport(self)
839
utf8_files = [('revision-history', ''),
842
control_files = lockable_files.LockableFiles(branch_transport, 'lock',
844
control_files.create_lock()
845
control_files.lock_write()
846
control_files.put_utf8('format', self.get_format_string())
848
for file, content in utf8_files:
849
control_files.put_utf8(file, content)
851
control_files.unlock()
852
return self.open(a_bzrdir, _found=True, )
855
super(BzrBranchFormat5, self).__init__()
856
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
858
def open(self, a_bzrdir, _found=False):
859
"""Return the branch object for a_bzrdir
861
_found is a private parameter, do not use it. It is used to indicate
862
if format probing has already be done.
865
format = BranchFormat.find_format(a_bzrdir)
866
assert format.__class__ == self.__class__
867
transport = a_bzrdir.get_branch_transport(None)
868
control_files = lockable_files.LockableFiles(transport, 'lock',
870
return BzrBranch5(_format=self,
871
_control_files=control_files,
873
_repository=a_bzrdir.find_repository())
876
return "Bazaar-NG Metadir branch format 5"
879
class BranchReferenceFormat(BranchFormat):
880
"""Bzr branch reference format.
882
Branch references are used in implementing checkouts, they
883
act as an alias to the real branch which is at some other url.
890
def get_format_string(self):
891
"""See BranchFormat.get_format_string()."""
892
return "Bazaar-NG Branch Reference Format 1\n"
894
def get_format_description(self):
895
"""See BranchFormat.get_format_description()."""
896
return "Checkout reference format 1"
898
def initialize(self, a_bzrdir, target_branch=None):
899
"""Create a branch of this format in a_bzrdir."""
900
if target_branch is None:
901
# this format does not implement branch itself, thus the implicit
902
# creation contract must see it as uninitializable
903
raise errors.UninitializableFormat(self)
904
mutter('creating branch reference in %s', a_bzrdir.transport.base)
905
branch_transport = a_bzrdir.get_branch_transport(self)
906
branch_transport.put_bytes('location',
907
target_branch.bzrdir.root_transport.base)
908
branch_transport.put_bytes('format', self.get_format_string())
909
return self.open(a_bzrdir, _found=True)
912
super(BranchReferenceFormat, self).__init__()
913
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
915
def _make_reference_clone_function(format, a_branch):
916
"""Create a clone() routine for a branch dynamically."""
917
def clone(to_bzrdir, revision_id=None):
918
"""See Branch.clone()."""
919
return format.initialize(to_bzrdir, a_branch)
920
# cannot obey revision_id limits when cloning a reference ...
921
# FIXME RBC 20060210 either nuke revision_id for clone, or
922
# emit some sort of warning/error to the caller ?!
925
def open(self, a_bzrdir, _found=False):
926
"""Return the branch that the branch reference in a_bzrdir points at.
928
_found is a private parameter, do not use it. It is used to indicate
929
if format probing has already be done.
932
format = BranchFormat.find_format(a_bzrdir)
933
assert format.__class__ == self.__class__
934
transport = a_bzrdir.get_branch_transport(None)
935
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
936
result = real_bzrdir.open_branch()
937
# this changes the behaviour of result.clone to create a new reference
938
# rather than a copy of the content of the branch.
939
# I did not use a proxy object because that needs much more extensive
940
# testing, and we are only changing one behaviour at the moment.
941
# If we decide to alter more behaviours - i.e. the implicit nickname
942
# then this should be refactored to introduce a tested proxy branch
943
# and a subclass of that for use in overriding clone() and ....
945
result.clone = self._make_reference_clone_function(result)
949
# formats which have no format string are not discoverable
950
# and not independently creatable, so are not registered.
951
__default_format = BzrBranchFormat5()
952
BranchFormat.register_format(__default_format)
953
BranchFormat.register_format(BranchReferenceFormat())
954
BranchFormat.set_default_format(__default_format)
955
_legacy_formats = [BzrBranchFormat4(),
958
class BzrBranch(Branch):
959
"""A branch stored in the actual filesystem.
961
Note that it's "local" in the context of the filesystem; it doesn't
962
really matter if it's on an nfs/smb/afs/coda/... share, as long as
963
it's writable, and can be accessed via the normal filesystem API.
966
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
967
relax_version_check=DEPRECATED_PARAMETER, _format=None,
968
_control_files=None, a_bzrdir=None, _repository=None):
969
"""Create new branch object at a particular location.
971
transport -- A Transport object, defining how to access files.
973
init -- If True, create new control files in a previously
974
unversioned directory. If False, the branch must already
977
relax_version_check -- If true, the usual check for the branch
978
version is not applied. This is intended only for
979
upgrade/recovery type use; it's not guaranteed that
980
all operations will work on old format branches.
983
self.bzrdir = bzrdir.BzrDir.open(transport.base)
985
self.bzrdir = a_bzrdir
986
self._transport = self.bzrdir.transport.clone('..')
987
self._base = self._transport.base
988
self._format = _format
989
if _control_files is None:
990
raise ValueError('BzrBranch _control_files is None')
991
self.control_files = _control_files
992
if deprecated_passed(init):
993
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
994
"deprecated as of bzr 0.8. Please use Branch.create().",
998
# this is slower than before deprecation, oh well never mind.
1000
self._initialize(transport.base)
1001
self._check_format(_format)
1002
if deprecated_passed(relax_version_check):
1003
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1004
"relax_version_check parameter is deprecated as of bzr 0.8. "
1005
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1009
if (not relax_version_check
1010
and not self._format.is_supported()):
1011
raise errors.UnsupportedFormatError(format=fmt)
1012
if deprecated_passed(transport):
1013
warn("BzrBranch.__init__(transport=XXX...): The transport "
1014
"parameter is deprecated as of bzr 0.8. "
1015
"Please use Branch.open, or bzrdir.open_branch().",
1018
self.repository = _repository
1021
return '%s(%r)' % (self.__class__.__name__, self.base)
1025
def _get_base(self):
1028
base = property(_get_base, doc="The URL for the root of this branch.")
1030
def _finish_transaction(self):
1031
"""Exit the current transaction."""
1032
return self.control_files._finish_transaction()
1034
def get_transaction(self):
1035
"""Return the current active transaction.
1037
If no transaction is active, this returns a passthrough object
1038
for which all data is immediately flushed and no caching happens.
1040
# this is an explicit function so that we can do tricky stuff
1041
# when the storage in rev_storage is elsewhere.
1042
# we probably need to hook the two 'lock a location' and
1043
# 'have a transaction' together more delicately, so that
1044
# we can have two locks (branch and storage) and one transaction
1045
# ... and finishing the transaction unlocks both, but unlocking
1046
# does not. - RBC 20051121
1047
return self.control_files.get_transaction()
1049
def _set_transaction(self, transaction):
1050
"""Set a new active transaction."""
1051
return self.control_files._set_transaction(transaction)
1053
def abspath(self, name):
1054
"""See Branch.abspath."""
1055
return self.control_files._transport.abspath(name)
1057
def _check_format(self, format):
1058
"""Identify the branch format if needed.
1060
The format is stored as a reference to the format object in
1061
self._format for code that needs to check it later.
1063
The format parameter is either None or the branch format class
1064
used to open this branch.
1066
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1069
format = BranchFormat.find_format(self.bzrdir)
1070
self._format = format
1071
mutter("got branch format %s", self._format)
1074
def get_root_id(self):
1075
"""See Branch.get_root_id."""
1076
tree = self.repository.revision_tree(self.last_revision())
1077
return tree.inventory.root.file_id
1079
def is_locked(self):
1080
return self.control_files.is_locked()
1082
def lock_write(self):
1083
self.repository.lock_write()
1085
self.control_files.lock_write()
1087
self.repository.unlock()
1090
def lock_read(self):
1091
self.repository.lock_read()
1093
self.control_files.lock_read()
1095
self.repository.unlock()
1099
# TODO: test for failed two phase locks. This is known broken.
1101
self.control_files.unlock()
1103
self.repository.unlock()
1105
def peek_lock_mode(self):
1106
if self.control_files._lock_count == 0:
1109
return self.control_files._lock_mode
1111
def get_physical_lock_status(self):
1112
return self.control_files.get_physical_lock_status()
1115
def print_file(self, file, revision_id):
1116
"""See Branch.print_file."""
1117
return self.repository.print_file(file, revision_id)
1120
def append_revision(self, *revision_ids):
1121
"""See Branch.append_revision."""
1122
for revision_id in revision_ids:
1123
_mod_revision.check_not_reserved_id(revision_id)
1124
mutter("add {%s} to revision-history" % revision_id)
1125
rev_history = self.revision_history()
1126
rev_history.extend(revision_ids)
1127
self.set_revision_history(rev_history)
1130
def set_revision_history(self, rev_history):
1131
"""See Branch.set_revision_history."""
1132
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1133
self.control_files.put_bytes(
1134
'revision-history', '\n'.join(rev_history))
1135
transaction = self.get_transaction()
1136
history = transaction.map.find_revision_history()
1137
if history is not None:
1138
# update the revision history in the identity map.
1139
history[:] = list(rev_history)
1140
# this call is disabled because revision_history is
1141
# not really an object yet, and the transaction is for objects.
1142
# transaction.register_dirty(history)
1144
transaction.map.add_revision_history(rev_history)
1145
# this call is disabled because revision_history is
1146
# not really an object yet, and the transaction is for objects.
1147
# transaction.register_clean(history)
1148
for hook in Branch.hooks['set_rh']:
1149
hook(self, rev_history)
1152
def revision_history(self):
1153
"""See Branch.revision_history."""
1154
transaction = self.get_transaction()
1155
history = transaction.map.find_revision_history()
1156
if history is not None:
1157
# mutter("cache hit for revision-history in %s", self)
1158
return list(history)
1159
get_cached_utf8 = cache_utf8.get_cached_utf8
1160
history = [get_cached_utf8(l.rstrip('\r\n')) for l in
1161
self.control_files.get('revision-history').readlines()]
1162
transaction.map.add_revision_history(history)
1163
# this call is disabled because revision_history is
1164
# not really an object yet, and the transaction is for objects.
1165
# transaction.register_clean(history, precious=True)
1166
return list(history)
1169
def generate_revision_history(self, revision_id, last_rev=None,
1171
"""Create a new revision history that will finish with revision_id.
1173
:param revision_id: the new tip to use.
1174
:param last_rev: The previous last_revision. If not None, then this
1175
must be a ancestory of revision_id, or DivergedBranches is raised.
1176
:param other_branch: The other branch that DivergedBranches should
1177
raise with respect to.
1179
revision_id = osutils.safe_revision_id(revision_id)
1180
# stop_revision must be a descendant of last_revision
1181
stop_graph = self.repository.get_revision_graph(revision_id)
1182
if last_rev is not None and last_rev not in stop_graph:
1183
# our previous tip is not merged into stop_revision
1184
raise errors.DivergedBranches(self, other_branch)
1185
# make a new revision history from the graph
1186
current_rev_id = revision_id
1188
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1189
new_history.append(current_rev_id)
1190
current_rev_id_parents = stop_graph[current_rev_id]
1192
current_rev_id = current_rev_id_parents[0]
1194
current_rev_id = None
1195
new_history.reverse()
1196
self.set_revision_history(new_history)
1199
def update_revisions(self, other, stop_revision=None):
1200
"""See Branch.update_revisions."""
1203
if stop_revision is None:
1204
stop_revision = other.last_revision()
1205
if stop_revision is None:
1206
# if there are no commits, we're done.
1209
stop_revision = osutils.safe_revision_id(stop_revision)
1210
# whats the current last revision, before we fetch [and change it
1212
last_rev = self.last_revision()
1213
# we fetch here regardless of whether we need to so that we pickup
1215
self.fetch(other, stop_revision)
1216
my_ancestry = self.repository.get_ancestry(last_rev)
1217
if stop_revision in my_ancestry:
1218
# last_revision is a descendant of stop_revision
1220
self.generate_revision_history(stop_revision, last_rev=last_rev,
1225
def basis_tree(self):
1226
"""See Branch.basis_tree."""
1227
return self.repository.revision_tree(self.last_revision())
1229
@deprecated_method(zero_eight)
1230
def working_tree(self):
1231
"""Create a Working tree object for this branch."""
1233
from bzrlib.transport.local import LocalTransport
1234
if (self.base.find('://') != -1 or
1235
not isinstance(self._transport, LocalTransport)):
1236
raise NoWorkingTree(self.base)
1237
return self.bzrdir.open_workingtree()
1240
def pull(self, source, overwrite=False, stop_revision=None):
1241
"""See Branch.pull."""
1244
old_count = len(self.revision_history())
1246
self.update_revisions(source, stop_revision)
1247
except DivergedBranches:
1251
self.set_revision_history(source.revision_history())
1252
new_count = len(self.revision_history())
1253
return new_count - old_count
1257
def get_parent(self):
1258
"""See Branch.get_parent."""
1260
_locs = ['parent', 'pull', 'x-pull']
1261
assert self.base[-1] == '/'
1264
parent = self.control_files.get(l).read().strip('\n')
1267
# This is an old-format absolute path to a local branch
1268
# turn it into a url
1269
if parent.startswith('/'):
1270
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1272
return urlutils.join(self.base[:-1], parent)
1273
except errors.InvalidURLJoin, e:
1274
raise errors.InaccessibleParent(parent, self.base)
1277
def get_push_location(self):
1278
"""See Branch.get_push_location."""
1279
push_loc = self.get_config().get_user_option('push_location')
1282
def set_push_location(self, location):
1283
"""See Branch.set_push_location."""
1284
self.get_config().set_user_option(
1285
'push_location', location,
1286
store=_mod_config.STORE_LOCATION_NORECURSE)
1289
def set_parent(self, url):
1290
"""See Branch.set_parent."""
1291
# TODO: Maybe delete old location files?
1292
# URLs should never be unicode, even on the local fs,
1293
# FIXUP this and get_parent in a future branch format bump:
1294
# read and rewrite the file, and have the new format code read
1295
# using .get not .get_utf8. RBC 20060125
1297
self.control_files._transport.delete('parent')
1299
if isinstance(url, unicode):
1301
url = url.encode('ascii')
1302
except UnicodeEncodeError:
1303
raise bzrlib.errors.InvalidURL(url,
1304
"Urls must be 7-bit ascii, "
1305
"use bzrlib.urlutils.escape")
1307
url = urlutils.relative_url(self.base, url)
1308
self.control_files.put_bytes('parent', url + '\n')
1310
@deprecated_function(zero_nine)
1311
def tree_config(self):
1312
"""DEPRECATED; call get_config instead.
1313
TreeConfig has become part of BranchConfig."""
1314
return TreeConfig(self)
1317
class BzrBranch5(BzrBranch):
1318
"""A format 5 branch. This supports new features over plan branches.
1320
It has support for a master_branch which is the data for bound branches.
1328
super(BzrBranch5, self).__init__(_format=_format,
1329
_control_files=_control_files,
1331
_repository=_repository)
1334
def pull(self, source, overwrite=False, stop_revision=None):
1335
"""Updates branch.pull to be bound branch aware."""
1336
bound_location = self.get_bound_location()
1337
if source.base != bound_location:
1338
# not pulling from master, so we need to update master.
1339
master_branch = self.get_master_branch()
1341
master_branch.pull(source)
1342
source = master_branch
1343
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1345
def get_bound_location(self):
1347
return self.control_files.get_utf8('bound').read()[:-1]
1348
except errors.NoSuchFile:
1352
def get_master_branch(self):
1353
"""Return the branch we are bound to.
1355
:return: Either a Branch, or None
1357
This could memoise the branch, but if thats done
1358
it must be revalidated on each new lock.
1359
So for now we just don't memoise it.
1360
# RBC 20060304 review this decision.
1362
bound_loc = self.get_bound_location()
1366
return Branch.open(bound_loc)
1367
except (errors.NotBranchError, errors.ConnectionError), e:
1368
raise errors.BoundBranchConnectionFailure(
1372
def set_bound_location(self, location):
1373
"""Set the target where this branch is bound to.
1375
:param location: URL to the target branch
1378
self.control_files.put_utf8('bound', location+'\n')
1381
self.control_files._transport.delete('bound')
1387
def bind(self, other):
1388
"""Bind this branch to the branch other.
1390
This does not push or pull data between the branches, though it does
1391
check for divergence to raise an error when the branches are not
1392
either the same, or one a prefix of the other. That behaviour may not
1393
be useful, so that check may be removed in future.
1395
:param other: The branch to bind to
1398
# TODO: jam 20051230 Consider checking if the target is bound
1399
# It is debatable whether you should be able to bind to
1400
# a branch which is itself bound.
1401
# Committing is obviously forbidden,
1402
# but binding itself may not be.
1403
# Since we *have* to check at commit time, we don't
1404
# *need* to check here
1406
# we want to raise diverged if:
1407
# last_rev is not in the other_last_rev history, AND
1408
# other_last_rev is not in our history, and do it without pulling
1410
last_rev = self.last_revision()
1411
if last_rev is not None:
1414
other_last_rev = other.last_revision()
1415
if other_last_rev is not None:
1416
# neither branch is new, we have to do some work to
1417
# ascertain diversion.
1418
remote_graph = other.repository.get_revision_graph(
1420
local_graph = self.repository.get_revision_graph(last_rev)
1421
if (last_rev not in remote_graph and
1422
other_last_rev not in local_graph):
1423
raise errors.DivergedBranches(self, other)
1426
self.set_bound_location(other.base)
1430
"""If bound, unbind"""
1431
return self.set_bound_location(None)
1435
"""Synchronise this branch with the master branch if any.
1437
:return: None or the last_revision that was pivoted out during the
1440
master = self.get_master_branch()
1441
if master is not None:
1442
old_tip = self.last_revision()
1443
self.pull(master, overwrite=True)
1444
if old_tip in self.repository.get_ancestry(self.last_revision()):
1450
class BranchTestProviderAdapter(object):
1451
"""A tool to generate a suite testing multiple branch formats at once.
1453
This is done by copying the test once for each transport and injecting
1454
the transport_server, transport_readonly_server, and branch_format
1455
classes into each copy. Each copy is also given a new id() to make it
1459
def __init__(self, transport_server, transport_readonly_server, formats):
1460
self._transport_server = transport_server
1461
self._transport_readonly_server = transport_readonly_server
1462
self._formats = formats
1464
def adapt(self, test):
1465
result = TestSuite()
1466
for branch_format, bzrdir_format in self._formats:
1467
new_test = deepcopy(test)
1468
new_test.transport_server = self._transport_server
1469
new_test.transport_readonly_server = self._transport_readonly_server
1470
new_test.bzrdir_format = bzrdir_format
1471
new_test.branch_format = branch_format
1472
def make_new_test_id():
1473
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1474
return lambda: new_id
1475
new_test.id = make_new_test_id()
1476
result.addTest(new_test)
1480
class BranchCheckResult(object):
1481
"""Results of checking branch consistency.
1486
def __init__(self, branch):
1487
self.branch = branch
1489
def report_results(self, verbose):
1490
"""Report the check results via trace.note.
1492
:param verbose: Requests more detailed display of what was checked,
1495
note('checked branch %s format %s',
1497
self.branch._format)
1500
######################################################################
1504
@deprecated_function(zero_eight)
1505
def is_control_file(*args, **kwargs):
1506
"""See bzrlib.workingtree.is_control_file."""
1507
from bzrlib import workingtree
1508
return workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
