zope.locking 3.0__py3-none-any.whl

zope/locking/tokens.py

@@ -0,0 +1,256 @@
+#############################################################################
+#
+# Copyright (c) 2018 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.
+#
+##############################################################################
+
+import datetime
+import functools
+
+import persistent
+from BTrees.OOBTree import OOBTree
+
+from zope import event
+from zope import interface
+from zope.locking import interfaces
+from zope.locking import utils
+
+
+NO_DURATION = datetime.timedelta()
+
+
+class AnnotationsMapping(OOBTree):
+    """a class on which security settings may be hung."""
+
+
+@functools.total_ordering
+class Token(persistent.Persistent):
+
+    def __init__(self, target):
+        self.context = self.__parent__ = target
+        self.annotations = AnnotationsMapping()
+        self.annotations.__parent__ = self  # for security.
+
+    _principal_ids = frozenset()
+
+    @property
+    def principal_ids(self):
+        return self._principal_ids
+
+    _started = None
+
+    @property
+    def started(self):
+        if self._utility is None:
+            raise interfaces.UnregisteredError(self)
+        return self._started
+
+    _utility = None
+
+    @property
+    def utility(self):
+        return self._utility
+
+    @utility.setter
+    def utility(self, value):
+        if self._utility is not None:
+            if value is not self._utility:
+                raise ValueError('cannot reset utility')
+        else:
+            assert interfaces.ITokenUtility.providedBy(value)
+            self._utility = value
+            assert self._started is None
+            self._started = utils.now()
+
+    def __eq__(self, other):
+        return (
+            (self._p_jar.db().database_name, self._p_oid) ==
+            (other._p_jar.db().database_name, other._p_oid))
+
+    def __lt__(self, other):
+        return (
+            (self._p_jar.db().database_name, self._p_oid) <
+            (other._p_jar.db().database_name, other._p_oid))
+
+
+class EndableToken(Token):
+
+    def __init__(self, target, duration=None):
+        super().__init__(target)
+        self._duration = duration
+
+    @property
+    def utility(self):
+        return self._utility
+
+    @utility.setter
+    def utility(self, value):
+        if self._utility is not None:
+            if value is not self._utility:
+                raise ValueError('cannot reset utility')
+        else:
+            assert interfaces.ITokenUtility.providedBy(value)
+            self._utility = value
+            assert self._started is None
+            self._started = utils.now()
+            if self._duration is not None:
+                self._expiration = self._started + self._duration
+                del self._duration  # to catch bugs.
+
+    _expiration = _duration = None
+
+    @property
+    def expiration(self):
+        if self._started is None:
+            raise interfaces.UnregisteredError(self)
+        return self._expiration
+
+    @expiration.setter
+    def expiration(self, value):
+        if self._started is None:
+            raise interfaces.UnregisteredError(self)
+        if self.ended:
+            raise interfaces.EndedError
+        if value is not None:
+            if not isinstance(value, datetime.datetime):
+                raise ValueError('expiration must be datetime.datetime')
+            elif value.tzinfo is None:
+                raise ValueError('expiration must be timezone-aware')
+        old = self._expiration
+        self._expiration = value
+        if old != self._expiration:
+            self.utility.register(self)
+            event.notify(interfaces.ExpirationChangedEvent(self, old))
+
+    @property
+    def duration(self):
+        if self._started is None:
+            return self._duration
+        if self._expiration is None:
+            return None
+        return self._expiration - self._started
+
+    @duration.setter
+    def duration(self, value):
+        if self._started is None:
+            self._duration = value
+        else:
+            if self.ended:
+                raise interfaces.EndedError
+            old = self._expiration
+            if value is None:
+                self._expiration = value
+            elif not isinstance(value, datetime.timedelta):
+                raise ValueError('duration must be datetime.timedelta')
+            else:
+                if value < NO_DURATION:
+                    raise ValueError('duration may not be negative')
+                self._expiration = self._started + value
+            if old != self._expiration:
+                self.utility.register(self)
+                event.notify(interfaces.ExpirationChangedEvent(self, old))
+
+    @property
+    def remaining_duration(self):
+        if self._started is None:
+            raise interfaces.UnregisteredError(self)
+        if self.ended is not None:
+            return NO_DURATION
+        if self._expiration is None:
+            return None
+        return self._expiration - utils.now()
+
+    @remaining_duration.setter
+    def remaining_duration(self, value):
+        if self._started is None:
+            raise interfaces.UnregisteredError(self)
+        if self.ended:
+            raise interfaces.EndedError
+        old = self._expiration
+        if value is None:
+            self._expiration = value
+        elif not isinstance(value, datetime.timedelta):
+            raise ValueError('duration must be datetime.timedelta')
+        else:
+            if value < NO_DURATION:
+                raise ValueError('duration may not be negative')
+            self._expiration = utils.now() + value
+        if old != self._expiration:
+            self.utility.register(self)
+            event.notify(interfaces.ExpirationChangedEvent(self, old))
+
+    _ended = None
+
+    @property
+    def ended(self):
+        if self._utility is None:
+            raise interfaces.UnregisteredError(self)
+        if self._ended is not None:
+            return self._ended
+        if (self._expiration is not None and
+                self._expiration <= utils.now()):
+            return self._expiration
+
+    def end(self):
+        if self.ended:
+            raise interfaces.EndedError
+        self._ended = utils.now()
+        self.utility.register(self)
+        event.notify(interfaces.TokenEndedEvent(self))
+
+
+@interface.implementer(interfaces.IExclusiveLock)
+class ExclusiveLock(EndableToken):
+
+    def __init__(self, target, principal_id, duration=None):
+        self._principal_ids = frozenset((principal_id,))
+        super().__init__(target, duration)
+
+
+@interface.implementer(interfaces.ISharedLock)
+class SharedLock(EndableToken):
+
+    def __init__(self, target, principal_ids, duration=None):
+        self._principal_ids = frozenset(principal_ids)
+        super().__init__(target, duration)
+
+    def add(self, principal_ids):
+        if self.ended:
+            raise interfaces.EndedError
+        old = self._principal_ids
+        self._principal_ids = self._principal_ids.union(principal_ids)
+        if old != self._principal_ids:
+            self.utility.register(self)
+            event.notify(interfaces.PrincipalsChangedEvent(self, old))
+
+    def remove(self, principal_ids):
+        if self.ended:
+            raise interfaces.EndedError
+        old = self._principal_ids
+        self._principal_ids = self._principal_ids.difference(principal_ids)
+        if not self._principal_ids:
+            self.end()
+        elif old != self._principal_ids:
+            self.utility.register(self)
+        else:
+            return
+        # principals changed if you got here
+        event.notify(interfaces.PrincipalsChangedEvent(self, old))
+
+
+@interface.implementer(interfaces.IEndableFreeze)
+class EndableFreeze(EndableToken):
+    pass
+
+
+@interface.implementer(interfaces.IFreeze)
+class Freeze(Token):
+    pass

zope/locking/utility.py

@@ -0,0 +1,149 @@
+##############################################################################
+#
+# Copyright (c) 2018 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.
+#
+##############################################################################
+
+import persistent
+import persistent.interfaces
+from BTrees.OOBTree import OOBTree
+from BTrees.OOBTree import OOTreeSet
+from zope.keyreference.interfaces import IKeyReference
+from zope.location import Location
+
+from zope import event
+from zope import interface
+from zope.locking import interfaces
+from zope.locking import utils
+
+
+@interface.implementer(interfaces.ITokenUtility)
+class TokenUtility(persistent.Persistent, Location):
+
+    def __init__(self):
+        self._locks = OOBTree()
+        self._expirations = OOBTree()
+        self._principal_ids = OOBTree()
+
+    def _del(self, tree, token, value):
+        """remove a token for a value within either of the two index trees"""
+        reg = tree[value]
+        reg.remove(token)
+        if not reg:
+            del tree[value]
+
+    def _add(self, tree, token, value):
+        """add a token for a value within either of the two index trees"""
+        reg = tree.get(value)
+        if reg is None:
+            reg = tree[value] = OOTreeSet()
+        reg.insert(token)
+
+    def _cleanup(self):
+        "clean out expired keys"
+        expiredkeys = []
+        for k in self._expirations.keys(max=utils.now()):
+            for token in self._expirations[k]:
+                assert token.ended
+                for p in token.principal_ids:
+                    self._del(self._principal_ids, token, p)
+                key_ref = IKeyReference(token.context)
+                del self._locks[key_ref]
+            expiredkeys.append(k)
+        for k in expiredkeys:
+            del self._expirations[k]
+
+    def register(self, token):
+        assert interfaces.IToken.providedBy(token)
+        if token.utility is None:
+            token.utility = self
+        elif token.utility is not self:
+            raise ValueError('Lock is already registered with another utility')
+        if persistent.interfaces.IPersistent.providedBy(token):
+            self._p_jar.add(token)
+        key_ref = IKeyReference(token.context)
+        current = self._locks.get(key_ref)
+        if current is not None:
+            current, principal_ids, expiration = current
+            current_endable = interfaces.IEndable.providedBy(current)
+            if current is not token:
+                if current_endable and not current.ended:
+                    raise interfaces.RegistrationError(token)
+                # expired token: clean up indexes and fall through
+                if current_endable and expiration is not None:
+                    self._del(self._expirations, current, expiration)
+                for p in principal_ids:
+                    self._del(self._principal_ids, current, p)
+            else:
+                # current is token; reindex and return
+                if current_endable and token.ended:
+                    if expiration is not None:
+                        self._del(self._expirations, token, expiration)
+                    for p in principal_ids:
+                        self._del(self._principal_ids, token, p)
+                    del self._locks[key_ref]
+                else:
+                    if current_endable and token.expiration != expiration:
+                        # reindex timeout
+                        if expiration is not None:
+                            self._del(self._expirations, token, expiration)
+                        if token.expiration is not None:
+                            self._add(
+                                self._expirations, token, token.expiration)
+                    orig = frozenset(principal_ids)
+                    new = frozenset(token.principal_ids)
+                    removed = orig.difference(new)
+                    added = new.difference(orig)
+                    for p in removed:
+                        self._del(self._principal_ids, token, p)
+                    for p in added:
+                        self._add(self._principal_ids, token, p)
+                    self._locks[key_ref] = (
+                        token,
+                        frozenset(token.principal_ids),
+                        current_endable and token.expiration or None)
+                self._cleanup()
+                return token
+        # expired current token or no current token; this is new
+        endable = interfaces.IEndable.providedBy(token)
+        self._locks[key_ref] = (
+            token,
+            frozenset(token.principal_ids),
+            endable and token.expiration or None)
+        if (endable and
+                token.expiration is not None):
+            self._add(self._expirations, token, token.expiration)
+        for p in token.principal_ids:
+            self._add(self._principal_ids, token, p)
+        self._cleanup()
+        event.notify(interfaces.TokenStartedEvent(token))
+        return token
+
+    def get(self, obj, default=None):
+        res = self._locks.get(IKeyReference(obj))
+        if res is not None and (
+                not interfaces.IEndable.providedBy(res[0])
+                or not res[0].ended):
+            return res[0]
+        return default
+
+    def iterForPrincipalId(self, principal_id):
+        locks = self._principal_ids.get(principal_id, ())
+        for lock in locks:
+            assert principal_id in frozenset(lock.principal_ids)
+            if not lock.ended:
+                yield lock
+
+    def __iter__(self):
+        for lock in self._locks.values():
+            if (not interfaces.IEndable.providedBy(lock[0])
+                    or not lock[0].ended):
+                yield lock[0]

zope/locking/utils.py

@@ -0,0 +1,23 @@
+##############################################################################
+#
+# Copyright (c) 2018 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.
+#
+##############################################################################
+
+import datetime
+
+import pytz
+
+
+# this is a small convenience, but is more important as a convenient monkey-
+# patch opportunity for the package's README.txt doctest.
+def now():
+    return datetime.datetime.now(pytz.utc)

zope.locking-3.0-py3.12-nspkg.pth

@@ -0,0 +1 @@
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zope',));importlib = __import__('importlib.util');__import__('importlib.machinery');m = sys.modules.setdefault('zope', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('zope', [os.path.dirname(p)])));m = m or sys.modules.setdefault('zope', types.ModuleType('zope'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)

zope_locking-3.0.dist-info/LICENSE.rst

@@ -0,0 +1,44 @@
+Zope Public License (ZPL) Version 2.1
+
+A copyright notice accompanies this license document that identifies the
+copyright holders.
+
+This license has been certified as open source. It has also been designated as
+GPL compatible by the Free Software Foundation (FSF).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions in source code must retain the accompanying copyright
+notice, this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the accompanying copyright
+notice, this list of conditions, and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Names of the copyright holders must not be used to endorse or promote
+products derived from this software without prior written permission from the
+copyright holders.
+
+4. The right to distribute this software or to use it for any purpose does not
+give you the right to use Servicemarks (sm) or Trademarks (tm) of the
+copyright
+holders. Use of them is covered by separate agreement with the copyright
+holders.
+
+5. If any files are modified, you must cause the modified files to carry
+prominent notices stating that you changed the files and the date of any
+change.
+
+Disclaimer
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.