810435250

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/zopefoundation/ZODB/commit/<a class=hub.com/zopefoundation/ZODB/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/ZODB/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/ZODB/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/ZODB/commit/135ed45e65d6d079f74b8298db1c02af9e900b78">135ed45e6">&lt;a href=&quot;https://github.com/zopefoundation/ZODB/commit/</a><a class="double-link" href="https://github.com/zopefoundation/ZODB/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/ZODB/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/ZODB/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/ZODB/commit/135ed45e65d6d079f74b8298db1c02af9e900b78">135ed45e6</a><a href="https://github.com/zopefoundation/ZODB/commit/135ed45e65d6d079f74b8298db1c02af9e900b78">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/zopefoundation/ZODB/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zopefoundation/ZODB/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/ZODB/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/ZODB/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/ZODB/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/ZODB/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/ZODB/commit/135ed45e65d6d079f74b8298db1c02af9e900b78&quot;&gt;135ed45e6&lt;/a&gt;&lt;a href=&quot;https://github.com/zopefoundation/ZODB/commit/135ed45e65d6d079f74b8298db1c02af9e900b78&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/zopefoundation/ZODB/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&a... (continued)

Pull Request Pull Request #323: loadAt

Run Details

95 of 95 new or added lines in 8 files covered. (100.0%)

6505 of 8632 relevant lines covered (75.36%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.1

/src/ZODB/utils.py

##############################################################################
#
# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################
from __future__ import print_function
import os
import struct
import sys
import time
import threading
import warnings
from binascii import hexlify, unhexlify

from tempfile import mkstemp

from persistent.timestamp import TimeStamp

from ZODB._compat import Unpickler
from ZODB._compat import BytesIO
from ZODB._compat import ascii_bytes

from six import PY2

__all__ = ['z64',
           'p64',
           'u64',
           'U64',
           'cp',
           'maxtid',
           'newTid',
           'oid_repr',
           'serial_repr',
           'tid_repr',
           'positive_id',
           'readable_tid_repr',
           'get_pickle_metadata',
           'locked',
          ]


if PY2:
    def as_bytes(obj):
        "Convert obj into bytes"
        return str(obj)

    def as_text(bytes):
        "Convert bytes into string"
        return bytes

    # Convert an element of a bytes object into an int
    byte_ord = ord
    byte_chr = chr

else:
    def as_bytes(obj):
        if isinstance(obj, bytes):
            # invoking str on a bytes object gives its repr()
            return obj
        return str(obj).encode("ascii")

    def as_text(bytes):
        return bytes.decode("ascii")

    def byte_ord(byte):
        return byte # elements of bytes are already ints

    def byte_chr(int):
        return bytes((int,))

z64 = b'\0' * 8

maxtid = b'\x7f\xff\xff\xff\xff\xff\xff\xff'

assert sys.hexversion >= 0x02030000

# The distinction between ints and longs is blurred in Python 2.2,
# so u64() are U64() really the same.

_OID_STRUCT = struct.Struct('>Q')
_OID_PACK = _OID_STRUCT.pack
_OID_UNPACK = _OID_STRUCT.unpack


def p64(v):
    """Pack an integer or long into a 8-byte string."""
    try:
        return _OID_PACK(v)
    except struct.error as e:
        raise ValueError(*(e.args + (v,)))

def u64(v):
    """Unpack an 8-byte string into a 64-bit long integer."""
    try:
        return _OID_UNPACK(v)[0]
    except struct.error as e:
        raise ValueError(*(e.args + (v,)))

U64 = u64


def cp(f1, f2, length=None, bufsize=64 * 1024):
    """Copy all data from one file to another.

    It copies the data from the current position of the input file (f1)
    appending it to the current position of the output file (f2).

    It copies at most 'length' bytes. If 'length' isn't given, it copies
    until the end of the input file.
    """
    read = f1.read
    write = f2.write
    n = bufsize

    if length is None:
        old_pos = f1.tell()
        f1.seek(0,2)
        length = f1.tell()
        f1.seek(old_pos)

    while length > 0:
        if n > length:
            n = length
        data = read(n)
        if not data:
            break
        write(data)
        length -= len(data)

def newTid(old):
    t = time.time()
    ts = TimeStamp(*time.gmtime(t)[:5]+(t%60,))
    if old is not None:
        ts = ts.laterThan(TimeStamp(old))
    return ts.raw()


def oid_repr(oid):
    if isinstance(oid, bytes) and len(oid) == 8:
        # Convert to hex and strip leading zeroes.
        as_hex = hexlify(oid).lstrip(b'0')
        # Ensure two characters per input byte.
        if len(as_hex) & 1:
            as_hex = b'0' + as_hex
        elif as_hex == b'':
            as_hex = b'00'
        return '0x' + as_hex.decode()
    else:
        return repr(oid)

def repr_to_oid(repr):
    repr = ascii_bytes(repr)
    if repr.startswith(b"0x"):
        repr = repr[2:]
    as_bin = unhexlify(repr)
    as_bin = b"\x00"*(8-len(as_bin)) + as_bin
    return as_bin

serial_repr = oid_repr
tid_repr = serial_repr

# For example, produce
#     '0x03441422948b4399 2002-04-14 20:50:34.815000'
# for 8-byte string tid b'\x03D\x14"\x94\x8bC\x99'.
def readable_tid_repr(tid):
    result = tid_repr(tid)
    if isinstance(tid, bytes) and len(tid) == 8:
        result = "%s %s" % (result, TimeStamp(tid))
    return result

# Addresses can "look negative" on some boxes, some of the time.  If you
# feed a "negative address" to an %x format, Python 2.3 displays it as
# unsigned, but produces a FutureWarning, because Python 2.4 will display
# it as signed.  So when you want to prodce an address, use positive_id() to
# obtain it.
# _ADDRESS_MASK is 2**(number_of_bits_in_a_native_pointer).  Adding this to
# a negative address gives a positive int with the same hex representation as
# the significant bits in the original.

_ADDRESS_MASK = 256 ** struct.calcsize('P')
def positive_id(obj):
    """Return id(obj) as a non-negative integer."""

    result = id(obj)
    if result < 0:
        result += _ADDRESS_MASK
        assert result > 0
    return result

# Given a ZODB pickle, return pair of strings (module_name, class_name).
# Do this without importing the module or class object.
# See ZODB/serialize.py's module docstring for the only docs that exist about
# ZODB pickle format.  If the code here gets smarter, please update those
# docs to be at least as smart.  The code here doesn't appear to make sense
# for what serialize.py calls formats 5 and 6.

def get_pickle_metadata(data):
    # Returns a 2-tuple of strings.

    # ZODB's data records contain two pickles.  The first is the class
    # of the object, the second is the object.  We're only trying to
    # pick apart the first here, to extract the module and class names.
    if data[0] in (0x80,    # Py3k indexes bytes -> int
                   b'\x80'  # Python2 indexes bytes -> bytes
                  ): # protocol marker, protocol > 1
        data = data[2:]
    if data.startswith(b'(c'):   # pickle MARK GLOBAL opcode sequence
        global_prefix = 2
    elif data.startswith(b'c'):  # pickle GLOBAL opcode
        global_prefix = 1
    else:
        global_prefix = 0

    if global_prefix:
        # Formats 1 and 2.
        # Don't actually unpickle a class, because it will attempt to
        # load the class.  Just break open the pickle and get the
        # module and class from it.  The module and class names are given by
        # newline-terminated strings following the GLOBAL opcode.
        modname, classname, rest = data.split(b'\n', 2)
        modname = modname[global_prefix:]   # strip GLOBAL opcode
        return modname.decode(), classname.decode()

    # Else there are a bunch of other possible formats.
    f = BytesIO(data)
    u = Unpickler(f)
    try:
        class_info = u.load()
    except Exception as err:
        return '', ''
    if isinstance(class_info, tuple):
        if isinstance(class_info[0], tuple):
            # Formats 3 and 4.
            modname, classname = class_info[0]
        else:
            # Formats 5 and 6 (probably) end up here.
            modname, classname = class_info
    else:
        # This isn't a known format.
        modname = repr(class_info)
        classname = ''
    return modname, classname

def mktemp(dir=None, prefix='tmp'):
    """Create a temp file, known by name, in a semi-secure manner."""
    handle, filename = mkstemp(dir=dir, prefix=prefix)
    os.close(handle)
    return filename

def check_precondition(precondition):
    if not precondition():
        raise AssertionError(
            "Failed precondition: ",
            precondition.__doc__.strip())

class Locked(object):

    def __init__(self, func, inst=None, class_=None, preconditions=()):
        self.__func__ = func
        self.__self__ = inst
        self.__self_class__ = class_
        self.preconditions = preconditions

    def __get__(self, inst, class_):
        return self.__class__(
            self.__func__, inst, class_, self.preconditions)

    def __call__(self, *args, **kw):
        inst = self.__self__
        if inst is None:
            inst = args[0]
        func = self.__func__.__get__(self.__self__, self.__self_class__)

        with inst._lock:
            for precondition in self.preconditions:
                if not precondition(inst):
                    raise AssertionError(
                        "Failed precondition: ",
                        precondition.__doc__.strip())

            return func(*args, **kw)

class locked(object):

    def __init__(self, *preconditions):
        self.preconditions = preconditions

    def __get__(self, inst, class_):
        # We didn't get any preconditions, so we have a single "precondition",
        # which is actually the function to call.
        func, = self.preconditions
        return Locked(func, inst, class_)

    def __call__(self, func):
        return Locked(func, preconditions=self.preconditions)


if os.environ.get('DEBUG_LOCKING'): # pragma: no cover
    # NOTE: This only works on Python 3.
    class Lock(object):

        lock_class = threading.Lock

        def __init__(self):
            self._lock = self.lock_class()

        def pr(self, name, a=None, kw=None):
            f = sys._getframe(2)
            if f.f_code.co_filename.endswith('ZODB/utils.py'):
                f = sys._getframe(3)
            f = '%s:%s' % (f.f_code.co_filename, f.f_lineno)
            print(id(self), self._lock, threading.get_ident(), f, name,
                  a if a else '', kw if kw else '')

        def acquire(self, *a, **kw):
            self.pr('acquire', a, kw)
            return self._lock.acquire(*a, **kw)

        def release(self):
            self.pr('release')
            return self._lock.release()

        def __enter__(self):
            self.pr('acquire')
            return self._lock.acquire()

        def __exit__(self, *ignored):
            self.pr('release')
            return self._lock.release()

    class RLock(Lock):

        lock_class = threading.RLock

    class Condition(Lock):

        lock_class = threading.Condition

        def wait(self, *a, **kw):
            self.pr('wait', a, kw)
            return self._lock.wait(*a, **kw)

        def wait_for(self, *a, **kw):
            self.pr('wait_for', a, kw)
            return self._lock.wait_for(*a, **kw)

        def notify(self, *a, **kw):
            self.pr('notify', a, kw)
            return self._lock.notify(*a, **kw)

        def notify_all(self):
            self.pr('notify_all')
            return self._lock.notify_all()

        notifyAll = notify_all

else:

    from threading import Condition, Lock, RLock


import ZODB.POSException

def load_current(storage, oid, version=''):
    """Load the most recent revision of an object by calling loadBefore

    Starting in ZODB 5, it's no longer necessary for storages to
    provide a load method.

    This function is mainly intended to facilitate transitioning from
    load to loadBefore.  It's mainly useful for tests that are meant
    to test storages, but do so by calling load on the storages.

    This function will likely become unnecessary and be deprecated
    some time in the future.
    """
    assert not version
    data, serial = loadBeforeEx(storage, oid, maxtid)
    if data is None:
        raise ZODB.POSException.POSKeyError(oid)
    return data, serial


_loadBeforeExWarned = set() # of storage class
def loadBeforeEx(storage, oid, before):
    """loadBeforeEx provides IStorageLoadBeforeEx semantic for all storages.

    Storages that do not implement loadBeforeEx are served via loadBefore.
    """
    loadBeforeEx = getattr(storage, 'loadBeforeEx', None)
    if loadBeforeEx is not None:
        try:
            return loadBeforeEx(oid, before)
        except NotImplementedError:
            pass

    # storage does not provide IStorageLoadBeforeEx - warn + fall back to loadBefore
    if type(storage) not in _loadBeforeExWarned:
        # there is potential race around _loadBeforeExWarned access, but due to the
        # GIL this race cannot result in that set corruption, and can only lead
        # to us emitting the warning twice instead of just once.
        # -> do not spend CPU on lock and just ignore it.
        warnings.warn(
            "FIXME %s does not provide loadBeforeEx - emulating it via loadBefore, but ...\n"
            "\t... 1) access will be potentially slower, and\n"
            "\t... 2) not full semantic of loadBeforeEx could be provided.\n"
            "\t...    this can lead to data corruption.\n"
            "\t... -> please see https://github.com/zopefoundation/ZODB/issues/318 for details." %
            type(storage), DeprecationWarning)
        _loadBeforeExWarned.add(type(storage))

    try:
        r = storage.loadBefore(oid, before)
    except ZODB.POSException.POSKeyError:
        return (None, z64)  # object does not exist at all

    if r is None:
        # object was removed; however loadBefore does not tell when.
        # return serial=0 - this is the "data corruption" case talked about above.
        return (None, z64)

    data, serial, next_serial = r
    return (data, serial)

1	##############################################################################
2	#
3	# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE
12	#
13	##############################################################################
14	from __future__ import print_function	1✔
15	import os	1✔
16	import struct	1✔
17	import sys	1✔
18	import time	1✔
19	import threading	1✔
20	import warnings	1✔
21	from binascii import hexlify, unhexlify	1✔
22
23	from tempfile import mkstemp	1✔
24
25	from persistent.timestamp import TimeStamp	1✔
26
27	from ZODB._compat import Unpickler	1✔
28	from ZODB._compat import BytesIO	1✔
29	from ZODB._compat import ascii_bytes	1✔
30
31	from six import PY2	1✔
32
33	__all__ = ['z64',	1✔
34	'p64',
35	'u64',
36	'U64',
37	'cp',
38	'maxtid',
39	'newTid',
40	'oid_repr',
41	'serial_repr',
42	'tid_repr',
43	'positive_id',
44	'readable_tid_repr',
45	'get_pickle_metadata',
46	'locked',
47	]
48
49
50	if PY2:	1✔
51	def as_bytes(obj):	×
52	"Convert obj into bytes"
53	return str(obj)	×
54
55	def as_text(bytes):	×
56	"Convert bytes into string"
57	return bytes	×
58
59	# Convert an element of a bytes object into an int
60	byte_ord = ord	×
61	byte_chr = chr	×
62
63	else:
64	def as_bytes(obj):	1✔
65	if isinstance(obj, bytes):	1✔
66	# invoking str on a bytes object gives its repr()
67	return obj	1✔
68	return str(obj).encode("ascii")	1✔
69
70	def as_text(bytes):	1✔
71	return bytes.decode("ascii")	1✔
72
73	def byte_ord(byte):	1✔
74	return byte # elements of bytes are already ints	1✔
75
76	def byte_chr(int):	1✔
77	return bytes((int,))	1✔
78
79	z64 = b'\0' * 8	1✔
80
81	maxtid = b'\x7f\xff\xff\xff\xff\xff\xff\xff'	1✔
82
83	assert sys.hexversion >= 0x02030000	1✔
84
85	# The distinction between ints and longs is blurred in Python 2.2,
86	# so u64() are U64() really the same.
87
88	_OID_STRUCT = struct.Struct('>Q')	1✔
89	_OID_PACK = _OID_STRUCT.pack	1✔
90	_OID_UNPACK = _OID_STRUCT.unpack	1✔
91
92
93	def p64(v):	1✔
94	"""Pack an integer or long into a 8-byte string."""
95	try:	1✔
96	return _OID_PACK(v)	1✔
97	except struct.error as e:	1✔
98	raise ValueError(*(e.args + (v,)))	1✔
99
100	def u64(v):	1✔
101	"""Unpack an 8-byte string into a 64-bit long integer."""
102	try:	1✔
103	return _OID_UNPACK(v)[0]	1✔
104	except struct.error as e:	1✔
105	raise ValueError(*(e.args + (v,)))	1✔
106
107	U64 = u64	1✔
108
109
110	def cp(f1, f2, length=None, bufsize=64 * 1024):	1✔
111	"""Copy all data from one file to another.
112
113	It copies the data from the current position of the input file (f1)
114	appending it to the current position of the output file (f2).
115
116	It copies at most 'length' bytes. If 'length' isn't given, it copies
117	until the end of the input file.
118	"""
119	read = f1.read	1✔
120	write = f2.write	1✔
121	n = bufsize	1✔
122
123	if length is None:	1✔
124	old_pos = f1.tell()	1✔
125	f1.seek(0,2)	1✔
126	length = f1.tell()	1✔
127	f1.seek(old_pos)	1✔
128
129	while length > 0:	1✔
130	if n > length:	1✔
131	n = length	1✔
132	data = read(n)	1✔
133	if not data:	1✔
134	break	×
135	write(data)	1✔
136	length -= len(data)	1✔
137
138	def newTid(old):	1✔
139	t = time.time()	1✔
140	ts = TimeStamp(*time.gmtime(t)[:5]+(t%60,))	1✔
141	if old is not None:	1✔
142	ts = ts.laterThan(TimeStamp(old))	1✔
143	return ts.raw()	1✔
144
145
146	def oid_repr(oid):	1✔
147	if isinstance(oid, bytes) and len(oid) == 8:	1✔
148	# Convert to hex and strip leading zeroes.
149	as_hex = hexlify(oid).lstrip(b'0')	1✔
150	# Ensure two characters per input byte.
151	if len(as_hex) & 1:	1✔
152	as_hex = b'0' + as_hex	1✔
153	elif as_hex == b'':	1✔
154	as_hex = b'00'	1✔
155	return '0x' + as_hex.decode()	1✔
156	else:
157	return repr(oid)	1✔
158
159	def repr_to_oid(repr):	1✔
160	repr = ascii_bytes(repr)	1✔
161	if repr.startswith(b"0x"):	1✔
162	repr = repr[2:]	1✔
163	as_bin = unhexlify(repr)	1✔
164	as_bin = b"\x00"*(8-len(as_bin)) + as_bin	1✔
165	return as_bin	1✔
166
167	serial_repr = oid_repr	1✔
168	tid_repr = serial_repr	1✔
169
170	# For example, produce
171	# '0x03441422948b4399 2002-04-14 20:50:34.815000'
172	# for 8-byte string tid b'\x03D\x14"\x94\x8bC\x99'.
173	def readable_tid_repr(tid):	1✔
174	result = tid_repr(tid)	1✔
175	if isinstance(tid, bytes) and len(tid) == 8:	1✔
176	result = "%s %s" % (result, TimeStamp(tid))	1✔
177	return result	1✔
178
179	# Addresses can "look negative" on some boxes, some of the time. If you
180	# feed a "negative address" to an %x format, Python 2.3 displays it as
181	# unsigned, but produces a FutureWarning, because Python 2.4 will display
182	# it as signed. So when you want to prodce an address, use positive_id() to
183	# obtain it.
184	# _ADDRESS_MASK is 2**(number_of_bits_in_a_native_pointer). Adding this to
185	# a negative address gives a positive int with the same hex representation as
186	# the significant bits in the original.
187
188	_ADDRESS_MASK = 256 ** struct.calcsize('P')	1✔
189	def positive_id(obj):	1✔
190	"""Return id(obj) as a non-negative integer."""
191
192	result = id(obj)	1✔
193	if result < 0:	1✔
194	result += _ADDRESS_MASK	×
195	assert result > 0	×
196	return result	1✔
197
198	# Given a ZODB pickle, return pair of strings (module_name, class_name).
199	# Do this without importing the module or class object.
200	# See ZODB/serialize.py's module docstring for the only docs that exist about
201	# ZODB pickle format. If the code here gets smarter, please update those
202	# docs to be at least as smart. The code here doesn't appear to make sense
203	# for what serialize.py calls formats 5 and 6.
204
205	def get_pickle_metadata(data):	1✔
206	# Returns a 2-tuple of strings.
207
208	# ZODB's data records contain two pickles. The first is the class
209	# of the object, the second is the object. We're only trying to
210	# pick apart the first here, to extract the module and class names.
211	if data[0] in (0x80, # Py3k indexes bytes -> int	1✔
212	b'\x80' # Python2 indexes bytes -> bytes
213	): # protocol marker, protocol > 1
214	data = data[2:]	1✔
215	if data.startswith(b'(c'): # pickle MARK GLOBAL opcode sequence	1✔
216	global_prefix = 2	×
217	elif data.startswith(b'c'): # pickle GLOBAL opcode	1✔
218	global_prefix = 1	1✔
219	else:
220	global_prefix = 0	1✔
221
222	if global_prefix:	1✔
223	# Formats 1 and 2.
224	# Don't actually unpickle a class, because it will attempt to
225	# load the class. Just break open the pickle and get the
226	# module and class from it. The module and class names are given by
227	# newline-terminated strings following the GLOBAL opcode.
228	modname, classname, rest = data.split(b'\n', 2)	1✔
229	modname = modname[global_prefix:] # strip GLOBAL opcode	1✔
230	return modname.decode(), classname.decode()	1✔
231
232	# Else there are a bunch of other possible formats.
233	f = BytesIO(data)	1✔
234	u = Unpickler(f)	1✔
235	try:	1✔
236	class_info = u.load()	1✔
237	except Exception as err:	1✔
238	return '', ''	1✔
239	if isinstance(class_info, tuple):	1✔
240	if isinstance(class_info[0], tuple):	1✔
241	# Formats 3 and 4.
242	modname, classname = class_info[0]	1✔
243	else:
244	# Formats 5 and 6 (probably) end up here.
245	modname, classname = class_info	×
246	else:
247	# This isn't a known format.
248	modname = repr(class_info)	×
249	classname = ''	×
250	return modname, classname	1✔
251
252	def mktemp(dir=None, prefix='tmp'):	1✔
253	"""Create a temp file, known by name, in a semi-secure manner."""
254	handle, filename = mkstemp(dir=dir, prefix=prefix)	1✔
255	os.close(handle)	1✔
256	return filename	1✔
257
258	def check_precondition(precondition):	1✔
259	if not precondition():	1✔
260	raise AssertionError(	×
261	"Failed precondition: ",
262	precondition.__doc__.strip())
263
264	class Locked(object):	1✔
265
266	def __init__(self, func, inst=None, class_=None, preconditions=()):	1✔
267	self.__func__ = func	1✔
268	self.__self__ = inst	1✔
269	self.__self_class__ = class_	1✔
270	self.preconditions = preconditions	1✔
271
272	def __get__(self, inst, class_):	1✔
273	return self.__class__(	1✔
274	self.__func__, inst, class_, self.preconditions)
275
276	def __call__(self, args, *kw):	1✔
277	inst = self.__self__	1✔
278	if inst is None:	1✔
279	inst = args[0]	1✔
280	func = self.__func__.__get__(self.__self__, self.__self_class__)	1✔
281
282	with inst._lock:	1✔
283	for precondition in self.preconditions:	1✔
284	if not precondition(inst):	1✔
285	raise AssertionError(	1✔
286	"Failed precondition: ",
287	precondition.__doc__.strip())
288
289	return func(args, *kw)	1✔
290
291	class locked(object):	1✔
292
293	def __init__(self, *preconditions):	1✔
294	self.preconditions = preconditions	1✔
295
296	def __get__(self, inst, class_):	1✔
297	# We didn't get any preconditions, so we have a single "precondition",
298	# which is actually the function to call.
299	func, = self.preconditions	1✔
300	return Locked(func, inst, class_)	1✔
301
302	def __call__(self, func):	1✔
303	return Locked(func, preconditions=self.preconditions)	1✔
304
305
306	if os.environ.get('DEBUG_LOCKING'): # pragma: no cover
307	# NOTE: This only works on Python 3.
308	class Lock(object):
309
310	lock_class = threading.Lock
311
312	def __init__(self):
313	self._lock = self.lock_class()
314
315	def pr(self, name, a=None, kw=None):
316	f = sys._getframe(2)
317	if f.f_code.co_filename.endswith('ZODB/utils.py'):
318	f = sys._getframe(3)
319	f = '%s:%s' % (f.f_code.co_filename, f.f_lineno)
320	print(id(self), self._lock, threading.get_ident(), f, name,
321	a if a else '', kw if kw else '')
322
323	def acquire(self, a, *kw):
324	self.pr('acquire', a, kw)
325	return self._lock.acquire(a, *kw)
326
327	def release(self):
328	self.pr('release')
329	return self._lock.release()
330
331	def __enter__(self):
332	self.pr('acquire')
333	return self._lock.acquire()
334
335	def __exit__(self, *ignored):
336	self.pr('release')
337	return self._lock.release()
338
339	class RLock(Lock):
340
341	lock_class = threading.RLock
342
343	class Condition(Lock):
344
345	lock_class = threading.Condition
346
347	def wait(self, a, *kw):
348	self.pr('wait', a, kw)
349	return self._lock.wait(a, *kw)
350
351	def wait_for(self, a, *kw):
352	self.pr('wait_for', a, kw)
353	return self._lock.wait_for(a, *kw)
354
355	def notify(self, a, *kw):
356	self.pr('notify', a, kw)
357	return self._lock.notify(a, *kw)
358
359	def notify_all(self):
360	self.pr('notify_all')
361	return self._lock.notify_all()
362
363	notifyAll = notify_all
364
365	else:
366
367	from threading import Condition, Lock, RLock	1✔
368
369
370	import ZODB.POSException	1✔
371
372	def load_current(storage, oid, version=''):	1✔
373	"""Load the most recent revision of an object by calling loadBefore
374
375	Starting in ZODB 5, it's no longer necessary for storages to
376	provide a load method.
377
378	This function is mainly intended to facilitate transitioning from
379	load to loadBefore. It's mainly useful for tests that are meant
380	to test storages, but do so by calling load on the storages.
381
382	This function will likely become unnecessary and be deprecated
383	some time in the future.
384	"""
385	assert not version	1✔
386	data, serial = loadBeforeEx(storage, oid, maxtid)	1✔
387	if data is None:	1✔
388	raise ZODB.POSException.POSKeyError(oid)	1✔
389	return data, serial	1✔
390
391
392	_loadBeforeExWarned = set() # of storage class	1✔
393	def loadBeforeEx(storage, oid, before):	1✔
394	"""loadBeforeEx provides IStorageLoadBeforeEx semantic for all storages.
395
396	Storages that do not implement loadBeforeEx are served via loadBefore.
397	"""
398	loadBeforeEx = getattr(storage, 'loadBeforeEx', None)	1✔
399	if loadBeforeEx is not None:	1✔
400	try:	1✔
401	return loadBeforeEx(oid, before)	1✔
402	except NotImplementedError:	1✔
403	pass	×
404
405	# storage does not provide IStorageLoadBeforeEx - warn + fall back to loadBefore
406	if type(storage) not in _loadBeforeExWarned:	×
407	# there is potential race around _loadBeforeExWarned access, but due to the
408	# GIL this race cannot result in that set corruption, and can only lead
409	# to us emitting the warning twice instead of just once.
410	# -> do not spend CPU on lock and just ignore it.
411	warnings.warn(	×
412	"FIXME %s does not provide loadBeforeEx - emulating it via loadBefore, but ...\n"
413	"\t... 1) access will be potentially slower, and\n"
414	"\t... 2) not full semantic of loadBeforeEx could be provided.\n"
415	"\t... this can lead to data corruption.\n"
416	"\t... -> please see https://github.com/zopefoundation/ZODB/issues/318 for details." %
417	type(storage), DeprecationWarning)
418	_loadBeforeExWarned.add(type(storage))	×
419
420	try:	×
421	r = storage.loadBefore(oid, before)	×
422	except ZODB.POSException.POSKeyError:	×
423	return (None, z64) # object does not exist at all	×
424
425	if r is None:	×
426	# object was removed; however loadBefore does not tell when.
427	# return serial=0 - this is the "data corruption" case talked about above.
428	return (None, z64)	×
429
430	data, serial, next_serial = r	×
431	return (data, serial)	×

zopefoundation / ZODB / 810435250

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous