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)
""" 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)
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. """