diff options
Diffstat (limited to 'bzrlib/plugins/weave_fmt/branch.py')
| -rw-r--r-- | bzrlib/plugins/weave_fmt/branch.py | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/bzrlib/plugins/weave_fmt/branch.py b/bzrlib/plugins/weave_fmt/branch.py new file mode 100644 index 0000000..f9852c2 --- /dev/null +++ b/bzrlib/plugins/weave_fmt/branch.py @@ -0,0 +1,219 @@ +# Copyright (C) 2010 Canonical Ltd +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +"""Weave-era branch implementations.""" + +from __future__ import absolute_import + +from bzrlib import ( + errors, + lockable_files, + ) + +from bzrlib.decorators import ( + needs_read_lock, + needs_write_lock, + only_raises, + ) +from bzrlib.lock import LogicalLockResult +from bzrlib.trace import mutter + +from bzrlib.branch import ( + BranchFormat, + BranchWriteLockResult, + ) +from bzrlib.branchfmt.fullhistory import ( + FullHistoryBzrBranch, + ) + + +class BzrBranch4(FullHistoryBzrBranch): + """Branch format 4.""" + + def lock_write(self, token=None): + """Lock the branch for write operations. + + :param token: A token to permit reacquiring a previously held and + preserved lock. + :return: A BranchWriteLockResult. + """ + if not self.is_locked(): + self._note_lock('w') + # All-in-one needs to always unlock/lock. + self.repository._warn_if_deprecated(self) + self.repository.lock_write() + try: + return BranchWriteLockResult(self.unlock, + self.control_files.lock_write(token=token)) + except: + self.repository.unlock() + raise + + def lock_read(self): + """Lock the branch for read operations. + + :return: A bzrlib.lock.LogicalLockResult. + """ + if not self.is_locked(): + self._note_lock('r') + # All-in-one needs to always unlock/lock. + self.repository._warn_if_deprecated(self) + self.repository.lock_read() + try: + self.control_files.lock_read() + return LogicalLockResult(self.unlock) + except: + self.repository.unlock() + raise + + @only_raises(errors.LockNotHeld, errors.LockBroken) + def unlock(self): + if self.control_files._lock_count == 2 and self.conf_store is not None: + self.conf_store.save_changes() + try: + self.control_files.unlock() + finally: + # All-in-one needs to always unlock/lock. + self.repository.unlock() + if not self.control_files.is_locked(): + # we just released the lock + self._clear_cached_state() + + def _get_checkout_format(self, lightweight=False): + """Return the most suitable metadir for a checkout of this branch. + """ + from bzrlib.plugins.weave_fmt.repository import RepositoryFormat7 + from bzrlib.bzrdir import BzrDirMetaFormat1 + format = BzrDirMetaFormat1() + if lightweight: + format.set_branch_format(self._format) + format.repository_format = self.bzrdir._format.repository_format + else: + format.repository_format = RepositoryFormat7() + return format + + def unbind(self): + raise errors.UpgradeRequired(self.user_url) + + def bind(self, other): + raise errors.UpgradeRequired(self.user_url) + + def set_bound_location(self, location): + raise NotImplementedError(self.set_bound_location) + + def get_bound_location(self): + return None + + def update(self): + return None + + def get_master_branch(self, possible_transports=None): + return None + + +class BzrBranchFormat4(BranchFormat): + """Bzr branch format 4. + + This format has: + - a revision-history file. + - a branch-lock lock file [ to be shared with the bzrdir ] + + It does not support binding. + """ + + def initialize(self, a_bzrdir, name=None, repository=None, + append_revisions_only=None): + """Create a branch of this format in a_bzrdir. + + :param a_bzrdir: The bzrdir to initialize the branch in + :param name: Name of colocated branch to create, if any + :param repository: Repository for this branch (unused) + """ + if append_revisions_only: + raise errors.UpgradeRequired(a_bzrdir.user_url) + if repository is not None: + raise NotImplementedError( + "initialize(repository=<not None>) on %r" % (self,)) + if not [isinstance(a_bzrdir._format, format) for format in + self._compatible_bzrdirs]: + raise errors.IncompatibleFormat(self, a_bzrdir._format) + utf8_files = [('revision-history', ''), + ('branch-name', ''), + ] + mutter('creating branch %r in %s', self, a_bzrdir.user_url) + branch_transport = a_bzrdir.get_branch_transport(self, name=name) + control_files = lockable_files.LockableFiles(branch_transport, + 'branch-lock', lockable_files.TransportLock) + control_files.create_lock() + try: + control_files.lock_write() + except errors.LockContention: + lock_taken = False + else: + lock_taken = True + try: + for (filename, content) in utf8_files: + branch_transport.put_bytes( + filename, content, + mode=a_bzrdir._get_file_mode()) + finally: + if lock_taken: + control_files.unlock() + branch = self.open(a_bzrdir, name, _found=True, + found_repository=None) + self._run_post_branch_init_hooks(a_bzrdir, name, branch) + return branch + + def __init__(self): + super(BzrBranchFormat4, self).__init__() + from bzrlib.plugins.weave_fmt.bzrdir import ( + BzrDirFormat4, BzrDirFormat5, BzrDirFormat6, + ) + self._matchingbzrdir = BzrDirFormat6() + self._compatible_bzrdirs = [BzrDirFormat4, BzrDirFormat5, + BzrDirFormat6] + + def network_name(self): + """The network name for this format is the control dirs disk label.""" + return self._matchingbzrdir.get_format_string() + + def get_format_description(self): + return "Branch format 4" + + def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False, + found_repository=None, possible_transports=None): + """See BranchFormat.open().""" + if name is None: + name = a_bzrdir._get_selected_branch() + if name != "": + raise errors.NoColocatedBranchSupport(self) + if not _found: + # we are being called directly and must probe. + raise NotImplementedError + if found_repository is None: + found_repository = a_bzrdir.open_repository() + return BzrBranch4(_format=self, + _control_files=a_bzrdir._control_files, + a_bzrdir=a_bzrdir, + name=name, + _repository=found_repository, + possible_transports=possible_transports) + + def __str__(self): + return "Bazaar-NG branch format 4" + + def supports_leaving_lock(self): + return False |