def processor(forType):
"""
Create an Axiom Item type which is suitable to use as a batch processor for
the given Axiom Item type.
Processors created this way depend on a L{iaxiom.IScheduler} powerup on the
on which store they are installed.
@type forType: L{item.MetaItem}
@param forType: The Axiom Item type for which to create a batch processor
type.
@rtype: L{item.MetaItem}
@return: An Axiom Item type suitable for use as a batch processor. If such
a type previously existed, it will be returned. Otherwise, a new type is
created.
"""
MILLI = 1000
try:
processor = _processors[forType]
except KeyError:
def __init__(self, *a, **kw):
item.Item.__init__(self, *a, **kw)
self.store.powerUp(self, iaxiom.IBatchProcessor)
attrs = {
'__name__':
'Batch_' + forType.__name__,
'__module__':
forType.__module__,
'__init__':
__init__,
'__repr__':
lambda self: '<Batch of %s #%d>' %
(reflect.qual(self.workUnitType), self.storeID),
'schemaVersion':
2,
'workUnitType':
forType,
'scheduled':
attributes.timestamp(doc="""
The next time at which this processor is scheduled to run.
""",
default=None),
# MAGIC NUMBERS AREN'T THEY WONDERFUL?
'busyInterval':
attributes.integer(doc="", default=MILLI / 10),
}
_processors[forType] = processor = item.MetaItem(
attrs['__name__'], (item.Item, _BatchProcessorMixin), attrs)
registerUpgrader(upgradeProcessor1to2, _processors[forType].typeName,
1, 2)
return processor
def processor(forType):
"""
Create an Axiom Item type which is suitable to use as a batch processor for
the given Axiom Item type.
Processors created this way depend on a L{iaxiom.IScheduler} powerup on the
on which store they are installed.
@type forType: L{item.MetaItem}
@param forType: The Axiom Item type for which to create a batch processor
type.
@rtype: L{item.MetaItem}
@return: An Axiom Item type suitable for use as a batch processor. If such
a type previously existed, it will be returned. Otherwise, a new type is
created.
"""
MILLI = 1000
try:
processor = _processors[forType]
except KeyError:
def __init__(self, *a, **kw):
item.Item.__init__(self, *a, **kw)
self.store.powerUp(self, iaxiom.IBatchProcessor)
attrs = {
'__name__': 'Batch_' + forType.__name__,
'__module__': forType.__module__,
'__init__': __init__,
'__repr__': lambda self: '<Batch of %s #%d>' % (reflect.qual(self.workUnitType), self.storeID),
'schemaVersion': 2,
'workUnitType': forType,
'scheduled': attributes.timestamp(doc="""
The next time at which this processor is scheduled to run.
""", default=None),
# MAGIC NUMBERS AREN'T THEY WONDERFUL?
'busyInterval': attributes.integer(doc="", default=MILLI / 10),
}
_processors[forType] = processor = item.MetaItem(
attrs['__name__'],
(item.Item, _BatchProcessorMixin),
attrs)
registerUpgrader(
upgradeProcessor1to2,
_processors[forType].typeName,
1, 2)
return processor
new = old.upgradeVersion(old.typeName,
1,
2,
_address=old.address,
_default=old._default,
smtpHost=old.smtpHost,
smtpPort=old.smtpPort,
smtpUsername=old.smtpUsername,
smtpPassword=old.smtpPassword)
if new._address == _getFromAddressFromStore(new.store):
new._address = None
return new
registerUpgrader(fromAddress1to2, FromAddress.typeName, 1, 2)
class MessageDelivery(item.Item):
"""
Handles the delivery of a single message to multiple addresses.
"""
composer = attributes.reference()
message = attributes.reference()
def allBounced(self):
"""
Did all of the addresses bounce?
@return: L{True} if all addresses bounced. L{False} otherwise.
if matched:
f.getAction().actOn(self, f, item, extraData)
if not proceed:
break
def ruleFilter1to2(old):
"""
Add messageSource field since RuleFilteringPowerup depends on
it. Remove installedOn.
"""
return old.upgradeVersion(RuleFilteringPowerup.typeName, 1, 2,
tagCatalog = old.tagCatalog,
messageSource = old.store.findUnique(
mail.MessageSource))
registerUpgrader(ruleFilter1to2, RuleFilteringPowerup.typeName, 1, 2)
class RuleFilterBenefactor(item.Item):
"""
Endows users with RuleFilteringPowerup.
"""
typeName = 'xquotient_filter_filterbenefactor'
implements(ixmantissa.IBenefactor)
powerupNames = ["xquotient.filter.RuleFilteringPowerup"]
installedOn = attributes.reference()
endowed = attributes.integer(default=0)
class MailingListFilterBenefactor(item.Item):
# -*- test-case-name: axiom.test.test_upgrading.DeletionTest.testPowerups -*-
from axiom.item import Item
from axiom.attributes import integer
class Obsolete(Item):
"""
This is a stub placeholder so that axiomInvalidateModule will invalidate
the appropriate typeName; it's probably bad practice to declare recent
versions of deleted portions of the schema, but that's not what this is
testing.
"""
typeName = 'test_upgrading_obsolete'
nothing = integer()
schemaVersion = 2
from axiom.upgrade import registerUpgrader
def obsolete1toNone(oldObsolete):
oldObsolete.deleteFromStore()
return None
registerUpgrader(obsolete1toNone, 'test_upgrading_obsolete', 1, 2)
newIndexer.reset()
return newIndexer
def _declareLegacyIndexerItem(typeClass, version):
item.declareLegacyItem(typeClass.typeName, version,
dict(indexCount=attributes.integer(),
installedOn=attributes.reference(),
indexDirectory=attributes.text()))
for cls in [HypeIndexer, XapianIndexer, PyLuceneIndexer]:
_declareLegacyIndexerItem(cls, 2)
registerUpgrader(
remoteIndexer1to2,
item.normalize(reflect.qual(cls)),
1,
2)
registerUpgrader(
remoteIndexer2to3,
item.normalize(reflect.qual(cls)),
2,
3)
del cls
_declareLegacyIndexerItem(PyLuceneIndexer, 3)
# Copy attributes. Rely on pyLuceneIndexer4to5 to reset the index due to
# sorting changes.
registerAttributeCopyingUpgrader(PyLuceneIndexer, 3, 4)
return self.store.query(
Tag,
AND(Tag.catalog == self,
Tag.object == obj)).getColumn("name")
def objectsIn(self, tagName):
return self.store.query(
Tag,
AND(Tag.catalog == self,
Tag.name == tagName)).getColumn("object")
def upgradeCatalog1to2(oldCatalog):
"""
Create _TagName instances which version 2 of Catalog automatically creates
for use in determining the tagNames result, but which version 1 of Catalog
did not create.
"""
newCatalog = oldCatalog.upgradeVersion('tag_catalog', 1, 2,
tagCount=oldCatalog.tagCount)
tags = newCatalog.store.query(Tag, Tag.catalog == newCatalog)
tagNames = tags.getColumn("name").distinct()
for t in tagNames:
_TagName(store=newCatalog.store, catalog=newCatalog, name=t)
return newCatalog
from axiom.upgrade import registerUpgrader
registerUpgrader(upgradeCatalog1to2, 'tag_catalog', 1, 2)
class A(Item):
typeName = 'test_circular_a'
b = reference()
class B(Item):
typeName = 'test_circular_b'
a = reference()
n = integer()
schemaVersion = 2
from axiom.upgrade import registerUpgrader
def b1to2(oldb):
# This upgrader isn't doing anything that actually makes sense; in a
# realistic upgrader, you'd probably be changing A around, perhaps deleting
# it to destroy old adjunct items and creating a new A. The point is,
# s.findUnique(A).b should give back the 'b' that you are upgrading whether
# it is run before or after the upgrade.
oldb.a.deleteFromStore()
newb = oldb.upgradeVersion('test_circular_b', 1, 2)
newb.n = oldb.n
newb.a = A(store=newb.store, b=newb)
return newb
registerUpgrader(b1to2, 'test_circular_b', 1, 2)
# we didn't originally set typeName, so it was generated from the
# fully-qualified classname ("diskwatcher.Sample"), then Axiom
# automatically lowercases and un-dot-ifies it to get
# "diskwatcher_sample". Now we explicitly provide a name.
typeName = "diskwatcher_sample"
# version 2 added the 'total' field
schemaVersion = 2
url = text(indexed=True)
when = timestamp(indexed=True)
total = integer()
used = integer()
avail = integer()
def upgradeSample1to2(old):
total = 0
return old.upgradeVersion("diskwatcher_sample",
1,
2,
url=old.url,
when=old.when,
total=0,
used=old.used,
avail=old.avail)
from axiom.upgrade import registerUpgrader
registerUpgrader(upgradeSample1to2, "diskwatcher_sample", 1, 2)
from axiom.attributes import reference, integer
class A(Item):
typeName = 'test_circular_a'
b = reference()
class B(Item):
typeName = 'test_circular_b'
a = reference()
n = integer()
schemaVersion = 2
from axiom.upgrade import registerUpgrader
def b1to2(oldb):
# This upgrader isn't doing anything that actually makes sense; in a
# realistic upgrader, you'd probably be changing A around, perhaps deleting
# it to destroy old adjunct items and creating a new A. The point is,
# s.findUnique(A).b should give back the 'b' that you are upgrading whether
# it is run before or after the upgrade.
oldb.a.deleteFromStore()
newb = oldb.upgradeVersion('test_circular_b', 1, 2)
newb.n = oldb.n
newb.a = A(store=newb.store,
b=newb)
return newb
registerUpgrader(b1to2, 'test_circular_b', 1, 2)
"Upgrader from Share version 1 to version 2."
sharedInterfaces = []
attrs = set(oldShare.sharedAttributeNames.split(u','))
for iface in implementedBy(oldShare.sharedItem.__class__):
if set(iface) == attrs or attrs == set('*'):
sharedInterfaces.append(iface)
newShare = oldShare.upgradeVersion('sharing_share', 1, 2,
shareID=oldShare.shareID,
sharedItem=oldShare.sharedItem,
sharedTo=oldShare.sharedTo,
sharedInterfaces=sharedInterfaces)
return newShare
registerUpgrader(upgradeShare1to2, 'sharing_share', 1, 2)
def genShareID(store):
"""
Generate a new, randomized share-ID for use as the default of shareItem, if
none is specified.
@return: a random share-ID.
@rtype: unicode.
"""
return unicode(os.urandom(16).encode('hex'), 'ascii')
portNumber=oldMTA.portNumber,
securePortNumber=oldMTA.securePortNumber,
certificateFile=oldMTA.certificateFile,
domain=oldMTA.domain)
return newMTA
else:
mda = MailDeliveryAgent(store=oldMTA.store)
mda.installedOn = oldMTA.store
oldMTA.store.powerUp(mda, smtp.IMessageDeliveryFactory)
oldMTA.store.powerDown(oldMTA, smtp.IMessageDeliveryFactory)
oldMTA.deleteFromStore()
# The MTA was deleted, there's no sensible Item to return here.
return mda
registerUpgrader(upgradeMailTransferAgent1to2, 'mantissa_mta', 1, 2)
def upgradeMailTransferAgent2to3(old):
"""
Add the userbase field since MTA depends on it and remove installedOn.
The isinstance check here is to avoid doing anything to MDA
instances returned by the 1to2 upgrader.
"""
if isinstance(old, MailDeliveryAgent):
return old
mta = old.upgradeVersion(MailTransferAgent.typeName,
2,
3,
messageCount=old.messageCount,
return pp.getResource()
return SharingIndex(self.application.open())
def upgradePublicWeb1To2(oldWeb):
newWeb = oldWeb.upgradeVersion('mantissa_public_web',
1,
2,
prefixURL=oldWeb.prefixURL,
application=oldWeb.application,
installedOn=oldWeb.installedOn)
newWeb.installedOn.powerUp(newWeb, ixmantissa.ICustomizablePublicPage)
return newWeb
upgrade.registerUpgrader(upgradePublicWeb1To2, 'mantissa_public_web', 1, 2)
def upgradePublicWeb2To3(oldWeb):
newWeb = oldWeb.upgradeVersion(
'mantissa_public_web',
2,
3,
prefixURL=oldWeb.prefixURL,
application=oldWeb.application,
installedOn=oldWeb.installedOn,
# There was only one PublicWeb before, and it definitely
# wanted to be sessioned.
sessioned=True)
newWeb.installedOn.powerDown(newWeb, ixmantissa.ICustomizablePublicPage)
other = newWeb.installedOn
updateInterval = integer(default=5)
privateApplication = dependsOn(PrivateApplication)
def getTabs(self):
return []
declareLegacyItem(AdminStatsApplication, 1,
dict(updateInterval=integer(default=5)))
def _adminStatsApplication1to2(old):
new = old.upgradeVersion(AdminStatsApplication.typeName, 1, 2,
updateInterval=old.updateInterval,
privateApplication=old.store.findOrCreate(PrivateApplication))
return new
registerUpgrader(_adminStatsApplication1to2, AdminStatsApplication.typeName, 1, 2)
class LocalUserBrowser(Item):
"""
XXX I am an unfortunate necessity.
This class shouldn't exist, and in fact, will be destroyed at the first
possible moment. It's stateless, existing only to serve as a web lookup
hook for the UserInteractionFragment view class.
"""
implements(INavigableElement)
typeName = 'local_user_browser'
schemaVersion = 2
"""
for iface, priority in self.__getPowerupInterfaces__([]):
self.store.powerUp(self, iface, priority)
def upgradeStaticSite1To2(oldSite):
newSite = oldSite.upgradeVersion(
'static_web_site', 1, 2,
staticContentPath=oldSite.staticContentPath,
prefixURL=oldSite.prefixURL,
sessionless=True)
for pc in newSite.store.query(_PowerupConnector,
AND(_PowerupConnector.powerup == newSite,
_PowerupConnector.interface == u'xmantissa.ixmantissa.ISiteRootPlugin')):
pc.item.powerDown(newSite, ISiteRootPlugin)
return newSite
upgrade.registerUpgrader(upgradeStaticSite1To2, 'static_web_site', 1, 2)
class StaticRedirect(Item, PrefixURLMixin):
implements(inevow.IResource,
ISessionlessSiteRootPlugin,
ISiteRootPlugin)
schemaVersion = 2
typeName = 'web_static_redirect'
targetURL = text(allowNone=False)
prefixURL = text(allowNone=False)
sessioned = boolean(default=True)
def upgradeParentHook1to2(oldHook):
"""
Add the scheduler attribute to the given L{_SubSchedulerParentHook}.
"""
newHook = oldHook.upgradeVersion(
oldHook.typeName,
1,
2,
loginAccount=oldHook.loginAccount,
scheduledAt=oldHook.scheduledAt,
scheduler=oldHook.store.findFirst(Scheduler))
return newHook
registerUpgrader(upgradeParentHook1to2, _SubSchedulerParentHook.typeName, 1, 2)
declareLegacyItem(
_SubSchedulerParentHook.typeName, 2,
dict(loginAccount=reference(),
scheduledAt=timestamp(default=None),
scheduler=reference()))
def upgradeParentHook2to3(old):
"""
Copy all attributes except C{scheduledAt}.
"""
return old.upgradeVersion(old.typeName,
2,
3,
name = text()
damagePerHit = integer()
owner = reference()
activated = inmemory()
def upgradePlayerAndSword(oldplayer):
newplayer = oldplayer.upgradeVersion('test_app_player', 1, 2)
newplayer.name = oldplayer.name
oldsword = oldplayer.sword
newsword = oldsword.upgradeVersion('test_app_sword', 1, 2)
newsword.name = oldsword.name
newsword.damagePerHit = oldsword.hurtfulness * 2
newsword.owner = newplayer
return newplayer, newsword
def player1to2(oldplayer):
raise UpgradersAreBrokenHere()
def sword1to2(oldsword):
raise UpgradersAreBrokenHere()
registerUpgrader(sword1to2, 'test_app_sword', 1, 2)
registerUpgrader(player1to2, 'test_app_player', 1, 2)
def _filter2to3(old):
"""
add dependencies as attributes, remove installedOn
"""
filter = old.upgradeVersion(old.typeName, 2, 3)
s = old.store
filter.usePostiniScore = old.usePostiniScore
filter.postiniThreshhold = old.postiniThreshhold
filter.messageSource = s.findOrCreate(MessageSource)
filter.tiSource = s.findOrCreate(_TrainingInstructionSource)
return filter
registerUpgrader(_filter2to3, Filter.typeName, 2, 3)
item.declareLegacyItem(
Filter.typeName, 3,
dict(messageSource=attributes.reference(),
scheduler=attributes.reference(),
tiSource=attributes.reference(),
usePostiniScore=attributes.boolean(default=False, allowNone=False),
postiniThreshhold=attributes.ieee754_double(default=0.03)))
def _filter3to4(old):
"""
Drop the scheduler reference, preserve everything else.
"""
return old.upgradeVersion(old.typeName,
declareLegacyItem(
Scheduler.typeName, 1,
dict(eventsRun=integer(default=0),
lastEventAt=timestamp(),
nextEventAt=timestamp()))
def scheduler1to2(old):
new = old.upgradeVersion(Scheduler.typeName, 1, 2)
new.store.powerDown(new, IService)
new.store.powerDown(new, IScheduler)
return new
registerUpgrader(scheduler1to2, Scheduler.typeName, 1, 2)
class _SubSchedulerParentHook(Item):
schemaVersion = 4
typeName = 'axiom_subscheduler_parent_hook'
subStore = reference(doc="""
The L{SubStore} for which this scheduling hook exists.
""",
reftype=SubStore)
def run(self):
"""
Tick our C{subStore}'s L{SubScheduler}.
"""
class Referee(Item):
"""
An item the upgrader of which replaces itself on L{Referrer} with a new
instance with a different value.
"""
# Don't import the old schema. -exarkun
typeName = normalize(
"axiom.test.upgrade_fixtures.replace_attribute_old.Referee")
schemaVersion = 2
value = integer()
def referee1to2(oldReferee):
"""
Find the L{Referrer} which refers to C{oldReferee} and replace its
C{referee} attribute with a new, different L{Referee} item with a different
C{value}.
"""
store = oldReferee.store
[referrer] = list(store.query(Referrer, Referrer.referee == oldReferee))
referrer.referee = Referee(store=store, value=NEW_VALUE)
return oldReferee.upgradeVersion(Referee.typeName,
1,
2,
value=oldReferee.value)
registerUpgrader(referee1to2, Referee.typeName, 1, 2)
installedOn=oldMTA.installedOn,
portNumber=oldMTA.portNumber,
securePortNumber=oldMTA.securePortNumber,
certificateFile=oldMTA.certificateFile,
domain=oldMTA.domain)
return newMTA
else:
mda = MailDeliveryAgent(store=oldMTA.store)
mda.installedOn = oldMTA.store
oldMTA.store.powerUp(mda, smtp.IMessageDeliveryFactory)
oldMTA.store.powerDown(oldMTA, smtp.IMessageDeliveryFactory)
oldMTA.deleteFromStore()
# The MTA was deleted, there's no sensible Item to return here.
return mda
registerUpgrader(upgradeMailTransferAgent1to2, 'mantissa_mta', 1, 2)
def upgradeMailTransferAgent2to3(old):
"""
Add the userbase field since MTA depends on it and remove installedOn.
The isinstance check here is to avoid doing anything to MDA
instances returned by the 1to2 upgrader.
"""
if isinstance(old, MailDeliveryAgent):
return old
mta = old.upgradeVersion(MailTransferAgent.typeName, 2, 3,
messageCount=old.messageCount,
portNumber=old.portNumber,
securePortNumber=old.securePortNumber,
certificateFile=old.certificateFile,
def setServiceParent(self, parent):
"""
Compatibility hack necessary to prevent the Axiom service startup
mechanism from barfing. Even though this Item is no longer an IService
powerup, it will still be found as one one more time and this method
will be called on it.
"""
def pop3Listener1to2(old):
p3l = old.upgradeVersion(POP3Listener.typeName, 1, 2)
p3l.userbase = old.store.findOrCreate(LoginSystem)
return p3l
registerUpgrader(pop3Listener1to2, POP3Listener.typeName, 1, 2)
declareLegacyItem(
POP3Listener.typeName, 2,
dict(portNumber=integer(default=6110),
securePortNumber=integer(default=0),
certificateFile=bytes(default=None),
userbase=reference(doc="dependsOn(LoginSystem)")))
def pop3listener2to3(oldPOP3):
"""
Create TCPPort and SSLPort items as appropriate.
"""
newPOP3 = oldPOP3.upgradeVersion(POP3Listener.typeName,
2,
def setServiceParent(self, parent):
"""
Compatibility hack necessary to prevent the Axiom service startup
mechanism from barfing. Even though this Item is no longer an IService
powerup, it will still be found as one one more time and this method
will be called on it.
"""
def pop3Listener1to2(old):
p3l = old.upgradeVersion(POP3Listener.typeName, 1, 2)
p3l.userbase = old.store.findOrCreate(LoginSystem)
return p3l
registerUpgrader(pop3Listener1to2, POP3Listener.typeName, 1, 2)
declareLegacyItem(
POP3Listener.typeName, 2, dict(portNumber=integer(default=6110),
securePortNumber=integer(default=0),
certificateFile=bytes(default=None),
userbase=reference(doc="dependsOn(LoginSystem)")))
def pop3listener2to3(oldPOP3):
"""
Create TCPPort and SSLPort items as appropriate.
"""
newPOP3 = oldPOP3.upgradeVersion(
POP3Listener.typeName, 2, 3,
userbase=oldPOP3.userbase,
certificateFile=oldPOP3.certificateFile)
typeName = normalize(
"axiom.test.upgrade_fixtures.replace_attribute_old.Referrer")
referee = reference()
class Referee(Item):
"""
An item the upgrader of which replaces itself on L{Referrer} with a new
instance with a different value.
"""
# Don't import the old schema. -exarkun
typeName = normalize(
"axiom.test.upgrade_fixtures.replace_attribute_old.Referee")
schemaVersion = 2
value = integer()
def referee1to2(oldReferee):
"""
Find the L{Referrer} which refers to C{oldReferee} and replace its
C{referee} attribute with a new, different L{Referee} item with a different
C{value}.
"""
store = oldReferee.store
[referrer] = list(store.query(Referrer, Referrer.referee == oldReferee))
referrer.referee = Referee(store=store, value=NEW_VALUE)
return oldReferee.upgradeVersion(
Referee.typeName, 1, 2, value=oldReferee.value)
registerUpgrader(referee1to2, Referee.typeName, 1, 2)
def _filter2to3(old):
"""
add dependencies as attributes, remove installedOn
"""
filter = old.upgradeVersion(old.typeName, 2, 3)
s = old.store
filter.usePostiniScore = old.usePostiniScore
filter.postiniThreshhold = old.postiniThreshhold
filter.messageSource = s.findOrCreate(MessageSource)
filter.tiSource = s.findOrCreate(_TrainingInstructionSource)
return filter
registerUpgrader(_filter2to3, Filter.typeName, 2, 3)
item.declareLegacyItem(Filter.typeName, 3,
dict(messageSource=attributes.reference(),
scheduler=attributes.reference(),
tiSource=attributes.reference(),
usePostiniScore=attributes.boolean(default=False,allowNone=False),
postiniThreshhold=attributes.ieee754_double(default=0.03)))
def _filter3to4(old):
"""
Drop the scheduler reference, preserve everything else.
"""
return old.upgradeVersion(
old.typeName, 3, 4,
usePostiniScore=old.usePostiniScore,
mimeType = attributes.text()
imageSet = attributes.reference()
message = attributes.reference()
def image1to2(old):
new = old.upgradeVersion('quotient_image', 1, 2,
part=old.part,
mimeType=old.mimeType,
message=old.message,
imageSet=None)
# XXX HACK
new.thumbnailPath = old.thumbnailPath
return new
registerUpgrader(image1to2, 'quotient_image', 1, 2)
class ThumbnailDisplay(rend.Page):
def __init__(self, original):
self.translator = ixmantissa.IWebTranslator(original.store)
rend.Page.__init__(self, original)
def locateChild(self, ctx, segments):
if len(segments) == 1:
imageWebID = segments[0]
imageStoreID = self.translator.linkFrom(imageWebID)
if imageStoreID is not None:
image = self.original.store.getItemByID(imageStoreID)
return (static.File(image.thumbnailPath.path), ())
newIgnores = list(removeIgnores(mask))
diff = set(self.ignores) - set(newIgnores)
self.ignores = newIgnores
return list(diff) or None
def ircbotconfig1to2(old):
return old.upgradeVersion(
IRCBotConfig.typeName, 1, 2,
hostname=old.hostname,
portNumber=old.portNumber,
nickname=old.nickname.decode('utf-8'),
_channels=old._channels.decode('utf-8'),
_ignores=old._ignores.decode('utf-8'))
registerUpgrader(ircbotconfig1to2, IRCBotConfig.typeName, 1, 2)
def ircbotconfig2to3(old):
return old.upgradeVersion(
IRCBotConfig.typeName, 2, 3,
hostname=old.hostname,
portNumber=old.portNumber,
nickname=old.nickname,
channels=old._channels.split(u','),
ignores=old._ignores.split(u','))
registerUpgrader(ircbotconfig2to3, IRCBotConfig.typeName, 2, 3)
registerAttributeCopyingUpgrader(IRCBotConfig, 3, 4)
registerAttributeCopyingUpgrader(IRCBotConfig, 4, 5)
from axiom.upgrade import registerUpgrader
class Referrer(Item):
# Don't import the old schema. -exarkun
typeName = normalize(
'axiom.test.upgrade_fixtures.two_upgrades_old.Referrer')
schemaVersion = 2
referee = reference()
def upgradeReferrer1to2(old):
return old.upgradeVersion(old.typeName, 1, 2, referee=old.referee)
registerUpgrader(upgradeReferrer1to2, Referrer.typeName, 1, 2)
class Referee(Item):
# Don't import the old schema. -exarkun
typeName = normalize(
'axiom.test.upgrade_fixtures.two_upgrades_old.Referee')
schemaVersion = 2
dummy = integer()
def upgradeReferee1to2(old):
return old.upgradeVersion(old.typeName, 1, 2, dummy=old.dummy)
registerUpgrader(upgradeReferee1to2, Referee.typeName, 1, 2)
"""
for iface, priority in self.__getPowerupInterfaces__([]):
self.store.powerUp(self, iface, priority)
def upgradeStaticSite1To2(oldSite):
newSite = oldSite.upgradeVersion(
'static_web_site', 1, 2,
staticContentPath=oldSite.staticContentPath,
prefixURL=oldSite.prefixURL,
sessionless=True)
for pc in newSite.store.query(_PowerupConnector,
AND(_PowerupConnector.powerup == newSite,
_PowerupConnector.interface == u'xmantissa.ixmantissa.ISiteRootPlugin')):
pc.item.powerDown(newSite, ISiteRootPlugin)
return newSite
upgrade.registerUpgrader(upgradeStaticSite1To2, 'static_web_site', 1, 2)
class StaticRedirect(Item, PrefixURLMixin):
implements(inevow.IResource,
ISessionlessSiteRootPlugin,
ISiteRootPlugin)
schemaVersion = 2
typeName = 'web_static_redirect'
targetURL = text(allowNone=False)
prefixURL = text(allowNone=False)
sessioned = boolean(default=True)
"""
store = Store()
t = nonUpgradedItem(store=store)
self.assertEquals(t.__legacy__, True)
self.assertFalse(store.objectCache.has(t.storeID))
t2 = store.getItemByID(t.storeID)
self.assertNotIdentical(t, t2)
self.assertTrue(isinstance(t2, UpgradedItem))
class UpgradedItem(Item):
"""
A simple item which is the current version of L{nonUpgradedItem}.
"""
schemaVersion = 2
dummy = integer()
nonUpgradedItem = declareLegacyItem(UpgradedItem.typeName, 1,
dict(dummy=integer()))
def item1to2(old):
"""
Upgrade an nonUpgradedItem to UpgradedItem
"""
return old.upgradeVersion(UpgradedItem.typeName, 1, 2, dummy=old.dummy)
registerUpgrader(item1to2, UpgradedItem.typeName, 1, 2)
# -*- test-case-name: axiom.test.test_upgrading.DeletionTest.testPowerups -*-
from axiom.item import Item
from axiom.attributes import integer
class Obsolete(Item):
"""
This is a stub placeholder so that axiomInvalidateModule will invalidate
the appropriate typeName; it's probably bad practice to declare recent
versions of deleted portions of the schema, but that's not what this is
testing.
"""
typeName = 'test_upgrading_obsolete'
nothing = integer()
schemaVersion = 2
from axiom.upgrade import registerUpgrader
def obsolete1toNone(oldObsolete):
oldObsolete.deleteFromStore()
return None
registerUpgrader(obsolete1toNone, 'test_upgrading_obsolete', 1, 2)
def fromAddress1to2(old):
new = old.upgradeVersion(old.typeName, 1, 2,
_address=old.address,
_default=old._default,
smtpHost=old.smtpHost,
smtpPort=old.smtpPort,
smtpUsername=old.smtpUsername,
smtpPassword=old.smtpPassword)
if new._address == _getFromAddressFromStore(new.store):
new._address = None
return new
registerUpgrader(fromAddress1to2, FromAddress.typeName, 1, 2)
class MessageDelivery(item.Item):
"""
Handles the delivery of a single message to multiple addresses.
"""
composer = attributes.reference()
message = attributes.reference()
def allBounced(self):
"""
Did all of the addresses bounce?
return IScheduler(self.store).now() + timedelta(seconds=delay)
declareLegacyItem(
MessageQueue.typeName, 1,
dict(messageCounter=integer(default=0, allowNone=False),
scheduler=reference()))
def upgradeMessageQueue1to2(old):
"""
Copy the C{messageCounter} attribute to the upgraded MessageQueue.
"""
return old.upgradeVersion(
MessageQueue.typeName, 1, 2, messageCounter=old.messageCounter)
registerUpgrader(upgradeMessageQueue1to2, MessageQueue.typeName, 1, 2)
#### High-level convenience API ####
AMP_MESSAGE_TYPE = u'mantissa.amp.message'
AMP_ANSWER_TYPE = u'mantissa.amp.answer'
class _ProtoAttributeArgument(Argument):
"""
Common factoring of L{TargetArgument} and L{SenderArgument}, for reading an
attribute from the 'proto' attribute.
@ivar attr: the name of the attribute to retrieve from the C{proto}
argument to L{_ProtoAttributeArgument.fromBox}.
uac.transport = self.dispatcher.transport
self.dispatcher.installTemporaryProcessor(sip.URL(host, localpart),
uac)
uac._doCall(partyA[1], fromName="Divmod")
def sipServer1to2(old):
ss = old.upgradeVersion(old.typeName, 1, 2)
ss.portno = old.portno
ss.pstn = old.pstn
ss.userbase = old.store.findOrCreate(LoginSystem)
return ss
registerUpgrader(sipServer1to2, SIPServer.typeName, 1, 2)
declareLegacyItem(
SIPServer.typeName, 2,
dict(portno=integer(),
pstn=bytes(),
scheduler=reference(),
userbase=reference()))
def sipServer2to3(old):
ss = old.upgradeVersion(old.typeName, 2, 3)
ss.portno = old.portno
ss.pstn = old.pstn
ss.userbase = old.userbase
return ss
ssl=ssl)
# DO IT *NOW*
self.scheduler.schedule(pg, extime.Time())
# OR MAYBE A LITTLE LATER
item.declareLegacyItem(GrabberConfiguration.typeName, 1, dict(
paused=attributes.boolean(default=False),
installedOn=attributes.reference()))
def _grabberConfiguration1to2(old):
new = old.upgradeVersion(GrabberConfiguration.typeName, 1, 2,
paused=old.paused,
privateApplication = old.store.findOrCreate(PrivateApplication),
deliveryAgent = old.store.findOrCreate(DeliveryAgent))
return new
registerUpgrader(_grabberConfiguration1to2, GrabberConfiguration.typeName, 1, 2)
item.declareLegacyItem(GrabberConfiguration.typeName, 2, dict(
paused=attributes.boolean(default=False),
scheduler=attributes.reference(),
privateApplication=attributes.reference(),
deliveryAgent=attributes.reference(),
))
def _grabberConfiguration2to3(old):
"""
Copy all the remaining attributes.
"""
new = old.upgradeVersion(GrabberConfiguration.typeName, 2, 3,
paused=old.paused,
MessageQueue.typeName, 1,
dict(messageCounter=integer(default=0, allowNone=False),
scheduler=reference()))
def upgradeMessageQueue1to2(old):
"""
Copy the C{messageCounter} attribute to the upgraded MessageQueue.
"""
return old.upgradeVersion(MessageQueue.typeName,
1,
2,
messageCounter=old.messageCounter)
registerUpgrader(upgradeMessageQueue1to2, MessageQueue.typeName, 1, 2)
#### High-level convenience API ####
AMP_MESSAGE_TYPE = u'mantissa.amp.message'
AMP_ANSWER_TYPE = u'mantissa.amp.answer'
class _ProtoAttributeArgument(Argument):
"""
Common factoring of L{TargetArgument} and L{SenderArgument}, for reading an
attribute from the 'proto' attribute.
@ivar attr: the name of the attribute to retrieve from the C{proto}
argument to L{_ProtoAttributeArgument.fromBox}.
"""
parent = attributes.inmemory()
running = attributes.inmemory()
name = attributes.inmemory()
statoscope = attributes.inmemory()
queryStatoscope = attributes.inmemory()
statTypes = attributes.inmemory()
currentMinuteBucket = attributes.integer(default=0)
currentQuarterHourBucket = attributes.integer(default=0)
observers = attributes.inmemory()
loginInterfaces = attributes.inmemory()
userStats = attributes.inmemory()
powerupInterfaces = (service.IService,)
class RemoteStatsObserver(item.Item):
"""
Obsolete. Only present for schema compatibility. Do not use.
"""
hostname = attributes.bytes(doc="A host to send stat updates to")
port = attributes.integer(doc="The port to send stat updates to")
protocol = attributes.inmemory(doc="The juice protocol instance to send stat updates over")
def upgradeStatBucket1to2(bucket):
bucket.deleteFromStore()
upgrade.registerUpgrader(upgradeStatBucket1to2, 'xmantissa_stats_statbucket', 1, 2)
class UpgradedItem(Item):
"""
A simple item which is the current version of L{nonUpgradedItem}.
"""
schemaVersion = 3
ref = reference()
nonUpgradedItem = declareLegacyItem(
UpgradedItem.typeName, 1,
dict(ref=reference()))
nonUpgradedItem2 = declareLegacyItem(
UpgradedItem.typeName, 2,
dict(ref=reference()))
registerAttributeCopyingUpgrader(UpgradedItem, 1, 2)
def item2to3(old):
"""
Upgrade an nonUpgradedItem to UpgradedItem
"""
return old.upgradeVersion(UpgradedItem.typeName, 2, 3, ref=old.ref)
registerUpgrader(item2to3, UpgradedItem.typeName, 2, 3)
t2 = store.getItemByID(t.storeID)
self.assertNotIdentical(t, t2)
self.assertTrue(isinstance(t2, UpgradedItem))
class UpgradedItem(Item):
"""
A simple item which is the current version of L{nonUpgradedItem}.
"""
schemaVersion = 3
ref = reference()
nonUpgradedItem = declareLegacyItem(UpgradedItem.typeName, 1,
dict(ref=reference()))
nonUpgradedItem2 = declareLegacyItem(UpgradedItem.typeName, 2,
dict(ref=reference()))
registerAttributeCopyingUpgrader(UpgradedItem, 1, 2)
def item2to3(old):
"""
Upgrade an nonUpgradedItem to UpgradedItem
"""
return old.upgradeVersion(UpgradedItem.typeName, 2, 3, ref=old.ref)
registerUpgrader(item2to3, UpgradedItem.typeName, 2, 3)
# -*- test-case-name: axiom.test.test_upgrading.DuringUpgradeTests.test_reentrantUpgraderFailure -*-
from axiom.attributes import integer, reference
from axiom.item import Item, normalize
from axiom.upgrade import registerUpgrader
class Simple(Item):
# Don't import the old schema. -exarkun
typeName = normalize(
"axiom.test.upgrade_fixtures.reentrant_old.Simple")
schemaVersion = 2
dummy = integer()
selfReference = reference()
def upgradeSimple1to2(old):
# Force the upgrade.
selfRef = old.store.getItemByID(old.storeID)
return old.upgradeVersion(
old.typeName, 1, 2,
dummy=old.dummy,
selfReference=selfRef)
registerUpgrader(upgradeSimple1to2, Simple.typeName, 1, 2)
A reference to the LoginAccount for which this is a login method.
""", allowNone=False)
verified = boolean(indexed=True, allowNone=False)
def upgradeLoginMethod1To2(old):
return old.upgradeVersion(
'login_method', 1, 2,
localpart=old.localpart,
domain=old.domain,
internal=old.internal,
protocol=old.protocol,
account=old.account,
verified=old.verified)
upgrade.registerUpgrader(upgradeLoginMethod1To2, 'login_method', 1, 2)
class LoginAccount(Item):
"""
I am an entry in a LoginBase.
@ivar avatars: An Item which is adaptable to various cred client
interfaces. Plural because it represents a collection of potentially
disparate implementors, such as an IResource for web access and an IContact
for SIP access.
@ivar disabled: This account has been disabled. It is still
database-resident but the user should not be allowed to log in.
"""
typeName = 'login'
def indirect(self, interface):
"""
Like __conform__, I adapt my store to whatever interface I am asked to
produce a powerup for. This allows for app stores to be installed as
powerups for their site stores directly, rather than having an
additional item type for each interface that we might wish to adapt to.
"""
return interface(self)
class SubStoreStartupService(Item, service.Service, InstallableMixin):
"""
This class no longer exists. It is here simply to trigger an upgrade which
deletes it. Ignore it, please.
"""
installedOn = reference()
parent = inmemory()
running = inmemory()
name = inmemory()
schemaVersion = 2
def eliminateSubStoreStartupService(subservice):
subservice.deleteFromStore()
return None
registerUpgrader(eliminateSubStoreStartupService,
SubStoreStartupService.typeName, 1, 2)
def owner():
def get(self):
return self.store.findUnique(InventoryEntry,
InventoryEntry.owned == self).owner
return get,
owner = property(*owner())
def sword2to3(oldsword):
raise RuntimeError("The database does not contain any swords of version 2,"
" so you should be able to skip this version.")
registerUpgrader(sword2to3, 'test_app_sword', 2, 3)
####### DOUBLE-LEGACY UPGRADE SPECTACULAR !! ###########
# declare legacy class.
from axiom.item import declareLegacyItem
declareLegacyItem(typeName = 'test_app_sword',
schemaVersion = 2,
attributes = dict(name=text(),
damagePerHit=integer(),
owner=reference(),
activated=inmemory()))
def image1to2(old):
new = old.upgradeVersion('quotient_image',
1,
2,
part=old.part,
mimeType=old.mimeType,
message=old.message,
imageSet=None)
# XXX HACK
new.thumbnailPath = old.thumbnailPath
return new
registerUpgrader(image1to2, 'quotient_image', 1, 2)
class ThumbnailDisplay(rend.Page):
def __init__(self, original):
self.translator = ixmantissa.IWebTranslator(original.store)
rend.Page.__init__(self, original)
def locateChild(self, ctx, segments):
if len(segments) == 1:
imageWebID = segments[0]
imageStoreID = self.translator.linkFrom(imageWebID)
if imageStoreID is not None:
image = self.original.store.getItemByID(imageStoreID)
return (static.File(image.thumbnailPath.path), ())
schemaVersion = 2
installedOn = reference()
def passwordReset1to2(old):
"""
Power down and delete the item
"""
new = old.upgradeVersion(old.typeName, 1, 2, installedOn=None)
for iface in new.store.interfacesFor(new):
new.store.powerDown(new, iface)
new.deleteFromStore()
upgrade.registerUpgrader(passwordReset1to2, 'password_reset', 1, 2)
class NoSuchFactory(Exception):
"""
An attempt was made to create a signup page using the name of a benefactor
factory which did not correspond to anything in the database.
"""
class TicketClaimer(Page):
def childFactory(self, ctx, name):
for T in self.original.store.query(
Ticket,
AND(Ticket.booth == self.original,
Ticket.nonce == unicode(name, 'ascii'))):
# -*- test-case-name: axiom.test.test_upgrading.DuringUpgradeTests.test_reentrantUpgraderFailure -*-
from axiom.attributes import integer, reference
from axiom.item import Item, normalize
from axiom.upgrade import registerUpgrader
class Simple(Item):
# Don't import the old schema. -exarkun
typeName = normalize("axiom.test.upgrade_fixtures.reentrant_old.Simple")
schemaVersion = 2
dummy = integer()
selfReference = reference()
def upgradeSimple1to2(old):
# Force the upgrade.
selfRef = old.store.getItemByID(old.storeID)
return old.upgradeVersion(old.typeName,
1,
2,
dummy=old.dummy,
selfReference=selfRef)
registerUpgrader(upgradeSimple1to2, Simple.typeName, 1, 2)
"Use the sharing system to provide public pages, not IPublicPage",
category=DeprecationWarning,
stacklevel=2)
return pp.getResource()
return SharingIndex(self.application.open())
def upgradePublicWeb1To2(oldWeb):
newWeb = oldWeb.upgradeVersion(
'mantissa_public_web', 1, 2,
prefixURL=oldWeb.prefixURL,
application=oldWeb.application,
installedOn=oldWeb.installedOn)
newWeb.installedOn.powerUp(newWeb, ixmantissa.ICustomizablePublicPage)
return newWeb
upgrade.registerUpgrader(upgradePublicWeb1To2, 'mantissa_public_web', 1, 2)
def upgradePublicWeb2To3(oldWeb):
newWeb = oldWeb.upgradeVersion(
'mantissa_public_web', 2, 3,
prefixURL=oldWeb.prefixURL,
application=oldWeb.application,
installedOn=oldWeb.installedOn,
# There was only one PublicWeb before, and it definitely
# wanted to be sessioned.
sessioned=True)
newWeb.installedOn.powerDown(newWeb, ixmantissa.ICustomizablePublicPage)
other = newWeb.installedOn
newWeb.installedOn = None
newWeb.installOn(other)
return newWeb
self.assertEquals(t.__legacy__, True)
self.assertFalse(store.objectCache.has(t.storeID))
t2 = store.getItemByID(t.storeID)
self.assertNotIdentical(t, t2)
self.assertTrue(isinstance(t2, UpgradedItem))
class UpgradedItem(Item):
"""
A simple item which is the current version of L{nonUpgradedItem}.
"""
schemaVersion = 2
dummy = integer()
nonUpgradedItem = declareLegacyItem(
UpgradedItem.typeName, 1,
dict(dummy=integer()))
def item1to2(old):
"""
Upgrade an nonUpgradedItem to UpgradedItem
"""
return old.upgradeVersion(UpgradedItem.typeName, 1, 2, dummy=old.dummy)
registerUpgrader(item1to2, UpgradedItem.typeName, 1, 2)
@coerce
def viewAverageHours(self, startTime: IDateTime, endTime: IDateTime) -> ICalendarData:
endTime = endTime.replace(days=1)
avgStart = startTime.replace(days=-90)
hours = self.viewHours(start=avgStart, end=endTime)
if hours.startTime() > startTime:
startTime = hours.startTime().replace(seconds=-1)
outdata = ICalendarData([])
for day in startTime.daysBetween(startTime, endTime):
if isinstance(day, tuple):
continue
total = hours.sumBetween(day.replace(days=-90), day)
print(151, total)
outdata.addTime(InMemoryTimePeriod(day, day + total / 90))
return outdata
def getSupervisors(self):
return self.powerupsFor(ISupervisedBy)
def upgrade_1_2(old: Employee):
supervisor = old.supervisor
keys = dict((str(name), getattr(old, name))
for (name, _) in old.getSchema())
keys.pop('supervisor')
newitem = old.upgradeVersion(Employee.typeName, 1, 2, **keys)
if supervisor:
newitem.powerUp(supervisor, ISupervisedBy)
registerUpgrader(upgrade_1_2, Employee.typeName, 1, 2)
from axiom.item import Item
from axiom.attributes import text, integer, timestamp
class Sample(Item):
# we didn't originally set typeName, so it was generated from the
# fully-qualified classname ("diskwatcher.Sample"), then Axiom
# automatically lowercases and un-dot-ifies it to get
# "diskwatcher_sample". Now we explicitly provide a name.
typeName = "diskwatcher_sample"
# version 2 added the 'total' field
schemaVersion = 2
url = text(indexed=True)
when = timestamp(indexed=True)
total = integer()
used = integer()
avail = integer()
def upgradeSample1to2(old):
return old.upgradeVersion("diskwatcher_sample", 1, 2,
url=old.url,
when=old.when,
total=0,
used=old.used,
avail=old.avail)
from axiom.upgrade import registerUpgrader
registerUpgrader(upgradeSample1to2, "diskwatcher_sample", 1, 2)
dict(paused=attributes.boolean(default=False),
installedOn=attributes.reference()))
def _grabberConfiguration1to2(old):
new = old.upgradeVersion(
GrabberConfiguration.typeName,
1,
2,
paused=old.paused,
privateApplication=old.store.findOrCreate(PrivateApplication),
deliveryAgent=old.store.findOrCreate(DeliveryAgent))
return new
registerUpgrader(_grabberConfiguration1to2, GrabberConfiguration.typeName, 1,
2)
item.declareLegacyItem(
GrabberConfiguration.typeName, 2,
dict(
paused=attributes.boolean(default=False),
scheduler=attributes.reference(),
privateApplication=attributes.reference(),
deliveryAgent=attributes.reference(),
))
def _grabberConfiguration2to3(old):
"""
Copy all the remaining attributes.
"""
return D
def upgradeInbox1to2(oldInbox):
"""
Create the extra state tracking items necessary for efficiently determining
distinct source addresses.
"""
newInbox = oldInbox.upgradeVersion(
"quotient_inbox", 1, 2, installedOn=oldInbox.installedOn, uiComplexity=oldInbox.uiComplexity
)
return newInbox
registerUpgrader(upgradeInbox1to2, "quotient_inbox", 1, 2)
declareLegacyItem(
Inbox.typeName,
2,
dict(installedOn=attributes.reference(), uiComplexity=attributes.integer(), catalog=attributes.reference()),
)
registerAttributeCopyingUpgrader(Inbox, 2, 3)
declareLegacyItem(
Inbox.typeName,
3,
dict(
installedOn=attributes.reference(),
catalog=attributes.reference(),
return (get,)
owner = property(*owner())
def sword2to3(oldsword):
newsword = oldsword.upgradeVersion("test_app_sword", 2, 3)
n = oldsword.store.getOldVersionOf("test_app_sword", 2)
itrbl = oldsword.store.query(n)
newsword.name = oldsword.name
newsword.damagePerHit = oldsword.damagePerHit
invent = InventoryEntry(store=newsword.store, owner=oldsword.owner, owned=newsword)
return newsword
registerUpgrader(sword2to3, "test_app_sword", 2, 3)
####### DOUBLE-LEGACY UPGRADE SPECTACULAR !! ###########
# declare legacy class.
from axiom.item import declareLegacyItem
declareLegacyItem(typeName="test_app_player", schemaVersion=2, attributes=dict(name=text(allowNone=True)))
registerAttributeCopyingUpgrader(Adventurer, 2, 3)
declareLegacyItem(
typeName="test_app_sword",
declareLegacyItem(
Scheduler.typeName, 1,
dict(eventsRun=integer(default=0),
lastEventAt=timestamp(),
nextEventAt=timestamp()))
def scheduler1to2(old):
new = old.upgradeVersion(Scheduler.typeName, 1, 2)
new.store.powerDown(new, IService)
new.store.powerDown(new, IScheduler)
return new
registerUpgrader(scheduler1to2, Scheduler.typeName, 1, 2)
class _SubSchedulerParentHook(Item):
schemaVersion = 4
typeName = 'axiom_subscheduler_parent_hook'
subStore = reference(
doc="""
The L{SubStore} for which this scheduling hook exists.
""", reftype=SubStore)
def run(self):
"""
Tick our C{subStore}'s L{SubScheduler}.
"""
return oldVolume.upgradeVersion('db_volume',
1,
2,
ifaceIndex=1,
vIn=oldVolume.vIn,
vOut=oldVolume.vOut,
timestamp=oldVolume.timestamp,
month=oldVolume.month,
year=oldVolume.year,
day=oldVolume.day,
port=oldVolume.port,
localIp=oldVolume.localIp)
# add interface Index attribute ifaceIndex
registerUpgrader(upgradeVolume1to2, 'db_volume', 1, 2)
class CDR(AccessBroker):
"""Describes the asterisk CDR DB"""
"""
"""
def userStartup(self):
cdr = self.table(
'cdr',
sa.Column('calldate', sa.DateTime),
sa.Column('clid', sa.String('80')),
sa.Column('src', sa.String('80')),
sa.Column('dst', sa.String('80')),
sa.Column('dcontext', sa.String('80')),
verified = boolean(indexed=True, allowNone=False)
def upgradeLoginMethod1To2(old):
return old.upgradeVersion('login_method',
1,
2,
localpart=old.localpart,
domain=old.domain,
internal=old.internal,
protocol=old.protocol,
account=old.account,
verified=old.verified)
upgrade.registerUpgrader(upgradeLoginMethod1To2, 'login_method', 1, 2)
class LoginAccount(Item):
"""
I am an entry in a LoginBase.
@ivar avatars: An Item which is adaptable to various cred client
interfaces. Plural because it represents a collection of potentially
disparate implementors, such as an IResource for web access and an IContact
for SIP access.
@ivar disabled: This account has been disabled. It is still
database-resident but the user should not be allowed to log in.
"""
