def __init__(self, logname, wrapper = wrapMessage): """ Initializes a new Logger. -logname - the name of the log to write to -wrapper - a method that takes a message as an argument and returns a formatted string to put in the log. """ super(Logger, self).__init__() self.logname = logname self.bplane = Backplane('LOG_' + logname) self.subscriber = SubscribeTo('LOG_' + logname) self.wrapper = wrapper #add the components as children self.addChildren(self.subscriber, self.bplane) self.link((self.subscriber, 'outbox'), (self, 'inbox')) self.link((self, 'signal'), (self.bplane, 'control'))
def PassThroughAudio(edlfile, tmpFilePath): """\ Prefab. Goes through the specified edit decision list file and reads in the audio frames corresponding to the video frames referred to in the reframing instructions in sequence. Outputs the audio frames out of the "outbox" outbox. Arguments: - edlfile -- full filepathname of the EDL xml file - tmpFilePath -- temp directory into which video frames have been saved Inboxes: - "inbox" -- NOT USED - "control" -- Shutdown signalling Outboxes: - "outbox" -- raw audio data, chunked by frames - "signal" -- Shutdown signalling """ backplane_name = "AUDIO_FORMAT" return Graphline( \ GET_EDL = EditDecisionSource(edlfile), AUDIO = Carousel( lambda edit : PassThroughAudioSegment(tmpFilePath, edit, backplane_name), make1stRequest=True), BACKPLANE = Backplane(backplane_name), AUDIOFORMAT = Pipeline( SubscribeTo(backplane_name), FirstOnly() ), linkages = { ("AUDIO", "requestNext") : ("GET_EDL", "inbox"), ("GET_EDL", "outbox") : ("AUDIO", "next"), ("AUDIO", "outbox") : ("", "outbox"), ("AUDIOFORMAT", "outbox") : ("", "audioformat"), ("GET_EDL", "signal") : ("AUDIO", "control"), ("AUDIO", "signal") : ("AUDIOFORMAT", "control"), ("AUDIOFORMAT", "signal") : ("BACKPLANE", "control"), ("BACKPLANE", "signal") : ("", "signal"), }, )
Pipeline( SubscribeTo("WEBCAM"), TagAndFilterWrapperKeepingTag(camera), PublishTo("WEBCAM"), ).activate() rhost, rport, serveport = parseOptions() # setup a server, if requested if serveport: LocalEventServer("WHITEBOARD", "AUDIO", port=serveport).activate() LocalWebcamEventServer("WEBCAM", port=(serveport + 1)).activate() # connect to remote host & port, if requested if rhost and rport: EventServerClients(rhost, rport, "WHITEBOARD", "AUDIO").activate() WebcamEventServerClients(rhost, (rport + 1), "WEBCAM").activate() # sys.path.append("../Introspection") # from Profiling import FormattedProfiler # # Pipeline(FormattedProfiler( 20.0, 1.0), # ConsoleEchoer() # ).activate() Backplane("WHITEBOARD").activate() Backplane("WEBCAM").activate() Backplane("AUDIO").run()
#!/usr/bin/python # -*- coding: utf-8 -*- import Axon from Kamaelia.Chassis.ConnectedServer import FastRestartServer from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Util.Backplane import Backplane, PublishTo, SubscribeTo from Kamaelia.Util.PureTransformer import PureTransformer Backplane("CHAT_ONE").activate() def EchoEveryone(**kwargs): peer = str(kwargs.get("peer", "<>")) peerport = str(kwargs.get("peerport", "<>")) return Pipeline( PureTransformer(lambda x: "%s:%s says %s" % (peer, peerport, x)), PublishTo("CHAT_ONE"), # ------------ SubscribeTo("CHAT_ONE"), ) FastRestartServer(protocol=EchoEveryone, port=1500).run()
# 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()
# # 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()
) 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 rhost, rport, serveport = parseOptions() # setup a server, if requested if serveport: LocalEventServer("WHITEBOARD", port=serveport).activate() # connect to remote host & port, if requested if rhost and rport: EventServerClients(rhost, rport, "WHITEBOARD").activate() Backplane("WHITEBOARD").run()
class Logger(component): """ This component is used to write messages to file. Upon instantiation, the a backplane is registered with the name LOG_ + logname, so that a log named 'foo.bar' would be registered under 'LOG_foo.bar'. Please note that the Logger will not be shut down automatically. It must be sent a shutdown message via its control box. Typically this component is to be used by a Chassis or some other Parent component to provide a log for its children. """ Inboxes = { 'inbox' : 'Receive a tuple containing the filename and message to log', 'control' : 'Receive shutdown messages',} Outboxes = {'outbox' : 'NOT USED', 'signal' : 'Send shutdown messages',} def __init__(self, logname, wrapper = wrapMessage): """ Initializes a new Logger. -logname - the name of the log to write to -wrapper - a method that takes a message as an argument and returns a formatted string to put in the log. """ super(Logger, self).__init__() self.logname = logname self.bplane = Backplane('LOG_' + logname) self.subscriber = SubscribeTo('LOG_' + logname) self.wrapper = wrapper #add the components as children self.addChildren(self.subscriber, self.bplane) self.link((self.subscriber, 'outbox'), (self, 'inbox')) self.link((self, 'signal'), (self.bplane, 'control')) def main(self): self.bplane.activate() self.subscriber.activate() self.first_run = False not_done = True while not_done: if self.dataReady('inbox'): file = open(self.logname, 'a') while self.dataReady('inbox'): msg = self.recv('inbox') file.write(self.wrapper(msg)) file.close() while self.dataReady('control'): msg = self.recv('control') if isinstance(msg, (shutdownMicroprocess)): not_done = False self.shutdown(msg) if not_done: self.pause() yield 1 def shutdown(self, msg): """ Sends shutdown message to signal box and removes children. """ self.send(msg, 'signal') self.removeChild(self.bplane) self.removeChild(self.subscriber)
from Kamaelia.UI.Pygame.Display import PygameDisplay from Kamaelia.UI.Pygame.VideoOverlay import VideoOverlay from Kamaelia.Util.Backplane import Backplane, PublishTo, SubscribeTo from Kamaelia.Util.RateFilter import MessageRateLimit PygameDisplay.setDisplayService( PygameDisplay(width=1024, height=500).activate()) Pipeline( UnixProcess("ffmpeg -i " + infile + " -f yuv4mpegpipe -y /dev/stdout"), 2, YUV4MPEGToFrame(), 50, MessageRateLimit(25, 25), PublishTo("VIDEO"), Backplane("VIDEO"), StopSelector(waitForTrigger=True), ).activate() Pipeline( SubscribeTo("VIDEO"), TagWithSequenceNumber(), DetectShotChanges(threshold), FormatOutput(), ConsoleEchoer(), ).activate() Pipeline(SubscribeTo("VIDEO"), VideoOverlay()).run()
linkages={ ("CANVAS", "eventsOut"): ("PAINTER", "inbox"), #("PAINTER", "outbox") : ("CANVAS", "inbox"), ("PAINTER", "outbox"): ("TWOWAY", "inbox"), #("CLEAR", "outbox") : ("CANVAS", "inbox"), ("CALIBRATE", "outbox"): ("CANVAS", "inbox"), #("CANVAS", "toApp") : ("CALIBRATE", "coords"), ("TWOWAY", "outbox"): ("CALIBRATE", "coords"), ("TWOWAY", "outbox2"): ("CANVAS", "inbox"), ("CALIBBUTTON", "outbox"): ("CALIBRATE", "inbox"), ("CALIBRATE", "finaldata"): ("FILEWRITER", "inbox"), ("FILEWRITER", "outbox"): ("CALIBRATE", "inbox"), }, ) if __name__ == "__main__": mainsketcher = \ Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768), linkages = { ('','inbox'):('SKETCHER','inbox'), ('SKETCHER','outbox'):('','outbox'), } ) # primary calibrator Pipeline(SubscribeTo("CALIBRATOR"), TagAndFilterWrapper(mainsketcher), PublishTo("CALIBRATOR")).activate() print("Starting calibration...") Backplane("CALIBRATOR").run()
{"PSI_Tables":"request"} ).activate() # ------------------------------------------------------------------------------ # now and next data on a backplane Pipeline( Subscribe("PSI_Tables", [EIT_PID]), ParseEventInformationTable_Subset(True, False, False, False), FilterOutNotCurrent(), SimplifyEIT(), NowNextProgrammeJunctionDetect(), PublishTo("nowEvents"), ).activate() Backplane("nowEvents").activate() # ------------------------------------------------------------------------------ # A service to map textual channel names to service_id's RegisterService( \ Graphline( TABLE_SOURCE = Subscribe("PSI_Tables", [SDT_PID]), PARSING = ParseServiceDescriptionTable_ActualTS(), LOOKUP = ChannelNameLookupService(), linkages = { ("","inbox") : ("LOOKUP", "request"), ("TABLE_SOURCE", "outbox") : ("PARSING", "inbox"), ("PARSING", "outbox") : ("LOOKUP", "inbox"), } ), {"LookupChannelName" : "inbox"}
if event[0] == "MAKELINKTO": mode = "LINK" print "MAKING LINK from", selected source = selected try: if '#' not in source: source = source+"#next" except TypeError,e: mode = None source = None sink = None priorselected = None selected = None Backplane("VIS").activate() Backplane("UI_Events").activate() X = Pipeline( SubscribeTo("VIS"), chunks_to_lines(), lines_to_tokenlists(), AxonVisualiser(position=(0,0)), ConsoleEchoer(forwarder=True), PublishTo("UI_Events"), ).activate() Graphline( EXAMPLE = example, ADDASSET = Button(caption="ADD ASSET", position=(800, 20), msg='add'),
data = self.recv("inbox") n += 1 print "Received: %s" % data yield 1 if self.dataReady("control"): data = self.recv("control") print "Control: %s" % data self.send(producerFinished(self), "signal") return #if not self.anyReady(): # self.pause() yield 1 backplane = Backplane("SAMPLE") backplane.activate() producer = Producer() consumer = Consumer() published = PublishTo("SAMPLE") subscribe = SubscribeTo("SAMPLE") pipe1 = Pipeline( producer, published, ) pipe1.activate() pipe2 = Pipeline( subscribe,
def setup(self): # Backplanes are like a global entry points that # can be accessible both for publishing and # recieving data. # In other words, a component interested # in advertising to many other components that # something happened may link one of its outbox # to a PublishTo component's inbox. # A component wishing to receive that piece of # information will link one of its inbox # to the SubscribeTo component's outbox. # This helps greatly to make components more # loosely connected but also allows for some data # to be dispatched at once to many (such as when # the server returns the per-session JID that # is of interest for most other components). Backplane("CONSOLE").activate() Backplane("JID").activate() # Used to inform components that the session is now active Backplane("BOUND").activate() # Used to inform components of the supported features Backplane("DISCO_FEAT").activate() sub = SubscribeTo("JID") self.link((sub, 'outbox'), (self, 'jid')) self.addChildren(sub) sub.activate() log = Logger(path=None, stdout=True, name='XmppLogger') Backplane('LOG_' + self.log_location).activate() Pipeline(SubscribeTo('LOG_' + self.log_location), log).activate() log_writable = WsgiLogWritable(self.log_location) log.activate() log_writable.activate() # We pipe everything typed into the console # directly to the console backplane so that # every components subscribed to the console # backplane inbox will get the typed data and # will decide it it's of concern or not. Pipeline(ConsoleReader(), PublishTo('CONSOLE')).activate() # Add two outboxes ro the ClientSteam to support specific extensions. ClientStream.Outboxes["%s.query" % XMPP_IBR_NS] = "Registration" ClientStream.Outboxes["%s.query" % XMPP_LAST_NS] = "Activity" ClientStream.Outboxes["%s.query" % XMPP_DISCO_INFO_NS] = "Discovery" self.client = ClientStream(self.jid, self.passwordLookup, use_tls=self.usetls) WsgiConfig ={ 'server_software' : "Example WSGI Web Server", 'server_admin' : "Jason Baker", 'wsgi_ver' : (1,0), } routing = [ ["/", SimpleWsgiFactory(log_writable, WsgiConfig, simple_app, '/simple')], ] #routing = [ ['/', Echoer]] self.graph = Graphline(client = self, console = SubscribeTo('CONSOLE'), logger = PublishTo('LOG_' + self.log_location), tcp = TCPClient(self.server, self.port), xmlparser = XMLIncrParser(), xmpp = self.client, streamerr = StreamError(), saslerr = SaslError(), discohandler = DiscoHandler(self.jid, self.domain), activityhandler = ActivityHandler(), rosterhandler = RosterHandler(self.jid), registerhandler = RegistrationHandler(self.username, self.password), msgdummyhandler = WebMessageHandler(), presencehandler = PresenceHandler(), presencedisp = PresenceDispatcher(), rosterdisp = RosterDispatcher(), msgdisp = MessageDispatcher(), discodisp = DiscoveryDispatcher(), activitydisp = ActivityDispatcher(), registerdisp = RegisterDispatcher(), pjid = PublishTo("JID"), pbound = PublishTo("BOUND"), proto_man = ProtocolManager(Protocol=HTTPProtocol(routing)), linkages = {('xmpp', 'terminated'): ('client', 'inbox'), ('console', 'outbox'): ('client', 'control'), ('client', 'forward'): ('xmpp', 'forward'), ('client', 'outbox'): ('tcp', 'inbox'), ('client', 'signal'): ('tcp', 'control'), ("tcp", "outbox") : ("xmlparser", "inbox"), ("xmpp", "starttls") : ("tcp", "makessl"), ("tcp", "sslready") : ("xmpp", "tlssuccess"), ("xmlparser", "outbox") : ("xmpp" , "inbox"), ("xmpp", "outbox") : ("tcp" , "inbox"), ("xmpp", "reset"): ("xmlparser", "reset"), ("client", "log"): ("logger", "inbox"), ("xmpp", "log"): ("logger", "inbox"), ("xmpp", "jid"): ("pjid", "inbox"), ("xmpp", "bound"): ("pbound", "inbox"), ("xmpp", "features"): ("client", "streamfeat"), ("client", "doauth"): ("xmpp", "auth"), # Registration ("xmpp", "%s.query" % XMPP_IBR_NS): ("registerdisp", "inbox"), ("registerdisp", "log"): ('logger', "inbox"), ("registerdisp", "xmpp.error"): ("registerhandler", "error"), ("registerdisp", "xmpp.result"): ("registerhandler", "inbox"), ("registerhandler", "outbox"): ("registerdisp", "forward"), ("client", "doregistration"): ("registerdisp", "forward"), ("registerdisp", "outbox"): ("xmpp", "forward"), # Presence ("xmpp", "%s.presence" % XMPP_CLIENT_NS): ("presencedisp", "inbox"), ("presencedisp", "log"): ('logger', "inbox"), ("presencedisp", "xmpp.subscribe"): ("presencehandler", "subscribe"), ("presencedisp", "xmpp.unsubscribe"): ("presencehandler", "unsubscribe"), ("presencehandler", "outbox"): ("presencedisp", "forward"), ("presencehandler", "roster"): ("rosterdisp", "forward"), ("presencedisp", "outbox"): ("xmpp", "forward"), # Roster ("xmpp", "%s.query" % XMPP_ROSTER_NS): ("rosterdisp", "inbox"), ("rosterdisp", "log"): ('logger', "inbox"), ('rosterdisp', 'xmpp.set'): ('rosterhandler', 'pushed'), ('rosterdisp', 'xmpp.result'): ('rosterhandler', 'inbox'), ('rosterhandler', 'result'): ('rosterdisp', 'forward'), ("rosterdisp", "outbox"): ("xmpp", "forward"), # Discovery ("xmpp", "%s.query" % XMPP_DISCO_INFO_NS): ("discodisp", "features.inbox"), ("discodisp", "log"): ('logger', "inbox"), ("discohandler", "features-disco"): ('discodisp', "features.forward"), ("discodisp", "out.features.result"): ('discohandler', "features.result"), ("discodisp", "outbox"): ("xmpp", "forward"), # Message ("xmpp", "%s.message" % XMPP_CLIENT_NS): ("msgdisp", "inbox"), ("msgdisp", "log"): ('logger', "inbox"), ("msgdisp", "xmpp.chat"): ('msgdummyhandler', 'inbox'), ("msgdummyhandler", "outbox"): ('msgdisp', 'forward'), ("msgdisp", "outbox"): ("xmpp", "forward"), ('msgdummyhandler', 'proto') : ('proto_man' , 'inbox'), ('proto_man', 'outbox') : ('msgdummyhandler', 'inbox'), # Activity ("xmpp", "%s.query" % XMPP_LAST_NS): ("activitydisp", "inbox"), ("activitydisp", "log"): ('logger', "inbox"), ("activitydisp", "outbox"): ("xmpp", "forward"), ("activityhandler", 'activity-supported'): ('rosterhandler', 'ask-activity'), ("rosterhandler", 'activity'): ('activitydisp', 'forward'), } ) self.addChildren(self.graph) self.graph.activate() return 1
#!/usr/bin/python from Kamaelia.Util.Backplane import Backplane, PublishTo, SubscribeTo from Kamaelia.Chassis.ConnectedServer import ServerCore from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Util.PureTransformer import PureTransformer Backplane( "CHAT").activate() # This handles the sharing of data between clients def ChatClient(*argc, **argd): peer = argd["peer"] peerport = argd["peerport"] return Pipeline( PureTransformer(lambda x: " %s:%s says %s" % (str(peer), str(peerport), str(x))), PublishTo("CHAT"), # Take data from client and publish to all clients # ---------------------- SubscribeTo("CHAT" ), # Take data from other clients and send to our client PureTransformer(lambda x: "Chat:" + str(x).strip() + "\n"), ) class ChatServer(ServerCore): protocol = ChatClient print "Chat server running on port 1501"
""" import Axon import time from Axon.Ipc import WaitComplete from Kamaelia.Chassis.Graphline import Graphline from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Util.Backplane import Backplane, SubscribeTo from Kamaelia.Util.TwoWaySplitter import TwoWaySplitter from Kamaelia.Util.Console import ConsoleEchoer from Kamaelia.Util.PureTransformer import PureTransformer from BackplaneTuner import TunableSubscriber, TunablePublisher locations = "holiday", "santasworkshop", "deliveringtoys", "study", "elfworkshop" for locale in locations: Backplane(locale).activate() debugging = 1 def tagger(tag): print "creating tag", tag return PureTransformer(lambda x: str((tag, x)) + "\n") def tagger2(tag): print "creating tag2", tag return PureTransformer(lambda x: (tag, x)) if debugging: