def mainBody(self):
while self.number_of_files > self.filenames_mailed:
"create a list of all the files in the provided directory"
self.filelisting = os.listdir(self.directory)
self.filelisting = self.find_files_of_type(self.filelisting, self.file_type) #remove files from list that are not of the right file type
if len(self.filelisting) == 0:
print "random_file_selector: No files of that type in the directory!", repr(self.file_type)
self.send(producerFinished("Done"),"signal")
return 0
file_index = random.randrange(0, len(self.filelisting)) #index for a random file
random_file = self.filelisting[file_index] #get the name of random file
print "random_file_selector: The randomly choosen file is", random_file
fullfilename = os.path.join(self.directory, random_file) #"root\file"
self.send(fullfilename,"outbox")
self.filenames_mailed = self.filenames_mailed + 1
return 1
self.send(producerFinished("Done"),"signal")
return 0
def cleanup(self):
"""Destroy child components and send producerFinished when we quit."""
self.debug("SimpleHTTPClient.cleanup()")
self.send(producerFinished(self), "_carouselsignal") #shutdown() not currently supported by Carousel
self.send(producerFinished(self), "signal")
self.removeChild(self.carousel)
self.unpause()
def main(self):
while True:
if self.dataReady("inbox"):
data = self.recv("inbox")
parseddata = feedparser.parse(data)
parseddata.href = self.feedUrl
if parseddata.has_key('bozo_exception'):
self.send(producerFinished(self), "signal")
stopped(self.feedUrl)
return
else:
self.send(parseddata, "outbox")
self.send(producerFinished(self), "signal")
stopped(self.feedUrl)
return
if self.dataReady("control"):
data = self.recv("control")
self.send(data, "signal")
if not isinstance(data, producerFinished):
print data
stopped(self.feedUrl)
return
if not self.anyReady():
self.pause()
yield 1
def main(self):
self.initiateInternalSplitter()
yield 1
while True:
mustStop, providerFinished = self.checkControl()
if mustStop:
self.send(mustStop, "signal")
return
self.handleChildTerminations()
while self.dataReady("inbox"):
feed = self.recv("inbox")
child = self.createChild(feed)
self.addChildren(child)
child.activate()
while self.dataReady("_parsed-feeds"):
parseddata = self.recv("_parsed-feeds")
self.send(parseddata, "outbox")
if providerFinished and len(self.childComponents()) == 1:
# TODO: CHECK IF THIS IS THE PROBLEM
# It's actually only waiting for the plugsplitter
for _ in self.waitForChildren(producerFinished(self)):
yield 1
pfinished = producerFinished(self)
self.send(pfinished, "signal")
return
if not self.anyReady():
self.pause()
yield 1
def main(self):
while 1:
yield 1
while self.dataReady("inbox"):
msg = self.recv("inbox")
# add this string to our character queue
self.forwardqueue.push(msg)
# while there is enough data to send another chunk
while len(self.forwardqueue) >= self.chunksize:
self.sendChunk()
# if nodelay then send any data not yet sent rather than waiting for more
if self.nodelay:
self.sendPartialChunk()
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, producerFinished):
self.sendPartialChunk()
self.send(producerFinished(self), "signal")
return
elif isinstance(msg, shutdown):
self.send(producerFinished(self), "signal")
return
self.pause()
def main(self):
while 1:
yield 1
while self.dataReady("inbox"):
msg = self.recv("inbox")
# add this string to our character queue
self.forwardqueue.push(msg)
# while there is enough data to send another chunk
while len(self.forwardqueue) >= self.chunksize:
self.sendChunk()
# if nodelay then send any data not yet sent rather than waiting for more
if self.nodelay:
self.sendPartialChunk()
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, producerFinished):
self.sendPartialChunk()
self.send(producerFinished(self), "signal")
return
elif isinstance(msg, shutdown):
self.send(producerFinished(self), "signal")
return
self.pause()
def main(self):
self.timebomb.activate()
self.child.activate()
yield 1
while not (self.child._isStopped() or (self.dataReady('_trigger') and self.recv('_trigger') is True)):
self.pause()
yield 1
if not self.timebomb._isStopped():
self.send(producerFinished(), '_disarm')
shutdown_messages = [ producerFinished(), shutdownMicroprocess(), serverShutdown(), shutdown() ]
for msg in shutdown_messages:
if not self.child._isStopped():
self.send( msg, "_sigkill")
yield 1
yield 1
else:
break
self.removeChild(self.child)
yield 1
if not self.child._isStopped():
self.child.stop()
yield 1
if 'signal' in self.Outboxes:
self.send(shutdownMicroprocess(), 'signal')
yield 1
def mainBody(self):
while self.number_of_files > self.filenames_mailed:
"create a list of all the files in the provided directory"
self.filelisting = os.listdir(self.directory)
self.filelisting = self.find_files_of_type(
self.filelisting, self.file_type
) #remove files from list that are not of the right file type
if len(self.filelisting) == 0:
print "random_file_selector: No files of that type in the directory!", repr(
self.file_type)
self.send(producerFinished("Done"), "signal")
return 0
file_index = random.randrange(0, len(
self.filelisting)) #index for a random file
random_file = self.filelisting[
file_index] #get the name of random file
print "random_file_selector: The randomly choosen file is", random_file
fullfilename = os.path.join(self.directory,
random_file) #"root\file"
self.send(fullfilename, "outbox")
self.filenames_mailed = self.filenames_mailed + 1
return 1
self.send(producerFinished("Done"), "signal")
return 0
def main(self):
p = DispatchParser()
# The DispatchParser allows to register callbacks per local name
# and namespaces. But here we simply register a default callback
# for any XML element parsed successfully and drop it into the outbox
# so that components that will be linked to it will have to make
# the decision whether or not the element is relevant to them
# or simply discard it.
p.register_default(self._done)
yield 1
while 1:
if self.dataReady("control"):
mes = self.recv("control")
if isinstance(mes, shutdownMicroprocess) or isinstance(mes, producerFinished):
self.send(producerFinished(), "signal")
break
if self.dataReady("reset"):
command = self.recv("reset")
if command == "RESET":
p.reset()
if self.dataReady("inbox"):
data = self.recv("inbox")
try:
p.feed(data)
except SAXParseException:
self.send(producerFinished(), "signal")
if not self.anyReady():
self.pause()
yield 1
def main(self):
self.initiateInternalSplitter()
yield 1
while True:
mustStop, providerFinished = self.checkControl()
if mustStop:
self.send(mustStop,"signal")
return
self.handleChildTerminations()
while self.dataReady("inbox"):
feed = self.recv("inbox")
child = self.createChild(feed)
self.addChildren(child)
child.activate()
while self.dataReady("_parsed-feeds"):
parseddata = self.recv("_parsed-feeds")
self.send(parseddata,"outbox")
if providerFinished and len(self.childComponents()) == 1:
# TODO: CHECK IF THIS IS THE PROBLEM
# It's actually only waiting for the plugsplitter
for _ in self.waitForChildren(producerFinished(self)):
yield 1
pfinished = producerFinished(self)
self.send(pfinished,"signal")
return
if not self.anyReady():
self.pause()
yield 1
def cleanup(self):
"""Destroy child components and send producerFinished when we quit."""
self.debug("SimpleHTTPClient.cleanup()")
self.send(producerFinished(self), "_carouselsignal") #shutdown() not currently supported by Carousel
self.send(producerFinished(self), "signal")
self.removeChild(self.carousel)
self.unpause()
def main(self):
while True:
if self.dataReady("inbox"):
data = self.recv("inbox")
parseddata = feedparser.parse(data)
parseddata.href = self.feedUrl
if parseddata.has_key('bozo_exception'):
self.send(producerFinished(self),"signal")
stopped(self.feedUrl)
return
else:
self.send(parseddata, "outbox")
self.send(producerFinished(self),"signal")
stopped(self.feedUrl)
return
if self.dataReady("control"):
data = self.recv("control")
self.send(data,"signal")
if not isinstance(data, producerFinished):
print data
stopped(self.feedUrl)
return
if not self.anyReady():
self.pause()
yield 1
def main(self):
resampler = None
format = None
shutdown = False
while self.anyReady() or not shutdown:
while self.dataReady("inbox"):
data = self.recv("inbox")
if data['type'] == "audio":
newformat = (data['sample_rate'], data['channels'],
data['format'])
if newformat != format:
format = newformat
# need new audio playback component
# first remove any old one
if resampler:
self.removeChild(resampler)
self.send(producerFinished(), "_ctrl")
for l in linkages:
self.unlink(thelinkage=l)
# now make and wire in a new one
resampler = RawResampleTo(format[0], format[1],
*self.params).activate()
self.addChildren(resampler)
linkages = [
self.link((self, "_data"), (resampler, "inbox")),
self.link((self, "_ctrl"), (resampler, "control")),
self.link((resampler, "outbox"),
(self, "_resampled")),
]
self.send(data['audio'], "_data")
while self.dataReady("_resampled"):
audio = self.recv("_resampled")
data = {}
data['type'] = 'audio'
data['sample_rate'] = self.params[0]
data['channels'] = self.params[1]
data['format'] = format[2]
data['audio'] = audio
self.send(data, "outbox")
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, (producerFinished, shutdownMicroprocess)):
shutdown = True
self.send(msg, "signal")
if not shutdown:
self.pause()
yield 1
if resampler:
self.send(producerFinished(), "_ctrl")
for linkage in linkages:
self.unlink(thelinkage=linkage)
def main(self):
# possible enhancements - support ESMTP and associated extensions
self.send("220 " + self.hostname + " ESMTP KamaeliaRJL\r\n", "outbox")
self.doRSET()
self.theirhostname = ""
self.state = self.stateGetHELO
while 1:
if self.state == self.stateQuit:
self.doQuit()
self.killInterface()
self.send(producerFinished(self), "signal")
return
yield 1
if self.shouldShutdown():
self.killInterface()
self.send(producerFinished(self), "signal")
return
while self.dataFetch():
pass
msg = self.nextLine()
while msg != None:
if self.state == self.stateQuit:
self.doQuit()
self.killInterface()
self.send(producerFinished(self), "signal")
return
newstate = self.state(msg)
if self.waitinguponqueueconfirm:
print "SENDING MESSAGE"
while self.waitinguponqueueconfirm:
if self.dataReady("queueconfirm"):
msgid = self.recv("queueconfirm")
self.waitinguponqueueconfirm = False
break
self.pause()
yield 1
print "SENT MESSAGE"
self.send(
"250 Written safely to disk #" + str(msgid) + "\r\n",
"outbox")
if newstate:
self.state = newstate
msg = self.nextLine()
else:
self.pause()
def main(self):
# possible enhancements - support ESMTP and associated extensions
self.send("220 " + self.hostname + " ESMTP KamaeliaRJL\r\n", "outbox")
self.doRSET()
self.theirhostname = ""
self.state = self.stateGetHELO
while 1:
if self.state == self.stateQuit:
self.doQuit()
self.killInterface()
self.send(producerFinished(self), "signal")
return
yield 1
if self.shouldShutdown():
self.killInterface()
self.send(producerFinished(self), "signal")
return
while self.dataFetch():
pass
msg = self.nextLine()
while msg != None:
if self.state == self.stateQuit:
self.doQuit()
self.killInterface()
self.send(producerFinished(self), "signal")
return
newstate = self.state(msg)
if self.waitinguponqueueconfirm:
print "SENDING MESSAGE"
while self.waitinguponqueueconfirm:
if self.dataReady("queueconfirm"):
msgid = self.recv("queueconfirm")
self.waitinguponqueueconfirm = False
break
self.pause()
yield 1
print "SENT MESSAGE"
self.send("250 Written safely to disk #" + str(msgid) + "\r\n", "outbox")
if newstate:
self.state = newstate
msg = self.nextLine()
else:
self.pause()
def main(self):
keepconnectionopen = True
while keepconnectionopen:
yield 1
while not self.anyReady():
self.pause()
yield 1
while self.dataReady(
"control"): # Control messages from the socket
temp = self.recv("control")
if isinstance(
temp, producerFinished
): # Socket has stopped sending us data (can still send data to it)
self.send(
temp, "Psignal"
) # pass on to the HTTP Parser. (eg could be a POST request)
# print "PRODUCER SHUTDOWN"
elif isinstance(
temp,
shutdown): # Socket is telling us connection is dead
self.send(shutdown(), "Psignal")
self.send(shutdown(), "Hsignal")
keepconnectionopen = False
# print "SOCKET DEAD"
while self.dataReady(
"Pcontrol"): # Control messages from the HTTP Parser
temp = self.recv("Pcontrol")
if isinstance(
temp, producerFinished
): # HTTP Parser is telling us they're done parsing
pass # XXXX Handling of shutdown messages from parser ???
# print "PARSER FINISHED"
self.send(temp, "Hsignal") # Pass on to the HTTP Handler
while self.dataReady(
"Hcontrol"): # Control messages from the HTTP Handler
temp = self.recv("Hcontrol")
if isinstance(temp, producerFinished
): # Have finished sending data to the client
sig = producerFinished(self) #
self.send(
sig, "Psignal"
) # Make sure HTTP Parser is shutting down - (should send a "shutdown" message)
self.send(sig, "signal")
keepconnectionopen = False
# print "HTTP HANDLER DEAD"
self.send(producerFinished(),
"signal") # We're done, close the connection.
yield 1 # And quit
def main(self):
resampler = None
format = None
shutdown = False
while self.anyReady() or not shutdown:
while self.dataReady("inbox"):
data = self.recv("inbox")
if data['type'] == "audio":
newformat = (data['sample_rate'], data['channels'], data['format'])
if newformat != format:
format=newformat
# need new audio playback component
# first remove any old one
if resampler:
self.removeChild(resampler)
self.send(producerFinished(), "_ctrl")
for l in linkages:
self.unlink(thelinkage=l)
# now make and wire in a new one
resampler = RawResampleTo(format[0],format[1], *self.params).activate()
self.addChildren(resampler)
linkages = [ self.link( (self,"_data"), (resampler, "inbox") ),
self.link( (self,"_ctrl"), (resampler, "control") ),
self.link( (resampler,"outbox"), (self, "_resampled") ),
]
self.send(data['audio'], "_data")
while self.dataReady("_resampled"):
audio = self.recv("_resampled")
data = {}
data['type'] = 'audio'
data['sample_rate'] = self.params[0]
data['channels'] = self.params[1]
data['format'] = format[2]
data['audio'] = audio
self.send(data,"outbox")
while self.dataReady("control"):
msg=self.recv("control")
if isinstance(msg, (producerFinished,shutdownMicroprocess)):
shutdown=True
self.send(msg,"signal")
if not shutdown:
self.pause()
yield 1
if resampler:
self.send(producerFinished(), "_ctrl")
for linkage in linkages:
self.unlink(thelinkage=linkage)
def main(self):
self.shutdownMsg = None
self.canStop = False
self.mustStop = False
try:
while 1:
while self.dataReady("inbox"):
canStop, mustStop = self.checkShutdown()
if mustStop:
raise UserWarning("STOP")
# ok, so there is data waiting to be emitted, so now we must wait for the 'next' signal
while not self.dataReady("next"):
canStop, mustStop = self.checkShutdown()
if mustStop:
raise UserWarning("STOP")
self.pause()
yield 1
self.recv("next")
data = self.recv("inbox")
while 1:
try:
self.send(data, "outbox")
break
except noSpaceInBox:
canStop, mustStop = self.checkShutdown()
if mustStop:
raise UserWarning("STOP")
self.pause()
yield 1
canStop, mustStop = self.checkShutdown()
if canStop:
raise UserWarning("STOP")
if not self.dataReady("inbox") and not self.dataReady(
"control"):
self.pause()
yield 1
except UserWarning:
if self.shutdownMsg:
self.send(self.shutdownMsg, "signal")
else:
self.send(producerFinished(), "signal")
return
self.send(producerFinished(), "signal")
def main(self):
self.shutdownMsg = None
self.canStop = False
self.mustStop = False
try:
while 1:
while self.dataReady("inbox"):
canStop, mustStop = self.checkShutdown()
if mustStop:
raise "STOP"
# ok, so there is data waiting to be emitted, so now we must wait for the 'next' signal
while not self.dataReady("next"):
canStop, mustStop = self.checkShutdown()
if mustStop:
raise "STOP"
self.pause()
yield 1
self.recv("next")
data = self.recv("inbox")
while 1:
try:
self.send(data,"outbox")
break
except noSpaceInBox:
canStop, mustStop = self.checkShutdown()
if mustStop:
raise "STOP"
self.pause()
yield 1
canStop, mustStop = self.checkShutdown()
if canStop:
raise "STOP"
if not self.dataReady("inbox") and not self.dataReady("control"):
self.pause()
yield 1
except "STOP":
if self.shutdownMsg:
self.send(self.shutdownMsg,"signal")
else:
self.send(producerFinished(),"signal")
return
self.send(producerFinished(),"signal")
def main(self):
timer = Timer().activate()
self.addChildren(timer)
self.link((self,"_toTimer"),(timer,"inbox"))
self.link((timer,"outbox"),(self,"_fromTimer"))
self.link((self,"_timerSignal"),(timer,"control"))
for i in range(0,10):
for _ in self.waitUntil( self.scheduler.time + 1.0): yield _
self.send( "Waited, then output "+str(i),"outbox")
yield 1
self.send(producerFinished(), "_timerSignal")
self.send(producerFinished(), "signal")
def main(self):
try:
self.send(self.getCurrentChoice(), "outbox")
except IndexError:
pass
done = False
while not done:
yield 1
while self.dataReady("inbox"):
send = True
msg = self.recv("inbox")
if msg == "SAME":
pass
elif msg == "NEXT":
send = self.gotoNext()
if not send:
done = True
self.send(producerFinished(self), "signal")
else:
send = False
if send:
try:
self.send(self.getCurrentChoice(), "outbox")
except IndexError:
pass
done = done or self.shutdown()
def test_Unplugging(self):
"""Plug will unplug and shutdown when child component dies."""
Axon.Scheduler.scheduler.run = Axon.Scheduler.scheduler()
splitter = Splitter()
splitter.activate()
target = DummyComponent()
plug = Plug(splitter, target).activate()
execute = Axon.Scheduler.scheduler.run.main()
for i in xrange(1, 100):
execute.next()
#send shutdown msg
msg = producerFinished()
target._deliver(msg, "control")
for i in xrange(1, 100):
execute.next()
# verify it reached the target
self.assert_(target.controllog == [msg])
# verify the plug has shutdown
self.assert_(plug._isStopped())
# verify the plug has no linkages
self.assert_(not plug.postoffice.linkages)
# verify that splitter only has outboxes "outbox" and "signal" now
self.assert_(len(splitter.outboxes) == 2)
self.assert_("outbox" in splitter.outboxes)
self.assert_("signal" in splitter.outboxes)
def main(self):
self.initialiseComponent()
loop = True
while loop:
yield 1
while self.dataReady("control"):
temp = self.recv("control")
if isinstance(temp, producerFinished):
self.send(temp, "mime-control")
elif isinstance(temp, shutdown):
self.send(shutdown(), "mime-control")
self.send(shutdown(), "http-control")
#print "HTTPServer received shutdown"
loop = False
break
while self.dataReady("mime-signal"):
temp = self.recv("mime-signal")
if isinstance(temp, producerFinished):
pass
#we don't need to care yet - wait 'til the request handler finishes
while self.dataReady("http-signal"):
temp = self.recv("http-signal")
if isinstance(temp, producerFinished):
sig = producerFinished(self)
self.send(sig, "mime-control")
self.send(sig, "signal")
loop = False
#close the connection
self.pause()
self.closeDownComponent()
def main(self):
yield self.initComponents()
while 1:
if self.dataReady("control"):
mes = self.recv("control")
if isinstance(mes, shutdownMicroprocess) or \
isinstance(mes, producerFinished):
self.send(producerFinished(), "signal")
break
if self.dataReady("monitor"):
url, comp = self.recv("monitor")
comp.activate()
newOut = self.addOutbox("monitoredOut")
self.link((self, newOut), (comp, 'inbox'))
self.addChildren(comp)
self.urls.append((url, newOut))
if self.dataReady("inbox"):
self.recv("inbox")
for url, targetOutbox in self.urls:
self.send(url, targetOutbox)
if not self.anyReady():
self.pause()
yield 1
def mainBody(self):
"""We check whether it's time to perform a new read, if it is, we
read some data. If we get some data, we put it in out outbox
"outbox", and to stdout (if debugging).
If we had an error state (eg EOF), we return 0, stopping this component, otherwise
we return 1 to live for another line/block.
"""
try:
if ((time.time() - self.time) > self.steptime):
self.time = time.time()
data = ""
data = self.getData()
if data:
assert self.debugger.note("ReadFileAdapter.main", 7,
"Read data, writing to outbox")
self.send(
data,
"outbox") # We kinda assume people are listening...
if self.debug:
sys.stdout.write(data)
sys.stdout.flush()
return 1 # Continue looping since there may be more data
except:
sig = producerFinished(self)
self.send(sig, "signal")
return 0 # Finish looping, we've stopped reading
def main(self):
counter = 0
while 1:
counter += 1
torrentfile = fopen(str(counter) + ".torrent")
metafile = fopen("meta.txt")
metafile.write(str(counter))
metafile.close()
resource = {
"statuscode": "200",
"data": u"<html><body>%d</body></html>" % counter,
"incomplete": False,
"type": "text/html"
}
receivingpost = False
while receivingpost:
while self.dataReady("inbox"):
msg = self.recv("inbox")
torrentfile.write(msg)
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, producerFinished):
receivingpost = False
if receivingpost:
yield 1
self.pause()
torrentfile.close()
self.send(resource, "outbox")
self.send(producerFinished(self), "signal")
Sessions[self.sessionid]["busy"] = False
self.pause()
yield 1
def main(self):
"""Main loop."""
try:
self.send( self.getCurrentChoice(), "outbox")
except IndexError:
pass
done = False
while not done:
yield 1
while self.dataReady("inbox"):
send = True
msg = self.recv("inbox")
if msg == "SAME":
pass
elif msg == "NEXT":
send = self.gotoNext()
if not send:
done = True
self.send( producerFinished(self), "signal")
else:
send = False
if send:
try:
self.send( self.getCurrentChoice(), "outbox")
except IndexError:
pass
done = done or self.shutdown()
if not done:
self.pause()
def main(self):
while len(self.messages) > 0:
yield 1
self.send(self.messages.pop(0), "outbox")
yield 1
self.send(producerFinished(self), "signal")
return
def testFilterOrder(self):
feeds = []
the_date = time.gmtime()
cur_year = the_date[0]
# One year after
the_future_date = (cur_year + 1, ) + the_date[1:]
# One year before
the_past_date = (cur_year - 1, ) + the_date[1:]
feeds.extend(self.generateFeeds(2, self.NO_DATE, 'notime'))
feeds.extend(self.generateFeeds(2, the_future_date, 'future'))
feeds.extend(self.generateFeeds(2, the_past_date, 'past'))
feeds.extend(self.generateFeeds(2, the_date, 'present'))
feeds.extend(self.generateFeeds(2, self.NO_DATE, 'notime'))
configObject = self.createConfigObject(5)
self.put(configObject, 'config-inbox')
for feed in feeds:
self.put(feed, 'inbox')
self.put(producerFinished(), "control")
for _ in range(2):
msg = self.get('outbox')
self.assertEquals(cur_year + 1, msg['entry']['updated_parsed'][0])
for _ in range(2):
msg = self.get('outbox')
self.assertEquals(cur_year , msg['entry']['updated_parsed'][0])
for _ in range(1):
msg = self.get('outbox')
self.assertEquals(cur_year - 1, msg['entry']['updated_parsed'][0])
self.assertOutboxEmpty('outbox')
def main(self):
brokenClient = False
self.handleConnect()
self.gettingdata = False
self.client_connected = True
self.breakConnection = False
while (not self.gettingdata) and (not self.breakConnection):
yield WaitComplete(self.getline(), tag="_getline1")
try:
command = self.line.split()
except AttributeError:
brokenClient = True
break
self.handleCommand(command)
if not brokenClient:
if (not self.breakConnection):
EndOfMessage = False
self.netPrint('354 Enter message, ending with "." on a line by itself')
while not EndOfMessage:
yield WaitComplete(self.getline(), tag="getline2")
if self.lastline():
EndOfMessage = True
self.netPrint("250 OK id-deferred")
self.send(producerFinished(),"signal")
if not brokenClient:
yield WaitComplete(self.handleDisconnect(),tag="_handleDisconnect")
self.logResult()
def main(self):
"""\
This contains no user serviceable parts :-)
Theory of operation is simple. It simply repeatedly asks the decoder
object for audio. That decoded audio is sent to the component's outbox.
If the decoder object responds with RETRY, the component retries.
If the decoder object responds with NEEDDATA, the component waits
for data on any inbox until some is available (from an inbox)
"""
decoding = True
producerDone = False
while decoding:
try:
data = self.decoder._getAudio()
self.send(data, "outbox")
except "RETRY":
pass
except "NEEDDATA":
while not (self.dataReady("inbox") > 0) and not (self.dataReady("control") >0):
if not producerDone:
self.pause()
yield 1
if self.dataReady("inbox"):
dataToSend = self.recv("inbox")
self.decoder.sendBytesForDecode(dataToSend)
if self.dataReady("control"):
shutdownMessage = self.recv("control")
sig = producerFinished(self)
self.send(sig, "signal")
producerDone = True # Necessary given next?
decoding = False
def testFilterOrder(self):
feeds = []
the_date = time.gmtime()
cur_year = the_date[0]
# One year after
the_future_date = (cur_year + 1, ) + the_date[1:]
# One year before
the_past_date = (cur_year - 1, ) + the_date[1:]
feeds.extend(self.generateFeeds(2, self.NO_DATE, 'notime'))
feeds.extend(self.generateFeeds(2, the_future_date, 'future'))
feeds.extend(self.generateFeeds(2, the_past_date, 'past'))
feeds.extend(self.generateFeeds(2, the_date, 'present'))
feeds.extend(self.generateFeeds(2, self.NO_DATE, 'notime'))
configObject = self.createConfigObject(5)
self.put(configObject, 'config-inbox')
for feed in feeds:
self.put(feed, 'inbox')
self.put(producerFinished(), "control")
for _ in range(2):
msg = self.get('outbox')
self.assertEquals(cur_year + 1, msg['entry']['updated_parsed'][0])
for _ in range(2):
msg = self.get('outbox')
self.assertEquals(cur_year, msg['entry']['updated_parsed'][0])
for _ in range(1):
msg = self.get('outbox')
self.assertEquals(cur_year - 1, msg['entry']['updated_parsed'][0])
self.assertOutboxEmpty('outbox')
def test_doesNotPropagateShutdownMsg(self):
"""If a graphline's "signal" outbox is specified to be wired to a child component, the graphline will send any messages itself out of its "signal" outbox, before or after all children have terminated, even if a shutdownMicroprocess or producerFinished message was sent to its "control" inbox."""
A = MockChild()
B = MockChild()
C = MockChild()
self.setup_initialise(A=A,
B=B,
C=C,
linkages={
("A", "signal"): ("", "signal"),
("A", "outbox"): ("B", "control"),
})
self.setup_activate()
self.runFor(cycles=100)
self.sendTo(producerFinished(), "control")
self.sendTo(shutdownMicroprocess(), "control")
self.runFor(cycles=100)
self.assert_(self.graphline in self.scheduler.listAllThreads())
self.assert_(not (self.dataReadyAt("signal")))
for child in self.children.values():
child.stopNow()
self.runFor(cycles=100)
self.assert_(not (self.dataReadyAt("signal")))
def test_receivesShutdownAndPropagates2(self):
"""If a graphline's "control" inbox and "signal" outbox are not specified to be wired to a child component in the graphline then, if a any non shutdownMicroprocess message is sent to the "control" inbox, a producerFinished message will be sent on out of the "signal" outbox once all children have terminated."""
A = MockChild()
B = MockChild()
C = MockChild()
self.setup_initialise(A=A,
B=B,
C=C,
linkages={
("A", "outbox"): ("B", "control"),
})
self.setup_activate()
self.runFor(cycles=100)
msg = producerFinished()
self.sendTo(msg, "control")
self.runFor(cycles=100)
self.assert_(self.graphline in self.scheduler.listAllThreads())
for child in self.children.values():
child.stopNow()
self.runFor(cycles=10)
self.assert_(self.graphline not in self.scheduler.listAllThreads())
self.assert_(self.dataReadyAt("signal"))
recvd = self.recvFrom("signal")
self.assert_(recvd != msg)
self.assert_(isinstance(recvd, producerFinished))
def InactivityChassis(somecomponent, timeout=2, debug=False):
"""
This convenience function will link a component up to an ActivityMonitor and
a ResettableSender that will emit a producerFinished signal within timeout
seconds if the component does not send any messages on its outbox or
CreatorFeedback boxes. To link the specified component to an external component
simply link it to the returned chassis's outbox or CreatorFeedback outboxes.
"""
linkages = {
("SHUTTERDOWNER", "outbox"): ("OBJ", "control"),
("self", "inbox"): ("OBJ", "inbox"),
("self", "control"): ("OBJ", "control"),
("self", "ReadReady"): ("OBJ", "ReadReady"),
("self", "SendReady"): ("OBJ", "SendReady"),
("OBJ", "outbox"): ("ACT", "inbox"),
("OBJ", "CreatorFeedback"): ("ACT", "inbox2"),
# ("OBJ","_selectorSignal"):("ACT","inbox3"),
("OBJ", "signal"): ("ACT", "control"),
("ACT", "observed"): ("SHUTTERDOWNER", "inbox"),
("ACT", "outbox"): ("self", "outbox"),
("ACT", "outbox2"): ("self", "CreatorFeedback"),
# ("ACT","outbox3"):("self","_selectorSignal"),
("ACT", "signal"): ("self", "signal"),
}
return Graphline(OBJ=somecomponent,
ACT=ActivityMonitor(),
SHUTTERDOWNER=ResettableSender(debug=debug,
message=producerFinished(),
timeout=timeout),
linkages=linkages)
def main(self):
for item in self.sequence:
if isinstance(item,str):
print item
continue
comp = item
self.addChildren(comp)
comp.activate()
linkages = [
self.link((comp,"outbox"),(self,"outbox"),passthrough=2),
self.link((self,"inbox"),(comp,"inbox"),passthrough=1),
# not linking signal-control, since we don't want downstream
# component to terminate prematurely
]
while not self.childrenDone():
self.pause()
yield 1
for linkage in linkages:
self.unlink(thelinkage=linkage)
self.send(producerFinished(self),"signal")
def testLinearShutdown(self):
"""A producerFinished() shutdown signal will be handled properly."""
self.setup_tests()
self.sendToControl(producerFinished())
self.runUntil()
self.failUnless(isinstance(self.recvSignal(), producerFinished))
self.checkStop(stopped=True)
def main(self):
counter = 0
while 1:
counter += 1
torrentfile = fopen(str(counter) + ".torrent")
metafile = fopen("meta.txt")
metafile.write(str(counter))
metafile.close()
resource = {
"statuscode" : "200",
"data" : u"<html><body>%d</body></html>" % counter,
"incomplete" : False,
"type" : "text/html"
}
receivingpost = False
while receivingpost:
while self.dataReady("inbox"):
msg = self.recv("inbox")
torrentfile.write(msg)
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, producerFinished):
receivingpost = False
if receivingpost:
yield 1
self.pause()
torrentfile.close()
self.send(resource, "outbox")
self.send(producerFinished(self), "signal")
Sessions[self.sessionid]["busy"] = False
self.pause()
yield 1
def test_SplitterShutdown(self):
"""If producerFinished or shutdownMicroprocess is received on the 'control' inbox they are passed on and the component shuts down"""
for msg in [producerFinished(self), shutdownMicroprocess(self)]:
split = Splitter()
Dummy = Axon.Component.component()
split.link((split, "outbox"), (Dummy, "inbox"))
split.link((split, "signal"), (Dummy, "control"))
split.activate()
for _ in xrange(0,10):
split.next()
self.assert_(0==len(split.outboxes["outbox"]))
self.assert_(0==len(split.outboxes["signal"]))
split._deliver( msg, "control" )
try:
for _ in xrange(0,10):
split.next()
self.fail()
except StopIteration:
pass
self.assert_(0==len(split.outboxes["outbox"]))
self.assert_(1==len(split.outboxes["signal"]))
# received = split._collect("signal")
received = Dummy.recv("control")
self.assert_( msg == received )
def _processMainInbox(self, msg):
protocol_component = self.Protocol(peer=msg.from_jid)
protocol_component.activate()
out_boxname = self.addOutbox("out_%s" % (protocol_component.name))
#print 'added ' + out_boxname
sig_boxname = self.addOutbox("sig_%s" % (protocol_component.name))
#print 'added ' + sig_boxname
in_boxname = self.addInbox("in_%s" % (protocol_component.name))
#print 'added ' + in_boxname
ctl_boxname = self.addInbox("ctl_%s" % (protocol_component.name))
#print 'added ' + ctl_boxname
tracked_data = {
'in': in_boxname,
'ctl': ctl_boxname,
'out': out_boxname,
'sig': sig_boxname,
'msg': msg,
}
self.tracked_components[protocol_component.name] = tracked_data
self.link((self, out_boxname), (protocol_component, 'inbox'))
self.link((protocol_component, 'outbox'), (self, in_boxname))
self.link((protocol_component, 'signal'), (self, ctl_boxname))
request = self.normalizeMsgBodies(msg)
#printable_request = request
#print 'received ' + printable_request
self.send(request, out_boxname)
self.send(producerFinished(self), sig_boxname)
def test_doesNotPropagateShutdownMsg(self):
"""If a graphline's "signal" outbox is specified to be wired to a child component, the graphline will send any messages itself out of its "signal" outbox, before or after all children have terminated, even if a shutdownMicroprocess or producerFinished message was sent to its "control" inbox."""
A=MockChild()
B=MockChild()
C=MockChild()
self.setup_initialise(
A=A, B=B, C=C,
linkages={
("A","signal"):("","signal"),
("A","outbox"):("B","control"),
})
self.setup_activate()
self.runFor(cycles=100)
self.sendTo(producerFinished(), "control")
self.sendTo(shutdownMicroprocess(), "control")
self.runFor(cycles=100)
self.assert_(self.graphline in self.scheduler.listAllThreads())
self.assert_(not(self.dataReadyAt("signal")))
for child in self.children.values():
child.stopNow()
self.runFor(cycles=100)
self.assert_(not(self.dataReadyAt("signal")))
def main(self):
while 1:
if self.dataReady("control"):
mes = self.recv("control")
if isinstance(mes, shutdownMicroprocess) or isinstance(mes, producerFinished):
self.send(producerFinished(), "signal")
break
if self.dataReady("inbox"):
r = self.recv('inbox')
if r.registered:
print "'%s' is already a registered username." % self.username
elif self.registration_id == r.stanza_id:
print "'%s' is now a registered user."\
"Please restart the client without the register flag." % self.username
else:
if 'username' in r.infos and 'password' in r.infos:
self.registration_id = generate_unique()
r = Registration(type=u'set', stanza_id=self.registration_id)
r.infos[u'username'] = self.username
r.infos[u'password'] = self.password
self.send(r, 'outbox')
if self.dataReady("error"):
r = self.recv('error')
print r.error
if not self.anyReady():
self.pause()
yield 1
def test_receivesShutdownAndPropagates23(self):
"""If a graphline's "control" inbox is specified to be wired to a child component, but its "signal" outbox is not then, irrespective of what message (eg. shutdownMicroprocess) is sent to the "control" inbox, a producerFinished message will be sent on out of the "signal" outbox once all children have terminated."""
possibleMessages = [ producerFinished(), shutdownMicroprocess(), "flurble" ]
for msg in possibleMessages:
A=MockChild()
B=MockChild()
C=MockChild()
self.setup_initialise(
A=A, B=B, C=C,
linkages={
("","control"):("A","control"),
("A","outbox"):("B","control"),
})
self.setup_activate()
self.runFor(cycles=100)
self.sendTo(msg,"control")
self.runFor(cycles=100)
self.assert_(self.graphline in self.scheduler.listAllThreads())
for child in self.children.values():
child.stopNow()
self.runFor(cycles=10)
self.assert_(self.graphline not in self.scheduler.listAllThreads())
self.assert_(self.dataReadyAt("signal"))
recvd=self.recvFrom("signal")
self.assert_(recvd != msg)
self.assert_(isinstance(recvd,producerFinished))
def test_queuedNextsFinishedIfProducerFinished(self):
"""If a producerFinished() is received, but there are still messages queued on the 'next' inbox, those messages are processed (and children created) first. *Then* the Carousel terminates."""
self.setup_test()
self.runFor(cycles=5)
self.sendToNext("BLAH")
self.runFor(cycles=50)
self.sendToControl(producerFinished())
for i in range(1, 10):
self.sendToNext("BLAH")
self.runFor(cycles=1000)
self.assert_(len(self.children) == 1)
self.assert_(not self.carousel._isStopped())
for i in range(0, 9):
self.assert_(self.children[i].wasActivated)
self.assert_(not self.children[i]._isStopped())
msg = self.children[i].recv("control")
self.assert_(
isinstance(msg, (shutdownMicroprocess, producerFinished)))
self.children[i].stopNow = True
while len(self.children) <= i + 1:
self.runFor(cycles=1)
while not self.children[-1].wasActivated:
self.runFor(cycles=1)
def test_receivesShutdownAndPropagates2(self):
"""If a graphline's "control" inbox and "signal" outbox are not specified to be wired to a child component in the graphline then, if a any non shutdownMicroprocess message is sent to the "control" inbox, a producerFinished message will be sent on out of the "signal" outbox once all children have terminated."""
A=MockChild()
B=MockChild()
C=MockChild()
self.setup_initialise(
A=A, B=B, C=C,
linkages={ ("A","outbox"):("B","control"),
})
self.setup_activate()
self.runFor(cycles=100)
msg=producerFinished()
self.sendTo(msg,"control")
self.runFor(cycles=100)
self.assert_(self.graphline in self.scheduler.listAllThreads())
for child in self.children.values():
child.stopNow()
self.runFor(cycles=10)
self.assert_(self.graphline not in self.scheduler.listAllThreads())
self.assert_(self.dataReadyAt("signal"))
recvd=self.recvFrom("signal")
self.assert_(recvd != msg)
self.assert_(isinstance(recvd,producerFinished))
def test_smokeTest5(self):
import random
X = klass()
Dummy = Axon.Component.component()
X.link((X, "outbox"),(Dummy, "inbox"))
X.link((X, "signal"),(Dummy, "control"))
X.activate()
shutdown_message = producerFinished()
X._deliver(shutdown_message,"control")
componentExit = False
for i in xrange(random.randrange(0,2000)):
try:
X.next()
except StopIteration:
componentExit = True
break
try:
# Y = X._collect("signal")
Y = Dummy.recv("control")
self.assertEqual(shutdown_message, Y)
except IndexError:
self.fail("Shutdown Message should be passed on")
def main(self):
while True:
while self.dataReady("inbox"):
data = self.recv("inbox")
self.ordered_entries.extend([
{
'feed' : data.feed,
'entry' : x,
'encoding' : data.encoding
} for x in data.entries
])
self.ordered_entries.sort(_cmp_entries)
self.checkConfig()
if self.config is not None:
self.ordered_entries = self.ordered_entries[:self.config.maxPostNumber]
mustStop, providerFinished = self.checkControl()
if mustStop:
self.send(mustStop,"signal")
return
if providerFinished is not None:
for entry in self.ordered_entries:
self.send(entry, 'outbox')
yield 1
self.send(producerFinished(self), 'signal')
return
if not self.anyReady():
self.pause()
yield 1
def main(self):
for item in self.sequence:
if isinstance(item,str):
print (item)
continue
comp = item
self.addChildren(comp)
comp.activate()
linkages = [
self.link((comp,"outbox"),(self,"outbox"),passthrough=2),
self.link((self,"inbox"),(comp,"inbox"),passthrough=1),
# not linking signal-control, since we don't want downstream
# component to terminate prematurely
]
while not self.childrenDone():
self.pause()
yield 1
for linkage in linkages:
self.unlink(thelinkage=linkage)
self.send(producerFinished(self),"signal")
def mainBody(self):
"""All the interesting work has been done by linking the file reader's output
to our output"""
if self.dataReady("_fromfile"):
temp = self.recv("_fromfile")
self.send(temp)
return 1
if self.dataReady("_sigfromfile"):
temp = self.recv("_sigfromfile")
self.send(temp, "signal")
if self.dataReady("inbox"):
temp = self.recv("inbox")
self.send(temp, "_pass")
if self.dataReady("_frommime"):
filename = self.recv("_frommime")
try:
file = open(filename, 'r')
close(file)
except Exception, e:
msg = 'HTTP/1.0 404 "Not Found\n\n"'
self.send(msg)
self.send(producerFinished(self), "signal")
if crashAndBurn["error404"]:
raise e
return 0
msg = 'HTTP/1.0 200 "OK\n\n"'
self.send(msg)
self.rfa = ReadFileAdapter(filename=filename, readmode="bitrate")
self.link(source=(self.rfa, "outbox"), sink=(self, "_fromfile"))
self.link(source=(self.rfa, "signal"), sink=(self, "_sigfromfile"))
self.addChildren(self.rfa)
# self.send(str(theData), "outbox")
# sig = producerFinished(self)
# self.send(sig, "signal")
return [self.rfa]
def main(self):
while True:
while self.dataReady("inbox"):
data = self.recv("inbox")
self.ordered_entries.extend([{
'feed': data.feed,
'entry': x,
'encoding': data.encoding
} for x in data.entries])
self.ordered_entries.sort(_cmp_entries)
self.checkConfig()
if self.config is not None:
self.ordered_entries = self.ordered_entries[:self.config.
maxPostNumber]
mustStop, providerFinished = self.checkControl()
if mustStop:
self.send(mustStop, "signal")
return
if providerFinished is not None:
for entry in self.ordered_entries:
self.send(entry, 'outbox')
yield 1
self.send(producerFinished(self), 'signal')
return
if not self.anyReady():
self.pause()
yield 1
def test_queuedNextsFinishedIfProducerFinished(self):
"""If a producerFinished() is received, but there are still messages queued on the 'next' inbox, those messages are processed (and children created) first. *Then* the Carousel terminates."""
self.setup_test()
self.runFor(cycles=5)
self.sendToNext("BLAH")
self.runFor(cycles=50)
self.sendToControl(producerFinished())
for i in range(1,10):
self.sendToNext("BLAH")
self.runFor(cycles=1000)
self.assert_(len(self.children)==1)
self.assert_(not self.carousel._isStopped())
for i in range(0,9):
self.assert_(self.children[i].wasActivated)
self.assert_(not self.children[i]._isStopped())
msg=self.children[i].recv("control")
self.assert_(isinstance(msg,(shutdownMicroprocess,producerFinished)))
self.children[i].stopNow=True
while len(self.children)<=i+1:
self.runFor(cycles=1)
while not self.children[-1].wasActivated:
self.runFor(cycles=1)
def InactivityChassis(somecomponent, timeout=2, debug=False):
"""
This convenience function will link a component up to an ActivityMonitor and
a ResettableSender that will emit a producerFinished signal within timeout
seconds if the component does not send any messages on its outbox or
CreatorFeedback boxes. To link the specified component to an external component
simply link it to the returned chassis's outbox or CreatorFeedback outboxes.
"""
linkages = {
("SHUTTERDOWNER","outbox"):("OBJ","control"),
("self","inbox") :("OBJ","inbox"),
("self","control") :("OBJ","control"),
("self","ReadReady"):("OBJ","ReadReady"),
("self","SendReady"):("OBJ","SendReady"),
("OBJ","outbox"):("ACT","inbox"),
("OBJ","CreatorFeedback"):("ACT","inbox2"),
# ("OBJ","_selectorSignal"):("ACT","inbox3"),
("OBJ","signal"):("ACT","control"),
("ACT","observed"):("SHUTTERDOWNER","inbox"),
("ACT","outbox") :("self","outbox"),
("ACT","outbox2"):("self","CreatorFeedback"),
# ("ACT","outbox3"):("self","_selectorSignal"),
("ACT","signal") :("self","signal"),
}
return Graphline(
OBJ=somecomponent,
ACT=ActivityMonitor(),
SHUTTERDOWNER=ResettableSender(debug=debug, message=producerFinished(), timeout=timeout),
linkages = linkages
)
def main(self):
""" Initialize the connection, and send the start-up message
"""
self.readbuffer = self.Buffer()
connection = self.Client(self.host, self.port, delay=self.delay)
self.addChildren(connection)
self.link((self, "request"), (connection, "inbox"))
self.link((connection, "outbox"), (self, "response"))
self.link((self, "connectionsignal"), (connection, "control"))
self.link((connection, "signal"), (self, "connectioncontrol"))
connection.activate()
# send start-up
self.request(SednaRequest(code=se.SEDNA_START_UP))
self.pause()
yield 1
#yield 1
# Now we loop.
while not self.shutdown():
self.pause()
yield 1
if self.dataReady("response"):
self.handleresponses()
# don't handle anything from the inbox until we are authenticated.
while self.authenticated and self.dataReady("inbox"):
self.handleinputs()
# we are in shutdown.
self.removeChild(self.children[0])
self.send(producerFinished(self), "signal")
def mainBody(self):
# print "ClientProtocolHandler: Checking mail..."
if self.dataReady("_displayFinished"):
print "ClientProtocolHandler: Message received! (_displayFinished)"
self.message = self.recv("_displayFinished")
if isinstance(self.message, producerFinished):
self.send(producerFinished("Done"), "signal")
return 0
else:
print "ClientProtocolHandler: Message from _displayFinished is..."
print self.message
if self.dataReady("control"):
print "ClientProtocolHandler: Message received! (control)"
self.controlMessage = self.recv("control")
if isinstance(self.controlMessage,
Kamaelia.KamaeliaIPC.socketShutdown
) or self.controlMessage == "StoppedThread":
self.send(self.controlMessage, "_filteredControlMessages")
else:
print "ClientProtocolHandler: Message from control is..."
print self.controlMessage
return 1
def main(self):
theCat = coordinatingassistanttracker.getcat()
service, inboxname = theCat.retrieveService(self.service)
self.link((self, "todb"), (service, inboxname))
# send self and my inbox name to the cursor server
self.send((self, "inbox"), "todb")
while 1:
self.pause()
yield 1
while self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
return
else:
self.send(msg, "signal")
if self.dataReady("inbox"):
conn = self.recv()
if isinstance(conn, self.cursortype):
self.send(conn)
else:
raise ValueError("Expected %s, got %s" %
(self.cursortype, conn))
self.send(producerFinished(), "signal")
self.unlink()
return
def test_Unplugging(self):
"""Plug will unplug and shutdown when child component dies."""
Axon.Scheduler.scheduler.run = Axon.Scheduler.scheduler()
splitter = Splitter()
splitter.activate()
target = DummyComponent()
plug = Plug(splitter, target).activate()
execute = Axon.Scheduler.scheduler.run.main()
for i in xrange(1,100):
execute.next()
#send shutdown msg
msg = producerFinished()
target._deliver(msg, "control")
for i in xrange(1,100):
execute.next()
# verify it reached the target
self.assert_(target.controllog == [msg])
# verify the plug has shutdown
self.assert_(plug._isStopped())
# verify the plug has no linkages
self.assert_(not plug.postoffice.linkages)
# verify that splitter only has outboxes "outbox" and "signal" now
self.assert_( len(splitter.outboxes) == 2)
self.assert_( "outbox" in splitter.outboxes)
self.assert_( "signal" in splitter.outboxes)
def main(self):
while True:
while self.dataReady("inbox"):
data = self.recv("inbox")
self.parsingXml(data)
# If the general config has been parsed, send it
if self.config is not None:
self.send(self.config, 'config-outbox')
self.config = None
# Send the parsed feeds
while len(self.feeds) > 0:
for feed in self.feeds:
self.send(feed, "feeds-outbox")
self.feeds = []
# If we're done, finish
if self.finished:
self.send(producerFinished(self), "signal")
return
if self.dataReady("control"):
data = self.recv("control")
self.send(data, "signal")
return
if not self.anyReady():
self.pause()
yield 1
