def test_legacyItemComparison(self):
"""
Legacy items with different versions must not compare equal.
"""
legacy1 = declareLegacyItem('test_type', 1, {})
legacy2 = declareLegacyItem('test_type', 2, {})
self.assertNotEqual(legacy1, legacy2)
self.assertEqual(legacy1, legacy1)
self.assertEqual(legacy2, legacy2)
def test_legacyItemComparison(self):
"""
Legacy items with different versions must not compare equal.
"""
legacy1 = declareLegacyItem('test_type', 1, {})
legacy2 = declareLegacyItem('test_type', 2, {})
self.assertNotEqual(legacy1, legacy2)
self.assertEqual(legacy1, legacy1)
self.assertEqual(legacy2, legacy2)
def test_queueMultipleVersions(self):
"""
If multiple schema versions are queued for upgrade, upgrades should be
attempted for all of them (but only attempted once per version).
"""
legacy1 = declareLegacyItem('test_type', 1, {})
legacy2 = declareLegacyItem('test_type', 2, {})
self._upgrader.queueTypeUpgrade(legacy1)
self._upgrader.queueTypeUpgrade(legacy2)
self._upgrader.queueTypeUpgrade(legacy2)
self.assertEqual(len(self._upgrader._oldTypesRemaining), 2)
def test_queueMultipleVersions(self):
"""
If multiple schema versions are queued for upgrade, upgrades should be
attempted for all of them (but only attempted once per version).
"""
legacy1 = declareLegacyItem('test_type', 1, {})
legacy2 = declareLegacyItem('test_type', 2, {})
self._upgrader.queueTypeUpgrade(legacy1)
self._upgrader.queueTypeUpgrade(legacy2)
self._upgrader.queueTypeUpgrade(legacy2)
self.assertEqual(len(self._upgrader._oldTypesRemaining), 2)
def test_axiomaticUpgradeExceptionBubbling(self):
"""
Exceptions encountered by L{Upgrade.upgradeStore} are handled and
re-raised as L{errors.ItemUpgradeError} with attributes indicating
which L{Item} was being upgraded when the exception occurred.
"""
choose(oldapp)
swordID = oldapp.Sword(store=self.store,
name='longsword',
hurtfulness=4).storeID
self.store.close()
choose(brokenapp)
self.store = store.Store(self.dbdir)
cmd = Upgrade()
cmd.parent = CommandStub(self.store, 'upgrade')
cmd.count = 100
err = self.assertRaises(errors.ItemUpgradeError,
callWithStdoutRedirect, cmd.upgradeStore,
self.store)
self.assertTrue(
err.originalFailure.check(brokenapp.UpgradersAreBrokenHere))
oldType = item.declareLegacyItem(oldapp.Sword.typeName,
oldapp.Sword.schemaVersion, {})
self.assertEqual(err.storeID, swordID)
self.assertIdentical(err.oldType, oldType)
self.assertIdentical(err.newType, brokenapp.Sword)
def test_axiomaticUpgradeExceptionBubbling(self):
"""
Exceptions encountered by L{Upgrade.upgradeStore} are handled and
re-raised as L{errors.ItemUpgradeError} with attributes indicating
which L{Item} was being upgraded when the exception occurred.
"""
choose(oldapp)
swordID = oldapp.Sword(
store=self.store, name='longsword', hurtfulness=4).storeID
self.store.close()
choose(brokenapp)
self.store = store.Store(self.dbdir)
cmd = Upgrade()
cmd.parent = CommandStub(self.store, 'upgrade')
cmd.count = 100
err = self.assertRaises(
errors.ItemUpgradeError,
callWithStdoutRedirect, cmd.upgradeStore, self.store)
self.assertTrue(
err.originalFailure.check(brokenapp.UpgradersAreBrokenHere))
oldType = item.declareLegacyItem(
oldapp.Sword.typeName,
oldapp.Sword.schemaVersion, {})
self.assertEqual(err.storeID, swordID)
self.assertIdentical(err.oldType, oldType)
self.assertIdentical(err.newType, brokenapp.Sword)
def checkException(ign):
# It's redundant that the errback is called and the failure is
# logged. See #2638.
loggedErrors = self.flushLoggedErrors(errors.ItemUpgradeError)
self.assertEqual(len(loggedErrors), 1)
oldType = item.declareLegacyItem(oldapp.Sword.typeName,
oldapp.Sword.schemaVersion, {})
e = loggedErrors[0].value
self.assertEqual(e.storeID, swordID)
self.assertIdentical(e.oldType, oldType)
self.assertIdentical(e.newType, brokenapp.Sword)
def checkException(ign):
# It's redundant that the errback is called and the failure is
# logged. See #2638.
loggedErrors = self.flushLoggedErrors(errors.ItemUpgradeError)
self.assertEqual(len(loggedErrors), 1)
upgradeError = loggedErrors[0]
loggedErrors = self.flushLoggedErrors(brokenapp.UpgradersAreBrokenHere)
self.assertEqual(len(loggedErrors), 1)
oldType = item.declareLegacyItem(
oldapp.Sword.typeName,
oldapp.Sword.schemaVersion, {})
e = upgradeError.value
self.assertEqual(e.storeID, swordID)
self.assertIdentical(e.oldType, oldType)
self.assertIdentical(e.newType, brokenapp.Sword)
def activate(self):
_SchedulerCompatMixin.activate(self)
def setServiceParent(self, parent):
"""
L{Scheduler} is no longer an L{IService}, but still provides this
method as a no-op in case an instance which was still an L{IService}
powerup is loaded (in which case it will be used like a service
once).
"""
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):
for answer in self.store.query(_AlreadyAnswered,
sort=_AlreadyAnswered.storeID.ascending):
self._deliverAnswer(answer)
nextmsg = self.store.findFirst(_QueuedMessage, default=None)
if nextmsg is not None:
delay = _RETRANSMIT_DELAY
else:
nextanswer = self.store.findFirst(_AlreadyAnswered, default=None)
if nextanswer is not None:
delay = _RETRANSMIT_DELAY
if delay is not None:
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'
sch.schedule(self, extime.Time() + nextTry)
if not self.running:
self.running = True
self.tries += 1
d = self.sendmail()
d.addCallback(self.mailSent, sch)
d.addErrback(self.failureSending, sch)
d.addErrback(log.err)
item.declareLegacyItem(
DeliveryToAddress.typeName, 2,
dict(composer=attributes.reference(),
message=attributes.reference(),
fromAddress=attributes.reference(),
toAddress=attributes.text(),
tries=attributes.integer(default=0)))
def deliveryToAddress2to3(old):
delivery = MessageDelivery(composer=old.composer,
message=old.message,
store=old.store)
new = old.upgradeVersion(old.typeName,
2,
3,
delivery=delivery,
message=old.message,
fromAddress=old.fromAddress,
newCertPath = site.store.newFilePath('server.pem')
oldCertPath.moveTo(newCertPath)
port = SSLPort(
store=site.store,
portNumber=oldSite.securePortNumber,
certificatePath=newCertPath,
factory=site)
installOn(port, site.store)
newSite.deleteFromStore()
declareLegacyItem(
WebSite.typeName, 1, dict(
hitCount = integer(default=0),
installedOn = reference(),
portNumber = integer(default=0),
securePortNumber = integer(default=0),
certificateFile = bytes(default=None)))
def upgradeWebSite1To6(oldSite):
return _makeSiteConfiguration(1, oldSite, False)
upgrade.registerUpgrader(upgradeWebSite1To6, 'mantissa_web_powerup', 1, 6)
declareLegacyItem(
WebSite.typeName, 2, dict(
hitCount = integer(default=0),
installedOn = reference(),
portNumber = integer(default=0),
securePortNumber = integer(default=0),
certificateFile = bytes(default=None),
def listen(self):
if self._listen is not None:
_listen = self._listen
else:
from twisted.internet import reactor
_listen = reactor.listenTCP
return _listen(self.portNumber,
self.factory.getFactory(),
interface=self.interface.encode('ascii'))
declareLegacyItem(typeName=normalize(qual(TCPPort)),
schemaVersion=1,
attributes=dict(portNumber=integer(),
factory=reference(),
parent=inmemory(),
_listen=inmemory(),
listeningPort=inmemory()))
registerAttributeCopyingUpgrader(TCPPort, 1, 2)
class SSLPort(PortMixin, Item):
"""
An Axiom Service Item which will bind a TCP port to a protocol factory when
it is started.
"""
schemaVersion = 2
portNumber = integer(doc="""
def _declareLegacyIndexerItem(typeClass, version):
item.declareLegacyItem(
typeClass.typeName, version,
dict(indexCount=attributes.integer(),
installedOn=attributes.reference(),
indexDirectory=attributes.text()))
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)
if oldPOP3.portNumber is not None:
port = TCPPort(store=newPOP3.store, portNumber=oldPOP3.portNumber, factory=newPOP3)
installOn(port, newPOP3.store)
"""
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,
loginAccount=old.loginAccount,
scheduler=old.scheduler)
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(),
uiComplexity=attributes.integer(),
showMoreDetail=attributes.boolean(),
),
)
contact = sip.IContact(self.store)
def regged(_):
return defer.succeed(None)
def unregged(e):
self.uas.dialogs = dialogs
return self.uas
return defer.maybeDeferred(contact.getRegistrationInfo, sip.parseAddress(msg.headers["from"][0])[1]).addCallbacks(regged, unregged)
else:
return defer.succeed(None)
def localElementByName(self, n):
for name, domain in userbase.getAccountNames(self.store, protocol=u'sip'):
#if we got here, we have a SIP account...
return useragent.ICallControllerFactory(self.store)
item.declareLegacyItem(VoicemailDispatcher.typeName, 1, dict(
localHost=bytes(),
installedOn=reference()))
def _voicemailDispatcher1to2(old):
df = old.upgradeVersion(VoicemailDispatcher.typeName, 1, 2,
localHost=old.localHost,
voicemailUser=old.store.findOrCreate(
AnonConfessionUser))
return df
registerUpgrader(_voicemailDispatcher1to2, VoicemailDispatcher.typeName, 1, 2)
# IPowerupIndirector
def indirect(self, interface):
"""
Indirect the implementation of L{IWebViewer} to
L{_AuthenticatedWebViewer}.
"""
if interface == IWebViewer:
return _AuthenticatedWebViewer(self)
return self
PrivateApplicationV2 = declareLegacyItem(
PrivateApplication.typeName, 2,
dict(
installedOn=reference(),
preferredTheme=text(),
hitCount=integer(default=0),
privateKey=integer(),
privateIndexPage=reference(),
))
PrivateApplicationV3 = declareLegacyItem(
PrivateApplication.typeName, 3,
dict(
preferredTheme=text(),
hitCount=integer(default=0),
privateKey=integer(),
privateIndexPage=reference(),
customizedPublicPage=reference("dependsOn(CustomizedPublicPage)"),
authenticationApplication=reference(
"dependsOn(AuthenticationApplication)"),
registerAdapter(ExtractRenderer, EmailAddressExtract, IRenderer)
registerExtractUpgrader1to2(EmailAddressExtract)
extractTypes = {'url': URLExtract,
'phone number': PhoneNumberExtract,
'email address': EmailAddressExtract}
class ExtractPowerup(Item):
schemaVersion = 2
gallery = dependsOn(Gallery)
thumbnailDisplayer = dependsOn(ThumbnailDisplayer)
def installed(self):
self.store.findUnique(mail.MessageSource).addReliableListener(self)
def processItem(self, message):
extractImages(message)
for et in extractTypes.itervalues():
et.extract(message)
declareLegacyItem(ExtractPowerup.typeName, 1, dict(
installedOn = attributes.reference()))
def _extractPowerup1to2(old):
return old.upgradeVersion(ExtractPowerup.typeName, 1, 2,
gallery=old.store.findOrCreate(Gallery),
thumbnailDisplayer=old.store.findOrCreate(ThumbnailDisplayer))
registerUpgrader(_extractPowerup1to2, ExtractPowerup.typeName, 1, 2)
def installed(self):
self.indexer.addSource(self.messageSource)
def count(self, term):
raise NotImplementedError("No one should ever call count, I think.")
def search(self, *a, **k):
if 'sortAscending' not in k:
k['sortAscending'] = False
d = self.indexer.search(*a, **k)
d.addCallback(_mailsearchui.SearchAggregatorFragment, self.store)
return d
declareLegacyItem(
MessageSearchProvider.typeName, 1,
dict(indexer=attributes.reference(), installedOn=attributes.reference()))
def _messageSearchProvider1to2(old):
new = old.upgradeVersion(MessageSearchProvider.typeName,
1,
2,
indexer=old.indexer,
messageSource=old.store.findUnique(
mail.MessageSource))
return new
registerUpgrader(_messageSearchProvider1to2, MessageSearchProvider.typeName, 1,
2)
'LOGIN': imap4.LOGINCredentials,
},
certOpts)
if self.debug:
self.factory = policies.TrafficLoggingFactory(self.factory, 'smtp')
return self.factory
# GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
def setServiceParent(self, parent):
pass
item.declareLegacyItem(typeName=MailTransferAgent.typeName,
schemaVersion=2,
attributes=dict(messageCount=attributes.integer(),
installedOn=attributes.reference(),
portNumber=attributes.integer(),
securePortNumber=attributes.integer(),
certificateFile=attributes.bytes(),
domain=attributes.bytes()))
def upgradeMailTransferAgent1to2(oldMTA):
"""
MailTransferAgent has been replaced with MailDeliveryAgent on B{user
stores}. Delete it from user stores and create a MailDelivery agent
there, but leave it alone on the site store.
"""
loginSystem = oldMTA.store.findUnique(userbase.LoginSystem, default=None)
if loginSystem is not None:
newMTA = oldMTA.upgradeVersion(
'mantissa_mta', 1, 2,
messageCount=oldMTA.messageCount,
# IPowerupIndirector
def indirect(self, interface):
"""
Indirect the implementation of L{IWebViewer} to
L{_AuthenticatedWebViewer}.
"""
if interface == IWebViewer:
return _AuthenticatedWebViewer(self)
return self
PrivateApplicationV2 = declareLegacyItem(PrivateApplication.typeName, 2, dict(
installedOn = reference(),
preferredTheme = text(),
hitCount = integer(default=0),
privateKey = integer(),
privateIndexPage = reference(),
))
PrivateApplicationV3 = declareLegacyItem(PrivateApplication.typeName, 3, dict(
preferredTheme=text(),
hitCount=integer(default=0),
privateKey=integer(),
privateIndexPage=reference(),
customizedPublicPage=reference("dependsOn(CustomizedPublicPage)"),
authenticationApplication=reference("dependsOn(AuthenticationApplication)"),
preferenceAggregator=reference("dependsOn(PreferenceAggregator)"),
defaultPreferenceCollection=reference("dependsOn(DefaultPreferenceCollection)"),
searchAggregator=reference("dependsOn(SearchAggregator)"),
website=reference(),
newCertPath = site.store.newFilePath('server.pem')
oldCertPath.moveTo(newCertPath)
port = SSLPort(
store=site.store,
portNumber=oldSite.securePortNumber,
certificatePath=newCertPath,
factory=site)
installOn(port, site.store)
newSite.deleteFromStore()
declareLegacyItem(
WebSite.typeName, 1, dict(
hitCount = integer(default=0),
installedOn = reference(),
portNumber = integer(default=0),
securePortNumber = integer(default=0),
certificateFile = bytes(default=None)))
def upgradeWebSite1To6(oldSite):
return _makeSiteConfiguration(1, oldSite, False)
upgrade.registerUpgrader(upgradeWebSite1To6, 'mantissa_web_powerup', 1, 6)
declareLegacyItem(
WebSite.typeName, 2, dict(
hitCount = integer(default=0),
installedOn = reference(),
portNumber = integer(default=0),
securePortNumber = integer(default=0),
certificateFile = bytes(default=None),
"""
Obsolete. Only present for schema compatibility. Do not use.
"""
powerupInterfaces = (INavigableElement,)
implements(INavigableElement)
schemaVersion = 2
typeName = 'administrator_application'
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.
'LOGIN': imap4.LOGINCredentials,
}, certOpts)
if self.debug:
self.factory = policies.TrafficLoggingFactory(
self.factory, 'smtp')
return self.factory
# GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
def setServiceParent(self, parent):
pass
item.declareLegacyItem(typeName=MailTransferAgent.typeName,
schemaVersion=2,
attributes=dict(messageCount=attributes.integer(),
installedOn=attributes.reference(),
portNumber=attributes.integer(),
securePortNumber=attributes.integer(),
certificateFile=attributes.bytes(),
domain=attributes.bytes()))
def upgradeMailTransferAgent1to2(oldMTA):
"""
MailTransferAgent has been replaced with MailDeliveryAgent on B{user
stores}. Delete it from user stores and create a MailDelivery agent
there, but leave it alone on the site store.
"""
loginSystem = oldMTA.store.findUnique(userbase.LoginSystem, default=None)
if loginSystem is not None:
newMTA = oldMTA.upgradeVersion(
'mantissa_mta',
doc="""
An application L{SubStore} whose default shared item should be
displayed on the root web resource. If None, the default index
of applications will be displayed.
""",
allowNone=True)
def createResourceWith(self, crud):
"""
Create a L{_PublicFrontPage} resource wrapping this object.
"""
return _PublicFrontPage(self, crud)
item.declareLegacyItem(
FrontPage.typeName,
1,
dict(publicViews = attributes.integer(),
privateViews = attributes.integer(),
prefixURL = attributes.text(allowNone=False)))
upgrade.registerAttributeCopyingUpgrader(FrontPage, 1, 2)
class PublicAthenaLivePage(_PublicPageMixin, website.MantissaLivePage):
"""
PublicAthenaLivePage is a publicly viewable Athena-enabled page which slots
a single fragment into the center of the page.
"""
docFactory = ThemedDocumentFactory('shell', 'templateResolver')
unsupportedBrowserLoader = ThemedDocumentFactory(
'athena-unsupported', 'templateResolver')
An application L{SubStore} whose default shared item should be
displayed on the root web resource. If None, the default index
of applications will be displayed.
""",
allowNone=True)
def createResourceWith(self, crud):
"""
Create a L{_PublicFrontPage} resource wrapping this object.
"""
return _PublicFrontPage(self, crud)
item.declareLegacyItem(
FrontPage.typeName, 1,
dict(publicViews=attributes.integer(),
privateViews=attributes.integer(),
prefixURL=attributes.text(allowNone=False)))
upgrade.registerAttributeCopyingUpgrader(FrontPage, 1, 2)
class PublicAthenaLivePage(_PublicPageMixin, website.MantissaLivePage):
"""
PublicAthenaLivePage is a publicly viewable Athena-enabled page which slots
a single fragment into the center of the page.
"""
docFactory = ThemedDocumentFactory('shell', 'templateResolver')
unsupportedBrowserLoader = ThemedDocumentFactory('athena-unsupported',
'templateResolver')
_SchedulerCompatMixin.activate(self)
def setServiceParent(self, parent):
"""
L{Scheduler} is no longer an L{IService}, but still provides this
method as a no-op in case an instance which was still an L{IService}
powerup is loaded (in which case it will be used like a service
once).
"""
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
# the middle will muck things up.
def go():
for msg in work:
for f in filters:
f.train(msg._spam, msg)
yield None
self.reclassify()
return coiterate(go())
registerAttributeCopyingUpgrader(Filter, 1, 2)
item.declareLegacyItem(
Filter.typeName, 2,
dict(installedOn=attributes.reference(),
usePostiniScore=attributes.boolean(default=False, allowNone=False),
postiniThreshhold=attributes.ieee754_double(default=0.03)))
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
""")
def listen(self):
if self._listen is not None:
_listen = self._listen
else:
from twisted.internet import reactor
_listen = reactor.listenTCP
return _listen(self.portNumber, self.factory.getFactory(),
interface=self.interface.encode('ascii'))
declareLegacyItem(
typeName=normalize(qual(TCPPort)),
schemaVersion=1,
attributes=dict(
portNumber=integer(),
factory=reference(),
parent=inmemory(),
_listen=inmemory(),
listeningPort=inmemory()))
registerAttributeCopyingUpgrader(TCPPort, 1, 2)
class SSLPort(PortMixin, Item):
"""
An Axiom Service Item which will bind a TCP port to a protocol factory when
it is started.
"""
schemaVersion = 2
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)
if oldPOP3.portNumber is not None:
def upgradeCompose1to2(oldComposer):
"""
Version 2 of the Composer powers up IMessageSender, which version 1 did
not. Correct that here.
"""
newComposer = oldComposer.upgradeVersion(
'quotient_composer', 1, 2,
installedOn=oldComposer.installedOn)
newComposer.installedOn.powerUp(
newComposer, iquotient.IMessageSender)
return newComposer
registerUpgrader(upgradeCompose1to2, 'quotient_composer', 1, 2)
item.declareLegacyItem(Composer.typeName, 2,
dict(installedOn=attributes.reference()))
def composer2to3(old):
"""
Remove the L{Composer.fromAddress} attribute
"""
return old.upgradeVersion(old.typeName, 2, 3,
installedOn=old.installedOn)
registerUpgrader(composer2to3, Composer.typeName, 2, 3)
item.declareLegacyItem(Composer.typeName, 3,
dict(installedOn=attributes.reference()))
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_sword',
schemaVersion = 2,
attributes = dict(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,
name=oldsword.name,
damagePerHit=oldsword.hurtfulness * 2,
owner=newplayer)
port = 110
pg = POP3Grabber(
store=self.store,
username=username,
password=password,
domain=domain,
port=port,
config=self,
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(),
"""
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)
self.assertEquals(t.__legacy__, True)
self.assertRaises(KeyError, store.objectCache.get, 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 = 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)
sch.schedule(self, extime.Time() + nextTry)
if not self.running:
self.running = True
self.tries += 1
d = self.sendmail()
d.addCallback(self.mailSent, sch)
d.addErrback(self.failureSending, sch)
d.addErrback(log.err)
item.declareLegacyItem(DeliveryToAddress.typeName, 2,
dict(composer = attributes.reference(),
message = attributes.reference(),
fromAddress = attributes.reference(),
toAddress = attributes.text(),
tries = attributes.integer(default=0)))
def deliveryToAddress2to3(old):
delivery = MessageDelivery(composer=old.composer,
message=old.message,
store=old.store)
new = old.upgradeVersion(old.typeName, 2, 3,
delivery=delivery,
message=old.message,
fromAddress=old.fromAddress,
toAddress=old.toAddress,
tries=old.tries,
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
registerUpgrader(sipServer2to3, SIPServer.typeName, 2, 3)
class Registration(Item):
typename = "sine_registration"
schemaVersion = 1
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
registerUpgrader(sipServer2to3, SIPServer.typeName, 2, 3)
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 upgradePlayerAndSword(oldplayer):
newplayer = oldplayer.upgradeVersion('test_app_player', 1, 2)
newplayer.name = oldplayer.name
oldsword = oldplayer.sword
newsword = oldsword.upgradeVersion('test_app_sword', 1, 3,
name=oldsword.name,
damagePerHit=oldsword.hurtfulness * 2)
invent = InventoryEntry(store=newsword.store,
owner=newplayer,
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)
}
return old.upgradeVersion('free_signup',
2,
3,
prefixURL=old.prefixURL,
booth=old.booth,
benefactor=old.benefactor,
emailTemplate=emailTemplate)
upgrade.registerUpgrader(freeTicketSignup2To3, 'free_signup', 2, 3)
declareLegacyItem(typeName='free_signup',
schemaVersion=3,
attributes=dict(prefixURL=text(),
booth=reference(),
benefactor=reference(),
emailTemplate=text()))
def freeTicketSignup3To4(old):
return old.upgradeVersion('free_signup',
3,
4,
prefixURL=old.prefixURL,
booth=old.booth,
benefactor=old.benefactor,
emailTemplate=old.emailTemplate,
prompt=u'Sign Up')
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(),
uiComplexity=attributes.integer(),
showMoreDetail=attributes.boolean()))
def inbox3to4(old):
"""
Copy over all attributes except for 'installedOn' and 'catalog', which
have been deleted.
emailTemplate = file(sibpath(__file__, 'signup.rfc2822')).read()
emailTemplate %= {'blurb': u'',
'subject': 'Welcome to a Generic Axiom Application!',
'linktext': "Click here to claim your 'generic axiom application' account"}
return old.upgradeVersion('free_signup', 2, 3,
prefixURL=old.prefixURL,
booth=old.booth,
benefactor=old.benefactor,
emailTemplate=emailTemplate)
upgrade.registerUpgrader(freeTicketSignup2To3, 'free_signup', 2, 3)
declareLegacyItem(typeName='free_signup',
schemaVersion=3,
attributes=dict(prefixURL=text(),
booth=reference(),
benefactor=reference(),
emailTemplate=text()))
def freeTicketSignup3To4(old):
return old.upgradeVersion('free_signup', 3, 4,
prefixURL=old.prefixURL,
booth=old.booth,
benefactor=old.benefactor,
emailTemplate=old.emailTemplate,
prompt=u'Sign Up')
upgrade.registerUpgrader(freeTicketSignup3To4, 'free_signup', 3, 4)
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
"""
def _declareLegacyIndexerItem(typeClass, version):
item.declareLegacyItem(typeClass.typeName, version,
dict(indexCount=attributes.integer(),
installedOn=attributes.reference(),
indexDirectory=attributes.text()))
port = 110
pg = POP3Grabber(store=self.store,
username=username,
password=password,
domain=domain,
port=port,
config=self,
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,
# XXX This really should use in-database state, otherwise a restart in
# the middle will muck things up.
def go():
for msg in work:
for f in filters:
f.train(msg._spam, msg)
yield None
self.reclassify()
return coiterate(go())
registerAttributeCopyingUpgrader(Filter, 1, 2)
item.declareLegacyItem(Filter.typeName, 2,
dict(installedOn = attributes.reference(),
usePostiniScore = attributes.boolean(default=False,allowNone=False),
postiniThreshhold = attributes.ieee754_double(default=0.03)))
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
def installed(self):
self.indexer.addSource(self.messageSource)
def count(self, term):
raise NotImplementedError("No one should ever call count, I think.")
def search(self, *a, **k):
if 'sortAscending' not in k:
k['sortAscending'] = False
d = self.indexer.search(*a, **k)
d.addCallback(_mailsearchui.SearchAggregatorFragment, self.store)
return d
declareLegacyItem(MessageSearchProvider.typeName, 1, dict(
indexer=attributes.reference(),
installedOn=attributes.reference()))
def _messageSearchProvider1to2(old):
new = old.upgradeVersion(MessageSearchProvider.typeName, 1, 2,
indexer=old.indexer,
messageSource=old.store.findUnique(mail.MessageSource))
return new
registerUpgrader(_messageSearchProvider1to2, MessageSearchProvider.typeName, 1, 2)
class QuotientBenefactor(Item):
implements(ixmantissa.IBenefactor)
typeName = 'quotient_benefactor'
schemaVersion = 1
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",
schemaVersion=2,
attributes=dict(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
for answer in self.store.query(
_AlreadyAnswered, sort=_AlreadyAnswered.storeID.ascending):
self._deliverAnswer(answer)
nextmsg = self.store.findFirst(_QueuedMessage, default=None)
if nextmsg is not None:
delay = _RETRANSMIT_DELAY
else:
nextanswer = self.store.findFirst(_AlreadyAnswered, default=None)
if nextanswer is not None:
delay = _RETRANSMIT_DELAY
if delay is not None:
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)