~bzr-pqm/bzr/bzr.dev : contents of bzrlib/transactions.py at revision 1185.85.85

~bzr-pqm/bzr/bzr.dev : (revision 1185.85.85)

# Copyright (C) 2005 by Canonical Ltd
#   Authors: Robert Collins <robert.collins@canonical.com>
#
# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""This module provides a transactional facility.

Transactions provide hooks to allow data objects (i.e. inventory weaves or
the revision-history file) to be placed in a registry and retrieved later
during the same transaction. Transactions in bzr are not atomic - they
depend on data ordering of writes, so we do not have commit or rollback
facilities at the transaction level.

Read only transactions raise an assert when objects are listed as dirty
against them - preventing unintended writes.

Write transactions preserve dirty objects in the cache, though due to the
write ordering approach we use for consistency 'dirty' is a misleading term.
A dirty object is one we have modified.

Both read and write transactions *may* flush unchanged objects out of 
memory, unless they are marked as 'precious' which indicates that 
repeated reads cannot be obtained if the object is ejected, or that
the object is an expensive one for obtaining.
"""

import sys

import bzrlib.errors as errors
from bzrlib.identitymap import IdentityMap, NullIdentityMap
from bzrlib.trace import mutter


class ReadOnlyTransaction(object):
    """A read only unit of work for data objects."""

    def finish(self):
        """Clean up this transaction."""

    def __init__(self):
        super(ReadOnlyTransaction, self).__init__()
        self.map = IdentityMap()
        self._clean_objects = set()
        self._clean_queue = []
        self._limit = -1
        self._precious_objects = set()

    def is_clean(self, an_object):
        """Return True if an_object is clean."""
        return an_object in self._clean_objects

    def register_clean(self, an_object, precious=False):
        """Register an_object as being clean.
        
        If the precious hint is True, the object will not
        be ejected from the object identity map ever.
        """
        self._clean_objects.add(an_object)
        self._clean_queue.append(an_object)
        if precious:
            self._precious_objects.add(an_object)
        self._trim()

    def register_dirty(self, an_object):
        """Register an_object as being dirty."""
        raise errors.ReadOnlyObjectDirtiedError(an_object)

    def set_cache_size(self, size):
        """Set a new cache size."""
        assert -1 <= size
        self._limit = size
        self._trim()

    def _trim(self):
        """Trim the cache back if needed."""
        if self._limit < 0 or self._limit - len(self._clean_objects) > 0:
            return
        needed = len(self._clean_objects) - self._limit
        offset = 0
        while needed and offset < len(self._clean_objects):
            # references we know of:
            # temp passed to getrefcount in our frame
            # temp in getrefcount's frame
            # the map forward
            # the map backwards
            # _clean_objects
            # _clean_queue
            # 1 missing ?
            if (sys.getrefcount(self._clean_queue[offset]) <= 7 and
                not self._clean_queue[offset] in self._precious_objects):
                removed = self._clean_queue[offset]
                self._clean_objects.remove(removed)
                del self._clean_queue[offset]
                self.map.remove_object(removed)
                mutter('removed object %r', removed)
                needed -= 1
            else:
                offset += 1


class WriteTransaction(ReadOnlyTransaction):
    """A write transaction

    - caches domain objects
    - clean objects can be removed from the cache
    - dirty objects are retained.
    """

    def __init__(self):
        super(WriteTransaction, self).__init__()
        self._dirty_objects = set()

    def is_dirty(self, an_object):
        """Return True if an_object is dirty."""
        return an_object in self._dirty_objects

    def register_dirty(self, an_object):
        """Register an_object as being dirty.
        
        Dirty objects are not ejected from the identity map
        until the transaction finishes.
        """
        self._dirty_objects.add(an_object)
        if self.is_clean(an_object):
            self._clean_objects.remove(an_object)
            del self._clean_queue[self._clean_queue.index(an_object)]
        self._trim()

        
class PassThroughTransaction(object):
    """A pass through transaction
    
    - nothing is cached.
    - nothing ever gets into the identity map.
    """

    def finish(self):
        """Clean up this transaction."""

    def __init__(self):
        super(PassThroughTransaction, self).__init__()
        self.map = NullIdentityMap()

    def register_clean(self, an_object, precious=False):
        """Register an_object as being clean.
        
        Note that precious is only a hint, and PassThroughTransaction
        ignores it.
        """

    def register_dirty(self, an_object):
        """Register an_object as being dirty."""

    def set_cache_size(self, ignored):
        """Do nothing, we are passing through."""

1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	1	# Copyright (C) 2005 by Canonical Ltd
	2	# Authors: Robert Collins <robert.collins@canonical.com>
	3	#
	4	# This program is free software; you can redistribute it and/or modify
	5	# it under the terms of the GNU General Public License as published by
	6	# the Free Software Foundation; either version 2 of the License, or
	7	# (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	17
	18	"""This module provides a transactional facility.
	19
	20	Transactions provide hooks to allow data objects (i.e. inventory weaves or
	21	the revision-history file) to be placed in a registry and retrieved later
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	22	during the same transaction. Transactions in bzr are not atomic - they
	23	depend on data ordering of writes, so we do not have commit or rollback
	24	facilities at the transaction level.
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	25
	26	Read only transactions raise an assert when objects are listed as dirty
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	27	against them - preventing unintended writes.
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	28
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	29	Write transactions preserve dirty objects in the cache, though due to the
	30	write ordering approach we use for consistency 'dirty' is a misleading term.
	31	A dirty object is one we have modified.
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	32
	33	Both read and write transactions may flush unchanged objects out of
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	34	memory, unless they are marked as 'precious' which indicates that
	35	repeated reads cannot be obtained if the object is ejected, or that
	36	the object is an expensive one for obtaining.
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	37	"""
	38
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	39	import sys
	40
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	41	import bzrlib.errors as errors
	42	from bzrlib.identitymap import IdentityMap, NullIdentityMap
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	43	from bzrlib.trace import mutter
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	44
	45
	46	class ReadOnlyTransaction(object):
	47	"""A read only unit of work for data objects."""
	48
	49	def finish(self):
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	50	"""Clean up this transaction."""
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	51
	52	def __init__(self):
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	53	super(ReadOnlyTransaction, self).__init__()
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	54	self.map = IdentityMap()
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	55	self._clean_objects = set()
	56	self._clean_queue = []
	57	self._limit = -1
	58	self._precious_objects = set()
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	59
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	60	def is_clean(self, an_object):
	61	"""Return True if an_object is clean."""
	62	return an_object in self._clean_objects
	63
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	64	def register_clean(self, an_object, precious=False):
	65	"""Register an_object as being clean.
	66
	67	If the precious hint is True, the object will not
	68	be ejected from the object identity map ever.
	69	"""
	70	self._clean_objects.add(an_object)
	71	self._clean_queue.append(an_object)
	72	if precious:
	73	self._precious_objects.add(an_object)
	74	self._trim()
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	75
1417.1.8 by Robert Collins use transactions in the weave store interface, which enables caching for log	76	def register_dirty(self, an_object):
	77	"""Register an_object as being dirty."""
1553.5.33 by Martin Pool LockDir review comment fixes	78	raise errors.ReadOnlyObjectDirtiedError(an_object)
1417.1.8 by Robert Collins use transactions in the weave store interface, which enables caching for log	79
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	80	def set_cache_size(self, size):
	81	"""Set a new cache size."""
	82	assert -1 <= size
	83	self._limit = size
	84	self._trim()
	85
	86	def _trim(self):
	87	"""Trim the cache back if needed."""
	88	if self._limit < 0 or self._limit - len(self._clean_objects) > 0:
	89	return
	90	needed = len(self._clean_objects) - self._limit
	91	offset = 0
	92	while needed and offset < len(self._clean_objects):
	93	# references we know of:
	94	# temp passed to getrefcount in our frame
	95	# temp in getrefcount's frame
	96	# the map forward
	97	# the map backwards
	98	# _clean_objects
	99	# _clean_queue
	100	# 1 missing ?
	101	if (sys.getrefcount(self._clean_queue[offset]) <= 7 and
	102	not self._clean_queue[offset] in self._precious_objects):
	103	removed = self._clean_queue[offset]
	104	self._clean_objects.remove(removed)
	105	del self._clean_queue[offset]
	106	self.map.remove_object(removed)
	107	mutter('removed object %r', removed)
	108	needed -= 1
	109	else:
	110	offset += 1
	111
	112
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	113	class WriteTransaction(ReadOnlyTransaction):
	114	"""A write transaction
	115
	116	- caches domain objects
	117	- clean objects can be removed from the cache
	118	- dirty objects are retained.
	119	"""
	120
	121	def __init__(self):
	122	super(WriteTransaction, self).__init__()
	123	self._dirty_objects = set()
	124
	125	def is_dirty(self, an_object):
	126	"""Return True if an_object is dirty."""
	127	return an_object in self._dirty_objects
	128
	129	def register_dirty(self, an_object):
	130	"""Register an_object as being dirty.
	131
	132	Dirty objects are not ejected from the identity map
	133	until the transaction finishes.
	134	"""
	135	self._dirty_objects.add(an_object)
	136	if self.is_clean(an_object):
	137	self._clean_objects.remove(an_object)
	138	del self._clean_queue[self._clean_queue.index(an_object)]
	139	self._trim()
	140
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	141
	142	class PassThroughTransaction(object):
	143	"""A pass through transaction
	144
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	145	- nothing is cached.
	146	- nothing ever gets into the identity map.
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	147	"""
	148
	149	def finish(self):
1563.2.34 by Robert Collins Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction	150	"""Clean up this transaction."""
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	151
	152	def __init__(self):
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	153	super(PassThroughTransaction, self).__init__()
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	154	self.map = NullIdentityMap()
	155
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	156	def register_clean(self, an_object, precious=False):
	157	"""Register an_object as being clean.
	158
	159	Note that precious is only a hint, and PassThroughTransaction
	160	ignores it.
	161	"""
1417.1.6 by Robert Collins introduce transactions for grouping actions done to and with branches	162
1417.1.8 by Robert Collins use transactions in the weave store interface, which enables caching for log	163	def register_dirty(self, an_object):
	164	"""Register an_object as being dirty."""
	165
1417.1.10 by Robert Collins add a cache bound to Transactions, and a precious facility, so that we keep inventory.weave in memory, but can discard weaves for other such files.	166	def set_cache_size(self, ignored):
	167	"""Do nothing, we are passing through."""