def _testSchedule(self, scheduler):
t1 = TestEvent(store=scheduler.store)
scheduler.schedule(t1, Time.fromPOSIXTimestamp(0))
self.failIf(self.calls,
"Should not have had any calls: %r" % (self.calls,))
self.assertIdentical(
scheduler._getNextEvent(Time.fromPOSIXTimestamp(1)).runnable, t1)
def _scheduleRunner(self, now, offset):
scheduledAt = Time.fromPOSIXTimestamp(now + offset)
rescheduleFor = Time.fromPOSIXTimestamp(now + offset + 10)
runnable = ScheduleCallingItem(store=self.substore,
rescheduleFor=rescheduleFor)
self.subscheduler.schedule(runnable, scheduledAt)
return runnable
def testScheduleWithLaterTimedEvents(self):
"""
Like L{testSchedule}, but use a SubScheduler which has pre-existing
TimedEvents which are beyond the new runnable's scheduled time (to
trigger the reschedule-using code-path in
_SubSchedulerParentHook._schedule).
"""
now = self.clock.seconds()
when = Time.fromPOSIXTimestamp(now + 30)
null = NullRunnable(store=self.substore)
self.subscheduler.schedule(null, when)
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
self.assertEqual(list(self.subscheduler.scheduledTimes(null)),
[Time.fromPOSIXTimestamp(now + 30)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.loginAccount == self.substoreItem)
self.assertEqual(list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(20)])
def testScheduleWithEarlierTimedEvents(self):
"""
Like L{testSchedule}, but use a SubScheduler which has pre-existing
TimedEvents which are before the new runnable's scheduled time.
"""
now = self.clock.seconds()
when = Time.fromPOSIXTimestamp(now + 15)
null = NullRunnable(store=self.substore)
self.subscheduler.schedule(null, when)
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
self.assertEqual(
list(self.subscheduler.scheduledTimes(null)),
[Time.fromPOSIXTimestamp(now + 15)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 15)])
def setUp(self):
self.clock = Clock()
self.dbdir = filepath.FilePath(self.mktemp())
self.store = Store(self.dbdir)
self.substoreItem = SubStore.createNew(self.store, ['sub'])
self.substore = self.substoreItem.open()
self.scheduler = IScheduler(self.store)
self.subscheduler = IScheduler(self.substore)
self.scheduler.callLater = self.clock.callLater
self.scheduler.now = lambda: Time.fromPOSIXTimestamp(self.clock.seconds())
self.subscheduler.now = lambda: Time.fromPOSIXTimestamp(self.clock.seconds())
IService(self.store).startService()
def _setUpMsg(self):
"""
Install an innocuous incoming message in a newly-created store
@rtype: L{xquotient.exmess.Message}
"""
s = self._setUpStore()
m = Message.createIncoming(s, _Part(store=s), u'test://test')
m.subject = u'the subject'
m.sender = u'sender@host'
m.senderDisplay = u'Sender'
m.recipient = u'recipient@host'
m.sentWhen = Time.fromPOSIXTimestamp(0)
m.receivedWhen = Time.fromPOSIXTimestamp(1)
m.classifyClean()
return m
def testSchedule(self):
"""
Test the schedule method, as invoked from the run method of an item
being run by the subscheduler.
"""
now = self.clock.seconds()
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.loginAccount == self.substoreItem)
self.assertEqual(list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 20)])
def test_now(self):
"""
The user store's L{IScheduler} powerup's C{now} method returns whatever
the site store's L{IScheduler} powerup's C{now} method returns.
"""
# I don't want the stubbed now method.
del self.scheduler.now
self.clock.advance(17)
self.assertEquals(self.scheduler.now(),
Time.fromPOSIXTimestamp(self.clock.seconds()))
def test_now(self):
"""
The user store's L{IScheduler} powerup's C{now} method returns whatever
the site store's L{IScheduler} powerup's C{now} method returns.
"""
# I don't want the stubbed now method.
del self.scheduler.now
self.clock.advance(17)
self.assertEquals(
self.scheduler.now(),
Time.fromPOSIXTimestamp(self.clock.seconds()))
def testSchedule(self):
"""
Test the schedule method, as invoked from the run method of an item
being run by the subscheduler.
"""
now = self.clock.seconds()
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 20)])
def test_blurbTimestampColumn(self):
"""
Verify the L{xmantissa.ixmantissa.IColumn} implementation of
L{hyperbola_view._BlurbTimestampColumn}.
"""
col = hyperbola_view._BlurbTimestampColumn()
self.assertEqual(col.attributeID, 'dateCreated')
self.assertEqual(col.getType(), 'timestamp')
self.blogPostItem.dateCreated = Time.fromPOSIXTimestamp(345)
value = col.extractValue(None, self.blogPostItem)
self.assertEqual(value, 345)
self.assertIdentical(col.sortAttribute(), hyperblurb.Blurb.dateCreated)
comparable = col.toComparableValue(345)
self.assertEqual(comparable, self.blogPostItem.dateCreated)
def testMultipleEventsPerTick(self):
"""
Test running several runnables in a single tick of the subscheduler.
"""
now = self.clock.seconds()
runnables = [
self._scheduleRunner(now, 10),
self._scheduleRunner(now, 11),
self._scheduleRunner(now, 12)
]
self.clock.advance(13)
for n, runnable in enumerate(runnables):
self.assertEqual(list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + n + 20)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.loginAccount == self.substoreItem)
self.assertEqual(list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 20)])
def setMetadata(self, meta):
"""
Set the topic in the database
"""
self.channelItem.topic = unicode(meta['topic'])
self.channelItem.topicAuthor = unicode(meta['topic_author'])
self.channelItem.topicTime = Time.fromPOSIXTimestamp(meta['topic_date'])
sets = []
for p in self.users.itervalues():
d = defer.maybeDeferred(p.groupMetaUpdate, self, meta)
d.addErrback(self._ebUserCall, p=p)
sets.append(d)
defer.DeferredList(sets).addCallback(self._cbUserCall)
return defer.succeed(None)
def setMetadata(self, meta):
"""
Set the topic in the database
"""
self.channelItem.topic = unicode(meta['topic'])
self.channelItem.topicAuthor = unicode(meta['topic_author'])
self.channelItem.topicTime = Time.fromPOSIXTimestamp(
meta['topic_date'])
sets = []
for p in self.users.itervalues():
d = defer.maybeDeferred(p.groupMetaUpdate, self, meta)
d.addErrback(self._ebUserCall, p=p)
sets.append(d)
defer.DeferredList(sets).addCallback(self._cbUserCall)
return defer.succeed(None)
def testMultipleEventsPerTick(self):
"""
Test running several runnables in a single tick of the subscheduler.
"""
now = self.clock.seconds()
runnables = [
self._scheduleRunner(now, 10),
self._scheduleRunner(now, 11),
self._scheduleRunner(now, 12)]
self.clock.advance(13)
for n, runnable in enumerate(runnables):
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + n + 20)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 20)])
def _makeMessages(self):
"""
Make 3 incoming messages
@rtype: C{list} of L{xquotient.exmess.Message}
"""
msgs = []
for (subject, timestamp) in ((u'3', 67), (u'1', 43), (u'2', 55)):
msgs.append(
testMessageFactory(
store=self.store,
read=False,
spam=False,
subject=subject,
receivedWhen=Time.fromPOSIXTimestamp(timestamp)))
return msgs
def _makeMessages(self):
"""
Make 3 incoming messages
@rtype: C{list} of L{xquotient.exmess.Message}
"""
msgs = []
for (subject, timestamp) in ((u'3', 67), (u'1', 43), (u'2', 55)):
msgs.append(
testMessageFactory(
store=self.store,
read=False,
spam=False,
subject=subject,
receivedWhen=Time.fromPOSIXTimestamp(timestamp)))
return msgs
def now(self):
return Time.fromPOSIXTimestamp(self.clock.seconds())
def fxn():
for x in xrange(itemCount):
yield (x * 2, u"Number %d" % (x, ),
Time.fromPOSIXTimestamp(now - x), colors[x % 2])
def readTimestamp(self):
return Time.fromPOSIXTimestamp(float(self.readline()))
def outfilter(self, dbval, oself):
if dbval is None:
return None
return Time.fromPOSIXTimestamp(dbval / MICRO)
def toComparableValue(self, value):
"""
Convert a float from the client back into a timestamp.
"""
return Time.fromPOSIXTimestamp(value)
def registerAddress(self, physicalURL, expiryTime):
self.physicalURL = physicalURL.toString()
self.expiryTime = Time.fromPOSIXTimestamp(time.time() + expiryTime)
return [(physicalURL, self.expiryTime)]
def _scheduleRunner(self, now, offset):
scheduledAt = Time.fromPOSIXTimestamp(now + offset)
rescheduleFor = Time.fromPOSIXTimestamp(now + offset + 10)
runnable = ScheduleCallingItem(store=self.substore, rescheduleFor=rescheduleFor)
self.subscheduler.schedule(runnable, scheduledAt)
return runnable
def fxn():
for x in xrange(itemCount):
yield (x * 2,
u"Number %d" % (x,),
Time.fromPOSIXTimestamp(now - x),
colors[x % 2])
"""
Generate a stub for the tests for the upgrade from schema version 2 to 3 of the
Person item.
"""
from epsilon.extime import Time
from axiom.test.historic.stubloader import saveStub
from xmantissa.people import Organizer, Person
NAME = u'Test User'
CREATED = Time.fromPOSIXTimestamp(1234567890)
def createDatabase(store):
"""
Make a L{Person} in the given store.
"""
organizer = Organizer(store=store)
person = Person(
store=store,
organizer=organizer,
name=NAME)
person.created = CREATED
if __name__ == '__main__':
saveStub(createDatabase, 13344)
from epsilon.extime import Time
from xquotient.exmess import Message
from xquotient.mimestorage import Part
attrs = dict(
sender=u"*****@*****.**",
subject=u"This is a spam",
recipient=u"*****@*****.**",
senderDisplay=u"Spammer",
spam=True,
archived=False,
trash=True,
outgoing=False,
draft=False,
trained=True,
read=True,
attachments=23,
sentWhen=Time.fromPOSIXTimestamp(123),
receivedWhen=Time.fromPOSIXTimestamp(456),
)
def createDatabase(s):
Message(store=s, impl=Part(store=s), **attrs)
if __name__ == "__main__":
saveStub(createDatabase, 7105)
def invoke(self, data):
value = data[self.param.name]
if value is not None:
value = Time.fromPOSIXTimestamp(value / 1000)
self.param.value = value
def main(cursor):
# All the ticket data in the database
tickets = tracstats.tickets(cursor)
# For the purposes of means, anything that is open gets a "close" time of
# right now.
now = Time().asNaiveDatetime()
# A mapping from ticket id to a two-tuple of open, closed times. If a
# ticket is closed multiple times, the closed time associated with it is
# the final close time. If the ticket is open, the closed time is None.
ticketInfos = {}
for id, tkt in tickets.iteritems():
ticketInfos[id] = (tkt['time'], now)
# Find all the latest close times for all the tickets
for change in tracstats.changes(
cursor,
Time.fromPOSIXTimestamp(0).asNaiveDatetime(), now):
id = change['ticket']
open, close = ticketInfos[id]
if isOpeningChange(change):
ticketInfos[id] = (open, now)
elif isClosingChange(change):
ticketInfos[id] = (open, change['time'])
# Create an ordering of ticket open and close times
events = []
for ticketId, (open, close) in ticketInfos.iteritems():
if close is None:
print 'Skipping', ticketId
continue
events.append((open, ticketId, 'open'))
events.append((close, ticketId, 'close'))
events.sort()
# A mapping of tickets which are open at the point in the events which to
# which processing has advanced. Keys are ticket ids, values are times
# when they opened.
openTickets = {}
# Data points for the output graph. First element of each two-tuple is a
# time, second element is mean ticket age at that time.
output = []
for (when, ticket, change) in events:
if openTickets:
output.append(
(when,
sum([when - v
for v in openTickets.itervalues()], timedelta(0)) /
len(openTickets)))
if change == 'open':
# A new ticket is now open.
openTickets[ticket] = when
elif change == 'closed':
# An old open ticket is now closed.
del openTickets[ticket]
def toInt(delta):
return delta.days * (60 * 60 * 24) + delta.seconds
return tracstats.TimeSeries("mean ticket age",
[(when, toInt(mean))
for (when, mean) in output])
from md5 import md5
from twisted.application import service
from twisted.python import log
from twisted.internet import defer
from axiom import store, substore, item, attributes as A
from zope.interface import Interface, implements
from epsilon.extime import Time
from webby import obscurement
from webby.iwebby import IFileObserver
EPOCH = Time.fromPOSIXTimestamp(0)
class DataService(item.Item, service.Service):
powerupInterfaces = (service.IService, )
schemaVersion = 1
smtpFrom = A.text(doc="The email address used as From: in emails")
smtpServer = A.text(doc="The SMTP server used for outgoing email")
parent = A.inmemory()
running = A.inmemory()
def startService(self):
log.msg("Starting service %r" % (self, ))
def toComparableValue(self, value):
"""
Override L{AttributeColumn}'s implementation to return a L{Time} instance.
"""
return Time.fromPOSIXTimestamp(value)
from md5 import md5
from twisted.application import service
from twisted.python import log
from twisted.internet import defer
from axiom import store, substore, item, attributes as A
from zope.interface import Interface, implements
from epsilon.extime import Time
from webby import obscurement
from webby.iwebby import IFileObserver
EPOCH = Time.fromPOSIXTimestamp(0)
class DataService(item.Item, service.Service):
powerupInterfaces = (service.IService,)
schemaVersion = 1
smtpFrom = A.text(doc="The email address used as From: in emails")
smtpServer = A.text(doc="The SMTP server used for outgoing email")
parent = A.inmemory()
running = A.inmemory()
def startService(self):
log.msg("Starting service %r" % (self, ))
class IArticle(Interface):
"""
def registerAddress(self, physicalURL, expiryTime):
self.physicalURL = physicalURL.toString()
self.expiryTime = Time.fromPOSIXTimestamp(time.time() + expiryTime)
return [(physicalURL, self.expiryTime)]
"""
Generate a stub for the tests for the upgrade from schema version 2 to 3 of the
Person item.
"""
from epsilon.extime import Time
from axiom.test.historic.stubloader import saveStub
from xmantissa.people import Organizer, Person
NAME = u"Test User"
CREATED = Time.fromPOSIXTimestamp(1234567890)
def createDatabase(store):
"""
Make a L{Person} in the given store.
"""
organizer = Organizer(store=store)
person = Person(store=store, organizer=organizer, name=NAME)
person.created = CREATED
if __name__ == "__main__":
saveStub(createDatabase, 13344)
from axiom.test.historic.stubloader import saveStub
from epsilon.extime import Time
from xquotient.exmess import Message
from xquotient.mimestorage import Part
attrs = dict(sender=u'*****@*****.**',
subject=u'This is a spam',
recipient=u'*****@*****.**',
senderDisplay=u'Spammer',
spam=True,
archived=False,
trash=True,
outgoing=False,
draft=False,
trained=True,
read=True,
attachments=23,
sentWhen=Time.fromPOSIXTimestamp(123),
receivedWhen=Time.fromPOSIXTimestamp(456))
def createDatabase(s):
Message(store=s,
impl=Part(store=s),
**attrs)
if __name__ == '__main__':
saveStub(createDatabase, 7105)
def readTimestamp(self):
return Time.fromPOSIXTimestamp(float(self.readline()))
def invoke(self, data):
value = data[self.param.name]
if value is not None:
value = Time.fromPOSIXTimestamp(value / 1000)
self.param.value = value
def outfilter(self, dbval, oself):
if dbval is None:
return None
return Time.fromPOSIXTimestamp(dbval / MICRO)
def toComparableValue(self, value):
"""
Override L{AttributeColumn}'s implementation to return a L{Time} instance.
"""
return Time.fromPOSIXTimestamp(value)