zope.app.locking 3.5.0

详细数据说明

对象锁定

这个包为对象锁定提供了一个框架。实施 旨在提供一个简单的通用锁定体系结构 可以构建哪些其他锁定应用程序（例如webdav锁定）。

锁定系统纯粹是advisory-它提供了一种关联 使用对象锁定，但它不会以任何方式强制锁定。起来了 到应用程序级代码，以确保锁定的对象在 一种适合应用程序的方法。

zope 3锁定模型定义接口和默认实现 那：

• allows for a single lock on an object, owned by a specific principal
• does not necessarily impose inherent semantic meaning (exclusive vs. non-exclusive, write vs. read) on locks, though it will provide fields that higher-level application components can use to implement and enforce such semantics
• can potentially be used to build more ambitious locking mechanisms (such as WebDAV locking equivalent to Zope 2)
• supports common use cases that have been uncovered in several years of development of real-world applications (such as reporting all of the objects locked by a given user)

zope3锁定架构定义了一个ilockable接口，并且 提供一个默认适配器实现，该实现只需要 对象适用于ikeyreference。所有持久对象都可以是 在zope 3中默认适应这个接口，因此实际上 持久对象是可锁定的。

默认的iLockable适配器实现支持：

• locking and unlocking an object
• breaking an existing lock on an object
• obtaining the lock information for an object

锁定操作（锁定、解锁、断开锁定）可能是 由应用程序或其他组件处理以与锁定交互 系统以松散耦合的方式。

通过支持 ilockinfo接口。ilockinfo接口意味着iannotatable， 所以其他的锁实现（取代或补充 默认实现）如果需要支持，可以存储更多信息 扩展锁定语义。

锁结构还支持一种有效的锁跟踪方法 它允许您确定对象上持有的锁。违约 实现提供了一个iLockTracker实用程序 快速查找由特定主体锁定的所有对象的应用程序。

锁紧必需品

通常，锁定由默认的锁定实现提供。在 在这个例子中，我们将创建一个简单的内容类。内容类 是持久的，这允许我们使用默认的锁定适配器和 公用事业。

>>> import persistent

>>> class Content(persistent.Persistent):
...     """A sample content object"""
...
...     def __init__(self, value):
...         self.value = value
...
...     def __call__(self):
...         return self
...
...     def __hash__(self):
...         return self.value
...
...     def __cmp__(self, other):
...         return cmp(self.value, other.value)

现在我们将创建几个示例对象来使用：

>>> item1 = Content("item1")
>>> item1.__name__ = "item1"

>>> item2 = Content("item2")
>>> item2.__name__ = "item2"

>>> item3 = Content("item3")
>>> item3.__name__ = "item3"

可以通过尝试测试对象是否支持锁定 要使其适应iLockable界面：

>>> from zope.app.locking.interfaces import ILockable
>>> from zope.app.locking.interfaces import ILockInfo

>>> ILockable(item1, None)
<Locking adapter for...

>>> ILockable(42, None)

必须有一个使用锁定的活动交互，以允许框架 确定执行锁定操作的主体。这个例子集 提供一些示例主体和一个帮助器，以便进一步切换主体 示例：

>>> class FauxPrincipal:
...    def __init__(self, id):
...        self.id = id

>>> britney = FauxPrincipal('britney')
>>> tim = FauxPrincipal('tim')

>>> class FauxParticipation:
...     interaction = None
...     def __init__(self, principal):
...         self.principal = principal

>>> import zope.security.management
>>> def set_principal(principal):
...     if zope.security.management.queryInteraction():
...         zope.security.management.endInteraction()
...     participation = FauxParticipation(principal)
...     zope.security.management.newInteraction(participation)

>>> set_principal(britney)

现在，让我们看看基本锁定。为了执行锁定操作，我们首先 必须将对象调整为ilockable：

>>> obj = ILockable(item1)
>>> from zope.interface.verify import verifyObject
>>> verifyObject(ILockable, obj)
True

我们可以询问对象是否已锁定：

>>> obj.locked()
False

如果锁上了，我们可以得到 锁定。因为它没有被锁定，所以将返回none：

>>> obj.locker()

现在我们锁定对象。注意，lock方法返回一个实例 在成功时实现ilockinfo的对象：

>>> info = obj.lock()
>>> verifyObject(ILockInfo, info)
True

>>> obj.locked()
True

>>> obj.locker()
'britney'

提供方法来检查当前主体是否已具有 对象上的锁以及该锁是否已由另一个 负责人：

>>> obj.ownLock()
True

>>> obj.isLockedOut()
False

如果我们转换原则，我们会看到答案反映了当前 负责人：

>>> set_principal(tim)
>>> obj.ownLock()
False

>>> obj.isLockedOut()
True

校长只能释放自己的锁：

>>> obj.unlock()
Traceback (most recent call last):
  ...
LockingError: Principal is not lock owner

如果我们换回原来的校长，我们会看到原来的校长 主体可以解锁对象：

>>> set_principal(britney)
>>> obj.unlock()

有一种机制可以打破锁帽子不接电流 考虑本金。这将破坏对象上的任何现有锁：

>>> obj.lock()
<...LockInfo...>

>>> set_principal(tim)
>>> obj.locked()
True

>>> obj.breaklock()
>>> obj.locked()
False

可以使用可选超时创建锁。如果提供超时， 它应该是从锁定开始的整数秒数 创建。

>>> # fake time function to avoid a time.sleep in tests!
>>> import time
>>> def faketime():
...    return time.time() + 3600.0

>>> obj.lock(timeout=10)
<...LockInfo...>

>>> obj.locked()
True

>>> import zope.app.locking.storage
>>> zope.app.locking.storage.timefunc = faketime
>>> obj.locked()
False

（请注意，我们在本模块的拆卸过程中撤消了时间限制。）

最后，可以显式地获取 包含对象的锁定信息。注意，锁可以 没有设置超时，则超时值为“无”。

>>> obj = ILockable(item2)
>>> obj.lock()
<...LockInfo...>

>>> info = obj.getLockInfo()
>>> info.principal_id
'tim'
>>> info.timeout

可以直接从 一个实例：

>>> target = info.target
>>> target.__name__ == 'item2'
True

ilockinfo接口扩展了imapping接口，因此应用程序 如有必要，代码可以存储有关锁的额外信息。建议 额外数据的键使用符合以下约定的限定名 通常用于注释：

>>> info['my.namespace.extra'] = 'spam'
>>> info['my.namespace.extra']
'spam'
>>> obj.unlock()
>>> obj.locked()
False

锁定跟踪

通常希望能够报告当前持有的锁 一个系统（特别是在每个用户的基础上），不需要昂贵的 暴力搜查。iLockTracker实用程序允许应用程序获取 主体的当前锁或所有当前锁：

>>> set_principal(tim)
>>> obj = ILockable(item2)
>>> obj.lock()
<...LockInfo...>

>>> set_principal(britney)
>>> obj = ILockable(item3)
>>> obj.lock()
<...LockInfo...>

>>> from zope.app.locking.interfaces import ILockTracker
>>> from zope.component import getUtility
>>> util = getUtility(ILockTracker)
>>> verifyObject(ILockTracker, util)
True

>>> items = util.getLocksForPrincipal('britney')
>>> len(items) == 1
True

>>> items = util.getAllLocks()
>>> len(items) >= 2
True

这些方法允许应用程序创建窗体和其他代码 对对象集执行解锁或断开锁定：

>>> items = util.getAllLocks()
>>> for item in items:
...     obj = ILockable(item.target)
...     obj.breaklock()

>>> items = util.getAllLocks()
>>> len(items)
0

锁存储实用程序提供了更多功能，是 标准锁适配器实现，但iLockable接口没有 取决于ilockstorage。ilockable的其他实现可能不使用 我的储藏室。但是，如果适配器使用它，它将提供有用的 能力。

>>> from zope.app.locking.interfaces import ILockStorage
>>> util = getUtility(ILockStorage)
>>> verifyObject(ILockStorage, util)
True

锁定事件

锁定操作（锁定、解锁、断开锁定）可以使用的火灾事件 通过申请。注意，锁的过期不会触发事件 （因为当前实现使用延迟过期方法）。

>>> import zope.event

>>> def log_event(event):
...     print event

>>> zope.event.subscribers.append(log_event)

>>> obj = ILockable(item2)
>>> obj.lock()
LockedEvent ...

>>> obj.unlock()
UnlockedEvent ...

>>> obj.lock()
LockedEvent ...

>>> obj.breaklock()
BreakLockEvent ...

基于锁定的装置条件

故事表达式可以使用命名路径适配器获取信息 关于对象的锁定状态，包括 对象可以被锁定。此适配器的默认注册使用 名称“locking”，因此条件可以表示为 例如，“context/locking:ownlock”。

对于不可锁定的对象，适配器提供信息 这是有道理的：

>>> from zope.component import getAdapter
>>> from zope.traversing.interfaces import IPathAdapter

>>> ns = getAdapter(42, IPathAdapter, "locking")
>>> ns.lockable
False

>>> ns.locked
False

>>> ns.lockedOut
False

>>> ns.ownLock
False

使用一个可锁定但未锁定的对象也可以 结果：

>>> ns = getAdapter(item1, IPathAdapter, "locking")
>>> ns.lockable
True

>>> ns.locked
False

>>> ns.lockedOut
False

>>> ns.ownLock
False

如果锁定了对象，则适配器指示该对象已锁定 我们拥有它：

>>> ob = ILockable(item1)
>>> ob.lock()
LockedEvent for ...

>>> ns.lockable
True

>>> ns.locked
True

>>> ns.lockedOut
False

>>> ns.ownLock
True

3.5.0（2009-02-01）

• 在测试中使用zope.site，而不是zope.app.folder。
• 删除不推荐使用的zope.app.zapi。

3.4.0（2007-10-25）

• 独立于主zope树的初始发布。