def test_cachingDBRemoveSpecial(self):
for processType in ("Single", "Combined",):
config.ProcessType = processType
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
# Do one insert and check the result
yield db.setGroupMembers("A", ("B", "C", "D",))
yield db.setGroupMembers("X", ("B", "C",))
membershipsB = yield db.getMemberships("B")
membershipsC = yield db.getMemberships("C")
membershipsD = yield db.getMemberships("D")
# Remove and check the result
yield db.removeGroup("A")
membersA = yield db.getMembers("A")
membersX = yield db.getMembers("X")
membershipsB = yield db.getMemberships("B")
membershipsC = yield db.getMemberships("C")
membershipsD = yield db.getMemberships("D")
self.assertEqual(membersA, set())
self.assertEqual(membersX, set(("B", "C",)))
self.assertEqual(membershipsB, set("X",))
self.assertEqual(membershipsC, set("X",))
self.assertEqual(membershipsD, set())
yield db.clean()
def test_DBIndexed(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
self.assertEqual(
set([
row[1] for row in (yield db.query("PRAGMA index_list(GROUPS)"))
]), set(("GROUPNAMES", "MEMBERS")))
def stepWithResult(self, result):
if self.doPostImport:
# Load proxy assignments from XML if specified
if (
self.config.ProxyLoadFromFile and
os.path.exists(self.config.ProxyLoadFromFile) and
not os.path.exists(
os.path.join(
self.config.DataRoot, "proxies.sqlite"
)
)
):
sqliteProxyService = ProxySqliteDB("proxies.sqlite")
yield loadDelegatesFromXML(
self.config.ProxyLoadFromFile,
sqliteProxyService
)
else:
sqliteProxyService = None
# # Populate the group membership cache
# if (self.config.GroupCaching.Enabled and
# self.config.GroupCaching.EnableUpdater):
# proxydb = calendaruserproxy.ProxyDBService
# if proxydb is None:
# proxydbClass = namedClass(self.config.ProxyDBService.type)
# proxydb = proxydbClass(**self.config.ProxyDBService.params)
# # MOVE2WHO FIXME: port to new group cacher
# updater = GroupMembershipCacheUpdater(proxydb,
# directory,
# self.config.GroupCaching.UpdateSeconds,
# self.config.GroupCaching.ExpireSeconds,
# self.config.GroupCaching.LockSeconds,
# namespace=self.config.GroupCaching.MemcachedPool,
# useExternalProxies=self.config.GroupCaching.UseExternalProxies)
# yield updater.updateCache(fast=True)
uid, gid = getCalendarServerIDs(self.config)
dbPath = os.path.join(self.config.DataRoot, "proxies.sqlite")
if os.path.exists(dbPath):
os.chown(dbPath, uid, gid)
# Process old inbox items
self.store.setMigrating(True)
yield self.processInboxItems()
self.store.setMigrating(False)
# Migrate mail tokens from sqlite to store
yield migrateTokensToStore(self.config.DataRoot, self.store)
# Migrate delegate assignments from sqlite to store
if sqliteProxyService is None:
sqliteProxyService = ProxySqliteDB("proxies.sqlite")
yield migrateDelegatesToStore(sqliteProxyService, self.store)
def test_cachingDBInsertUncached(self):
for processType in ("Single", "Combined",):
config.ProcessType = processType
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
# Do one insert and check the result for the one we will remove
yield db.setGroupMembers("AA", ("BB", "CC", "DD",))
yield db.getMemberships("DD")
# Change and check the result
yield db.setGroupMembers("AA", ("BB", "CC", "EE",))
membersAA = yield db.getMembers("AA")
membershipsBB = yield db.getMemberships("BB")
membershipsCC = yield db.getMemberships("CC")
membershipsDD = yield db.getMemberships("DD")
membershipsEE = yield db.getMemberships("EE")
self.assertEqual(membersAA, set(("BB", "CC", "EE",)))
self.assertEqual(membershipsBB, set(("AA",)))
self.assertEqual(membershipsCC, set(("AA",)))
self.assertEqual(membershipsDD, set())
self.assertEqual(membershipsEE, set(("AA",)))
yield db.clean()
def test_normalDB(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
yield db.setGroupMembers("A", ("B", "C", "D",))
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
def test_normalDB(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
yield db.setGroupMembers("A", ("B", "C", "D",))
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
def test_normalDBNonAscii(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
principalID = "Test \xe4\xbd\x90\xe8\x97\xa4"
yield db.setGroupMembers(principalID, ("B", "C", "D",))
membersA = yield db.getMembers(principalID)
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set((principalID,)))
def test_normalDBNonAscii(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
principalID = "Test \xe4\xbd\x90\xe8\x97\xa4"
yield db.setGroupMembers(principalID, ("B", "C", "D",))
membersA = yield db.getMembers(principalID)
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set((principalID,)))
def test_cachingDBInsertUncached(self):
for processType in ("Single", "Combined",):
config.ProcessType = processType
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
# Do one insert and check the result for the one we will remove
yield db.setGroupMembers("AA", ("BB", "CC", "DD",))
yield db.getMemberships("DD")
# Change and check the result
yield db.setGroupMembers("AA", ("BB", "CC", "EE",))
membersAA = yield db.getMembers("AA")
membershipsBB = yield db.getMemberships("BB")
membershipsCC = yield db.getMemberships("CC")
membershipsDD = yield db.getMemberships("DD")
membershipsEE = yield db.getMemberships("EE")
self.assertEqual(membersAA, set(("BB", "CC", "EE",)))
self.assertEqual(membershipsBB, set(("AA",)))
self.assertEqual(membershipsCC, set(("AA",)))
self.assertEqual(membershipsDD, set())
self.assertEqual(membershipsEE, set(("AA",)))
yield db.clean()
def test_DBUpgrade(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = self.old_ProxyDB(db_path)
yield db.setGroupMembers("A", ("B", "C", "D",))
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
self.assertEqual(set([row[1] for row in (yield db.query("PRAGMA index_list(GROUPS)"))]), set())
db.close()
db = None
db = ProxySqliteDB(db_path)
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
self.assertEqual(set([row[1] for row in (yield db.query("PRAGMA index_list(GROUPS)"))]), set(("GROUPNAMES", "MEMBERS")))
db.close()
db = None
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 test_DBUpgrade(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = self.old_ProxyDB(db_path)
yield db.setGroupMembers("A", ("B", "C", "D",))
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
self.assertEqual(set([row[1] for row in (yield db.query("PRAGMA index_list(GROUPS)"))]), set())
db.close()
db = None
db = ProxySqliteDB(db_path)
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
self.assertEqual(set([row[1] for row in (yield db.query("PRAGMA index_list(GROUPS)"))]), set(("GROUPNAMES", "MEMBERS")))
db.close()
db = None
def test_cachingDBInsert(self):
for processType in ("Single", "Combined",):
config.ProcessType = processType
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
# Do one insert and check the result
yield db.setGroupMembers("A", ("B", "C", "D",))
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
membershipsC = yield db.getMemberships("C")
membershipsD = yield db.getMemberships("D")
membershipsE = yield db.getMemberships("E")
self.assertEqual(membersA, set(("B", "C", "D",)))
self.assertEqual(membershipsB, set(("A",)))
self.assertEqual(membershipsC, set(("A",)))
self.assertEqual(membershipsD, set(("A",)))
self.assertEqual(membershipsE, set(()))
# Change and check the result
yield db.setGroupMembers("A", ("B", "C", "E",))
membersA = yield db.getMembers("A")
membershipsB = yield db.getMemberships("B")
membershipsC = yield db.getMemberships("C")
membershipsD = yield db.getMemberships("D")
membershipsE = yield db.getMemberships("E")
self.assertEqual(membersA, set(("B", "C", "E",)))
self.assertEqual(membershipsB, set(("A",)))
self.assertEqual(membershipsC, set(("A",)))
self.assertEqual(membershipsD, set())
self.assertEqual(membershipsE, set(("A",)))
def test_DBIndexed(self):
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
self.assertEqual(set([row[1] for row in (yield db.query("PRAGMA index_list(GROUPS)"))]), set(("GROUPNAMES", "MEMBERS")))
def test_cachingDBRemoveSpecial(self):
for processType in (
"Single",
"Combined",
):
config.ProcessType = processType
# Get the DB
db_path = os.path.abspath(self.mktemp())
db = ProxySqliteDB(db_path)
# Do one insert and check the result
yield db.setGroupMembers("A", (
"B",
"C",
"D",
))
yield db.setGroupMembers("X", (
"B",
"C",
))
membershipsB = yield db.getMemberships("B")
membershipsC = yield db.getMemberships("C")
membershipsD = yield db.getMemberships("D")
# Remove and check the result
yield db.removeGroup("A")
membersA = yield db.getMembers("A")
membersX = yield db.getMembers("X")
membershipsB = yield db.getMemberships("B")
membershipsC = yield db.getMemberships("C")
membershipsD = yield db.getMemberships("D")
self.assertEqual(membersA, set())
self.assertEqual(membersX, set((
"B",
"C",
)))
self.assertEqual(membershipsB, set("X", ))
self.assertEqual(membershipsC, set("X", ))
self.assertEqual(membershipsD, set())
yield db.clean()
db.close()
