def test_renderIProtocol(self):
"""
If the protocol returned by C{lookupProtocol} isn't a
C{WebSocketsProtocol}, L{WebSocketsResource} wraps it automatically
with L{WebSocketsProtocolWrapper}.
"""
def lookupProtocol(names, otherRequest):
return AccumulatingProtocol(), None
self.resource = WebSocketsResource(lookupProtocol)
request = DummyRequest("/")
request.requestHeaders = Headers()
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
request.transport = transport
request.headers.update({
"upgrade": "Websocket",
"connection": "Upgrade",
"sec-websocket-key": "secure",
"sec-websocket-version": "13"
})
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertIsInstance(transport.protocol, WebSocketsProtocolWrapper)
self.assertIsInstance(transport.protocol.wrappedProtocol,
AccumulatingProtocol)
def setUp(self):
class SavingEchoFactory(Factory):
def buildProtocol(oself, addr):
return self.echoProtocol
factory = SavingEchoFactory()
self.echoProtocol = WebSocketsProtocol(SavingEchoReceiver())
self.resource = WebSocketsResource(lookupProtocolForFactory(factory))
class ChatFactory(Factory):
protocol = MyChat
clients = []
resource = WebSocketsResource(lookupProtocolForFactory(ChatFactory()))
root = Resource()
#serve chat protocol on /ws
root.putChild("ws",resource)
application = service.Application("chatserver")
#run a TCP server on port 1025, serving the chat protocol.
internet.TCPServer(1025, Site(root)).setServiceParent(application)
def run():
factory = serverFactoryProtocol()
reactor.listenTCP(TCP_PORT, factory)
# Config HTTP
from http import app
from twisted.web.wsgi import WSGIResource
resource = WSGIResource(reactor, reactor.getThreadPool(), app)
reactor.listenTCP(HTTP_PORT, Site(resource))
# Config Websocket
ws_resource = WebSocketsResource(lookupProtocolForFactory(factory))
reactor.listenTCP(WEBSOCKET_PORT, Site(ws_resource))
reactor.run()
def test_renderProtocol(self):
"""
If protocols are specified via the C{Sec-WebSocket-Protocol} header,
L{WebSocketsResource} passes them to its C{lookupProtocol} argument,
which can decide which protocol to return, and which is accepted.
"""
def lookupProtocol(names, otherRequest):
self.assertEqual(["foo", "bar"], names)
self.assertIdentical(request, otherRequest)
return self.echoProtocol, "bar"
self.resource = WebSocketsResource(lookupProtocol)
request = DummyRequest("/")
request.requestHeaders = Headers(
{"sec-websocket-protocol": ["foo", "bar"]})
transport = StringTransportWithDisconnection()
transport.protocol = Protocol()
request.transport = transport
request.headers.update({
"upgrade": "Websocket",
"connection": "Upgrade",
"sec-websocket-key": "secure",
"sec-websocket-version": "13"
})
result = self.resource.render(request)
self.assertEqual(NOT_DONE_YET, result)
self.assertEqual(
{
"connection": "Upgrade",
"upgrade": "WebSocket",
"sec-websocket-protocol": "bar",
"sec-websocket-accept": "oYBv54i42V5dw6KnZqOFroecUTc="
}, request.outgoingHeaders)
self.assertEqual([""], request.written)
self.assertEqual(101, request.responseCode)
if coo[0] == "x":
self.p.do_pan(int(coo[1]))
print "Update X=%s" % coo[1]
if coo[0] == "y":
self.p.do_tilt(int(coo[1]))
print "Update Y=%s" % coo[1]
self.factory.messages[float(time.time())] = data
self.updateClients(data)
def updateClients(self, data):
for c in self.factory.clients:
c.message(data)
def message(self, message):
self.transport.write(message + '\n')
class ChatFactory(Factory):
protocol = WebsocketChat
clients = []
messages = {}
resource = WebSocketsResource(lookupProtocolForFactory(ChatFactory()))
root = Resource()
#serve chat protocol on /ws
root.putChild("ws", resource)
application = service.Application("chatserver")
#run a TCP server on port 1025, serving the chat protocol.
internet.TCPServer(1025, Site(root)).setServiceParent(application)
from twisted_share.wsgi import WsgiRoot
from twisted.python.threadpool import ThreadPool
from django.core.handlers.wsgi import WSGIHandler
# Environment setup for your Django project files:
#sys.path.append("cib_simulator")
sys.path.append("gameMT")
os.environ['DJANGO_SETTINGS_MODULE'] = 'gameMT.settings'
shared_messages = {}
resource = HttpShare(shared_messages)
factory = Site(resource)
ws_resource = WebSocketsResource(lookupProtocolForFactory(resource.wsFactory))
#Create a resource which will correspond to the root of the URL hierarchy: all URLs are children of this resource.
root = Resource()
root.putChild("",resource) #the http protocol is up at /
root.putChild("ws",ws_resource) #the websocket protocol is at /ws
# Twisted Application Framework setup:
application = service.Application("shareserver")
#This is the port for pass messages
internet.TCPServer(1035, Site(root)).setServiceParent(application)
#serving django over wsgi
# Create and start a thread pool,
wsgiThreadPool = ThreadPool()
def getChild(self, name, request):
factory = self.factories.get(name)
if not factory:
factory = self.wsFactory(name)
self.factories[name] = factory
return WebSocketsResource(lookupProtocolForFactory(factory))
