← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transactions.py

  • Committer: Vincent Ladeuil
  • Date: 2016-02-07 18:23:13 UTC
  • mto: (6615.3.1 2.7)
  • mto: This revision was merged to the branch mainline in revision 6620.
  • Revision ID: v.ladeuil+lp@free.fr-20160207182313-jwz7z3vj4mpyjn7y
Ensure http://pad.lv/1323805 won't come back.

Since the 2.6.0 release pypi policy changed and release tarballs can't be
hosted on launchpad anymore, they have to be uploaded to
http://pypi.python.org/pypi


This fixes setup.py sdist to generate the right tarball with nearly the same
content as the one produced for 2.7.0.

Such a tarball have been uploaded to pypi properly signed and tested for
installation in venv.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transactions.py
 
1
# Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
 
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.
 
25
 
 
26
Read only transactions raise an assert when objects are listed as dirty
 
27
against them - preventing unintended writes.
 
28
 
 
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.
 
32
 
 
33
Both read and write transactions *may* flush unchanged objects out of
 
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.
 
37
"""
 
38
 
 
39
from __future__ import absolute_import
 
40
 
 
41
import sys
 
42
 
 
43
import bzrlib.errors as errors
 
44
from bzrlib.identitymap import IdentityMap, NullIdentityMap
 
45
from bzrlib.trace import mutter
 
46
 
 
47
 
 
48
class ReadOnlyTransaction(object):
 
49
    """A read only unit of work for data objects."""
 
50
 
 
51
    def finish(self):
 
52
        """Clean up this transaction."""
 
53
 
 
54
    def __init__(self):
 
55
        super(ReadOnlyTransaction, self).__init__()
 
56
        self.map = IdentityMap()
 
57
        self._clean_objects = set()
 
58
        self._clean_queue = []
 
59
        self._limit = -1
 
60
        self._precious_objects = set()
 
61
 
 
62
    def is_clean(self, an_object):
 
63
        """Return True if an_object is clean."""
 
64
        return (an_object in self._clean_objects)
 
65
 
 
66
    def register_clean(self, an_object, precious=False):
 
67
        """Register an_object as being clean.
 
68
 
 
69
        If the precious hint is True, the object will not
 
70
        be ejected from the object identity map ever.
 
71
        """
 
72
        self._clean_objects.add(an_object)
 
73
        self._clean_queue.append(an_object)
 
74
        if precious:
 
75
            self._precious_objects.add(an_object)
 
76
        self._trim()
 
77
 
 
78
    def register_dirty(self, an_object):
 
79
        """Register an_object as being dirty."""
 
80
        raise errors.ReadOnlyObjectDirtiedError(an_object)
 
81
 
 
82
    def set_cache_size(self, size):
 
83
        """Set a new cache size."""
 
84
        if size < -1:
 
85
            raise ValueError(size)
 
86
        self._limit = size
 
87
        self._trim()
 
88
 
 
89
    def _trim(self):
 
90
        """Trim the cache back if needed."""
 
91
        if self._limit < 0 or self._limit - len(self._clean_objects) > 0:
 
92
            return
 
93
        needed = len(self._clean_objects) - self._limit
 
94
        offset = 0
 
95
        while needed and offset < len(self._clean_objects):
 
96
            # references we know of:
 
97
            # temp passed to getrefcount in our frame
 
98
            # temp in getrefcount's frame
 
99
            # the map forward
 
100
            # the map backwards
 
101
            # _clean_objects
 
102
            # _clean_queue
 
103
            # 1 missing ?
 
104
            if (sys.getrefcount(self._clean_queue[offset]) <= 7 and
 
105
                not self._clean_queue[offset] in self._precious_objects):
 
106
                removed = self._clean_queue[offset]
 
107
                self._clean_objects.remove(removed)
 
108
                del self._clean_queue[offset]
 
109
                self.map.remove_object(removed)
 
110
                mutter('removed object %r', removed)
 
111
                needed -= 1
 
112
            else:
 
113
                offset += 1
 
114
 
 
115
    def writeable(self):
 
116
        """Read only transactions do not allow writes."""
 
117
 
 
118
 
 
119
class WriteTransaction(ReadOnlyTransaction):
 
120
    """A write transaction
 
121
 
 
122
    - caches domain objects
 
123
    - clean objects can be removed from the cache
 
124
    - dirty objects are retained.
 
125
    """
 
126
 
 
127
    def finish(self):
 
128
        """Clean up this transaction."""
 
129
        for thing in self._dirty_objects:
 
130
            callback = getattr(thing, 'transaction_finished', None)
 
131
            if callback is not None:
 
132
                callback()
 
133
 
 
134
    def __init__(self):
 
135
        super(WriteTransaction, self).__init__()
 
136
        self._dirty_objects = set()
 
137
 
 
138
    def is_dirty(self, an_object):
 
139
        """Return True if an_object is dirty."""
 
140
        return (an_object in self._dirty_objects)
 
141
 
 
142
    def register_dirty(self, an_object):
 
143
        """Register an_object as being dirty.
 
144
 
 
145
        Dirty objects are not ejected from the identity map
 
146
        until the transaction finishes and get informed
 
147
        when the transaction finishes.
 
148
        """
 
149
        self._dirty_objects.add(an_object)
 
150
        if self.is_clean(an_object):
 
151
            self._clean_objects.remove(an_object)
 
152
            del self._clean_queue[self._clean_queue.index(an_object)]
 
153
        self._trim()
 
154
 
 
155
    def writeable(self):
 
156
        """Write transactions allow writes."""
 
157
        return True
 
158
 
 
159
 
 
160
class PassThroughTransaction(object):
 
161
    """A pass through transaction
 
162
 
 
163
    - nothing is cached.
 
164
    - nothing ever gets into the identity map.
 
165
    """
 
166
 
 
167
    def finish(self):
 
168
        """Clean up this transaction."""
 
169
        for thing in self._dirty_objects:
 
170
            callback = getattr(thing, 'transaction_finished', None)
 
171
            if callback is not None:
 
172
                callback()
 
173
 
 
174
    def __init__(self):
 
175
        super(PassThroughTransaction, self).__init__()
 
176
        self.map = NullIdentityMap()
 
177
        self._dirty_objects = set()
 
178
 
 
179
    def register_clean(self, an_object, precious=False):
 
180
        """Register an_object as being clean.
 
181
 
 
182
        Note that precious is only a hint, and PassThroughTransaction
 
183
        ignores it.
 
184
        """
 
185
 
 
186
    def register_dirty(self, an_object):
 
187
        """Register an_object as being dirty.
 
188
 
 
189
        Dirty objects get informed
 
190
        when the transaction finishes.
 
191
        """
 
192
        self._dirty_objects.add(an_object)
 
193
 
 
194
    def set_cache_size(self, ignored):
 
195
        """Do nothing, we are passing through."""
 
196
 
 
197
    def writeable(self):
 
198
        """Pass through transactions allow writes."""
 
199
        return True