def run():
options = parse_commandline()
from bucker.provider.memcached import MemcachedQueue
servers = options.servers.split(',')
ip, port = options.id_generator.split(':')
queue = MemcachedQueue(servers=servers, queue_list_name=options.queue,
id_gen_address=(ip, int(port)))
logger = None
if options.logger_path:
from bucker.lib.logger import Logger
logger = Logger(options.logger_path, False)
queue.set_logger(logger)
MemcachedQueue.setService(queue)
queue.activate()
from bucker.provider.memcached import MemcachedQueueProtocol
from Kamaelia.Chassis.ConnectedServer import SimpleServer
def make_protocol():
mqp = MemcachedQueueProtocol()
if logger:
mqp.set_logger(logger)
return mqp
s = SimpleServer(protocol=make_protocol, port=9876)
s.run()
def main(self):
#Create something to listen for a connection
#Create something to give you files
#Bolt them together
#Go!
server = SimpleServer(protocol=self.localFileServerFactory, port=8042)
server.activate()
scheduler.run.runThreads()
def main(self):
#Create something to listen for a connection
#Create something to give you files
#Bolt them together
#Go!
server = SimpleServer( protocol = self.localFileServerFactory, port = 8042)
server.activate()
scheduler.run.runThreads()
def run():
from bucker.lib.midgen import MessageIdService, MessageIdProtocol
service, shutdownservice, serv = MessageIdService.getService()
serv.activate()
def make_protocol():
return MessageIdProtocol()
from Kamaelia.Chassis.ConnectedServer import SimpleServer
s = SimpleServer(protocol=make_protocol, port=9877)
s.run()
def __init__(self):
super(testHarness,self).__init__()
self.serverport = 4444
self.server = SimpleServer(protocol=FortuneCookieProtocol, port=self.serverport)
self.client = None
self.display = ConsoleEchoer()
self.displayerr = ConsoleEchoer()
def LocalEventServer(whiteboardBackplane="WHITEBOARD",
audioBackplane="AUDIO",
port=1500):
def configuredClientConnector():
return clientconnector(whiteboardBackplane=whiteboardBackplane,
audioBackplane=audioBackplane,
port=port)
return SimpleServer(protocol=clientconnector, port=port)
def LocalEventServer(whiteboardBackplane="WHITEBOARD",
audioBackplane="AUDIO",
port=1500):
from Kamaelia.Chassis.ConnectedServer import SimpleServer
from Kamaelia.Util.Console import ConsoleEchoer
def clientconnector():
return Pipeline(
chunks_to_lines(),
lines_to_tokenlists(),
Graphline(
WHITEBOARD=FilterAndTagWrapper(
Pipeline(
publishTo(whiteboardBackplane),
# well, should be to separate pipelines, this is lazier!
subscribeTo(whiteboardBackplane),
)),
AUDIO=Pipeline(
SimpleDetupler(1), # remove 'SOUND' tag
SpeexDecode(3),
FilterAndTagWrapperKeepingTag(
Pipeline(
publishTo(audioBackplane),
# well, should be to separate pipelines, this is lazier!
subscribeTo(audioBackplane),
), ),
RawAudioMixer(),
SpeexEncode(3),
Entuple(prefix=["SOUND"], postfix=[]),
),
ROUTER=Router(
((lambda tuple: tuple[0] == "SOUND"), "audio"),
((lambda tuple: tuple[0] != "SOUND"), "whiteboard"),
),
linkages={
# incoming messages go to a router
("", "inbox"): ("ROUTER", "inbox"),
# distribute messages to appropriate destinations
("ROUTER", "audio"): ("AUDIO", "inbox"),
("ROUTER", "whiteboard"): ("WHITEBOARD", "inbox"),
# aggregate all output
("AUDIO", "outbox"): ("", "outbox"),
("WHITEBOARD", "outbox"): ("", "outbox"),
# shutdown routing, not sure if this will actually work, but hey!
("", "control"): ("ROUTER", "control"),
("ROUTER", "signal"): ("AUDIO", "control"),
("AUDIO", "signal"): ("WHITEBOARD", "control"),
("WHITEBOARD", "signal"): ("", "signal")
},
),
tokenlists_to_lines(),
)
return SimpleServer(protocol=clientconnector, port=port)
def __init__(self):
super(testHarness, self).__init__(
) # I wonder if this can get forced to be called automagically?
import random
self.serverport = random.randint(4000, 8000)
self.server = SimpleServer(protocol=FortuneCookieProtocol,
port=self.serverport)
self.client = None
self.display = ConsoleEchoer()
def run():
options = parse_commandline()
from Kamaelia.Chassis.ConnectedServer import SimpleServer
from bucker.lib.logger import Logger
logger = None
if options.logger_path:
from bucker.lib.logger import Logger
logger = Logger(options.logger_path, True)
from bucker.api.bus import MessageManagerServer, MessageManagerProtocol
ip, port = options.server.split(":")
mgr = MessageManagerServer(qs_host=ip, qs_port=int(port))
if logger:
mgr.set_logger(logger)
MessageManagerServer.setService(mgr)
mgr.activate()
m = SimpleServer(protocol=MessageManagerProtocol, port=9875)
m.run()
def run():
options = parse_commandline()
from bucker.lib.logger import Logger
logger = None
if options.logger_path:
from bucker.lib.logger import Logger
logger = Logger(options.logger_path, True)
from Kamaelia.Chassis.ConnectedServer import SimpleServer
from bucker.api.bus import ServiceBusServer, ServiceBusProtocol
ip, port = options.server.split(':')
queues = [unicode(q) for q in options.queues.split(',')]
server = ServiceBusServer(queues=queues, host=ip, port=int(port),
manager_host='127.0.0.1', manager_port=9875)
if logger:
server.set_logger(logger)
ServiceBusServer.setService(server)
server.activate()
s = SimpleServer(protocol=ServiceBusProtocol, port=9888)
s.run()
def LocalEventServer(backplane="WHITEBOARD", port=1500):
from Kamaelia.Chassis.ConnectedServer import SimpleServer
from Kamaelia.Util.Console import ConsoleEchoer
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(),
)
return SimpleServer(protocol=clientconnector, port=serveport)
# 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.
# -------------------------------------------------------------------------
"""\
========================
HTTP Server
========================
The fundamental parts of a webserver - an HTTP request parser and a request
handler/response generator. One instance of this component can handle one
TCP connection. Use a SimpleServer or similar component to allow several
concurrent HTTP connections to the server.
Example Usage
-------------
SimpleServer(protocol=lambda : HTTPServer(
HTTPResourceGlue.createRequestHandler, port=80).run()
"lambda : HTTPServer(HTTPResourceGlue.createRequestHandler)" is the
#
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()
def initialiseComponent(self):
"""\
Initialises component. Sets up a ReadFileAdapter to read in the contents
of an audio file at 95.2kbit/s and wires it to fire the contents out
"""
myDataSource = ReadFileAdaptor(command="./afortune.pl",
readmode="bitrate",
bitrate=95200,
chunkrate=25)
assert self.debugger.note(
"AudioCookieProtocol.initialiseComponent", 1,
"Initialising AudioCookieProtocol protocol handler ", self.name)
self.link(source=(myDataSource, "outbox"),
sink=(self, "outbox"),
passthrough=2)
self.addChildren(myDataSource)
return newComponent(myDataSource)
def mainBody(self):
"""Main body - sits and waits, as ReadFileAdapter is getting on with the work for us"""
return 1
__kamaelia_components__ = (AudioCookieProtocol, )
if __name__ == '__main__':
from Kamaelia.Chassis.ConnectedServer import SimpleServer
SimpleServer(protocol=AudioCookieProtocol, port=1500).run()
If any message is received on its "control" inbox, the component passes the message
onto its "signal" outbox and terminates.
"""
from Axon.Component import component
class EchoProtocol(component):
"""\
EchoProtocol() -> new EchoProtocol component
Simple component that copies anything sent to its "inbox" inbox to its "outbox"
outbox.
"""
def main(self):
while not self.dataReady("control"):
for message in self.Inbox("inbox"):
self.send(message, "outbox")
if not self.anyReady():
self.pause()
yield 1
self.send(self.recv("control"), "signal")
__kamaelia_components__ = (EchoProtocol, )
if __name__ == '__main__':
from Kamaelia.Chassis.ConnectedServer import SimpleServer
SimpleServer(protocol=EchoProtocol, port=1501).run()
self.addChildren(myDataSource)
assert self.debugger.note("FortuneCookieProtocol.main", 1, self.name,
"Added Child", myDataSource)
return newComponent(myDataSource)
def mainBody(self):
"""\
Main body.
All the interesting work has been done by linking the file reader's output
to our output. Messages sent to control are unchecked and the first
message causes the component to exit.
"""
self.pause()
while self.dataReady("control"):
data = self.recv("control")
self.send(data, "signal")
return 0
assert self.debugger.note("FortuneCookieProtocol.main", 10, self.name,
"Main Loop")
return 1
__kamaelia_components__ = (FortuneCookieProtocol, )
if __name__ == '__main__':
from Kamaelia.Chassis.ConnectedServer import SimpleServer
SimpleServer(protocol=FortuneCookieProtocol, port=1500).run()
return newComponent( myDataSource )
def handleDataIn(self):
if self.dataReady("datain"):
data = self.recv("datain")
if self.debug:
sys.stdout.write(data)
self.send(data,"outbox")
return 1
def handleInbox(self):
if self.dataReady("inbox"):
data = self.recv("inbox")
self.send(data,"outbox")
return 1
def mainBody(self):
self.handleDataIn()
self.handleInbox()
return 1
__kamaelia_components__ = ( HelloServer, )
if __name__ == '__main__':
SimpleServer(protocol=HelloServer, port=5222).activate()
# HelloServer(debug = 1).activate()
scheduler.run.runThreads(slowmo=0)
self.disconnectResourceHandler()
self.debug("sendEnd")
if lengthMethod == "close" or connection.lower() == "close":
self.send(producerFinished(), "signal") #this functionality is semi-complete
return
self.updateShouldShutdown()
if self.ssCode > 0:
return
self.pause()
__kamaelia_components__ = ( HTTPServer, HTTPRequestHandler, )
if __name__ == '__main__':
import socket
from Kamaelia.Chassis.ConnectedServer import SimpleServer
# this works out what the correct response to a request is
from Kamaelia.Community.RJL.Kamaelia.Protocol.HTTP.HTTPResourceGlue import createRequestHandler
def createhttpserver():
return HTTPServer(createRequestHandler)
SimpleServer(
protocol=createhttpserver,
port=8082,
socketOptions=(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
).run()
def main(self):
while 1:
self.send(("ballpos", self.x,self.y), "outbox")
self.moveball()
time.sleep(0.04)
Backplane("GameEvents").activate()
if sys.argv[1] == "server":
def ClientProtocol():
return Pipeline(
SubscribeTo("GameEvents"),
PureTransformer(lambda x : "|".join([str(y) for y in x])+"X")
)
SimpleServer(port=1601, protocol=ClientProtocol).activate()
Pipeline(
GameModel(),
PublishTo("GameEvents"),
).activate()
else:
B = ""
def unmarshall(x):
global B
B = B+x
if B.find("X") != -1:
L = B[:B.find("X")]
B = B[B.find("X")+1:]
L = L.split("|")
def mkTCPClient(args):
return TCPClient(*args)
#
#\-----------------------------------------------------------------
#/-----------------------------------------------------------------
# So we can handle requests for our control port for building
# the mesh
#
def mySwarmer():
return SimpleSwarm(mydataport)
SimpleServer(protocol=mySwarmer, port=mycontrolport).activate()
#
#\-----------------------------------------------------------------
#/-----------------------------------------------------------------
# Mechanism to allow the audio data to be shared to all clients
#
Backplane("RADIO").activate()
#
#\-----------------------------------------------------------------
#/-----------------------------------------------------------------
# The client portion of the P2P swarm
#
Graphline(
CONFIGURE=ConnectToSwarm(rootip, rootcontrolport, myip, mycontrolport),
SERVERPORT = 1500
def MultiFileReaderProtocol(filenames, bitrate, chunksizebytes):
def protocolFactory(*argv, **argd):
return JoinChooserToCarousel(
ForwardIteratingChooser(filenames),
FixedRateControlledReusableFileReader(readmode="bytes",
rate=bitrate/8,
chunksize=chunksizebytes)
)
return protocolFactory
if __name__ == '__main__':
from Axon.Scheduler import scheduler
filereader = MultiFileReaderProtocol( FILES_TO_STREAM, BITRATE, CHUNKSIZEBYTES)
server = SimpleServer( protocol = filereader, port = SERVERPORT ).activate()
if 0:
from Kamaelia.Internet.TCPClient import TCPClient
from Kamaelia.Util.Introspector import Introspector
pipeline(Introspector(), TCPClient("127.0.0.1",1501)).activate()
scheduler.run.runThreads(slowmo=0)
# data port - connecting to here gets you the data. Its good form
# to ask on the control port first if you can connect there.
#
# As a result that's why there's two SimpleServer instances.
#
import Axon
from Kamaelia.Chassis.ConnectedServer import SimpleServer
from Kamaelia.Internet.TCPClient import TCPClient
from likefile import *
background = schedulerThread().start()
class Echo(Axon.Component.component):
def main(self):
while 1:
while self.dataReady("inbox"):
self.send(self.recv("inbox"), "outbox")
yield 1
SimpleServer(protocol=Echo, port=1600).activate()
time.sleep(1)
#
# We can then write code here to demo the use of likefile with TCPClient.
#
"Bye."
]
def main(self):
message_from_server = None
i = 0
while message_from_server != "Bye.":
yield self.waitinbox()
message_from_server = self.recv("inbox")
print "MESSAGE FROM SERVER:", message_from_server
if message_from_server != "Bye.":
self.send(self.myscript[i], "outbox")
i = i+1
self.send(Axon.Ipc.producerFinished(), "signal")
SimpleServer(protocol = MyServer, port = 1500).activate()
Graphline(
HANDLER = MyClient(),
CONNECTION = TCPClient("127.0.0.1", 1500),
linkages = {
# Data from the handler to the network connection (ie to the server)
("HANDLER", "outbox") : ("CONNECTION", "inbox"),
("HANDLER", "signal") : ("CONNECTION", "control"),
# Data from the network connection back to the handler (ie from the server)
("CONNECTION","outbox") : ("HANDLER","inbox"),
("CONNECTION","signal") : ("HANDLER","control"),
}
).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()
#
# 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 Kamaelia.Chassis.ConnectedServer import SimpleServer
from Kamaelia.Protocol.FortuneCookieProtocol import FortuneCookieProtocol
from Axon.Ipc import shutdownMicroprocess
from Axon.Component import component
import time
class TerminatingProtocol(component):
"""runs for one second"""
def main(self):
lasttime = time.time()
life = 1 #runs for 1 seconds
while time.time() < lasttime + life:
yield 1
if self.dataReady():
print self.recv()
self.send(shutdownMicroprocess(), "signal") #close the socket
print "shutdownMicroprocess sent"
yield 1
port = 50000
SimpleServer(protocol=TerminatingProtocol, port=port).run()
hostname = "localhost"
locallist = ["ronline.no-ip.info", "localhost"]
localdict = listToDict(locallist)
uniqueid = UniqueId().activate()
deliveryqueueone = DeliveryQueueOne().activate()
deliveryqueuetwo = DeliveryQueueTwo(localdict=localdict).activate()
localdelivery = LocalDelivery(deliveryqueuedir="received",
localmaildir="local").activate()
remotedelivery = RemoteDelivery().activate()
deliveryqueueone.link((deliveryqueueone, "outbox"),
(deliveryqueuetwo, "inbox"))
deliveryqueuetwo.link((deliveryqueuetwo, "local"),
(localdelivery, "inbox"))
deliveryqueuetwo.link((deliveryqueuetwo, "remote"),
(localdelivery, "inbox"))
SMTPServerProtocol = lambda: SMTPServer(hostname="localhost",
storagequeue=deliveryqueueone,
localdict=localdict,
uniqueidservice=uniqueid,
funccreateinterface=
DeliveryQueueOneInterface)
SimpleServer(protocol=SMTPServerProtocol,
port=8025,
socketOptions=(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)).activate()
scheduler.run.runThreads(slowmo=0)
FILES_TO_STREAM = [shortfile, shortfile,
shortfile] # [ file_to_stream, file_to_stream2 ]
BITRATE = 800000 # 38000
CHUNKSIZEBYTES = 512
SERVERPORT = 1500
def MultiFileReaderProtocol(filenames, bitrate, chunksizebytes):
def protocolFactory(*argv, **argd):
return JoinChooserToCarousel(
ForwardIteratingChooser(filenames),
FixedRateControlledReusableFileReader(readmode="bytes",
rate=bitrate / 8,
chunksize=chunksizebytes))
return protocolFactory
if __name__ == '__main__':
filereader = MultiFileReaderProtocol(FILES_TO_STREAM, BITRATE,
CHUNKSIZEBYTES)
if 0:
from Kamaelia.Internet.TCPClient import TCPClient
from Kamaelia.Util.Introspector import Introspector
Pipeline(Introspector(), TCPClient("127.0.0.1", 1501)).activate()
server = SimpleServer(protocol=filereader, port=SERVERPORT).run()
# 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()
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"),
})
SimpleServer(protocol=Pop3Proxy, port=PROXYSERVER_PORT).run()
nlnl = '\n', '\n'
key = nlnl
def new_key(key, word):
if word == '\n': return nlnl
else: return (key[1], word)
class Chatty(Axon.Component.component):
data = {}
def updateChain(self, message):
key = nlnl
for word in message.split():
self.__class__.data.setdefault(key, []).append(word)
key = new_key(key, word)
def response(self):
key, result, word = nlnl, [], None
while word != "\n":
word = random.choice(self.__class__.data.get(key, nlnl))
key = new_key(key, word)
result.append(word)
return " ".join(result)
def main(self):
while 1:
if self.dataReady("inbox"):
message = self.recv("inbox")
self.updateChain(message)
self.send(self.response(), "outbox")
yield 1
SimpleServer(protocol=Chatty, port=1500).run()
self.send(footer, "outbox")
yield 1
# and shutdown nicely
self.send(Axon.Ipc.producerFinished(self), "signal")
yield 1
def EchoHandler(request):
return Pipeline(Cat(request), ExampleWrapper())
def servePage(request):
return Minimal(request=request,
homedirectory=homedirectory,
indexfilename=indexfilename)
def HTTPProtocol():
return HTTPServer(
requestHandlers([
["/echo", EchoHandler],
["/hello", HelloHandler],
["/", servePage],
]))
SimpleServer(protocol=HTTPProtocol,
port=8082,
socketOptions=(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)).run()
def LocalWebcamEventServer(webcamBackplane="WEBCAM", port=1501):
def configuredClientConnector():
return clientconnectorwc(webcamBackplane=webcamBackplane, port=port)
return SimpleServer(protocol=clientconnectorwc, port=port)
def LocalWebcamEventServer(webcamBackplane="WEBCAM", port=1501):
# Sets up the webcam server in a similar way to the one used for images and audio
def configuredClientConnector():
return clientconnectorwc(webcamBackplane=webcamBackplane, port=port)
return SimpleServer(protocol=clientconnectorwc, port=port)
