def updateProxyStore(self, store):
"""
Move the XML file proxies over to the store database.
"""
directory = store.directoryService()
txn = store.newTransaction(label="xmlDelegatesToStore")
for item in self.items:
guid, write_proxies, read_proxies = item
delegatorRecord = yield directory.recordWithUID(guid)
if delegatorRecord is None:
continue
for proxy in write_proxies:
delegateRecord = yield directory.recordWithUID(proxy)
if delegateRecord is None:
continue
yield Delegates.addDelegate(txn, delegatorRecord, delegateRecord, True)
for proxy in read_proxies:
delegateRecord = yield directory.recordWithUID(proxy)
if delegateRecord is None:
continue
yield Delegates.addDelegate(txn, delegatorRecord, delegateRecord, False)
yield txn.commit()
def updateProxyStore(self, store):
"""
Move the XML file proxies over to the store database.
"""
directory = store.directoryService()
txn = store.newTransaction(label="xmlDelegatesToStore")
for item in self.items:
guid, write_proxies, read_proxies = item
delegatorRecord = yield directory.recordWithUID(guid)
if delegatorRecord is None:
continue
for proxy in write_proxies:
delegateRecord = yield directory.recordWithUID(proxy)
if delegateRecord is None:
continue
yield Delegates.addDelegate(txn, delegatorRecord,
delegateRecord, True)
for proxy in read_proxies:
delegateRecord = yield directory.recordWithUID(proxy)
if delegateRecord is None:
continue
yield Delegates.addDelegate(txn, delegatorRecord,
delegateRecord, False)
yield txn.commit()
def test_proxyFor(self):
"""
Test that L{DirectoryPrincipalResource.proxyFor} returns the correct results.
"""
principal01 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user01")))
principal02 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user02")))
principal03 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user03")))
# Check proxy for
proxies = yield principal01.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal01.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(True)
self.assertEqual(proxies, set())
# Make user02 a read-only proxy for user01, and user03 a read-write proxy for user01
yield Delegates.addDelegate(self.transactionUnderTest(), principal01.record, principal02.record, False)
yield Delegates.addDelegate(self.transactionUnderTest(), principal01.record, principal03.record, True)
yield self.commit()
# Check proxy for
proxies = yield principal01.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal01.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(False)
self.assertEqual(proxies, set((principal01,)))
proxies = yield principal02.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(True)
self.assertEqual(proxies, set((principal01,)))
# Remove user02 as read-only proxy for user01, and user03 as read-write proxy for user01
yield Delegates.removeDelegate(self.transactionUnderTest(), principal01.record, principal02.record, False)
yield Delegates.removeDelegate(self.transactionUnderTest(), principal01.record, principal03.record, True)
yield self.commit()
# Check proxy for
proxies = yield principal01.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal01.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(True)
self.assertEqual(proxies, set())
def test_proxyFor(self):
"""
Test that L{DirectoryPrincipalResource.proxyFor} returns the correct results.
"""
principal01 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user01")))
principal02 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user02")))
principal03 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user03")))
# Check proxy for
proxies = yield principal01.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal01.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(True)
self.assertEqual(proxies, set())
# Make user02 a read-only proxy for user01, and user03 a read-write proxy for user01
yield Delegates.addDelegate(self.transactionUnderTest(), principal01.record, principal02.record, False)
yield Delegates.addDelegate(self.transactionUnderTest(), principal01.record, principal03.record, True)
yield self.commit()
# Check proxy for
proxies = yield principal01.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal01.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(False)
self.assertEqual(proxies, set((principal01,)))
proxies = yield principal02.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(True)
self.assertEqual(proxies, set((principal01,)))
# Remove user02 as read-only proxy for user01, and user03 as read-write proxy for user01
yield Delegates.removeDelegate(self.transactionUnderTest(), principal01.record, principal02.record, False)
yield Delegates.removeDelegate(self.transactionUnderTest(), principal01.record, principal03.record, True)
yield self.commit()
# Check proxy for
proxies = yield principal01.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal01.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal02.proxyFor(True)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(False)
self.assertEqual(proxies, set())
proxies = yield principal03.proxyFor(True)
self.assertEqual(proxies, set())
def test_hideDisabledProxies(self):
"""
Make sure users that are missing or not enabled for calendaring are removed
from the proxyFor list.
"""
# Check proxies empty right now
principal01 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user01")))
self.assertTrue(len((yield principal01.proxyFor(False))) == 0)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
principal02 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user02")))
self.assertTrue(len((yield principal02.proxyFor(False))) == 0)
self.assertTrue(len((yield principal02.proxyFor(True))) == 0)
principal03 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user03")))
self.assertTrue(len((yield principal03.proxyFor(False))) == 0)
self.assertTrue(len((yield principal03.proxyFor(True))) == 0)
# Make user01 a read-only proxy for user02 and user03
yield Delegates.addDelegate(self.transactionUnderTest(), principal02.record, principal01.record, False)
yield Delegates.addDelegate(self.transactionUnderTest(), principal03.record, principal01.record, False)
yield self.commit()
self.assertTrue(len((yield principal01.proxyFor(False))) == 2)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Now disable user02
yield self.changeRecord(principal02.record, self.directory.fieldName.hasCalendars, False)
self.assertTrue(len((yield principal01.proxyFor(False))) == 1)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Now enable user02
yield self.changeRecord(principal02.record, self.directory.fieldName.hasCalendars, True)
self.assertTrue(len((yield principal01.proxyFor(False))) == 2)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Now remove user02
yield self.directory.removeRecords((principal02.record.uid,))
self.assertTrue(len((yield principal01.proxyFor(False))) == 1)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Remove user01 as read-only proxy for user02 and user03
yield Delegates.removeDelegate(self.transactionUnderTest(), principal02.record, principal01.record, False)
yield Delegates.removeDelegate(self.transactionUnderTest(), principal03.record, principal01.record, False)
yield self.commit()
self.assertTrue(len((yield principal01.proxyFor(False))) == 0)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
def test_hideDisabledProxies(self):
"""
Make sure users that are missing or not enabled for calendaring are removed
from the proxyFor list.
"""
# Check proxies empty right now
principal01 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user01")))
self.assertTrue(len((yield principal01.proxyFor(False))) == 0)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
principal02 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user02")))
self.assertTrue(len((yield principal02.proxyFor(False))) == 0)
self.assertTrue(len((yield principal02.proxyFor(True))) == 0)
principal03 = yield self.principalRootResource.principalForUID((yield self.userUIDFromShortName("user03")))
self.assertTrue(len((yield principal03.proxyFor(False))) == 0)
self.assertTrue(len((yield principal03.proxyFor(True))) == 0)
# Make user01 a read-only proxy for user02 and user03
yield Delegates.addDelegate(self.transactionUnderTest(), principal02.record, principal01.record, False)
yield Delegates.addDelegate(self.transactionUnderTest(), principal03.record, principal01.record, False)
yield self.commit()
self.assertTrue(len((yield principal01.proxyFor(False))) == 2)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Now disable user02
yield self.changeRecord(principal02.record, self.directory.fieldName.hasCalendars, False)
self.assertTrue(len((yield principal01.proxyFor(False))) == 1)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Now enable user02
yield self.changeRecord(principal02.record, self.directory.fieldName.hasCalendars, True)
self.assertTrue(len((yield principal01.proxyFor(False))) == 2)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Now remove user02
yield self.directory.removeRecords((principal02.record.uid,))
self.assertTrue(len((yield principal01.proxyFor(False))) == 1)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
# Remove user01 as read-only proxy for user02 and user03
yield Delegates.removeDelegate(self.transactionUnderTest(), principal02.record, principal01.record, False)
yield Delegates.removeDelegate(self.transactionUnderTest(), principal03.record, principal01.record, False)
yield self.commit()
self.assertTrue(len((yield principal01.proxyFor(False))) == 0)
self.assertTrue(len((yield principal01.proxyFor(True))) == 0)
def test_noDuplication(self):
"""
Make sure addDelegate( ) is idempotent
"""
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
# Delegate users:
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, delegate1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, delegate1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
results = (
yield txn._selectDelegatesQuery.on(
txn,
delegator=delegator.uid.encode("utf-8"),
readWrite=1
)
)
yield txn.commit()
self.assertEquals([["__sagen1__"]], results)
# Delegate groups:
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, group1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, group1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
results = (
yield txn._selectDelegateGroupsQuery.on(
txn,
delegator=delegator.uid.encode("utf-8"),
readWrite=1
)
)
yield txn.commit()
self.assertEquals([["__top_group_1__"]], results)
def test_noDuplication(self):
"""
Make sure addDelegate( ) is idempotent
"""
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
# Delegate users:
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, delegate1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, delegate1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
results = yield DelegateRecord.query(
txn,
(DelegateRecord.delegator == delegator.uid.encode("utf-8")).And(
DelegateRecord.readWrite == 1))
yield txn.commit()
self.assertEquals([
"__sagen1__",
], [record.delegate for record in results])
# Delegate groups:
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, group1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, group1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
results = yield DelegateGroupsRecord.delegateGroups(
txn,
delegator.uid,
True,
)
yield txn.commit()
self.assertEquals([
"__top_group_1__",
], [record.groupUID for record in results])
def _delegatesOfResults(self, delegator, readWrite, expanded, results):
delegates = (yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, readWrite, expanded))
self.assertEquals(
set([d.uid for d in delegates]),
set([delegate.uid for delegate in results]),
msg="uid:{}, rw={}, expanded={}".format(delegator.uid, readWrite, expanded)
)
def _delegatedToResults(self, delegate, readWrite, results):
delegators = (yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, readWrite))
self.assertEquals(
set([d.uid for d in delegators]),
set([delegator.uid for delegator in results]),
msg="uid:{}, rw={}".format(delegate.uid, readWrite)
)
def _delegatedToResults(self, delegate, readWrite, results):
delegators = (yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, readWrite))
self.assertEquals(
set([d.uid for d in delegators]),
set([delegator.uid for delegator in results]),
msg="uid:{}, rw={}".format(delegate.uid, readWrite)
)
def recv_set_delegates(self, txn, request):
"""
Process a set delegates cross-pod request. Request arguments as per L{send_set_delegates}.
@param request: request arguments
@type request: C{dict}
"""
delegator = yield txn.directoryService().recordWithUID(request["uid"])
if delegator is None or not delegator.thisServer():
raise FailedCrossPodRequestError(
"Cross-pod delegate not on this server: {}".format(
delegator.uid))
delegates = []
for uid in request["delegates"]:
delegate = yield txn.directoryService().recordWithUID(uid)
if delegate is None:
raise FailedCrossPodRequestError(
"Cross-pod delegate missing on this server: {}".format(
uid))
delegates.append(delegate)
yield Delegates.setDelegates(txn, delegator, delegates,
request["read-write"])
def _delegatesOfResults(self, delegator, readWrite, expanded, results):
delegates = (yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, readWrite, expanded))
self.assertEquals(
set([d.uid for d in delegates]),
set([delegate.uid for delegate in results]),
msg="uid:{}, rw={}, expanded={}".format(delegator.uid, readWrite, expanded)
)
def test_noDuplication(self):
"""
Make sure addDelegate( ) is idempotent
"""
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
# Delegate users:
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, delegate1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, delegate1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
results = yield DelegateRecord.query(
txn,
(DelegateRecord.delegator == delegator.uid.encode("utf-8")).And(
DelegateRecord.readWrite == 1
)
)
yield txn.commit()
self.assertEquals(["__sagen1__", ], [record.delegate for record in results])
# Delegate groups:
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, group1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
yield Delegates.addDelegate(txn, delegator, group1, True)
yield txn.commit()
txn = self.store.newTransaction(label="test_noDuplication")
results = yield DelegateGroupsRecord.delegateGroups(
txn,
delegator.uid,
True,
)
yield txn.commit()
self.assertEquals(["__top_group_1__", ], [record.groupUID for record in results])
def test_cacheUsed(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
# Patch transaction so we can monitor whether cache is being used
original_delegates = CommonStoreTransaction.delegates
delegates_query = [0]
def _delegates(self, delegator, readWrite, expanded=False):
delegates_query[0] += 1
return original_delegates(self, delegator, readWrite, expanded)
self.patch(CommonStoreTransaction, "delegates", _delegates)
original_delegators = CommonStoreTransaction.delegators
delegators_query = [0]
def _delegators(self, delegate, readWrite):
delegators_query[0] += 1
return original_delegators(self, delegate, readWrite)
self.patch(CommonStoreTransaction, "delegators", _delegators)
# Not used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True, False)
self.assertEqual(delegates_query[0], 1)
# Used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True, False)
self.assertEqual(delegates_query[0], 1)
# Not used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False, False)
self.assertEqual(delegates_query[0], 2)
# Used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False, False)
self.assertEqual(delegates_query[0], 2)
# Not used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, True)
self.assertEqual(delegators_query[0], 1)
# Used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, True)
self.assertEqual(delegators_query[0], 1)
# Not used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, False)
self.assertEqual(delegators_query[0], 2)
# Used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, False)
self.assertEqual(delegators_query[0], 2)
def test_cacheUsed(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
# Patch transaction so we can monitor whether cache is being used
original_delegates = CommonStoreTransaction.delegates
delegates_query = [0]
def _delegates(self, delegator, readWrite, expanded=False):
delegates_query[0] += 1
return original_delegates(self, delegator, readWrite, expanded)
self.patch(CommonStoreTransaction, "delegates", _delegates)
original_delegators = CommonStoreTransaction.delegators
delegators_query = [0]
def _delegators(self, delegate, readWrite):
delegators_query[0] += 1
return original_delegators(self, delegate, readWrite)
self.patch(CommonStoreTransaction, "delegators", _delegators)
# Not used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True, False)
self.assertEqual(delegates_query[0], 1)
# Used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True, False)
self.assertEqual(delegates_query[0], 1)
# Not used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False, False)
self.assertEqual(delegates_query[0], 2)
# Used
yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False, False)
self.assertEqual(delegates_query[0], 2)
# Not used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, True)
self.assertEqual(delegators_query[0], 1)
# Used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, True)
self.assertEqual(delegators_query[0], 1)
# Not used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, False)
self.assertEqual(delegators_query[0], 2)
# Used
yield Delegates.delegatedTo(self.transactionUnderTest(), delegate1, False)
self.assertEqual(delegators_query[0], 2)
def migrateWiki(store, principalID):
"""
Iterate calendar homes looking for wiki principals; create resources
for each.
"""
directory = store.directoryService()
recordType = CalRecordType.resource
prefix = WikiDirectoryService.uidPrefix
ch = schema.CALENDAR_HOME
if principalID is not None:
delegateRecord = yield recordForPrincipalID(directory, principalID)
else:
delegateRecord = None
# Look up in the DB all the uids starting with the wiki prefix
txn = store.newTransaction()
rows = (yield Select(
[
ch.OWNER_UID,
],
From=ch,
Where=(ch.OWNER_UID.StartsWith(prefix)),
).on(txn))
yield txn.commit()
# For each wiki uid, if the resource record does not already exist,
# create a record
for uid in [row[0] for row in rows]:
uid = uid.decode("utf-8")
record = yield directory.recordWithUID(uid)
if record is None:
name = uid[len(prefix):]
fields = {
directory.fieldName.recordType: recordType,
directory.fieldName.uid: uid,
directory.fieldName.shortNames: [name],
directory.fieldName.fullNames: [name],
directory.fieldName.hasCalendars: True,
directory.fieldName.hasContacts: False,
}
record = DirectoryRecord(directory, fields)
yield record.service.updateRecords([record], create=True)
print("Added '{}'".format(name))
# Refetch the record
yield directory.flush()
record = yield directory.recordWithUID(uid)
if delegateRecord is not None:
txn = store.newTransaction()
yield Delegates.addDelegate(txn, record, delegateRecord, True)
yield txn.commit()
def groupChanged(self, groupID, addedUIDs, removedUIDs):
"""
Called when membership of a group changes.
@param groupID: group id of group that changed
@type groupID: L{str}
@param addedUIDs: set of new member UIDs added to the group
@type addedUIDs: L{set} of L{str}
@param removedUIDs: set of old member UIDs removed from the group
@type removedUIDs: L{set} of L{str}
"""
yield Delegates.groupChanged(self, groupID, addedUIDs, removedUIDs)
def groupChanged(self, groupID, addedUIDs, removedUIDs):
"""
Called when membership of a group changes.
@param groupID: group id of group that changed
@type groupID: L{str}
@param addedUIDs: set of new member UIDs added to the group
@type addedUIDs: L{set} of L{str}
@param removedUIDs: set of old member UIDs removed from the group
@type removedUIDs: L{set} of L{str}
"""
yield Delegates.groupChanged(self, groupID, addedUIDs, removedUIDs)
def applyExternalAssignments(self, txn, delegatorUID, readDelegateUID,
writeDelegateUID):
self.log.debug("External delegate assignments changed for {uid}",
uid=delegatorUID)
# Retrieve the previous delegate assignments (if any) because we have
# to invalidate their cached entries after calling assignExternalDelegates()
(previousReadDelegateUID, previousWriteDelegateUID
) = yield txn.externalDelegatesForDelegator(delegatorUID)
readDelegateGroupID = writeDelegateGroupID = None
if readDelegateUID:
readDelegateGroup = yield txn.groupByUID(readDelegateUID)
if readDelegateGroup is None:
# The group record does not actually exist
readDelegateUID = None
else:
readDelegateGroupID = readDelegateGroup.groupID
if writeDelegateUID:
writeDelegateGroup = yield txn.groupByUID(writeDelegateUID)
if writeDelegateGroup is None:
# The group record does not actually exist
writeDelegateUID = None
else:
writeDelegateGroupID = writeDelegateGroup.groupID
yield txn.assignExternalDelegates(delegatorUID, readDelegateGroupID,
writeDelegateGroupID,
readDelegateUID, writeDelegateUID)
# Send cache change notifications
if self.cacheNotifier is not None:
self.cacheNotifier.changed(delegatorUID)
if readDelegateUID:
self.cacheNotifier.changed(readDelegateUID)
if writeDelegateUID:
self.cacheNotifier.changed(writeDelegateUID)
if previousReadDelegateUID:
self.cacheNotifier.changed(previousReadDelegateUID)
if previousWriteDelegateUID:
self.cacheNotifier.changed(previousWriteDelegateUID)
# Invalidate the relevant memcached entries
yield Delegates.invalidateExternalAssignment(txn, delegatorUID,
readDelegateUID,
writeDelegateUID,
previousReadDelegateUID,
previousWriteDelegateUID)
def test_migrateWiki(self):
# Ensure the two records do not exist yet
record = yield self.directory.recordWithUID(u"wiki-xyzzy")
self.assertEquals(record, None)
record = yield self.directory.recordWithUID(u"wiki-plugh")
self.assertEquals(record, None)
# We need to create the calendar homes, but we can't unless there are
# records for these uids. Since we've disabled the wiki service above,
# we're temporarily going to substitute a wiki directory service while
# we create the calendar homes:
realDirectory = self.store.directoryService()
tmpWikiService = WikiDirectoryService("test", None)
tmpWikiService.serversDB = lambda: None
self.store._directoryService = tmpWikiService
txn = self.store.newTransaction()
yield txn.calendarHomeWithUID(u"wiki-xyzzy", create=True)
yield txn.calendarHomeWithUID(u"wiki-plugh", create=True)
yield txn.commit()
self.store._directoryService = realDirectory
# Migrate wiki principals to resources
yield migrateWiki(self.store, "users:admin")
txn = self.store.newTransaction()
record = yield self.directory.recordWithUID(u"wiki-xyzzy")
self.assertEquals(record.shortNames, [u"xyzzy"])
self.assertEquals(record.recordType, CalRecordType.resource)
delegates = (yield Delegates.delegatesOf(txn, record, True))
self.assertEquals([u"admin"], [d.shortNames[0] for d in delegates])
record = yield self.directory.recordWithUID(u"wiki-plugh")
self.assertEquals(record.shortNames, [u"plugh"])
self.assertEquals(record.recordType, CalRecordType.resource)
delegates = (yield Delegates.delegatesOf(txn, record, True))
self.assertEquals([u"admin"], [d.shortNames[0] for d in delegates])
yield txn.commit()
def _removeProxy(self, command, proxyType):
record = yield recordForPrincipalID(self.dir, command['Principal'])
if record is None:
self.respondWithError("Principal not found: %s" % (command['Principal'],))
returnValue(None)
proxyRecord = yield recordForPrincipalID(self.dir, command['Proxy'])
if proxyRecord is None:
self.respondWithError("Proxy not found: %s" % (command['Proxy'],))
returnValue(None)
txn = self.store.newTransaction()
yield Delegates.removeDelegate(txn, record, proxyRecord, (proxyType == "write"))
yield txn.commit()
yield self.respondWithProxies(command, record, proxyType)
def _removeProxy(self, command, proxyType):
record = yield recordForPrincipalID(self.dir, command['Principal'])
if record is None:
self.respondWithError("Principal not found: %s" % (command['Principal'],))
returnValue(None)
proxyRecord = yield recordForPrincipalID(self.dir, command['Proxy'])
if proxyRecord is None:
self.respondWithError("Proxy not found: %s" % (command['Proxy'],))
returnValue(None)
txn = self.store.newTransaction()
yield Delegates.removeDelegate(txn, record, proxyRecord, (proxyType == "write"))
yield txn.commit()
yield self.respondWithProxies(command, record, proxyType)
def recv_get_delegates(self, txn, request):
"""
Process an delegates cross-pod request. Request arguments as per L{send_get_delegates}.
@param request: request arguments
@type request: C{dict}
"""
delegator = yield txn.directoryService().recordWithUID(request["uid"])
if delegator is None or not delegator.thisServer():
raise FailedCrossPodRequestError("Cross-pod delegate not on this server: {}".format(delegator.uid))
delegates = yield Delegates._delegatesOfUIDs(txn, delegator, request["read-write"], request["expanded"])
returnValue(list(delegates))
def recv_get_delegates(self, txn, request):
"""
Process an delegates cross-pod request. Request arguments as per L{send_get_delegates}.
@param request: request arguments
@type request: C{dict}
"""
delegator = yield txn.directoryService().recordWithUID(request["uid"])
if delegator is None or not delegator.thisServer():
raise FailedCrossPodRequestError("Cross-pod delegate not on this server: {}".format(delegator.uid))
delegates = yield Delegates._delegatesOfUIDs(txn, delegator, request["read-write"], request["expanded"])
returnValue(list(delegates))
def recv_get_delegators(self, txn, request):
"""
Process an delegators cross-pod request. Request arguments as per L{send_get_delegators}.
@param request: request arguments
@type request: C{dict}
"""
delegate = yield txn.directoryService().recordWithUID(request["uid"])
if delegate is None or delegate.thisServer():
raise FailedCrossPodRequestError("Cross-pod delegate missing or on this server: {}".format(delegate.uid))
delegators = yield Delegates._delegatedToUIDs(txn, delegate, request["read-write"], onlyThisServer=True)
returnValue(list(delegators))
def recv_get_delegators(self, txn, request):
"""
Process an delegators cross-pod request. Request arguments as per L{send_get_delegators}.
@param request: request arguments
@type request: C{dict}
"""
delegate = yield txn.directoryService().recordWithUID(request["uid"])
if delegate is None or delegate.thisServer():
raise FailedCrossPodRequestError("Cross-pod delegate missing or on this server: {}".format(delegate.uid))
delegators = yield Delegates._delegatedToUIDs(txn, delegate, request["read-write"], onlyThisServer=True)
returnValue(list(delegators))
def migrateDelegatesToStore(store):
"""
Migrate the old sqlite proxyDB data into the store. Remove the sqlite file
afterwards.
@param store: the store to migrate into
@type store: L{CommonDataStore}
"""
log.warn("Migrating delegates to the store")
service = ProxySqliteDB("proxies.sqlite")
directory = store.directoryService()
txn = store.newTransaction(label="migrateDelegatesToStore")
for groupName, memberUID in (
yield service.query(
"select GROUPNAME, MEMBER from GROUPS"
)
):
if "#" not in groupName:
continue
delegatorUID, groupType = groupName.split("#")
delegatorRecord = yield directory.recordWithUID(delegatorUID)
if delegatorRecord is None:
continue
delegateRecord = yield directory.recordWithUID(memberUID)
if delegateRecord is None:
continue
readWrite = (groupType == "calendar-proxy-write")
yield Delegates.addDelegate(txn, delegatorRecord, delegateRecord, readWrite)
yield txn.commit()
# Remove the old file
service.close()
os.remove(service.dbpath)
journalPath = service.dbpath + "-journal"
if os.path.exists(journalPath):
os.remove(journalPath)
def recv_set_delegates(self, txn, request):
"""
Process a set delegates cross-pod request. Request arguments as per L{send_set_delegates}.
@param request: request arguments
@type request: C{dict}
"""
delegator = yield txn.directoryService().recordWithUID(request["uid"])
if delegator is None or not delegator.thisServer():
raise FailedCrossPodRequestError("Cross-pod delegate not on this server: {}".format(delegator.uid))
delegates = []
for uid in request["delegates"]:
delegate = yield txn.directoryService().recordWithUID(uid)
if delegate is None:
raise FailedCrossPodRequestError("Cross-pod delegate missing on this server: {}".format(uid))
delegates.append(delegate)
yield Delegates.setDelegates(txn, delegator, delegates, request["read-write"])
def test_indirectDelegation(self):
txn = self.store.newTransaction(label="test_indirectDelegation")
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
group2 = yield self.directory.recordWithUID(u"__sub_group_1__")
# Add group delegate
yield Delegates.addDelegate(txn, delegator, group1, True)
# Passing expanded=False will return the group
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=False))
self.assertEquals(1, len(delegates))
self.assertEquals(delegates[0].uid, u"__top_group_1__")
# Passing expanded=True will return not the group -- it only returns
# non-groups
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__", u"__glyph1__"]),
set([d.uid for d in delegates])
)
delegators = (yield Delegates.delegatedTo(txn, delegate1, True))
self.assertEquals([u"__wsanchez1__"], [d.uid for d in delegators])
# Verify we can ask for all delegated-to groups
yield Delegates.addDelegate(txn, delegator, group2, True)
groups = (yield txn.allGroupDelegates())
self.assertEquals(
set([u'__sub_group_1__', u'__top_group_1__']), set(groups)
)
# Delegate to a user who is already indirectly delegated-to
yield Delegates.addDelegate(txn, delegator, delegate1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__", u"__glyph1__"]),
set([d.uid for d in delegates])
)
# Add a member to the group; they become a delegate
newSet = set()
for name in (u"wsanchez1", u"cdaboo1", u"sagen1", u"glyph1", u"dre1"):
record = (
yield self.directory.recordWithShortName(RecordType.user, name)
)
newSet.add(record.uid)
group = yield txn.groupByUID(group1.uid)
_ignore_added, _ignore_removed = (
yield self.groupCacher.synchronizeMembers(txn, group.groupID, newSet)
)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__", u"__glyph1__", u"__dre1__"]),
set([d.uid for d in delegates])
)
# Remove delegate access from the top group
yield Delegates.removeDelegate(txn, delegator, group1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
# Remove delegate access from the sub group
yield Delegates.removeDelegate(txn, delegator, group2, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__"]),
set([d.uid for d in delegates])
)
yield txn.commit()
def test_setGroupDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegates = [
(yield self.directory.recordWithUID(u"__sagen1__")),
(yield self.directory.recordWithUID(u"__cdaboo1__")),
(yield self.directory.recordWithUID(u"__glyph1__")),
(yield self.directory.recordWithUID(u"__dre1__")),
]
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
group2 = yield self.directory.recordWithUID(u"__sub_group_1__")
yield self.transactionUnderTest().groupByUID(u"__top_group_1__")
yield self.transactionUnderTest().groupByUID(u"__sub_group_1__")
yield self.commit()
def delegateMatch(*args):
return [delegates[i] for i in args]
# Add group delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group1], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__top_group_1__/",))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 2), None, None)
yield self._memcacherAllMembershipResults(delegator, None, None)
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, None, None, None, None)
yield self._memcacherAllMembershipResults(delegate, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group1], delegateMatch(0, 1, 2), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
yield self._delegatedToAllResults(delegates[3], [], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group1], delegateMatch(0, 1, 2), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[3], [], [])
# Add individual delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group1, delegates[3]], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__dre1__/"))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 2, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[3], None, [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group1, delegates[3]], delegateMatch(0, 1, 2, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group1, delegates[3]], delegateMatch(0, 1, 2, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Switch to sub-group
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group2, delegates[3]], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__top_group_1__/", u"/principals/__uids__/__sub_group_1__/"))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], None, [])
yield self._memcacherAllMembershipResults(delegates[1], None, [])
yield self._memcacherAllMembershipResults(delegates[2], None, [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group2, delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group2, delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Add member of existing group
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group2, delegates[0], delegates[3]], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__sagen1__/"))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group2, delegates[0], delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group2, delegates[0], delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Remove group
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[0], delegates[3]], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__sub_group_1__/"))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], None, [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[0], delegates[3]], delegateMatch(0, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [], [])
yield self._delegatedToAllResults(delegates[2], [], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[0], delegates[3]], delegateMatch(0, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
def test_setDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegates = [
(yield self.directory.recordWithUID(u"__sagen1__")),
(yield self.directory.recordWithUID(u"__cdaboo1__")),
(yield self.directory.recordWithUID(u"__dre1__")),
]
# Add delegates
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[0], delegates[1]], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__sagen1__/", u"/principals/__uids__/__cdaboo1__/",))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [delegates[0], delegates[1]], None, None)
yield self._memcacherAllMembershipResults(delegator, None, None)
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, None, None, None, None)
yield self._memcacherAllMembershipResults(delegate, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[0], delegates[1]], [delegates[0], delegates[1]], [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[0], delegates[1]], [delegates[0], delegates[1]], [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
# Remove delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[1], delegates[2]], True)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__sagen1__/", u"/principals/__uids__/__dre1__/"))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [delegates[1], delegates[2]], [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], None, [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], None, [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
# Add delegate with other mode
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[0]], False)
yield self.commit()
# Notifications
self.assertEqual(set(Delegates.cacheNotifier.history), set((u"/principals/__uids__/__wsanchez1__/", u"/principals/__uids__/__sagen1__/"))) # @UndefinedVariable
Delegates.cacheNotifier.clear() # @UndefinedVariable
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], None, [delegates[0]])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], None)
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [delegates[0]], [delegates[0]])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [], [delegator])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [delegates[0]], [delegates[0]])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], [delegator])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
def test_directDelegation(self):
txn = self.store.newTransaction(label="test_directDelegation")
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
delegate2 = yield self.directory.recordWithUID(u"__cdaboo1__")
# Add 1 delegate
yield Delegates.addDelegate(txn, delegator, delegate1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals([u"__sagen1__"], [d.uid for d in delegates])
delegators = (yield Delegates.delegatedTo(txn, delegate1, True))
self.assertEquals([u"__wsanchez1__"], [d.uid for d in delegators])
yield txn.commit() # So delegateService will see the changes
txn = self.store.newTransaction(label="test_directDelegation")
# The "proxy-write" pseudoGroup will have one member
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.writeDelegateGroup,
u"__wsanchez1__"
)
self.assertEquals(pseudoGroup.uid, u"__wsanchez1__#calendar-proxy-write")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[u"__sagen1__"]
)
# The "proxy-read" pseudoGroup will have no members
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.readDelegateGroup,
u"__wsanchez1__"
)
self.assertEquals(pseudoGroup.uid, u"__wsanchez1__#calendar-proxy-read")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[]
)
# The "proxy-write-for" pseudoGroup will have one member
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.writeDelegatorGroup,
u"__sagen1__"
)
self.assertEquals(pseudoGroup.uid, u"__sagen1__#calendar-proxy-write-for")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[u"__wsanchez1__"]
)
# The "proxy-read-for" pseudoGroup will have no members
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.readDelegatorGroup,
u"__sagen1__"
)
self.assertEquals(pseudoGroup.uid, u"__sagen1__#calendar-proxy-read-for")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[]
)
# Add another delegate
yield Delegates.addDelegate(txn, delegator, delegate2, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
delegators = (yield Delegates.delegatedTo(txn, delegate2, True))
self.assertEquals([u"__wsanchez1__"], [d.uid for d in delegators])
# Remove 1 delegate
yield Delegates.removeDelegate(txn, delegator, delegate1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals([u"__cdaboo1__"], [d.uid for d in delegates])
delegators = (yield Delegates.delegatedTo(txn, delegate1, True))
self.assertEquals(0, len(delegators))
# Remove the other delegate
yield Delegates.removeDelegate(txn, delegator, delegate2, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(0, len(delegates))
delegators = (yield Delegates.delegatedTo(txn, delegate2, True))
self.assertEquals(0, len(delegators))
yield txn.commit() # So delegateService will see the changes
# Now set delegate assignments by using pseudoGroup.setMembers()
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.writeDelegateGroup,
u"__wsanchez1__"
)
yield pseudoGroup.setMembers([delegate1, delegate2])
# Verify the assignments were made
txn = self.store.newTransaction(label="test_directDelegation")
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
yield txn.commit()
# Set a different group of assignments:
yield pseudoGroup.setMembers([delegate2])
# Verify the assignments were made
txn = self.store.newTransaction(label="test_directDelegation")
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(
set([u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
yield txn.commit()
def test_addRemoveDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
delegate2 = yield self.directory.recordWithUID(u"__cdaboo1__")
# Add delegate
yield Delegates.addDelegate(self.transactionUnderTest(), delegator,
delegate1, True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [delegate1],
None, None)
yield self._memcacherAllMemberResults(delegate1, None, None, None,
None)
yield self._memcacherAllMemberResults(delegate2, None, None, None,
None)
yield self._memcacherAllMembershipResults(delegator, None, None)
yield self._memcacherAllMembershipResults(delegate1, None, None)
yield self._memcacherAllMembershipResults(delegate2, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(
delegator,
[delegate1],
[delegate1],
[],
[],
)
yield self._delegatesOfAllResults(
delegate1,
[],
[],
[],
[],
)
yield self._delegatesOfAllResults(
delegate2,
[],
[],
[],
[],
)
yield self._delegatedToAllResults(
delegator,
[],
[],
)
yield self._delegatedToAllResults(
delegate1,
[delegator],
[],
)
yield self._delegatedToAllResults(
delegate2,
[],
[],
)
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegate1],
[delegate1], [], [])
yield self._memcacherAllMemberResults(delegate1, [], [], [], [])
yield self._memcacherAllMemberResults(delegate2, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegate1, [delegator],
[])
yield self._memcacherAllMembershipResults(delegate2, [], [])
# Remove delegate
yield Delegates.removeDelegate(self.transactionUnderTest(), delegator,
delegate1, True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [], [], [])
yield self._memcacherAllMemberResults(delegate1, [], [], [], [])
yield self._memcacherAllMemberResults(delegate2, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegate1, None, [])
yield self._memcacherAllMembershipResults(delegate2, [], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(
delegator,
[],
[],
[],
[],
)
yield self._delegatesOfAllResults(
delegate1,
[],
[],
[],
[],
)
yield self._delegatesOfAllResults(
delegate2,
[],
[],
[],
[],
)
yield self._delegatedToAllResults(
delegator,
[],
[],
)
yield self._delegatedToAllResults(
delegate1,
[],
[],
)
yield self._delegatedToAllResults(
delegate2,
[],
[],
)
# Check cache
yield self._memcacherAllMemberResults(delegator, [], [], [], [])
yield self._memcacherAllMemberResults(delegate1, [], [], [], [])
yield self._memcacherAllMemberResults(delegate2, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegate1, [], [])
yield self._memcacherAllMembershipResults(delegate2, [], [])
def copyAssignments(assignments, pod, directory, store):
"""
Go through the list of assignments from the old db, and selectively copy them
into the new store.
@param assignments: the assignments from the old db
@type assignments: a list of (delegator group, delegate) tuples
@param pod: the name of the pod you want to migrate assignments for; assignments
for delegators who don't reside on this pod will be ignored. Set this
to None to copy all assignments.
@param directory: the directory service
@param store: the store
"""
delegatorsMissingPodInfo = set()
numCopied = 0
numOtherPod = 0
numDirectoryBased = 0
numExamined = 0
# If locations and resources' delegate assignments come from the directory,
# then we're only interested in copying assignments where the delegator is a
# user.
if config.GroupCaching.Enabled and config.GroupCaching.UseDirectoryBasedDelegates:
delegatorRecordTypes = (RecordType.user, )
else:
delegatorRecordTypes = None
# When faulting in delegates, only worry about users and groups.
delegateRecordTypes = (RecordType.user, RecordType.group)
total = len(assignments)
for groupname, delegateUID in assignments:
numExamined += 1
if numExamined % 100 == 0:
print("Processed: {} of {}...".format(numExamined, total))
if "#" in groupname:
delegatorUID, permission = groupname.split("#")
try:
delegatorRecords = yield directory.recordsFromExpression(
MatchExpression(FieldName.uid,
delegatorUID,
matchType=MatchType.equals),
recordTypes=delegatorRecordTypes)
delegatorRecord = uniqueResult(delegatorRecords)
except Exception, e:
print("Failed to look up record for {}: {}".format(
delegatorUID, str(e)))
continue
if delegatorRecord is None:
continue
if config.GroupCaching.Enabled and config.GroupCaching.UseDirectoryBasedDelegates:
if delegatorRecord.recordType != RecordType.user:
print("Skipping non-user")
numDirectoryBased += 1
continue
if pod:
try:
if delegatorRecord.serviceNodeUID != pod:
numOtherPod += 1
continue
except AttributeError:
print("Record missing serviceNodeUID",
delegatorRecord.fullNames)
delegatorsMissingPodInfo.add(delegatorUID)
continue
try:
delegateRecords = yield directory.recordsFromExpression(
MatchExpression(FieldName.uid,
delegateUID,
matchType=MatchType.equals),
recordTypes=delegateRecordTypes)
delegateRecord = uniqueResult(delegateRecords)
except Exception, e:
print("Failed to look up record for {}: {}".format(
delegateUID, str(e)))
continue
if delegateRecord is None:
continue
txn = store.newTransaction(label="DelegatesMigrationService")
yield Delegates.addDelegate(txn, delegatorRecord, delegateRecord,
(permission == "calendar-proxy-write"))
numCopied += 1
yield txn.commit()
def test_setDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegates = [
(yield self.directory.recordWithUID(u"__sagen1__")),
(yield self.directory.recordWithUID(u"__cdaboo1__")),
(yield self.directory.recordWithUID(u"__dre1__")),
]
# Add delegates
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[0], delegates[1]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [delegates[0], delegates[1]], None, None)
yield self._memcacherAllMembershipResults(delegator, None, None)
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, None, None, None, None)
yield self._memcacherAllMembershipResults(delegate, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[0], delegates[1]], [delegates[0], delegates[1]], [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[0], delegates[1]], [delegates[0], delegates[1]], [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
# Remove delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[1], delegates[2]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [delegates[1], delegates[2]], [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], None, [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], None, [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
# Add delegate with other mode
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[0]], False)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], None, [delegates[0]])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], None)
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [delegates[0]], [delegates[0]])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [], [delegator])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[1], delegates[2]], [delegates[1], delegates[2]], [delegates[0]], [delegates[0]])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], [delegator])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
def test_directDelegation(self):
txn = self.store.newTransaction(label="test_directDelegation")
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
delegate2 = yield self.directory.recordWithUID(u"__cdaboo1__")
# Add 1 delegate
yield Delegates.addDelegate(txn, delegator, delegate1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals([u"__sagen1__"], [d.uid for d in delegates])
delegators = (yield Delegates.delegatedTo(txn, delegate1, True))
self.assertEquals([u"__wsanchez1__"], [d.uid for d in delegators])
yield txn.commit() # So delegateService will see the changes
txn = self.store.newTransaction(label="test_directDelegation")
# The "proxy-write" pseudoGroup will have one member
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.writeDelegateGroup,
u"__wsanchez1__"
)
self.assertEquals(pseudoGroup.uid, u"__wsanchez1__#calendar-proxy-write")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[u"__sagen1__"]
)
# The "proxy-read" pseudoGroup will have no members
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.readDelegateGroup,
u"__wsanchez1__"
)
self.assertEquals(pseudoGroup.uid, u"__wsanchez1__#calendar-proxy-read")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[]
)
# The "proxy-write-for" pseudoGroup will have one member
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.writeDelegatorGroup,
u"__sagen1__"
)
self.assertEquals(pseudoGroup.uid, u"__sagen1__#calendar-proxy-write-for")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[u"__wsanchez1__"]
)
# The "proxy-read-for" pseudoGroup will have no members
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.readDelegatorGroup,
u"__sagen1__"
)
self.assertEquals(pseudoGroup.uid, u"__sagen1__#calendar-proxy-read-for")
self.assertEquals(
[r.uid for r in (yield pseudoGroup.members())],
[]
)
# Add another delegate
yield Delegates.addDelegate(txn, delegator, delegate2, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
delegators = (yield Delegates.delegatedTo(txn, delegate2, True))
self.assertEquals([u"__wsanchez1__"], [d.uid for d in delegators])
# Remove 1 delegate
yield Delegates.removeDelegate(txn, delegator, delegate1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals([u"__cdaboo1__"], [d.uid for d in delegates])
delegators = (yield Delegates.delegatedTo(txn, delegate1, True))
self.assertEquals(0, len(delegators))
# Remove the other delegate
yield Delegates.removeDelegate(txn, delegator, delegate2, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(0, len(delegates))
delegators = (yield Delegates.delegatedTo(txn, delegate2, True))
self.assertEquals(0, len(delegators))
yield txn.commit() # So delegateService will see the changes
# Now set delegate assignments by using pseudoGroup.setMembers()
pseudoGroup = yield self.directory.recordWithShortName(
DelegateRecordType.writeDelegateGroup,
u"__wsanchez1__"
)
yield pseudoGroup.setMembers([delegate1, delegate2])
# Verify the assignments were made
txn = self.store.newTransaction(label="test_directDelegation")
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
yield txn.commit()
# Set a different group of assignments:
yield pseudoGroup.setMembers([delegate2])
# Verify the assignments were made
txn = self.store.newTransaction(label="test_directDelegation")
delegates = (yield Delegates.delegatesOf(txn, delegator, True))
self.assertEquals(
set([u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
yield txn.commit()
def test_setGroupDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegates = [
(yield self.directory.recordWithUID(u"__sagen1__")),
(yield self.directory.recordWithUID(u"__cdaboo1__")),
(yield self.directory.recordWithUID(u"__glyph1__")),
(yield self.directory.recordWithUID(u"__dre1__")),
]
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
group2 = yield self.directory.recordWithUID(u"__sub_group_1__")
yield self.transactionUnderTest().groupByUID(u"__top_group_1__")
yield self.transactionUnderTest().groupByUID(u"__sub_group_1__")
yield self.commit()
def delegateMatch(*args):
return [delegates[i] for i in args]
# Add group delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group1], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 2), None, None)
yield self._memcacherAllMembershipResults(delegator, None, None)
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, None, None, None, None)
yield self._memcacherAllMembershipResults(delegate, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group1], delegateMatch(0, 1, 2), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
yield self._delegatedToAllResults(delegates[3], [], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group1], delegateMatch(0, 1, 2), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[3], [], [])
# Add individual delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group1, delegates[3]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 2, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[3], None, [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group1, delegates[3]], delegateMatch(0, 1, 2, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group1, delegates[3]], delegateMatch(0, 1, 2, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Switch to sub-group
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group2, delegates[3]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], None, [])
yield self._memcacherAllMembershipResults(delegates[1], None, [])
yield self._memcacherAllMembershipResults(delegates[2], None, [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group2, delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group2, delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Add member of existing group
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [group2, delegates[0], delegates[3]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [group2, delegates[0], delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [group2, delegates[0], delegates[3]], delegateMatch(0, 1, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Remove group
yield Delegates.setDelegates(self.transactionUnderTest(), delegator, [delegates[0], delegates[3]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, delegateMatch(0, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], None, [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator, [delegates[0], delegates[3]], delegateMatch(0, 3), [], [])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [], [])
yield self._delegatedToAllResults(delegates[2], [], [])
yield self._delegatedToAllResults(delegates[3], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegates[0], delegates[3]], delegateMatch(0, 3), [], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [delegator], [])
yield self._memcacherAllMembershipResults(delegates[1], [], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
yield self._memcacherAllMembershipResults(delegates[3], [delegator], [])
def postCheck(self):
"""
Checks after migration is done
"""
# Check that the home has been moved
home = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user01")
self.assertTrue(home.external())
home = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_NORMAL)
self.assertTrue(home is None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_EXTERNAL)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_MIGRATING)
self.assertTrue(home is None)
yield self.commitTransaction(0)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user01")
self.assertTrue(home.normal())
home = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_NORMAL)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_EXTERNAL)
self.assertTrue(home is None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_MIGRATING)
self.assertTrue(home is None)
yield self.commitTransaction(1)
# Check that the notifications have been moved
notifications = yield self.notificationCollectionUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_NORMAL)
self.assertTrue(notifications is None)
notifications = yield self.notificationCollectionUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_EXTERNAL)
self.assertTrue(notifications is None)
notifications = yield self.notificationCollectionUnderTest(self.theTransactionUnderTest(0), name="user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(notifications is not None)
yield self.commitTransaction(0)
notifications = yield self.notificationCollectionUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_NORMAL)
self.assertTrue(notifications is not None)
notifications = yield self.notificationCollectionUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_EXTERNAL)
self.assertTrue(notifications is None)
notifications = yield self.notificationCollectionUnderTest(self.theTransactionUnderTest(1), name="user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(notifications is not None)
yield self.commitTransaction(1)
# New pod data
homes = {}
homes["user01"] = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user01")
homes["user02"] = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user02")
self.assertTrue(homes["user02"].external())
homes["user03"] = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="user03")
self.assertTrue(homes["user03"].external())
homes["puser01"] = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="puser01")
self.assertTrue(homes["puser01"].normal())
homes["puser02"] = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="puser02")
self.assertTrue(homes["puser02"].normal())
homes["puser03"] = yield self.homeUnderTest(self.theTransactionUnderTest(1), name="puser03")
self.assertTrue(homes["puser03"].normal())
# Check calendar data on new pod
calendars = yield homes["user01"].loadChildren()
calnames = dict([(calendar.name(), calendar) for calendar in calendars])
self.assertEqual(
set(calnames.keys()),
set(("calendar", "tasks", "inbox", self.stash["sharename_user02_to_user01"], self.stash["sharename_puser02_to_user01"],))
)
# Check shared-by user01 on new pod
shared = calnames["calendar"]
invitations = yield shared.sharingInvites()
by_sharee = dict([(invitation.shareeUID, invitation) for invitation in invitations])
self.assertEqual(len(invitations), 2)
self.assertEqual(set(by_sharee.keys()), set(("user03", "puser03",)))
self.assertEqual(by_sharee["user03"].shareeHomeID, homes["user03"].id())
self.assertEqual(by_sharee["puser03"].shareeHomeID, homes["puser03"].id())
# Check shared-to user01 on new pod
shared = calnames[self.stash["sharename_user02_to_user01"]]
self.assertEqual(shared.ownerHome().uid(), "user02")
self.assertEqual(shared.ownerHome().id(), homes["user02"].id())
shared = calnames[self.stash["sharename_puser02_to_user01"]]
self.assertEqual(shared.ownerHome().uid(), "puser02")
self.assertEqual(shared.ownerHome().id(), homes["puser02"].id())
shared = yield homes["puser02"].calendarWithName("calendar")
invitations = yield shared.sharingInvites()
self.assertEqual(len(invitations), 1)
self.assertEqual(invitations[0].shareeHomeID, homes["user01"].id())
yield self.commitTransaction(1)
# Old pod data
homes = {}
homes["user01"] = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user01")
homes["user02"] = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user02")
self.assertTrue(homes["user02"].normal())
homes["user03"] = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="user03")
self.assertTrue(homes["user03"].normal())
homes["puser01"] = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="puser01")
self.assertTrue(homes["puser01"] is None)
homes["puser02"] = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="puser02")
self.assertTrue(homes["puser02"].external())
homes["puser03"] = yield self.homeUnderTest(self.theTransactionUnderTest(0), name="puser03")
self.assertTrue(homes["puser03"].external())
# Check shared-by user01 on old pod
shared = yield homes["user03"].calendarWithName(self.stash["sharename_user01_to_user03"])
self.assertEqual(shared.ownerHome().uid(), "user01")
self.assertEqual(shared.ownerHome().id(), homes["user01"].id())
# Check shared-to user01 on old pod
shared = yield homes["user02"].calendarWithName("calendar")
invitations = yield shared.sharingInvites()
self.assertEqual(len(invitations), 1)
self.assertEqual(invitations[0].shareeHomeID, homes["user01"].id())
yield self.commitTransaction(0)
# Delegates on each pod
for pod in range(self.numberOfStores):
txn = self.theTransactionUnderTest(pod)
records = {}
for ctr in range(10):
uid = u"user{:02d}".format(ctr + 1)
records[uid] = yield txn.directoryService().recordWithUID(uid)
for ctr in range(10):
uid = u"puser{:02d}".format(ctr + 1)
records[uid] = yield txn.directoryService().recordWithUID(uid)
for ctr in range(10):
uid = u"group{:02d}".format(ctr + 1)
records[uid] = yield txn.directoryService().recordWithUID(uid)
delegates = yield Delegates.delegatesOf(txn, records["user01"], True, False)
self.assertTrue(records["user02"] in delegates)
self.assertTrue(records["group02"] in delegates)
delegates = yield Delegates.delegatesOf(txn, records["user01"], True, True)
self.assertTrue(records["user02"] in delegates)
self.assertTrue(records["user06"] in delegates)
self.assertTrue(records["user07"] in delegates)
self.assertTrue(records["user08"] in delegates)
delegates = yield Delegates.delegatesOf(txn, records["user01"], False, False)
self.assertTrue(records["user03"] in delegates)
self.assertTrue(records["group03"] in delegates)
self.assertTrue(records["puser01"] in delegates)
delegates = yield Delegates.delegatesOf(txn, records["user01"], False, True)
self.assertTrue(records["user03"] in delegates)
self.assertTrue(records["user07"] in delegates)
self.assertTrue(records["user08"] in delegates)
self.assertTrue(records["user09"] in delegates)
self.assertTrue(records["puser01"] in delegates)
# Attachments
obj = yield self.calendarObjectUnderTest(txn=self.theTransactionUnderTest(1), name="01_3.ics", calendar_name="calendar", home="user01")
attachment = yield obj.attachmentWithManagedID(self.stash["user01_attachment_mid"])
self.assertTrue(attachment is not None)
self.assertEqual(attachment.md5(), self.stash["user01_attachment_md5"])
data = yield self.attachmentToString(attachment)
self.assertEqual(data, "Here is some text #1.")
# Check removal of data from new pod
# Make sure all jobs are done
yield JobItem.waitEmpty(self.theStoreUnderTest(1).newTransaction, reactor, 60)
# No migration state data left
txn = self.theTransactionUnderTest(1)
for migrationType in (CalendarMigrationRecord, CalendarObjectMigrationRecord, AttachmentMigrationRecord,):
records = yield migrationType.all(txn)
self.assertEqual(len(records), 0, msg=migrationType.__name__)
yield self.commitTransaction(1)
# No homes
txn = self.theTransactionUnderTest(1)
oldhome = yield txn.calendarHomeWithUID("user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
oldhome = yield txn.notificationsWithUID("user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
# Check removal of data from old pod
# Make sure all jobs are done
yield JobItem.waitEmpty(self.theStoreUnderTest(0).newTransaction, reactor, 60)
# No homes
txn = self.theTransactionUnderTest(0)
oldhome = yield txn.calendarHomeWithUID("user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
oldhome = yield txn.notificationsWithUID("user01", status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
# No delegates
for delegateType in (DelegateRecord, DelegateGroupsRecord, ExternalDelegateGroupsRecord):
records = yield delegateType.query(txn, delegateType.delegator == "user01")
self.assertEqual(len(records), 0, msg=delegateType.__name__)
# No work items
for workType in allScheduleWork:
records = yield workType.query(txn, workType.homeResourceID == self.stash["user01_pod0_home_id"])
self.assertEqual(len(records), 0, msg=workType.__name__)
def test_indirectDelegation(self):
txn = self.store.newTransaction(label="test_indirectDelegation")
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
group1 = yield self.directory.recordWithUID(u"__top_group_1__")
group2 = yield self.directory.recordWithUID(u"__sub_group_1__")
# Add group delegate
yield Delegates.addDelegate(txn, delegator, group1, True)
# Passing expanded=False will return the group
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=False))
self.assertEquals(1, len(delegates))
self.assertEquals(delegates[0].uid, u"__top_group_1__")
# Passing expanded=True will return not the group -- it only returns
# non-groups
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__", u"__glyph1__"]),
set([d.uid for d in delegates])
)
delegators = (yield Delegates.delegatedTo(txn, delegate1, True))
self.assertEquals([u"__wsanchez1__"], [d.uid for d in delegators])
# Verify we can ask for all delegated-to groups
yield Delegates.addDelegate(txn, delegator, group2, True)
groups = (yield txn.allGroupDelegates())
self.assertEquals(
set([u'__sub_group_1__', u'__top_group_1__']), set(groups)
)
# Delegate to a user who is already indirectly delegated-to
yield Delegates.addDelegate(txn, delegator, delegate1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__", u"__glyph1__"]),
set([d.uid for d in delegates])
)
# Add a member to the group; they become a delegate
newSet = set()
for name in (u"wsanchez1", u"cdaboo1", u"sagen1", u"glyph1", u"dre1"):
record = (
yield self.directory.recordWithShortName(RecordType.user, name)
)
newSet.add(record.uid)
group = yield txn.groupByUID(group1.uid)
_ignore_added, _ignore_removed = (
yield self.groupCacher.synchronizeMembers(txn, group.groupID, newSet)
)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__", u"__glyph1__", u"__dre1__"]),
set([d.uid for d in delegates])
)
# Remove delegate access from the top group
yield Delegates.removeDelegate(txn, delegator, group1, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__", u"__cdaboo1__"]),
set([d.uid for d in delegates])
)
# Remove delegate access from the sub group
yield Delegates.removeDelegate(txn, delegator, group2, True)
delegates = (yield Delegates.delegatesOf(txn, delegator, True, expanded=True))
self.assertEquals(
set([u"__sagen1__"]),
set([d.uid for d in delegates])
)
yield txn.commit()
def test_addRemoveDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegate1 = yield self.directory.recordWithUID(u"__sagen1__")
delegate2 = yield self.directory.recordWithUID(u"__cdaboo1__")
# Add delegate
yield Delegates.addDelegate(self.transactionUnderTest(), delegator, delegate1, True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [delegate1], None, None)
yield self._memcacherAllMemberResults(delegate1, None, None, None, None)
yield self._memcacherAllMemberResults(delegate2, None, None, None, None)
yield self._memcacherAllMembershipResults(delegator, None, None)
yield self._memcacherAllMembershipResults(delegate1, None, None)
yield self._memcacherAllMembershipResults(delegate2, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(
delegator,
[delegate1], [delegate1], [], [],
)
yield self._delegatesOfAllResults(
delegate1,
[], [], [], [],
)
yield self._delegatesOfAllResults(
delegate2,
[], [], [], [],
)
yield self._delegatedToAllResults(
delegator,
[], [],
)
yield self._delegatedToAllResults(
delegate1,
[delegator], [],
)
yield self._delegatedToAllResults(
delegate2,
[], [],
)
# Check cache
yield self._memcacherAllMemberResults(delegator, [delegate1], [delegate1], [], [])
yield self._memcacherAllMemberResults(delegate1, [], [], [], [])
yield self._memcacherAllMemberResults(delegate2, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegate1, [delegator], [])
yield self._memcacherAllMembershipResults(delegate2, [], [])
# Remove delegate
yield Delegates.removeDelegate(self.transactionUnderTest(), delegator, delegate1, True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None, [], [], [])
yield self._memcacherAllMemberResults(delegate1, [], [], [], [])
yield self._memcacherAllMemberResults(delegate2, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegate1, None, [])
yield self._memcacherAllMembershipResults(delegate2, [], [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(
delegator,
[], [], [], [],
)
yield self._delegatesOfAllResults(
delegate1,
[], [], [], [],
)
yield self._delegatesOfAllResults(
delegate2,
[], [], [], [],
)
yield self._delegatedToAllResults(
delegator,
[], [],
)
yield self._delegatedToAllResults(
delegate1,
[], [],
)
yield self._delegatedToAllResults(
delegate2,
[], [],
)
# Check cache
yield self._memcacherAllMemberResults(delegator, [], [], [], [])
yield self._memcacherAllMemberResults(delegate1, [], [], [], [])
yield self._memcacherAllMemberResults(delegate2, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegate1, [], [])
yield self._memcacherAllMembershipResults(delegate2, [], [])
def postCheck(self):
"""
Checks after migration is done
"""
# Check that the home has been moved
home = yield self.homeUnderTest(self.theTransactionUnderTest(0),
name="user01")
self.assertTrue(home.external())
home = yield self.homeUnderTest(self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_NORMAL)
self.assertTrue(home is None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_EXTERNAL)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_MIGRATING)
self.assertTrue(home is None)
yield self.commitTransaction(0)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1),
name="user01")
self.assertTrue(home.normal())
home = yield self.homeUnderTest(self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_NORMAL)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_EXTERNAL)
self.assertTrue(home is None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(home is not None)
home = yield self.homeUnderTest(self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_MIGRATING)
self.assertTrue(home is None)
yield self.commitTransaction(1)
# Check that the notifications have been moved
notifications = yield self.notificationCollectionUnderTest(
self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_NORMAL)
self.assertTrue(notifications is None)
notifications = yield self.notificationCollectionUnderTest(
self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_EXTERNAL)
self.assertTrue(notifications is None)
notifications = yield self.notificationCollectionUnderTest(
self.theTransactionUnderTest(0),
name="user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(notifications is not None)
yield self.commitTransaction(0)
notifications = yield self.notificationCollectionUnderTest(
self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_NORMAL)
self.assertTrue(notifications is not None)
notifications = yield self.notificationCollectionUnderTest(
self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_EXTERNAL)
self.assertTrue(notifications is None)
notifications = yield self.notificationCollectionUnderTest(
self.theTransactionUnderTest(1),
name="user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(notifications is not None)
yield self.commitTransaction(1)
# New pod data
homes = {}
homes["user01"] = yield self.homeUnderTest(
self.theTransactionUnderTest(1), name="user01")
homes["user02"] = yield self.homeUnderTest(
self.theTransactionUnderTest(1), name="user02")
self.assertTrue(homes["user02"].external())
homes["user03"] = yield self.homeUnderTest(
self.theTransactionUnderTest(1), name="user03")
self.assertTrue(homes["user03"].external())
homes["puser01"] = yield self.homeUnderTest(
self.theTransactionUnderTest(1), name="puser01")
self.assertTrue(homes["puser01"].normal())
homes["puser02"] = yield self.homeUnderTest(
self.theTransactionUnderTest(1), name="puser02")
self.assertTrue(homes["puser02"].normal())
homes["puser03"] = yield self.homeUnderTest(
self.theTransactionUnderTest(1), name="puser03")
self.assertTrue(homes["puser03"].normal())
# Check calendar data on new pod
calendars = yield homes["user01"].loadChildren()
calnames = dict([(calendar.name(), calendar)
for calendar in calendars])
self.assertEqual(
set(calnames.keys()),
set((
"calendar",
"tasks",
"inbox",
self.stash["sharename_user02_to_user01"],
self.stash["sharename_puser02_to_user01"],
)))
# Check shared-by user01 on new pod
shared = calnames["calendar"]
invitations = yield shared.sharingInvites()
by_sharee = dict([(invitation.shareeUID, invitation)
for invitation in invitations])
self.assertEqual(len(invitations), 2)
self.assertEqual(set(by_sharee.keys()), set((
"user03",
"puser03",
)))
self.assertEqual(by_sharee["user03"].shareeHomeID,
homes["user03"].id())
self.assertEqual(by_sharee["puser03"].shareeHomeID,
homes["puser03"].id())
# Check shared-to user01 on new pod
shared = calnames[self.stash["sharename_user02_to_user01"]]
self.assertEqual(shared.ownerHome().uid(), "user02")
self.assertEqual(shared.ownerHome().id(), homes["user02"].id())
shared = calnames[self.stash["sharename_puser02_to_user01"]]
self.assertEqual(shared.ownerHome().uid(), "puser02")
self.assertEqual(shared.ownerHome().id(), homes["puser02"].id())
shared = yield homes["puser02"].calendarWithName("calendar")
invitations = yield shared.sharingInvites()
self.assertEqual(len(invitations), 1)
self.assertEqual(invitations[0].shareeHomeID, homes["user01"].id())
yield self.commitTransaction(1)
# Old pod data
homes = {}
homes["user01"] = yield self.homeUnderTest(
self.theTransactionUnderTest(0), name="user01")
homes["user02"] = yield self.homeUnderTest(
self.theTransactionUnderTest(0), name="user02")
self.assertTrue(homes["user02"].normal())
homes["user03"] = yield self.homeUnderTest(
self.theTransactionUnderTest(0), name="user03")
self.assertTrue(homes["user03"].normal())
homes["puser01"] = yield self.homeUnderTest(
self.theTransactionUnderTest(0), name="puser01")
self.assertTrue(homes["puser01"] is None)
homes["puser02"] = yield self.homeUnderTest(
self.theTransactionUnderTest(0), name="puser02")
self.assertTrue(homes["puser02"].external())
homes["puser03"] = yield self.homeUnderTest(
self.theTransactionUnderTest(0), name="puser03")
self.assertTrue(homes["puser03"].external())
# Check shared-by user01 on old pod
shared = yield homes["user03"].calendarWithName(
self.stash["sharename_user01_to_user03"])
self.assertEqual(shared.ownerHome().uid(), "user01")
self.assertEqual(shared.ownerHome().id(), homes["user01"].id())
# Check shared-to user01 on old pod
shared = yield homes["user02"].calendarWithName("calendar")
invitations = yield shared.sharingInvites()
self.assertEqual(len(invitations), 1)
self.assertEqual(invitations[0].shareeHomeID, homes["user01"].id())
yield self.commitTransaction(0)
# Delegates on each pod
for pod in range(self.numberOfStores):
txn = self.theTransactionUnderTest(pod)
records = {}
for ctr in range(10):
uid = u"user{:02d}".format(ctr + 1)
records[uid] = yield txn.directoryService().recordWithUID(uid)
for ctr in range(10):
uid = u"puser{:02d}".format(ctr + 1)
records[uid] = yield txn.directoryService().recordWithUID(uid)
for ctr in range(10):
uid = u"group{:02d}".format(ctr + 1)
records[uid] = yield txn.directoryService().recordWithUID(uid)
delegates = yield Delegates.delegatesOf(txn, records["user01"],
True, False)
self.assertTrue(records["user02"] in delegates)
self.assertTrue(records["group02"] in delegates)
delegates = yield Delegates.delegatesOf(txn, records["user01"],
True, True)
self.assertTrue(records["user02"] in delegates)
self.assertTrue(records["user06"] in delegates)
self.assertTrue(records["user07"] in delegates)
self.assertTrue(records["user08"] in delegates)
delegates = yield Delegates.delegatesOf(txn, records["user01"],
False, False)
self.assertTrue(records["user03"] in delegates)
self.assertTrue(records["group03"] in delegates)
self.assertTrue(records["puser01"] in delegates)
delegates = yield Delegates.delegatesOf(txn, records["user01"],
False, True)
self.assertTrue(records["user03"] in delegates)
self.assertTrue(records["user07"] in delegates)
self.assertTrue(records["user08"] in delegates)
self.assertTrue(records["user09"] in delegates)
self.assertTrue(records["puser01"] in delegates)
# Attachments
obj = yield self.calendarObjectUnderTest(
txn=self.theTransactionUnderTest(1),
name="01_3.ics",
calendar_name="calendar",
home="user01")
attachment = yield obj.attachmentWithManagedID(
self.stash["user01_attachment_mid"])
self.assertTrue(attachment is not None)
self.assertEqual(attachment.md5(), self.stash["user01_attachment_md5"])
data = yield self.attachmentToString(attachment)
self.assertEqual(data, "Here is some text #1.")
# Check removal of data from new pod
# Make sure all jobs are done
yield JobItem.waitEmpty(
self.theStoreUnderTest(1).newTransaction, reactor, 60)
# No migration state data left
txn = self.theTransactionUnderTest(1)
for migrationType in (
CalendarMigrationRecord,
CalendarObjectMigrationRecord,
AttachmentMigrationRecord,
):
records = yield migrationType.all(txn)
self.assertEqual(len(records), 0, msg=migrationType.__name__)
yield self.commitTransaction(1)
# No homes
txn = self.theTransactionUnderTest(1)
oldhome = yield txn.calendarHomeWithUID("user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
oldhome = yield txn.notificationsWithUID("user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
# Check removal of data from old pod
# Make sure all jobs are done
yield JobItem.waitEmpty(
self.theStoreUnderTest(0).newTransaction, reactor, 60)
# No homes
txn = self.theTransactionUnderTest(0)
oldhome = yield txn.calendarHomeWithUID("user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
oldhome = yield txn.notificationsWithUID("user01",
status=_HOME_STATUS_DISABLED)
self.assertTrue(oldhome is None)
# No delegates
for delegateType in (DelegateRecord, DelegateGroupsRecord,
ExternalDelegateGroupsRecord):
records = yield delegateType.query(
txn, delegateType.delegator == "user01")
self.assertEqual(len(records), 0, msg=delegateType.__name__)
# No work items
for workType in allScheduleWork:
records = yield workType.query(
txn,
workType.homeResourceID == self.stash["user01_pod0_home_id"])
self.assertEqual(len(records), 0, msg=workType.__name__)
def initialState(self):
"""
Setup the server with an initial set of data
user01 - migrating user
user02 - has a calendar shared with user01
user03 - shared to by user01
puser01 - user on other pod
puser02 - has a calendar shared with user01
puser03 - shared to by user01
"""
# Data for user01
home = yield self.homeUnderTest(txn=self.theTransactionUnderTest(0),
name="user01",
create=True)
self.stash["user01_pod0_home_id"] = home.id()
calendar = yield home.childWithName("calendar")
yield calendar.createCalendarObjectWithName(
"01_1.ics", Component.fromString(self.data01_1))
yield calendar.createCalendarObjectWithName(
"01_2.ics", Component.fromString(self.data01_2))
obj3 = yield calendar.createCalendarObjectWithName(
"01_3.ics", Component.fromString(self.data01_3))
attachment, _ignore_location = yield obj3.addAttachment(
None, MimeType.fromString("text/plain"), "test.txt",
MemoryStream("Here is some text #1."))
self.stash["user01_attachment_id"] = attachment.id()
self.stash["user01_attachment_md5"] = attachment.md5()
self.stash["user01_attachment_mid"] = attachment.managedID()
yield self.commitTransaction(0)
# Data for user02
home = yield self.homeUnderTest(txn=self.theTransactionUnderTest(0),
name="user02",
create=True)
calendar = yield home.childWithName("calendar")
yield calendar.createCalendarObjectWithName(
"02_1.ics", Component.fromString(self.data02_1))
yield calendar.createCalendarObjectWithName(
"02_2.ics", Component.fromString(self.data02_2))
yield calendar.createCalendarObjectWithName(
"02_3.ics", Component.fromString(self.data02_3))
yield self.commitTransaction(0)
# Data for puser02
home = yield self.homeUnderTest(txn=self.theTransactionUnderTest(1),
name="puser02",
create=True)
calendar = yield home.childWithName("calendar")
yield calendar.createCalendarObjectWithName(
"p02_1.ics", Component.fromString(self.datap02_1))
yield calendar.createCalendarObjectWithName(
"p02_2.ics", Component.fromString(self.datap02_2))
yield calendar.createCalendarObjectWithName(
"p02_3.ics", Component.fromString(self.datap02_3))
yield self.commitTransaction(1)
# Share calendars
self.stash["sharename_user01_to_user03"] = yield self._createShare(
"user01", "user03")
self.stash["sharename_user01_to_puser03"] = yield self._createShare(
"user01", "puser03")
self.stash["sharename_user02_to_user01"] = yield self._createShare(
"user02", "user01")
self.stash["sharename_puser02_to_user01"] = yield self._createShare(
"puser02", "user01")
# Add some delegates
txn = self.theTransactionUnderTest(0)
record01 = yield txn.directoryService().recordWithUID(u"user01")
record02 = yield txn.directoryService().recordWithUID(u"user02")
record03 = yield txn.directoryService().recordWithUID(u"user03")
precord01 = yield txn.directoryService().recordWithUID(u"puser01")
group02 = yield txn.directoryService().recordWithUID(u"group02")
group03 = yield txn.directoryService().recordWithUID(u"group03")
# Add user02 and user03 as individual delegates
yield Delegates.addDelegate(txn, record01, record02, True)
yield Delegates.addDelegate(txn, record01, record03, False)
yield Delegates.addDelegate(txn, record01, precord01, False)
# Add group delegates
yield Delegates.addDelegate(txn, record01, group02, True)
yield Delegates.addDelegate(txn, record01, group03, False)
# Add external delegates
yield txn.assignExternalDelegates(u"user01", None, None, u"external1",
u"external2")
yield self.commitTransaction(0)
yield self.waitAllEmpty()
def initialState(self):
"""
Setup the server with an initial set of data
user01 - migrating user
user02 - has a calendar shared with user01
user03 - shared to by user01
puser01 - user on other pod
puser02 - has a calendar shared with user01
puser03 - shared to by user01
"""
# Data for user01
home = yield self.homeUnderTest(txn=self.theTransactionUnderTest(0), name="user01", create=True)
self.stash["user01_pod0_home_id"] = home.id()
calendar = yield home.childWithName("calendar")
yield calendar.createCalendarObjectWithName("01_1.ics", Component.fromString(self.data01_1))
yield calendar.createCalendarObjectWithName("01_2.ics", Component.fromString(self.data01_2))
obj3 = yield calendar.createCalendarObjectWithName("01_3.ics", Component.fromString(self.data01_3))
attachment, _ignore_location = yield obj3.addAttachment(None, MimeType.fromString("text/plain"), "test.txt", MemoryStream("Here is some text #1."))
self.stash["user01_attachment_id"] = attachment.id()
self.stash["user01_attachment_md5"] = attachment.md5()
self.stash["user01_attachment_mid"] = attachment.managedID()
yield self.commitTransaction(0)
# Data for user02
home = yield self.homeUnderTest(txn=self.theTransactionUnderTest(0), name="user02", create=True)
calendar = yield home.childWithName("calendar")
yield calendar.createCalendarObjectWithName("02_1.ics", Component.fromString(self.data02_1))
yield calendar.createCalendarObjectWithName("02_2.ics", Component.fromString(self.data02_2))
yield calendar.createCalendarObjectWithName("02_3.ics", Component.fromString(self.data02_3))
yield self.commitTransaction(0)
# Data for puser02
home = yield self.homeUnderTest(txn=self.theTransactionUnderTest(1), name="puser02", create=True)
calendar = yield home.childWithName("calendar")
yield calendar.createCalendarObjectWithName("p02_1.ics", Component.fromString(self.datap02_1))
yield calendar.createCalendarObjectWithName("p02_2.ics", Component.fromString(self.datap02_2))
yield calendar.createCalendarObjectWithName("p02_3.ics", Component.fromString(self.datap02_3))
yield self.commitTransaction(1)
# Share calendars
self.stash["sharename_user01_to_user03"] = yield self._createShare("user01", "user03")
self.stash["sharename_user01_to_puser03"] = yield self._createShare("user01", "puser03")
self.stash["sharename_user02_to_user01"] = yield self._createShare("user02", "user01")
self.stash["sharename_puser02_to_user01"] = yield self._createShare("puser02", "user01")
# Add some delegates
txn = self.theTransactionUnderTest(0)
record01 = yield txn.directoryService().recordWithUID(u"user01")
record02 = yield txn.directoryService().recordWithUID(u"user02")
record03 = yield txn.directoryService().recordWithUID(u"user03")
precord01 = yield txn.directoryService().recordWithUID(u"puser01")
group02 = yield txn.directoryService().recordWithUID(u"group02")
group03 = yield txn.directoryService().recordWithUID(u"group03")
# Add user02 and user03 as individual delegates
yield Delegates.addDelegate(txn, record01, record02, True)
yield Delegates.addDelegate(txn, record01, record03, False)
yield Delegates.addDelegate(txn, record01, precord01, False)
# Add group delegates
yield Delegates.addDelegate(txn, record01, group02, True)
yield Delegates.addDelegate(txn, record01, group03, False)
# Add external delegates
yield txn.assignExternalDelegates(u"user01", None, None, u"external1", u"external2")
yield self.commitTransaction(0)
yield self.waitAllEmpty()
def test_setDelegation(self):
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
delegates = [
(yield self.directory.recordWithUID(u"__sagen1__")),
(yield self.directory.recordWithUID(u"__cdaboo1__")),
(yield self.directory.recordWithUID(u"__dre1__")),
]
# Add delegates
yield Delegates.setDelegates(self.transactionUnderTest(), delegator,
[delegates[0], delegates[1]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None,
[delegates[0], delegates[1]],
None, None)
yield self._memcacherAllMembershipResults(delegator, None, None)
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, None, None, None,
None)
yield self._memcacherAllMembershipResults(delegate, None, None)
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator,
[delegates[0], delegates[1]],
[delegates[0], delegates[1]], [],
[])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [delegator], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [], [])
# Check cache
yield self._memcacherAllMemberResults(delegator,
[delegates[0], delegates[1]],
[delegates[0], delegates[1]],
[], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0],
[delegator], [])
yield self._memcacherAllMembershipResults(delegates[1],
[delegator], [])
yield self._memcacherAllMembershipResults(delegates[2], [], [])
# Remove delegate
yield Delegates.setDelegates(self.transactionUnderTest(), delegator,
[delegates[1], delegates[2]], True)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator, None,
[delegates[1], delegates[2]], [],
[])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], None, [])
yield self._memcacherAllMembershipResults(delegates[1], [delegator],
[])
yield self._memcacherAllMembershipResults(delegates[2], None, [])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator,
[delegates[1], delegates[2]],
[delegates[1], delegates[2]], [],
[])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [], [])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator,
[delegates[1], delegates[2]],
[delegates[1], delegates[2]],
[], [])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], [])
yield self._memcacherAllMembershipResults(delegates[1],
[delegator], [])
yield self._memcacherAllMembershipResults(delegates[2],
[delegator], [])
# Add delegate with other mode
yield Delegates.setDelegates(self.transactionUnderTest(), delegator,
[delegates[0]], False)
yield self.commit()
# Some cache entries invalid
yield self._memcacherAllMemberResults(delegator,
[delegates[1], delegates[2]],
[delegates[1], delegates[2]],
None, [delegates[0]])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [], None)
yield self._memcacherAllMembershipResults(delegates[1], [delegator],
[])
yield self._memcacherAllMembershipResults(delegates[2], [delegator],
[])
# Read the delegate information twice - first time should be without cache, second with
for _ignore in range(2):
yield self._delegatesOfAllResults(delegator,
[delegates[1], delegates[2]],
[delegates[1], delegates[2]],
[delegates[0]], [delegates[0]])
for delegate in delegates:
yield self._delegatesOfAllResults(delegate, [], [], [], [])
yield self._delegatedToAllResults(delegator, [], [])
yield self._delegatedToAllResults(delegates[0], [], [delegator])
yield self._delegatedToAllResults(delegates[1], [delegator], [])
yield self._delegatedToAllResults(delegates[2], [delegator], [])
# Check cache
yield self._memcacherAllMemberResults(delegator,
[delegates[1], delegates[2]],
[delegates[1], delegates[2]],
[delegates[0]],
[delegates[0]])
for delegate in delegates:
yield self._memcacherAllMemberResults(delegate, [], [], [], [])
yield self._memcacherAllMembershipResults(delegator, [], [])
yield self._memcacherAllMembershipResults(delegates[0], [],
[delegator])
yield self._memcacherAllMembershipResults(delegates[1],
[delegator], [])
yield self._memcacherAllMembershipResults(delegates[2],
[delegator], [])
def test_directoryBasedDelegationChanges(self):
groupCacher = GroupCacher(self.directory)
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
groupRecord1 = yield self.directory.recordWithUID(u"__top_group_1__")
group1 = yield self.transactionUnderTest().groupByUID("__top_group_1__")
groupRecord2 = yield self.directory.recordWithUID(u"__sub_group_1__")
group2 = yield self.transactionUnderTest().groupByUID("__sub_group_1__")
groupRecord3 = yield self.directory.recordWithUID(u"left_coast")
group3 = yield self.transactionUnderTest().groupByUID("left_coast")
delegate = yield self.directory.recordWithUID(u"__sagen1__")
# No delegates
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 0)
# No delegators to this group
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 0)
# User is not a delegate
delegators = yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, True)
self.assertEquals(len(delegators), 0)
# Apply an external read-only assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, None
)
# Now there is a read-only delegate
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 1)
# Now this group is read-only delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 1)
# Apply an external read-write assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, groupRecord2.uid
)
# Now there are read-only and read-write delegates
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 1)
self.assertEquals(delegates[0].uid, "__top_group_1__")
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True)
self.assertEquals(len(delegates), 1)
self.assertEquals(delegates[0].uid, "__sub_group_1__")
# Now both groups are delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 1)
delegators = yield self.transactionUnderTest().delegatorsToGroup(group2.groupID, True)
self.assertEquals(len(delegators), 1)
# User is now a delegate (cache must have been invalidated properly)
delegators = yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, True)
self.assertEquals(len(delegators), 1)
# Change read-write assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, groupRecord3.uid
)
# Now this group is not delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group2.groupID, True)
self.assertEquals(len(delegators), 0)
# ..but this group is delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group3.groupID, True)
self.assertEquals(len(delegators), 1)
# Remove external read-write assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, None
)
# Now there is only a read-only delegate
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 1)
self.assertEquals(delegates[0].uid, "__top_group_1__")
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True)
self.assertEquals(len(delegates), 0)
# Now this group is read-only delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 1)
# Now this group is not delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group3.groupID, True)
self.assertEquals(len(delegators), 0)
# User is not a delegate anymore (cache must have been invalidated properly)
delegators = yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, True)
self.assertEquals(len(delegators), 0)
# Remove external assignments altogether
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, None, None
)
# Now there are no delegates
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 0)
# No groups are delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 0)
delegators = yield self.transactionUnderTest().delegatorsToGroup(group2.groupID, True)
self.assertEquals(len(delegators), 0)
delegators = yield self.transactionUnderTest().delegatorsToGroup(group3.groupID, True)
self.assertEquals(len(delegators), 0)
def copyAssignments(assignments, pod, directory, store):
"""
Go through the list of assignments from the old db, and selectively copy them
into the new store.
@param assignments: the assignments from the old db
@type assignments: a list of (delegator group, delegate) tuples
@param pod: the name of the pod you want to migrate assignments for; assignments
for delegators who don't reside on this pod will be ignored. Set this
to None to copy all assignments.
@param directory: the directory service
@param store: the store
"""
delegatorsMissingPodInfo = set()
numCopied = 0
numOtherPod = 0
numDirectoryBased = 0
numExamined = 0
# If locations and resources' delegate assignments come from the directory,
# then we're only interested in copying assignments where the delegator is a
# user.
if config.GroupCaching.Enabled and config.GroupCaching.UseDirectoryBasedDelegates:
delegatorRecordTypes = (RecordType.user,)
else:
delegatorRecordTypes = None
# When faulting in delegates, only worry about users and groups.
delegateRecordTypes = (RecordType.user, RecordType.group)
total = len(assignments)
for groupname, delegateUID in assignments:
numExamined += 1
if numExamined % 100 == 0:
print("Processed: {} of {}...".format(numExamined, total))
if "#" in groupname:
delegatorUID, permission = groupname.split("#")
try:
delegatorRecords = yield directory.recordsFromExpression(
MatchExpression(FieldName.uid, delegatorUID, matchType=MatchType.equals),
recordTypes=delegatorRecordTypes
)
delegatorRecord = uniqueResult(delegatorRecords)
except Exception, e:
print("Failed to look up record for {}: {}".format(delegatorUID, str(e)))
continue
if delegatorRecord is None:
continue
if config.GroupCaching.Enabled and config.GroupCaching.UseDirectoryBasedDelegates:
if delegatorRecord.recordType != RecordType.user:
print("Skipping non-user")
numDirectoryBased += 1
continue
if pod:
try:
if delegatorRecord.serviceNodeUID != pod:
numOtherPod += 1
continue
except AttributeError:
print("Record missing serviceNodeUID", delegatorRecord.fullNames)
delegatorsMissingPodInfo.add(delegatorUID)
continue
try:
delegateRecords = yield directory.recordsFromExpression(
MatchExpression(FieldName.uid, delegateUID, matchType=MatchType.equals),
recordTypes=delegateRecordTypes
)
delegateRecord = uniqueResult(delegateRecords)
except Exception, e:
print("Failed to look up record for {}: {}".format(delegateUID, str(e)))
continue
if delegateRecord is None:
continue
txn = store.newTransaction(label="DelegatesMigrationService")
yield Delegates.addDelegate(
txn, delegatorRecord, delegateRecord,
(permission == "calendar-proxy-write")
)
numCopied += 1
yield txn.commit()
