def NetworkLinkage(ip1, port1, ip2, port2): return Graphline(PIPE=Pipeline( TCPClient(ip1, port1), TCPClient(ip2, port2), ), linkages={ ("PIPE", "outbox"): ("PIPE", "inbox"), ("PIPE", "signal"): ("PIPE", "control"), })
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 Pop3Proxy(): return Graphline(SERVER=TCPClient(POP3SERVER_NAME, POP3SERVER_PORT), RELAY=Pop3CommandRelay(), LINESPLIT_CMDS=LineSplit(), LINESPLIT_RESP=LineSplit(), DELETION_STORE=SimpleCache(PERSISTENCE_STORE_FILENAME), linkages={ ("", "inbox"): ("LINESPLIT_CMDS", "inbox"), ("", "control"): ("LINESPLIT_CMDS", "control"), ("LINESPLIT_CMDS", "outbox"): ("RELAY", "inbox"), ("LINESPLIT_CMDS", "signal"): ("RELAY", "control"), ("RELAY", "toServer"): ("SERVER", "inbox"), ("RELAY", "toServerControl"): ("SERVER", "control"), ("SERVER", "outbox"): ("LINESPLIT_RESP", "inbox"), ("SERVER", "signal"): ("LINESPLIT_RESP", "control"), ("LINESPLIT_RESP", "outbox"): ("RELAY", "fromServer"), ("LINESPLIT_RESP", "signal"): ("RELAY", "fromServerSignal"), ("RELAY", "outbox"): ("", "outbox"), ("RELAY", "signal"): ("", "signal"), ("RELAY", "toStore"): ("DELETION_STORE", "inbox"), ("RELAY", "toStoreControl"): ("DELETION_STORE", "control"), ("DELETION_STORE", "outbox"): ("RELAY", "fromStore"), })
def start_task(self): from Axon.Introspector import Introspector from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Internet.TCPClient import TCPClient self.p = Pipeline(Introspector(), TCPClient(*self.visualiser_addr)) self.p.activate()
def EventServerClients(rhost, rport, whiteboardBackplane="WHITEBOARD", audioBackplane="AUDIO"): # plug a TCPClient into the backplane loadingmsg = "Fetching sketch from server..." return Graphline( # initial messages sent to the server, and the local whiteboard GETIMG = Pipeline( OneShot(msg=[["GETIMG"]]), tokenlists_to_lines() ), BLACKOUT = OneShot(msg="CLEAR 0 0 0\r\n" "WRITE 100 100 24 255 255 255 "+loadingmsg+"\r\n"), NETWORK = TCPClient(host=rhost,port=rport), APPCOMMS = clientconnector(whiteboardBackplane=whiteboardBackplane, audioBackplane=audioBackplane), linkages = { ("GETIMG", "outbox") : ("NETWORK", "inbox"), # Single shot out ("APPCOMMS", "outbox") : ("NETWORK", "inbox"), # Continuous out ("BLACKOUT", "outbox") : ("APPCOMMS", "inbox"), # Single shot in ("NETWORK", "outbox") : ("APPCOMMS", "inbox"), # Continuous in } )
def main(self): self.lagger = Lagger() self.irc = IRCBot("[kambot-logging]", "", "#kamaelia", "kamaeliabot") self.kambot = Kambot("[kambot-logging]", "#kamaelia") self.client = TCPClient("irc.freenode.net", 6667, 1) self.writer = DateNamedLogger( "/home/ryan/kamhttpsite/kamaelia/irc/", ".txt") # IRC <-> Kambot self.link((self.irc, "heard"), (self.kambot, "inbox")) self.link((self.kambot, "outbox"), (self.irc, "command")) # Kambot -> file writer self.link((self.kambot, "log"), (self.writer, "inbox")) # TCP <-> IRC self.link((self.irc, "outbox"), (self.client, "inbox")) self.link((self.client, "outbox"), (self.irc, "inbox")) self.addChildren(self.lagger, self.irc, self.kambot, self.client, self.writer) yield Axon.Ipc.newComponent(*(self.children)) while 1: self.pause() yield 1
def HTTPDataStreamingClient(fullurl, method="GET", body=None, headers={}, username=None, password=None, proxy=None): # NOTE: username not supported yet # NOTE: password not supported yet headers = dict(headers) proto, host, port, path = parse_url(fullurl) if username is not None and password is not None: (header_field, header_value) = http_basic_auth_header(username, password) headers[header_field] = header_value if proxy != None: request = fullurl _, req_host , req_port, _ = parse_url(proxy) else: request = path req_host , req_port = host, port return Pipeline( HTTPClientRequest(url=request, host=host, method=method, postbody=body, headers=headers), TCPClient(req_host, req_port, wait_for_serverclose=True), HTTPClientResponseHandler(suppress_header = True), ) # Leaving this here for a little while, since it is interesting/useful # Worth bearing in mind this next line will never execute return Pipeline( HTTPClientRequest(url=request, host=host, method=method, postbody=body, headers=headers), ComponentBoxTracer( TCPClient(req_host, req_port, wait_for_serverclose=True), Pipeline( PureFilter(lambda x: x[0] == "outbox"), # Only interested in data from the connection PureTransformer(lambda x: x[1]), # Just want the data from the wire PureTransformer(lambda x: base64.b64encode(x)+"\n"), # To ensure we capture data as chunked on the way in SimpleFileWriter("tweets.b64.txt"), # Capture for replay / debug ), ), ComponentBoxTracer( HTTPClientResponseHandler(suppress_header = True), Pipeline( PureFilter(lambda x: x[0] == "outbox"), # Only want the processed data here PureTransformer(lambda x: x[1]), # Only want the raw data SimpleFileWriter("tweets.raw.txt"), ), ) )
def _buildPublicProtocol(self): addr = getattr(self.publicServer.server,'lastAddr','127.0.0.1') if addr in self.allowed_addresses: print "Accepted public petition from: %s" % addr client = TCPClient( self.remote_server, port=self.remote_port ) protocol = _ProtocolForwarder() self.link((protocol, "fromsocket"), (client, "inbox")) self.link((client, "outbox"), (protocol, "tosocket")) self.link((client, "signal"), (protocol, "control")) client.activate() return protocol else: print "Rejected public petition from: %s" % addr return _NotAuthorizedProtocol()
def WebcamEventServerClients(rhost, rport, webcamBackplane="WEBCAM"): # plug a TCPClient into the backplane return Graphline( NETWORK=TCPClient(host=rhost, port=rport), APPCOMMS=clientconnectorwc(webcamBackplane=webcamBackplane), linkages={ ("APPCOMMS", "outbox"): ("NETWORK", "inbox"), # Continuous out ("NETWORK", "outbox"): ("APPCOMMS", "inbox"), # Continuous in })
def __init__(self, host, portnumber, delay = 0, workers = 5, debug = 1): JsonRPCBase.__init__(self, workers = workers, debug = debug) self.host = host self.portnumber = portnumber self.delay = delay self.client = Graphline( TCPCLIENT = TCPClient(self.host, self.portnumber, self.delay), PROTOCOL = self.jsonprotocol(), linkages = { ('TCPCLIENT', 'outbox') : ('PROTOCOL', 'inbox'), ('PROTOCOL', 'outbox') : ('TCPCLIENT', 'inbox'), ('TCPCLIENT', 'signal') : ('PROTOCOL', 'control'), ('PROTOCOL', 'signal') : ('TCPCLIENT', 'control'), } ) self.handle = Handle(self.client)
def main(self): import random port = self.port host = self.host # client = TCPClient(host,port) # clientProtocol = self.IRC_Handler(self.nick, self.nickinfo, self.defaultChannel) subsystem = Graphline(SELF=self, CLIENT=TCPClient(host, port), PROTO=self.IRC_Handler(self.nick, self.nickinfo, self.defaultChannel), linkages={ ("CLIENT", ""): ("CLIENT", ""), ("CLIENT", ""): ("PROTO", ""), ("PROTO", ""): ("CLIENT", ""), ("PROTO", ""): ("PROTO", ""), ("CLIENT", "outbox"): ("PROTO", "inbox"), ("PROTO", "outbox"): ("CLIENT", "inbox"), ("PROTO", "heard"): ("SELF", "outbox"), ("SELF", "inbox"): ("PROTO", "talk"), ("SELF", "topic"): ("PROTO", "topic"), ("SELF", "control"): ("PROTO", "control"), ("PROTO", "signal"): ("CLIENT", "control"), ("CLIENT", "signal"): ("SELF", "signal"), }) # self.link((client,"outbox"), (clientProtocol,"inbox")) # self.link((clientProtocol,"outbox"), (client,"inbox")) # # self.link((clientProtocol, "heard"), (self, "outbox"), passthrough=2) # self.link((self, "inbox"), (clientProtocol, "talk"), passthrough=1) # self.link((self, "topic"), (clientProtocol, "topic"), passthrough=1) # # self.link((self, "control"), (clientProtocol, "control"), passthrough=1) # self.link((clientProtocol, "signal"), (client, "control")) # self.link((client, "signal"), (self, "signal"), passthrough=2) # self.addChildren(subsystem) yield _Axon.Ipc.newComponent(*(self.children)) while 1: self.pause() yield 1
def clientRequest(rootip, rootport, myip, myport): servip, servport = rootip, rootport port = 0 while port == 0: l = LikeFile(TCPClient( servip, servport)) # "REQUEST connecting to ", servip, servport l.activate() l.send("REQCONNECT %s:%d" % (myip, myport)) resp_raw = l.recv() resp = resp_raw.split(" ") if resp[0] == "CONNECT": # "Connecting to", port port = int(resp[1]) ip = servip elif resp[ 0] == "REQCONNECT": #"REDIRECTED : request connecting to ", servip, servport servip, servport = resp[1].split(":") servport = int(servport) return servip, port # Resulting server ip/port we can connect to
def SimpleIRCClientPrefab(host='irc.freenode.net', port=6667): """\ SimpleIRCClientPrefab(...) -> IRC_Client connected to tcp via a Graphline. Routes its "inbox" to IRC_Client's "talk" and IRC_Client's "heard" to "outbox" Keyword arguments: - host -- the server to connect to. Default irc.freenode.net - port -- the port to connect on. Default 6667. """ client = Graphline(irc=IRC_Client(), tcp=TCPClient(host, port), linkages={ ("self", "inbox"): ("irc", "talk"), ("irc", "outbox"): ("tcp", "inbox"), ("tcp", "outbox"): ("irc", "inbox"), ("irc", "heard"): ("self", "outbox"), }) return client
def OSCARClient(server, port): """\ OSCARClient(server, port) -> returns an OSCARProtocol component connected to a TCPClient. User input goes into OSCARClient's "inbox" in the form (channel, flap body) and useable output comes out of "outbox" in the same form. """ return Graphline(oscar=OSCARProtocol(), tcp=TCPClient(server, port), linkages={ ("oscar", "outbox"): ("tcp", "inbox"), ("tcp", "outbox"): ("oscar", "inbox"), ("oscar", "signal"): ("tcp", "control"), ("self", "inbox"): ("oscar", "talk"), ("oscar", "heard"): ("self", "outbox"), ("self", "control"): ("oscar", "control"), ("tcp", "signal"): ("self", "signal"), })
def ComplexIRCClientPrefab(host="127.0.0.1", port=6667, nick="kamaeliabot", nickinfo="Kamaelia", defaultChannel="#kamaeliatest", IRC_Handler=IRC_Client): return Graphline( CLIENT=TCPClient(host, port), PROTO=IRC_Handler(nick, nickinfo, defaultChannel), SPLIT=Fanout(["toGraphline", "toTCP"]), linkages={ ("CLIENT", "outbox"): ("PROTO", "inbox"), ("PROTO", "outbox"): ("SPLIT", "inbox"), ("PROTO", "heard"): ("SELF", "outbox"), #passthrough ("SELF", "inbox"): ("PROTO", "talk"), #passthrough ("SELF", "control"): ("PROTO", "control"), #passthrough ("PROTO", "signal"): ("CLIENT", "control"), ("CLIENT", "signal"): ("SELF", "signal"), #passthrough ("SPLIT", "toGraphline"): ("SELF", "sendCopy"), #passthrough ("SPLIT", "toTCP"): ("CLIENT", "inbox") })
def SimpleIRCClientPrefab(host="127.0.0.1", port=6667, nick="kamaeliabot", nickinfo="Kamaelia", defaultChannel="#kamaeliatest", IRC_Handler=IRC_Client, Input_Handler=InputFormatter): return Graphline( CLIENT=TCPClient(host, port), PROTO=IRC_Handler(nick, nickinfo, defaultChannel), FORMAT=PureTransformer(Input_Handler), linkages={ ("CLIENT", "outbox"): ("PROTO", "inbox"), ("PROTO", "outbox"): ("CLIENT", "inbox"), ("PROTO", "heard"): ("SELF", "outbox"), #SELF refers to the Graphline. Passthrough linkage ("SELF", "inbox"): ("FORMAT", "inbox"), #passthrough ("FORMAT", "outbox"): ("PROTO", "talk"), ("SELF", "control"): ("PROTO", "control"), #passthrough ("PROTO", "signal"): ("CLIENT", "control"), ("CLIENT", "signal"): ("SELF", "signal"), #passthrough })
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"),
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)
#!/usr/bin/python # -*- coding: utf-8 -*- from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Util.Console import * # ------- START OF CODE FRAGMENT NEEDED TO CONNECT TO INTROSPECTOR ---- # Remember to start Kamaelia/Tools/AxonVisualiser before doing this. # cd Kamaelia/Tools # ./AxonVisualiser.py --port=1600 from Kamaelia.Util.Introspector import Introspector from Kamaelia.Internet.TCPClient import TCPClient Pipeline( Introspector(), TCPClient("127.0.0.1", 1600), ).activate() # ------- END OF CODE FRAGMENT NEEDED TO CONNECT TO INTROSPECTOR ---- Pipeline( ConsoleReader(), ConsoleEchoer(), ).run()
elif splitline[0] == "NICK": msg = string.join(splitline[1:], " ")[1:] msg = ( "NICK", linesender, splitline[1], msg ) self.send(msg, "heard") elif splitline[0] > '000' and splitline[0] < '300 else: self.pause() from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Chassis.Graphline import Graphline from Kamaelia.Util.Console import ConsoleReader, ConsoleEchoer host = 'irc.freenode.net' port = 6667 nick = 'ryans_irc_client' pwd = '' user = '******' if __name__ == '__main__': Graphline(irc = IRCClient(host, port, nick, pwd, user), tcp = TCPClient(host, port), out = ConsoleEchoer(), linkages = { ("irc", "outbox") : ("tcp", "inbox"), ("irc", "signal") : ("tcp", "control"), ("tcp", "outbox") : ("irc", "inbox"), ("tcp", "signal") : ("irc", "control"), ("irc", "heard") : ("out", "inbox") } ).run()
# This is a quick example of using kamaelia as a general tcp client in your system. host = "irc.freenode.net" port = 6667 import Axon.background import Axon.Handle import time import Queue from Kamaelia.Util.Console import ConsoleEchoer from Kamaelia.Internet.TCPClient import TCPClient Axon.background.background().start() print "what channel on freenode?" channel = raw_input(">>> ") # this is to prevent spammage of the default settings. client = Axon.Handle.Handle(TCPClient(host = host, port = port)).activate() time.sleep(1) client.put("user likefile likefile likefile :likefile\n","inbox") client.put("nick likefile\n","inbox") client.put("JOIN %s\n" % channel, "inbox") while True: try: print client.get("outbox") except Queue.Empty: time.sleep(0.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. # ------------------------------------------------------------------------- # # Simple test harness for integrating TCP clients and servers in one system, sharing selector components etc. # # import random from Kamaelia.Protocol.FortuneCookieProtocol import FortuneCookieProtocol from Kamaelia.Chassis.ConnectedServer import SimpleServer from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.Console import ConsoleEchoer from Kamaelia.Chassis.Pipeline import Pipeline from Kamaelia.Util.Introspector import Introspector # Start the introspector and connect to a local visualiser Pipeline( Introspector(), TCPClient("127.0.0.1", 1500), ).activate() clientServerTestPort = random.randint(1501, 1599) SimpleServer(protocol=FortuneCookieProtocol, port=clientServerTestPort).activate() Pipeline(TCPClient("127.0.0.1", clientServerTestPort), ConsoleEchoer()).run()
# 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. # a slightly more complicated example of a TCP client, where we define an echo. from Kamaelia.Chassis.ConnectedServer import SimpleServer from Kamaelia.Protocol.EchoProtocol import EchoProtocol from Kamaelia.Internet.TCPClient import TCPClient from Axon.likefile import LikeFile, schedulerThread import time schedulerThread(slowmo=0.01).start() PORT = 1900 # This starts an echo server in the background. SimpleServer(protocol=EchoProtocol, port=PORT).activate() # give the component time to commence listening on a port. time.sleep(0.5) echoClient = LikeFile(TCPClient(host="localhost", port=PORT)) while True: echoClient.put(raw_input(">>> ")) print echoClient.get()
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()
# 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()
if __name__ == '__main__': import sys raw_config = get_config_lines() C = parse_config(raw_config) # print config # C = default_config channel = "#kamaelia-test" Name = "kamaeliabot" pwd = None logdir = "." if len(sys.argv) > 1: channel = sys.argv[1] if len(sys.argv) > 2: Name = sys.argv[2] if len(sys.argv) > 3: pwd = sys.argv[3] from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Util.Introspector import Introspector from Kamaelia.Chassis.Pipeline import Pipeline Pipeline( Introspector(), TCPClient("127.0.0.1",1501) ).activate() print "Logging %s as %s" % (C["channel"], C["name"],) Logger(C["channel"], name=C["name"], host=C["host"], password=C["pwd"], logdir=C["logdir"], formatter=(lambda data: Kamaelia.Apps.IRCLogger.Support.HTMLOutformat(data)), filewriter = Kamaelia.Apps.IRCLogger.Support.LoggerWriter, ).run()
'lynx -dump -source >phrases.txt http://thwackety.com/phrases.txt' ).run() print "Got it!" f = open("phrases.txt") phrases = [line.strip() for line in f] f.close() pprint.pprint(phrases) username = sys.argv[1] password = sys.argv[2] server = sys.argv[3] port = int(sys.argv[4]) print "username ="******"password ="******"server =", server print "port =", repr(port) if 1: Graphline(RAWCLIENT=basicPop3Client(username=username, password=password), CLIENT=Pop3Client(phrases=phrases), SERVER=TCPClient(server, port), linkages={ ("CLIENT", "outbox"): ("RAWCLIENT", "client_inbox"), ("RAWCLIENT", "client_outbox"): ("CLIENT", "inbox"), ("RAWCLIENT", "outbox"): ("SERVER", "inbox"), ("SERVER", "outbox"): ("RAWCLIENT", "inbox"), ("RAWCLIENT", "signal"): ("SERVER", "control"), ("SERVER", "signal"): ("RAWCLIENT", "control"), }).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)
#!/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.Chassis.Pipeline import Pipeline from Kamaelia.Chassis.ConnectedServer import SimpleServer from Kamaelia.Internet.TCPClient import TCPClient from Kamaelia.Codec.Vorbis import VorbisDecode, AOAudioPlaybackAdaptor import Kamaelia.File.ReadFileAdaptor import random file_to_stream = "../SupportingMediaFiles/KDE_Startup_2.ogg" clientServerTestPort = random.randint(1500, 2000) print "Client Server demo running on port", clientServerTestPort def AdHocFileProtocolHandler(filename): class klass(Kamaelia.File.ReadFileAdaptor.ReadFileAdaptor): def __init__(self, *argv, **argd): super(klass, self).__init__(filename, readmode="bitrate", bitrate=128000) return klass server = SimpleServer(protocol=AdHocFileProtocolHandler(file_to_stream), port=clientServerTestPort).activate() Pipeline(TCPClient("127.0.0.1", clientServerTestPort), VorbisDecode(), AOAudioPlaybackAdaptor()).run()