def EventServerClients(rhost, rport, backplane="WHITEBOARD"): # plug a TCPClient into the backplae from Kamaelia.Internet.TCPClient import TCPClient loadingmsg = "Fetching sketch from server..." return pipeline( subscribeTo(backplane), TagAndFilterWrapper( Graphline( GETIMG = OneShot(msg=[["GETIMG"]]), PIPE = pipeline( tokenlists_to_lines(), TCPClient(host=rhost,port=rport), chunks_to_lines(), lines_to_tokenlists(), ), BLACKOUT = OneShot(msg=[["CLEAR",0,0,0],["WRITE",100,100,24,255,255,255,loadingmsg]]), linkages = { ("self","inbox") : ("PIPE","inbox"), ("self","control") : ("PIPE","control"), ("PIPE","outbox") : ("self","outbox"), ("PIPE","signal") : ("self","signal"), ("GETIMG","outbox") : ("PIPE","inbox"), ("BLACKOUT","outbox") : ("self","outbox"), }, ) ), publishTo(backplane), ) #.activate()
def test_Simple(self): # initially manual wotsit pipeline(filePointer(), LocalFileServer(), Tester(self) ).activate() scheduler.run.runThreads()
def clientconnector(): return pipeline( chunks_to_lines(), lines_to_tokenlists(), FilterAndTagWrapper( pipeline( publishTo(backplane), # well, should be to separate pipelines, this is lazier! subscribeTo(backplane), ) ), tokenlists_to_lines(), )
def main(self): mylagger = Lagger(0.1) mysourcestream = RateControlledFileReader( "streamingfile.mpg", "bytes", rate=1280000, chunksize=100000) #ReducedConsoleReader() mychunkifier = Chunkifier(5000000) mydistributor = ChunkDistributor("chunks/") myfilewriter = WholeFileWriter() mytorrentmakerthread = TorrentMaker( "http://localhost:6969/announce", "chunks/") mytorrentmaker = pipeline(mytorrentmakerthread) myoutputconsole = consoleEchoer() """ mysourcestream -> mychunkifier -> mydistributor -> myfilewriter -> mytorrentmaker -> myoutputconsole """ self.link((mysourcestream, "outbox"), (mychunkifier, "inbox")) self.link((mychunkifier, "outbox"), (mydistributor, "inbox")) self.link((mydistributor, "outbox"), (myfilewriter, "inbox")) #self.link( (myfilewriter, "outbox"), (mydistributor, "filecompletion") ) #self.link( (mydistributor, "torrentmaker"), (mytorrentmaker, "inbox") ) self.link((myfilewriter, "outbox"), (mytorrentmaker, "inbox")) self.link((mytorrentmaker, "outbox"), (myoutputconsole, "inbox")) self.addChildren(mylagger, mysourcestream, mychunkifier, mydistributor, myfilewriter, mytorrentmaker, myoutputconsole) yield Axon.Ipc.newComponent(*(self.children)) while 1: self.pause() yield 1
def main(self): mylagger = Lagger(0.1) mysourcestream = RateControlledFileReader("streamingfile.mpg", "bytes", rate=1280000, chunksize=100000) #ReducedConsoleReader() mychunkifier = Chunkifier(5000000) mydistributor = ChunkDistributor("chunks/") myfilewriter = WholeFileWriter() mytorrentmakerthread = TorrentMaker( "http://localhost:6969/announce", "chunks/" ) mytorrentmaker = pipeline( mytorrentmakerthread ) myoutputconsole = consoleEchoer() """ mysourcestream -> mychunkifier -> mydistributor -> myfilewriter -> mytorrentmaker -> myoutputconsole """ self.link( (mysourcestream, "outbox"), (mychunkifier, "inbox") ) self.link( (mychunkifier, "outbox"), (mydistributor, "inbox") ) self.link( (mydistributor, "outbox"), (myfilewriter, "inbox") ) #self.link( (myfilewriter, "outbox"), (mydistributor, "filecompletion") ) #self.link( (mydistributor, "torrentmaker"), (mytorrentmaker, "inbox") ) self.link ( (myfilewriter, "outbox"), (mytorrentmaker, "inbox") ) self.link( (mytorrentmaker, "outbox"), (myoutputconsole, "inbox") ) self.addChildren(mylagger, mysourcestream, mychunkifier, mydistributor, myfilewriter, mytorrentmaker, myoutputconsole) yield Axon.Ipc.newComponent(*(self.children)) while 1: self.pause() yield 1
import sys if len(sys.argv) > 1: dj1port = int(sys.argv[1]) else: dj1port = 1701 class ConsoleReader(threadedcomponent): def run(self): while 1: line = raw_input("DJ1-> ") line = line + "\n" self.send(line, "outbox") class message_source(Axon.Component.component): def main(self): while 1: self.send("hello", "outbox") yield 1 pipeline( ReadFileAdaptor("audio.1.raw", readmode="bitrate", bitrate =1536000), # ReadFileAdaptor("audio.1.raw", readmode="bitrate", bitrate =200000000), TCPClient("127.0.0.1", dj1port), ).run() if 0: pipeline( ConsoleReader(), TCPClient("127.0.0.1", dj1port), ).run()
def main(self): while 1: try: if self.dataReady("inbox"): (data, mac) = self.recv("inbox") checksum = self.decryptobj.decrypt(mac) if checksum == self.calcHash(data): self.send(data, "outbox") else: # we have a hash failure raise IntegrityError # This mechanism needs improvement except IntegrityError: print "Integrity Error" yield 1 if __name__ == "__main__": pipeline( SerialChargen(), MAC_Stamper("1234567812345678", mode="CBC"), DisruptiveComponent(), MAC_Checker("1234567812345678", mode="CBC"), consoleEchoer() ).run()
self.multitorrent.rawserver.add_task(self.get_status, self.config['display_interval']) status = self.torrent.get_status(self.config['spew']) self.d.display(status) def global_error(self, level, text): self.d.error(text) def error(self, torrent, level, text): self.d.error(text) def failed(self, torrent, is_external): self.doneflag.set() def finished(self, torrent): self.d.finished() if __name__ == '__main__': from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.Util.Console import ConsoleReader, ConsoleEchoer # download a linux distro pipeline( ConsoleReader(">>> ", ""), TorrentClient( "http://www.tlm-project.org/public/distributions/damnsmall/current/dsl-2.4.iso.torrent" ), ConsoleEchoer(), ).run()
from WholeFileWriter import WholeFileWriter from TorrentMaker import TorrentMaker from Kamaelia.Util.Fanout import fanout from HTTPHelpers import HTTPMakePostRequest from HTTPClient import SimpleHTTPClient from TorrentPatron import TorrentPatron from PureTransformer import PureTransformer from OnDemandIntrospector import OnDemandIntrospector from Kamaelia.File.Writing import SimpleFileWriter if __name__ == '__main__': pipeline( ConsoleReader(), OnDemandIntrospector(), ConsoleEchoer(), ).activate() Graphline( streamin=pipeline( IcecastClient("http://127.0.0.1:1234/"), # a stream's address IcecastDemux(), IcecastStreamRemoveMetadata(), Chunkifier(500000), ChunkDistributor("./"), WholeFileWriter(), TorrentMaker("http://192.168.1.5:6969/announce"), ), split=fanout(["toMetaUploader", "toSharer"]), fileupload=pipeline(ChunkDistributor("./torrents/", ".torrent"), WholeFileWriter(),
class echoer(Axon.Component.component): def main(self): count = 0 while 1: self.pause() yield 1 while self.dataReady("inbox"): data = self.recv("inbox") print "echoer #",self.id,":", data, "count:", count count = count +1 # create a back plane by name Random talk Backplane("RandomTalk").activate() # create a reader and pipeline it to publish object pipeline( MyReader(), Encryptor("12345678901234567890123456789012"), publishTo("RandomTalk"), ).activate() #pipeline the subscribe object to the echoer #note the connection publisher and subscriber is via BACKPLANE:) pipeline( subscribeTo("RandomTalk"), Decryptor("12345678901234567890123456789012"), echoer(), ).run()
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ This is a simple proxy to relay multicast data from a given multicast group and port as a TCP Service on a given port. It's worth noting that this is one way - any data from the TCP connection is discarded. """ from Kamaelia.Util.Backplane import Backplane, publishTo, subscribeTo from Kamaelia.Internet.Multicast_transceiver import Multicast_transceiver from Kamaelia.Util.PipelineComponent import pipeline from config import mcast_group, mcast_port, mcast_tcp_splitter_port p = Backplane("MulticastProxy").activate() pipeline( Multicast_transceiver("0.0.0.0", mcast_port, mcast_group, 0), publishTo("MulticastProxy"), ).activate() def RelayMulticastData(): # Protocol handler for each connected client return subscribeTo("MulticastProxy") SimpleServer(RelayMulticastData, mcast_tcp_splitter_port).run()
self.send( shutdownMicroprocess(self), "signal") # we'll destroy outselves when we receive a shutdown message ourselves self.label["text"] = "Shutting down..." self.playbutton.destroy() if __name__ == "__main__": from Axon.Scheduler import scheduler from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.vorbisDecodeComponent import VorbisDecode, AOAudioPlaybackAdaptor from Kamaelia.File.Reading import FixedRateControlledReusableFileReader # make pipeline, but make the signal->control path loop round, so a shutdownMicroprocess() # message sent by ControlWindow will eventually get back to ControlWindow() p=pipeline( ControlWindow(), FixedRateControlledReusableFileReader( readmode="bytes", rate=128000/8, chunksize=1024 ), VorbisDecode(), AOAudioPlaybackAdaptor() ).activate() p.link( (p,"signal"), (p,"control") ) if 0: from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.Introspector import Introspector pipeline(Introspector(), TCPClient("127.0.0.1",1500)).activate() scheduler.run.runThreads(slowmo=0)
c += 1 data = self.recv("inbox") size += len(data) self.send(data, "outbox") if (c % 20) == 0: t_dash = time.time() if t_dash - t > 1: print int((size / (t_dash - t)) * 8) t = t_dash size = 0 yield 1 if 1: pipeline( DVB_Multiplex(freq, [600, 601], feparams), SimpleFileWriter("somefile.ts"), ).run() if 0: pipeline( ReadFileAdaptor("somefile.ts", readsize=8000000), MaxSizePacketiser(), Multicast_transceiver("0.0.0.0", 0, "224.168.2.9", 1600), ).activate() pipeline( Multicast_transceiver("0.0.0.0", 1600, "224.168.2.9", 0), SimpleDetupler(1), SimpleFileWriter("otherfile.ts"), ).run()
"CBBC":4671, } import time class dataRateMeasure(component): def main(self): size = 0 c = 0 t = time.time() while 1: while self.dataReady("inbox"): c += 1 data = self.recv("inbox") size += len(data) self.send(data, "outbox") if (c % 20) == 0: t_dash = time.time() if t_dash - t > 1: print int((size/(t_dash - t))*8) t = t_dash size = 0 yield 1 if 1: pipeline( Multicast_transceiver("0.0.0.0", 1600, "224.168.2.9", 0), SimpleDetupler(1), dataRateMeasure(), Pipethrough("mplayer -"), ).run()
("PAINTER", "outbox") : ("SPLIT", "inbox"), ("SPLIT", "outbox") : ("CANVAS", "inbox"), ("SPLIT", "outbox2") : ("self", "outbox"), # send to network ("self", "inbox") : ("PREFILTER", "inbox"), ("PREFILTER", "outbox") : ("CANVAS", "inbox"), ("PREFILTER", "history_event") : ("HISTORY", "inbox"), ("CANVAS", "outbox") : ("self", "outbox"), ("CANVAS","surfacechanged") : ("HISTORY", "inbox"), }, ) mainsketcher = \ Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768), CONSOLE = pipeline(ConsoleReader(),text_to_tokenlists(),parseCommands()), linkages = { ('self','inbox'):('SKETCHER','inbox'), ('SKETCHER','outbox'):('self','outbox'), ('CONSOLE','outbox'):('SKETCHER','inbox'), } ) # primary whiteboard pipeline( subscribeTo("WHITEBOARD"), TagAndFilterWrapper(mainsketcher), publishTo("WHITEBOARD") ).activate() if __name__=="__main__": import sys, getopt, re
class printer(component): def tick(self,ID): for i in (1,2,3,4,5,6,7,8,9,10): print "TICK", ID, i yield i print "TICK DONE" def main(self): ID = randint(0,20000) print "PRE-WAIT" yield WaitComplete(self.tick(ID)) print "POST-WAIT" while 1: yield 1 try: data = self.recv("inbox") print data, except: print "NO DATA READY, LETS WAIT A BIT" ID = randint(0,20000) print "PRE-WAIT" yield WaitComplete(self.tick(ID)) print "POST-WAIT" pipeline( cat("""\ Information Center, n.: A room staffed by professional computer people whose job it is to tell you why you cannot have the information you require. """.split(" ")), printer(), ).run()
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import Axon from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.Console import ConsoleEchoer class linesender(Axon.Component.component): def __init__(self, *lines): super(linesender, self).__init__() self.lines = lines[:] def main(self): for line in self.lines: self.send(line+"\r\n", "outbox") yield 1 pipeline( linesender("GET /cgi-bin/blog/feed.cgi HTTP/1.0", "Host: 127.0.0.1", ""), TCPClient("127.0.0.1", 80), ConsoleEchoer(), ).run()
# (1) Kamaelia Contributors are listed in the AUTHORS file and at # http://www.kamaelia.org/AUTHORS - please extend this file, # not this notice. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ The purpose behind this component is to allow the following to occur: pipeline( dataSource(), ExternalPipeThrough("command", *args), dataSink(), ).run() More specificaly, the longer term interface of this component will be: ExternalPipeThrough: inbox - data recieved here is sent to the program's stdin outbox - data sent here is from the program's stdout control - at some point we'll define a mechanism for describing control messages - these will largely map to SIG* messages
def dumping_client(): return pipeline( TCPClient("132.185.131.178", 1700), printer(), )
assert (mode == "play" or mode == "record") filename = sys.argv[2] rhost = sys.argv[3] rport = int(sys.argv[4]) except: sys.stderr.write( "Usage:\n ./WhiteboardClerk play|record filename host port\n\n") sys.exit(1) if mode == "record": print "Recording..." pipeline( OneShot(msg=[["GETIMG"]]), tokenlists_to_lines(), TCPClient(host=rhost, port=rport), chunks_to_lines(), Timestamp(), IntersperseNewlines(), SimpleFileWriter(filename), ).run() elif mode == "play": print "Playing..." pipeline( Graphline( FILEREADER=PromptedFileReader(filename, "lines"), DETIMESTAMP=DeTimestamp(), linkages={ # data from file gets detimestamped and sent on ("FILEREADER", "outbox"): ("DETIMESTAMP", "inbox"), ("DETIMESTAMP", "outbox"): ("", "outbox"),
self.postoffice.deregisterlinkage(thelinkage = linkages[box]) self.deleteOutbox(outboxes[box]) del self.actors[actorName] def exeuntAll(self, includingNarrator=False): self.send("EXIT ALL...\n","outbox") for actor in self.actors.keys(): if includingNarrator or actor != "NARRATOR": for retval in self.exeunt(actor): yield retval if __name__ == "__main__": from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.File.Reading import RateControlledFileReader from Kamaelia.Util.ConsoleEcho import consoleEchoer pipeline( RateControlledFileReader("../CE/twelfthnight.txt", readmode="lines", rate=50, chunksize=1), demodulation(), error_correction(), demultiplexing(), director("127.0.0.1", "#theglobe"), consoleEchoer(), ).run()
from Kamaelia.ReadFileAdaptor import ReadFileAdaptor from Kamaelia.Util.Graphline import Graphline channels_london = { "MORE4+1" : ( 538, #MHz [ 701, 702 ] # PID (programme ID) for video and PID for audio ) } services = { "NEWS24": (754, [640, 641]), "MORE4+1": (810, [701,702]), "TMF": (810, [201,202]) } if 0: pipeline( DVB_Multiplex(754, [640, 641, 620, 621, 622, 610, 611, 612, 600, 601, 602, 12]), SimpleFileWriter("multiplex_new.data") ).run() if 1: Graphline( SOURCE=ReadFileAdaptor("multiplex.data"), DEMUX=DVB_Demuxer({ "640": "NEWS24", "641": "NEWS24", "600": "BBCONE", "601": "BBCONE", "610": "BBCTWO", "611": "BBCTWO", "620": "CBBC", "621": "CBBC", }), NEWS24=SimpleFileWriter("news24.data"),
torrents.append([msg.torrentid, msg.savefolder]) elif isinstance(msg, TIPCTorrentStatusUpdate): print msg.torrentid if msg.torrentid == torrents[0][0]: print msg.statsdictionary if msg.statsdictionary.get("fractionDone", 0) == 1: self.send(torrents[0][1], "outbox") torrents.pop(0) self.pause() if __name__ == "__main__": partslist = "filelist.txt" resourcefetcher = TriggeredFileReader # SimpleHTTPClient pipeline(ConsoleReader(), OnDemandIntrospector(), ConsoleEchoer()).activate() pipeline( CheapAndCheerfulClock(30.0), TriggeredSource(partslist), resourcefetcher(), LineSplit(), UnseenOnly(), PureTransformer(lambda x: x or None), # eradicate blank lines resourcefetcher(), TorrentPatron(), StreamReconstructor(), ConsoleEchoer(), ).run()
t = time.time() while 1: while self.dataReady("inbox"): c += 1 data = self.recv("inbox") size += len(data) self.send(data, "outbox") if (c % 20) == 0: t_dash = time.time() if t_dash - t > 1: print int((size/(t_dash - t))*8) t = t_dash size = 0 yield 1 pipeline( AlsaRecorder(), SpeexEncode(3), # Encryptor("1234567812345678", "AES"), dataRateMeasure(), SingleServer(port=1601), ).activate() pipeline( TCPClient("127.0.0.1", 1601), # Decryptor("1234567812345678", "AES"), SpeexDecode(3), AlsaPlayer(), ).run()
if self.dataReady("linknode"): self.recv("linknode") if node is not None: linkstart = node linkmode = True TVC = TopologyViewerComponent(position=(0,0)).activate() Graphline( NEW = Button(caption="New Component", msg="NEXT", position=(72,8)), EDIT = Button(caption="Edit Component", msg="NEXT", position=(182,8)), DEL = Button(caption="Delete Component", msg="NEXT", position=(292,8)), LINK = Button(caption="Make Link", msg="NEXT", position=(402,8)), CONSOLEINPUT = pipeline( ConsoleReader(">>> "), chunks_to_lines(), lines_to_tokenlists(), ), EDITOR_LOGIC = EditorLogic(), DEBUG = ConsoleEchoer(), TVC = TVC, linkages = { ("CONSOLEINPUT", "outbox"): ("TVC", "inbox"), ("NEW", "outbox"): ("EDITOR_LOGIC", "newnode"), ("EDIT", "outbox"): ("EDITOR_LOGIC", "editnode"), ("DEL", "outbox") : ("EDITOR_LOGIC", "delnode"), ("LINK", "outbox") : ("EDITOR_LOGIC", "linknode"), ("TVC", "outbox") : ("EDITOR_LOGIC", "itemselect"), ("EDITOR_LOGIC", "outbox") : ("DEBUG", "inbox"), ("EDITOR_LOGIC", "nodeevents") : ("TVC", "inbox"), }
#!/usr/bin/env python # The contents of this file are subject to the BitTorrent Open Source License # Version 1.1 (the License). You may not copy or use this file, in either # source code or executable form, except in compliance with the License. You # may obtain a copy of the License at http://www.bittorrent.com/license/. # # Software distributed under the License is distributed on an AS IS basis, # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License # for the specific language governing rights and limitations under the # License. """\ ================= .torrent Maker ================= This component accepts filenames, one per message, in "inbox" and outputs the metadata (contents of the .torrent file) for that file to outbox. Example Usage ------------- This setup accepts filenames, one per line, and then seeds them using the given tracker. pipeline( ConsoleReader(eol=""), TorrentMaker(defaulttracker="http://sometracker.example.com:6969/announce"), TorrentPatron() ).run()
if self.dataReady("linknode"): self.recv("linknode") if node is not None: linkstart = node linkmode = True TVC = TopologyViewerComponent(position=(0, 0)).activate() Graphline(NEW=Button(caption="New Component", msg="NEXT", position=(72, 8)), EDIT=Button(caption="Edit Component", msg="NEXT", position=(182, 8)), DEL=Button(caption="Delete Component", msg="NEXT", position=(292, 8)), LINK=Button(caption="Make Link", msg="NEXT", position=(402, 8)), CONSOLEINPUT=pipeline( ConsoleReader(">>> "), chunks_to_lines(), lines_to_tokenlists(), ), EDITOR_LOGIC=EditorLogic(), DEBUG=ConsoleEchoer(), TVC=TVC, linkages={ ("CONSOLEINPUT", "outbox"): ("TVC", "inbox"), ("NEW", "outbox"): ("EDITOR_LOGIC", "newnode"), ("EDIT", "outbox"): ("EDITOR_LOGIC", "editnode"), ("DEL", "outbox"): ("EDITOR_LOGIC", "delnode"), ("LINK", "outbox"): ("EDITOR_LOGIC", "linknode"), ("TVC", "outbox"): ("EDITOR_LOGIC", "itemselect"), ("EDITOR_LOGIC", "outbox"): ("DEBUG", "inbox"), ("EDITOR_LOGIC", "nodeevents"): ("TVC", "inbox"), }).run()
if __name__ == "__main__": from Axon.Scheduler import scheduler from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.Visualisation.PhysicsGraph.TopologyViewerComponent import TopologyViewerComponent from Kamaelia.Util.Splitter import PlugSplitter as Splitter from Kamaelia.Util.Splitter import Plug # from Filters import FilterSelectMsgs, FilterTopologyMsgs from PipeBuild import PipeBuild from PipelineWriter import PipelineWriter from BuildViewer import BuildViewer from GUI import BuilderControlsGUI, TextOutputGUI items = list(getAllClasses(COMPONENTS)) pipegen = Splitter(pipeline(BuilderControlsGUI(items), PipeBuild())) viewer = Splitter(BuildViewer()) Plug(viewer, pipegen).activate() # feedback loop for 'selected' msgs Plug(pipegen, viewer).activate() Plug(pipegen, pipeline(PipelineWriter(), TextOutputGUI("Pipeline code"))).activate() scheduler.run.runThreads()
# you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from Axon.Component import component from Axon.Ipc import producerFinished, shutdown from PureTransformer import PureTransformer """\ ================= Data Source component ================= This component outputs messages specified at its creation one after another. Example Usage ------------- To output "hello" then "world": pipeline( DataSource(["hello", "world"]), ConsoleEchoer() ).run()
else: i = None if "navelgaze" in dictArgs: del dictArgs["navelgaze"] dictArgs['noServer'] = True from Kamaelia.Util.Introspector import Introspector i = Introspector() if "introspect" in dictArgs: (server, port) = dictArgs["introspect"] del dictArgs["introspect"] from Kamaelia.Util.Introspector import Introspector from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.PipelineComponent import pipeline pipeline( Introspector(), TCPClient(server, port) ).activate() app = AxonVisualiserServer(caption="Axon / Kamaelia Visualiser", **dictArgs) if i: i.link( (i,"outbox"), (app,"inbox") ) i.activate() app.activate() _scheduler.run.runThreads(slowmo=0)
# if we should send some more if we can if len(self.outboxes["outbox"]) < self.maxqueue: if self.dataReady("_selectorready"): #print "selector is ready" msg = self.recv("_selectorready") self.tryReadChunk(self.fd) self.selectorWait(self.fd) self.pause() self.send(producerFinished(self), "signal") #print "IntelligentFileReader terminated" class DebugOutput(component): def main(self): while 1: yield 1 self.pause() #if self.dataReady("inbox"): # msg = self.recv("inbox") #print "Queue length = " + str(len(self.["inbox"])) if __name__ == "__main__": pipeline( ConsoleReader(), IntelligentFileReader("/dev/urandom", 1024, 5), DebugOutput(), ).run()
"outbox" : PPostbox.Outbox } from Kamaelia.UI.PygameDisplay import PygameDisplay pgd = PygameDisplay(width=800,height=600).activate() PygameDisplay.setDisplayService(pgd) TVC = TopologyViewerComponent(position=(0,48), laws = AxonLaws(), particleTypes=particleTypes) SANDBOX = Sandbox() Graphline( CONSOLEINPUT = pipeline( ConsoleReader(">>> "), chunks_to_lines(), lines_to_tokenlists(), ), DEBUG = ConsoleEchoer(forwarder=True), TVC = TVC, INTROSPECTOR = pipeline(Introspector(SANDBOX), chunks_to_lines(), lines_to_tokenlists()), SANDBOX = SANDBOX, NEW = Button(caption="New Component", msg="NEXT", position=(8,8)), CHANGE = Button(caption="Change Component", msg="NEXT", position=(128,8)), DEL = Button(caption="Delete Component", msg="NEXT", position=(256,8)), LINK = Button(caption="Make Link", msg="NEXT", position=(402,8)), UNLINK = Button(caption="Break Link", msg="NEXT", position=(480,8)), GO = Button(caption="Activate!", msg="NEXT", position=(590,8)), EDITOR_LOGIC = EditorLogic(), CED = ComponentEditor(classes), linkages = {
# limitations under the License. from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.Util.Console import ConsoleReader, ConsoleEchoer import sys sys.path.append("../../") sys.path.append("../../Util") sys.path.append("../../HTTP") sys.path.append("../../Torrent") from DataSource import DataSource from OnDemandIntrospector import OnDemandIntrospector from TorrentClient import TorrentClient, BasicTorrentExplainer from TorrentMaker import TorrentMaker if __name__ == '__main__': # seed a file pipeline( ConsoleReader(">>> ",""), TorrentMaker("http://localhost:6969/announce"), TorrentPatron(), BasicTorrentExplainer(), ConsoleEchoer() #TorrentPatron(), #BasicTorrentExplainer(), #ConsoleEchoer(), ).run()
class Tuple2string(component): def main(self): while 1: yield 1 if self.dataReady("inbox"): item = self.recv("inbox") data_id = str(item[0]) data_length = str(len(str(item[1]))) data = str(item[1]) item = "%s %s %s" % (data_id, data_length, data) self.send(item, "outbox") class String2tuple(component): def main(self): while 1: yield 1 if self.dataReady("inbox"): item = self.recv("inbox") temp_list = str.split(item) data_id = int(temp_list[0]) data = temp_list[2] item = (data_id, data) self.send(item, "outbox") pipeline(Source(), Annotator(), Tuple2string(), Duplicate(), Throwaway(), Reorder(), String2tuple(), RecoverOrder(), consoleEchoer()).run()
class display(component): "Takes a message from it's inbox, does stuff to it and sends it to it's outbox indefinitely" def main(self): while 1: if self.dataReady("inbox"): pygame.init() self.list_surface_components = self.recv("inbox") myDisplay.prepare_display(self.list_surface_components) myDisplay.display() #debug yield 1 myDisplay = pygame_display.MyDisplay() display_size = [1000, 800] filename = "twelfthnight.txt" picture_directory = "characters" app = pipeline(producer(filename), demodulation(), error_correction(), demultiplexing(), decode(picture_directory), video_scaling(), display()) app.activate() scheduler.run.runThreads(slowmo=0)
phoneLibs = False # IP_toConnectTo = "132.185.133.36" IP_toConnectTo = "127.0.0.1" print IP_toConnectTo serverport = 1616 delay = 5 windows_ClientContentDir = "C:\\ClientContent\\" mac_ClientContentDir = "/temp/" phone_ClientContentDir = "E:\\Ciaran's Files\\Temp" ClientContentDir = [windows_ClientContentDir, mac_ClientContentDir, phone_ClientContentDir] demo_mode = True import sys sys.path.append("..\Layout") from Introspector import Introspector from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.PipelineComponent import pipeline pipeline( Introspector(), TCPClient("132.185.133.29",1500) ).activate() t = UserInterface(IP_toConnectTo, serverport, delay, ClientContentDir, demo_mode) t.activate() scheduler.run.runThreads(slowmo=0) # t = Client() # t.activate() # scheduler.run.runThreads(slowmo=0)
while self.dataReady("inbox"): c += 1 data = self.recv("inbox") size += len(data) self.send(data, "outbox") if (c % 20) == 0: t_dash = time.time() if t_dash - t > 1: print int((size/(t_dash - t))*8) t = t_dash size = 0 yield 1 if 1: pipeline( DVB_Multiplex(freq, [600,601], feparams), SimpleFileWriter("somefile.ts"), ).run() if 0: pipeline( ReadFileAdaptor("somefile.ts",readsize=8000000), MaxSizePacketiser(), Multicast_transceiver("0.0.0.0", 0, "224.168.2.9", 1600), ).activate() pipeline( Multicast_transceiver("0.0.0.0", 1600, "224.168.2.9", 0), SimpleDetupler(1), SimpleFileWriter("otherfile.ts"), ).run()
def main(self): while 1: yield 1 while self.dataReady("inbox"): msg = self.recv("inbox") self.forwardqueue.push(msg) while len(self.forwardqueue) >= self.chunksize: self.sendChunk() if self.nodelay: self.sendPartialChunk() while self.dataReady("control"): msg = self.recv("control") if isinstance(msg, producerFinished): self.sendPartialChunk() self.send(msg, "signal") return elif isinstance(msg, shutdown): self.send(msg, "signal") return self.pause() if __name__ == '__main__': from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.Util.Console import ConsoleEchoer, ConsoleReader pipeline(ConsoleReader(eol=""), Chunkifier(20), ConsoleEchoer()).run()
result.append(chr(mixed_lsb)) result.append(chr(mixed_msb)) except IndexError: print "WARNING: odd (not even) packet size" return "".join(result) Backplane("DJ1").activate() Backplane("DJ2").activate() Backplane("music").activate() Backplane("destination").activate() pipeline( SingleServer(port=dj1port), publishTo("DJ1"), ).activate() pipeline( SingleServer(port=dj2port), publishTo("DJ2"), ).activate() pipeline( SingleServer(port=musicport), publishTo("music"), ).activate() livecontrol = 1 networkserve = 0 standalone = 1
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.Util.Console import ConsoleReader, ConsoleEchoer import sys sys.path.append("../../") sys.path.append("../../Util") sys.path.append("../../HTTP") sys.path.append("../../Torrent") from DataSource import DataSource from OnDemandIntrospector import OnDemandIntrospector from TorrentClient import TorrentClient, BasicTorrentExplainer from TorrentMaker import TorrentMaker if __name__ == '__main__': # seed a file pipeline(ConsoleReader(">>> ", ""), TorrentMaker("http://localhost:6969/announce"), TorrentPatron(), BasicTorrentExplainer(), ConsoleEchoer() #TorrentPatron(), #BasicTorrentExplainer(), #ConsoleEchoer(), ).run()
def dumping_server(): return pipeline( SingleServer(mockserverport), printer(), )
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Splitting server. This expects a single inbound connection on one port and spits it out to all recipients who connect on another port. This can be used as an alternate server for the TCPRelayMulticast to connect to, and it would expect to be fed using MulticastTCPClientRelay. """ from Kamaelia.Util.Backplane import Backplane, publishTo, subscribeTo from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.SimpleServerComponent import SimpleServer from Kamaelia.SingleServer import SingleServer from config import tcp_tcp_splitter_port, tcp_splitter_client_port p = Backplane("Splitting").activate() pipeline(SingleServer(tcp_tcp_splitter_port), publishTo("Splitting")).activate() def SubscribeToSplitData(): # Protocol handler for each connected client return subscribeTo("Splitting") SimpleServer(SubscribeToSplitData, tcp_splitter_client_port).run()
def dumping_server(): return pipeline( SingleServer(1700), printer(), )
if mp["done"]: flags.append("[DONE]") output += "%8d %8d %6.2f %6d %s %s\n" % ( mp["running"], mp["active"], mp["%usage"], mp["lineno"], mp["name"], " ".join(flags)) output += "---------------------------------------------------------\n" self.send(output, "outbox") yield 1 self.pause() def FormattedProfiler(*largs, **kargs): return pipeline(Profiler(*largs, **kargs), ProfilerOutputFormatter()) if __name__ == "__main__": from Kamaelia.Util.Console import ConsoleEchoer class BusyComponent(component): def main(self): while 1: yield 1 BusyComponent().activate() pipeline( FormattedProfiler(10.0, 1.0), ConsoleEchoer(), ).run()
# See the License for the specific language governing permissions and # limitations under the License. # ------------------------------------------------------------------------- # # RETIRED print """ /Sketches/filereading/ClientStreamToFile.py This file has been retired. It is retired because it is now part of the main code base. If you want to use this, you can now find it in: Kamaelia-Distribution/Examples/example12/ClientStreamToFile.py (Hopefully contains enough info to do what you wanted to do.) """ import sys sys.exit(0) # from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.PipelineComponent import pipeline from WriteFileAdapter import WriteFileAdapter outputfile = "/tmp/received.raw" clientServerTestPort=1500 pipeline(TCPClient("127.0.0.1",clientServerTestPort), WriteFileAdapter(outputfile) ).run()
def FormattedProfiler(*largs, **kargs): return pipeline(Profiler(*largs, **kargs), ProfilerOutputFormatter())
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Splitting server. This expects a single inbound connection on one port and spits it out to all recipients who connect on another port. This can be used as an alternate server for the TCPRelayMulticast to connect to, and it would expect to be fed using MulticastTCPClientRelay. """ from Kamaelia.Util.Backplane import Backplane, publishTo, subscribeTo from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.SimpleServerComponent import SimpleServer from Kamaelia.SingleServer import SingleServer from config import tcp_tcp_splitter_port, tcp_splitter_client_port p = Backplane("Splitting").activate() pipeline( SingleServer(tcp_tcp_splitter_port), publishTo("Splitting"), ).activate() def SubscribeToSplitData(): # Protocol handler for each connected client return subscribeTo("Splitting") SimpleServer(SubscribeToSplitData, tcp_splitter_client_port).run()
#!/usr/bin/python from Kamaelia.Util.PipelineComponent import pipeline from Record import AlsaRecorder from Play import AlsaPlayer from Kamaelia.SingleServer import SingleServer from Kamaelia.Internet.TCPClient import TCPClient pipeline( AlsaRecorder(), SingleServer(port=1601), ).activate() pipeline( TCPClient("127.0.0.1", 1601), AlsaPlayer(), ).run()
from Kamaelia.Util.PipelineComponent import pipeline from Kamaelia.File.Writing import SimpleFileWriter from Kamaelia.ReadFileAdaptor import ReadFileAdaptor from Kamaelia.Util.Graphline import Graphline from Kamaelia.Util.Console import ConsoleEchoer Graphline( # SOURCE=ReadFileAdaptor("/home/matteh/eit.ts"), SOURCE=DVB_Multiplex(505833330.0 / 1000000.0, [18, 20]), DEMUX=DVB_Demuxer({ "18": "_EIT_", "20": "_DATETIME_" }), EIT=pipeline( PSIPacketReconstructor(), EITPacketParser(), NowNextServiceFilter(4164, 4228), # BBC ONE & BBC TWO NowNextChanges(), ConsoleEchoer(), ), DATETIME=pipeline( PSIPacketReconstructor(), TimeAndDatePacketParser(), ConsoleEchoer(), ), linkages={ ("SOURCE", "outbox"): ("DEMUX", "inbox"), ("DEMUX", "_EIT_"): ("EIT", "inbox"), ("DEMUX", "_DATETIME_"): ("DATETIME", "inbox"), }).run()