<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[11956] CalendarServer/branches/users/sagen/groupcacher</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.calendarserver.org//changeset/11956">11956</a></dd>
<dt>Author</dt> <dd>gaya@apple.com</dd>
<dt>Date</dt> <dd>2013-11-15 13:13:28 -0800 (Fri, 15 Nov 2013)</dd>
</dl>
<h3>Log Message</h3>
<pre>add group changes back to txdav.common.datastore.sql, converting uuid -> str when needed</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#CalendarServerbranchesuserssagengroupcachertwextwhogroupspy">CalendarServer/branches/users/sagen/groupcacher/twext/who/groups.py</a></li>
<li><a href="#CalendarServerbranchesuserssagengroupcachertxdavcommondatastoresqlpy">CalendarServer/branches/users/sagen/groupcacher/txdav/common/datastore/sql.py</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="CalendarServerbranchesuserssagengroupcachertwextwhogroupspy"></a>
<div class="modfile"><h4>Modified: CalendarServer/branches/users/sagen/groupcacher/twext/who/groups.py (11955 => 11956)</h4>
<pre class="diff"><span>
<span class="info">--- CalendarServer/branches/users/sagen/groupcacher/twext/who/groups.py        2013-11-15 19:28:30 UTC (rev 11955)
+++ CalendarServer/branches/users/sagen/groupcacher/twext/who/groups.py        2013-11-15 21:13:28 UTC (rev 11956)
</span><span class="lines">@@ -263,7 +263,7 @@
</span><span class="cx"> members = list(members)
</span><span class="cx"> members.sort(cmp=lambda x, y: cmp(x.guid, y.guid))
</span><span class="cx"> for member in members:
</span><del>- membershipHashContent.update(member.guid)
</del><ins>+ membershipHashContent.update(str(member.guid))
</ins><span class="cx"> membershipHash = membershipHashContent.hexdigest()
</span><span class="cx"> groupID, cachedName, cachedMembershipHash = (yield #@UnusedVariable
</span><span class="cx"> txn.groupByGUID(groupGUID))
</span></span></pre></div>
<a id="CalendarServerbranchesuserssagengroupcachertxdavcommondatastoresqlpy"></a>
<div class="modfile"><h4>Modified: CalendarServer/branches/users/sagen/groupcacher/txdav/common/datastore/sql.py (11955 => 11956)</h4>
<pre class="diff"><span>
<span class="info">--- CalendarServer/branches/users/sagen/groupcacher/txdav/common/datastore/sql.py        2013-11-15 19:28:30 UTC (rev 11955)
+++ CalendarServer/branches/users/sagen/groupcacher/txdav/common/datastore/sql.py        2013-11-15 21:13:28 UTC (rev 11956)
</span><span class="lines">@@ -63,8 +63,8 @@
</span><span class="cx"> from txdav.common.datastore.sql_tables import _BIND_MODE_OWN, \
</span><span class="cx"> _BIND_STATUS_ACCEPTED, _BIND_STATUS_DECLINED
</span><span class="cx"> from txdav.common.datastore.sql_tables import schema, splitSQLString
</span><del>-from txdav.common.icommondatastore import ConcurrentModification
-from txdav.common.icommondatastore import HomeChildNameNotAllowedError, \
</del><ins>+from txdav.common.icommondatastore import ConcurrentModification, \
+ NotFoundError, HomeChildNameNotAllowedError, \
</ins><span class="cx"> HomeChildNameAlreadyExistsError, NoSuchHomeChildError, \
</span><span class="cx"> ObjectResourceNameNotAllowedError, ObjectResourceNameAlreadyExistsError, \
</span><span class="cx"> NoSuchObjectResourceError, AllRetriesFailed, InvalidSubscriptionValues, \
</span><span class="lines">@@ -81,6 +81,7 @@
</span><span class="cx">
</span><span class="cx"> import sys
</span><span class="cx"> import time
</span><ins>+import datetime
</ins><span class="cx">
</span><span class="cx"> current_sql_schema = getModule(__name__).filePath.sibling("sql_schema").child("current.sql").getContent()
</span><span class="cx">
</span><span class="lines">@@ -869,7 +870,439 @@
</span><span class="cx">
</span><span class="cx"> # End of IMIP
</span><span class="cx">
</span><ins>+ # Groups
</ins><span class="cx">
</span><ins>+
+ @classproperty
+ def _addGroupQuery(cls): #@NoSelf
+ gr = schema.GROUPS
+ return Insert({gr.NAME: Parameter("name"),
+ gr.GROUP_GUID: Parameter("groupGUID"),
+ gr.MEMBERSHIP_HASH: Parameter("membershipHash")},
+ Return=gr.GROUP_ID)
+
+
+ @classproperty
+ def _updateGroupQuery(cls): #@NoSelf
+ gr = schema.GROUPS
+ return Update({gr.MEMBERSHIP_HASH: Parameter("membershipHash"),
+ gr.NAME: Parameter("name"), gr.MODIFIED: Parameter("timestamp")},
+ Where=(gr.GROUP_GUID == Parameter("groupGUID")))
+
+
+ @classproperty
+ def _groupByGUID(cls): #@NoSelf
+ gr = schema.GROUPS
+ return Select([gr.GROUP_ID, gr.NAME, gr.MEMBERSHIP_HASH], From=gr,
+ Where=(
+ gr.GROUP_GUID == Parameter("groupGUID")
+ )
+ )
+
+
+ @classproperty
+ def _groupByID(cls): #@NoSelf
+ gr = schema.GROUPS
+ return Select([gr.GROUP_GUID, gr.NAME, gr.MEMBERSHIP_HASH], From=gr,
+ Where=(
+ gr.GROUP_ID == Parameter("groupID")
+ )
+ )
+
+
+ @classproperty
+ def _deleteGroup(cls): #@NoSelf
+ gr = schema.GROUPS
+ return Delete(From=gr,
+ Where=(gr.GROUP_ID == Parameter("groupID")))
+
+
+ def addGroup(self, groupGUID, name, membershipHash):
+ return self._addGroupQuery.on(self, name=name,
+ groupGUID=str(groupGUID), membershipHash=membershipHash)
+
+
+ def updateGroup(self, groupGUID, name, membershipHash):
+ timestamp = datetime.datetime.utcnow()
+ return self._updateGroupQuery.on(self, name=name,
+ groupGUID=str(groupGUID), timestamp=timestamp,
+ membershipHash=membershipHash)
+
+
+ @inlineCallbacks
+ def groupByGUID(self, groupGUID):
+ results = (yield self._groupByGUID.on(self, groupGUID=str(groupGUID)))
+ if results:
+ returnValue(results[0])
+ else:
+ savepoint = SavepointAction("groupByGUID")
+ yield savepoint.acquire(self)
+ try:
+ yield self.addGroup(groupGUID, "", "")
+ except Exception:
+ yield savepoint.rollback(self)
+ results = (yield self._groupByGUID.on(self,
+ groupGUID=str(groupGUID)))
+ if results:
+ returnValue(results[0])
+ else:
+ raise
+ else:
+ yield savepoint.release(self)
+ results = (yield self._groupByGUID.on(self,
+ groupGUID=str(groupGUID)))
+ if results:
+ returnValue(results[0])
+ else:
+ raise
+
+
+ @inlineCallbacks
+ def groupByID(self, groupID):
+ try:
+ results = (yield self._groupByID.on(self, groupID=groupID))[0]
+ returnValue(results)
+ except IndexError:
+ raise NotFoundError
+
+
+ def deleteGroup(self, groupID):
+ return self._deleteGroup.on(self, groupID=groupID)
+
+ # End of Groups
+
+
+ # Group Members
+
+ @classproperty
+ def _addMemberToGroupQuery(cls): #@NoSelf
+ gm = schema.GROUP_MEMBERSHIP
+ return Insert({gm.GROUP_ID: Parameter("groupID"),
+ gm.MEMBER_GUID: Parameter("memberGUID")})
+
+ @classproperty
+ def _removeMemberFromGroupQuery(cls): #@NoSelf
+ gm = schema.GROUP_MEMBERSHIP
+ return Delete(From=gm,
+ Where=(gm.GROUP_ID == Parameter("groupID")).And(
+ gm.MEMBER_GUID == Parameter("memberGUID")))
+
+
+ @classproperty
+ def _selectGroupMembersQuery(cls): #@NoSelf
+ gm = schema.GROUP_MEMBERSHIP
+ return Select([gm.MEMBER_GUID], From=gm,
+ Where=(
+ gm.GROUP_ID == Parameter("groupID")
+ )
+ )
+
+
+ def addMemberToGroup(self, memberGUID, groupID):
+ return self._addMemberToGroupQuery.on(self,
+ groupID=groupID, memberGUID=str(memberGUID))
+
+
+ def removeMemberFromGroup(self, memberGUID, groupID):
+ return self._removeMemberFromGroupQuery.on(self,
+ groupID=groupID, memberGUID=str(memberGUID))
+
+
+ @inlineCallbacks
+ def membersOfGroup(self, groupID):
+ """
+ Returns the cached set of GUIDs for members of the given groupID.
+ Sub-groups are not returned in the results but their members are.
+
+ @param groupID: the group ID
+ @type groupID: C{int}
+ @return: the set of member GUIDs
+ @rtype: a Deferred which fires with a set() of C{str} GUIDs
+ """
+ members = set()
+ results = (yield self._selectGroupMembersQuery.on(self,
+ groupID=groupID))
+ for row in results:
+ members.add(row[0])
+ returnValue(members)
+
+ # End of Group Members
+
+ # Delegates
+
+
+ @classproperty
+ def _addDelegateQuery(cls): #@NoSelf
+ de = schema.DELEGATES
+ return Insert({de.DELEGATOR: Parameter("delegator"),
+ de.DELEGATE: Parameter("delegate"),
+ de.READ_WRITE: Parameter("readWrite"),
+ })
+
+
+ @classproperty
+ def _addDelegateGroupQuery(cls): #@NoSelf
+ ds = schema.DELEGATE_GROUPS
+ return Insert({ds.DELEGATOR: Parameter("delegator"),
+ ds.GROUP_ID: Parameter("groupID"),
+ ds.READ_WRITE: Parameter("readWrite"),
+ })
+
+
+ @classproperty
+ def _removeDelegateQuery(cls): #@NoSelf
+ de = schema.DELEGATES
+ return Delete(From=de,
+ Where=(de.DELEGATOR == Parameter("delegator")).And(
+ de.DELEGATE == Parameter("delegate")).And(
+ de.READ_WRITE == Parameter("readWrite"))
+ )
+
+
+ @classproperty
+ def _removeDelegateGroupQuery(cls): #@NoSelf
+ ds = schema.DELEGATE_GROUPS
+ return Delete(From=ds,
+ Where=(ds.DELEGATOR == Parameter("delegator")).And(
+ ds.GROUP_ID == Parameter("groupID")).And(
+ ds.READ_WRITE == Parameter("readWrite"))
+ )
+
+
+ @classproperty
+ def _selectDelegatesQuery(cls): #@NoSelf
+ de = schema.DELEGATES
+ return Select([de.DELEGATE], From=de,
+ Where=(de.DELEGATOR == Parameter("delegator")).And(
+ de.READ_WRITE == Parameter("readWrite"))
+ )
+
+
+ @classproperty
+ def _selectDelegateGroupsQuery(cls): #@NoSelf
+ ds = schema.DELEGATE_GROUPS
+ return Select([ds.GROUP_ID], From=ds,
+ Where=(
+ ds.DELEGATOR == Parameter("delegator")).And(
+ ds.READ_WRITE == Parameter("readWrite"))
+ )
+
+
+ @classproperty
+ def _selectDirectDelegatorsQuery(cls): #@NoSelf
+ de = schema.DELEGATES
+ return Select([de.DELEGATOR], From=de,
+ Where=(
+ de.DELEGATE == Parameter("delegate")).And(
+ de.READ_WRITE == Parameter("readWrite"))
+ )
+
+
+ @classproperty
+ def _selectIndirectDelegatorsQuery(cls): #@NoSelf
+ dg = schema.DELEGATE_GROUPS
+ gm = schema.GROUP_MEMBERSHIP
+
+ return Select(
+ [dg.DELEGATOR],
+ From=dg,
+ Where=(
+ dg.GROUP_ID.In(
+ Select(
+ [gm.GROUP_ID],
+ From=gm,
+ Where=(gm.MEMBER_GUID == Parameter("delegate"))
+ )
+ ).And(
+ dg.READ_WRITE == Parameter("readWrite")
+ )
+ )
+ )
+
+
+ @classproperty
+ def _selectIndirectDelegatesQuery(cls): #@NoSelf
+ dg = schema.DELEGATE_GROUPS
+ gm = schema.GROUP_MEMBERSHIP
+
+ return Select(
+ [gm.MEMBER_GUID],
+ From=gm,
+ Where=(
+ gm.GROUP_ID.In(
+ Select(
+ [dg.GROUP_ID],
+ From=dg,
+ Where=(dg.DELEGATOR == Parameter("delegator")).And(
+ dg.READ_WRITE == Parameter("readWrite"))
+ )
+ )
+ )
+ )
+
+
+ def addDelegate(self, delegator, delegate, readWrite):
+ """
+ Adds a row to the DELEGATES table. The delegate should not be a
+ group. To delegate to a group, call addDelegateGroup() instead.
+
+ @param delegator: the GUID of the delegator
+ @type delegator: C{str} in normalized form (lowercase, no dashes)
+ @param delegate: the GUID of the delegate
+ @type delegate: C{str} in normalized form (lowercase, no dashes)
+ @param readWrite: grant read and write access if True, otherwise
+ read-only access
+ @type readWrite: C{boolean}
+ """
+ return self._addDelegateQuery.on(self, delegator=str(delegator),
+ delegate=str(delegate), readWrite=1 if readWrite else 0)
+
+
+ def addDelegateGroup(self, delegator, delegateGroupID, readWrite):
+ """
+ Adds a row to the DELEGATE_GROUPS table. The delegate should be a
+ group. To delegate to a person, call addDelegate() instead.
+
+ @param delegator: the GUID of the delegator
+ @type delegator: C{str} in normalized form (lowercase, no dashes)
+ @param delegateGroupID: the GROUP_ID of the delegate group
+ @type delegateGroupID: C{int}
+ @param readWrite: grant read and write access if True, otherwise
+ read-only access
+ @type readWrite: C{boolean}
+ """
+ return self._addDelegateGroupQuery.on(self, delegator=str(delegator),
+ groupID=delegateGroupID, readWrite=1 if readWrite else 0)
+
+
+ def removeDelegate(self, delegator, delegate, readWrite):
+ """
+ Removes a row from the DELEGATES table. The delegate should not be a
+ group. To remove a delegate group, call removeDelegateGroup() instead.
+
+ @param delegator: the GUID of the delegator
+ @type delegator: C{str} in normalized form (lowercase, no dashes)
+ @param delegate: the GUID of the delegate
+ @type delegate: C{str} in normalized form (lowercase, no dashes)
+ @param readWrite: remove read and write access if True, otherwise
+ read-only access
+ @type readWrite: C{boolean}
+ """
+ return self._removeDelegateQuery.on(self, delegator=str(delegator),
+ delegate=delegate, readWrite=1 if readWrite else 0)
+
+
+ def removeDelegateGroup(self, delegator, delegateGroupID, readWrite):
+ """
+ Removes a row from the DELEGATE_GROUPS table. The delegate should be a
+ group. To remove a delegate person, call removeDelegate() instead.
+
+ @param delegator: the GUID of the delegator
+ @type delegator: C{str} in normalized form (lowercase, no dashes)
+ @param delegateGroupID: the GROUP_ID of the delegate group
+ @type delegateGroupID: C{int}
+ @param readWrite: remove read and write access if True, otherwise
+ read-only access
+ @type readWrite: C{boolean}
+ """
+ return self._removeDelegateGroupQuery.on(self, delegator=str(delegator),
+ groupID=delegateGroupID, readWrite=1 if readWrite else 0)
+
+
+ @inlineCallbacks
+ def delegates(self, delegator, readWrite):
+ """
+ Returns the GUIDs of all delegates for the given delegator. If
+ delegate access was granted to any groups, those groups' members
+ (flattened) will be included. No GUIDs of the groups themselves
+ will be returned.
+
+ @param delegator: the GUID of the delegator
+ @type delegator: C{str} in normalized form (lowercase, no dashes)
+ @param readWrite: the access-type to check for; read and write
+ access if True, otherwise read-only access
+ @type readWrite: C{boolean}
+ @returns: the GUIDs of the delegates (for the specified access
+ type)
+ @rtype: a Deferred resulting in a set
+ """
+ delegates = set()
+
+ # First get the direct delegates
+ results = (yield self._selectDelegatesQuery.on(self,
+ delegator=str(delegator), readWrite=1 if readWrite else 0))
+ for row in results:
+ delegates.add(row[0])
+
+ # Finally get those who are in groups which have been delegated to
+ results = (yield self._selectIndirectDelegatesQuery.on(self,
+ delegator=str(delegator), readWrite=1 if readWrite else 0))
+ for row in results:
+ delegates.add(row[0])
+
+ returnValue(delegates)
+
+
+ @inlineCallbacks
+ def delegators(self, delegate, readWrite):
+ """
+ Returns the GUIDs of all delegators which have granted access to
+ the given delegate, either directly or indirectly via groups.
+
+ @param delegate: the GUID of the delegate
+ @type delegate: C{str} in normalized form (lowercase, no dashes)
+ @param readWrite: the access-type to check for; read and write
+ access if True, otherwise read-only access
+ @type readWrite: C{boolean}
+ @returns: the GUIDs of the delegators (for the specified access
+ type)
+ @rtype: a Deferred resulting in a set
+ """
+ delegators = set()
+
+ # First get the direct delegators
+ results = (yield self._selectDirectDelegatorsQuery.on(self,
+ delegate=delegate, readWrite=1 if readWrite else 0))
+ for row in results:
+ delegators.add(row[0])
+
+ # Finally get those who have delegated to groups the delegate
+ # is a member of
+ results = (yield self._selectIndirectDelegatorsQuery.on(self,
+ delegate=delegate, readWrite=1 if readWrite else 0))
+ for row in results:
+ delegators.add(row[0])
+
+ returnValue(delegators)
+
+
+ @inlineCallbacks
+ def allGroupDelegates(self):
+ """
+ Return the GUIDs of all groups which have been delegated to. Useful
+ for obtaining the set of groups which need to be synchronized from
+ the directory.
+
+ @returns: the GUIDs of all delegated-to groups
+ @rtype: a Deferred resulting in a set
+ """
+ gr = schema.GROUPS
+ dg = schema.DELEGATE_GROUPS
+
+ results = (yield Select(
+ [gr.GROUP_GUID],
+ From=gr,
+ Where=(gr.GROUP_ID.In(Select([dg.GROUP_ID], From=dg, Where=None)))
+ ).on(self))
+ delegates = set()
+ for row in results:
+ delegates.add(row[0])
+
+ returnValue(delegates)
+
+ # End of Delegates
+
+
</ins><span class="cx"> def preCommit(self, operation):
</span><span class="cx"> """
</span><span class="cx"> Run things before C{commit}. (Note: only provided by SQL
</span></span></pre>
</div>
</div>
</body>
</html>