class BaseUnitTest(unittest.TestCase):
path = ['']
def setUp(self):
self.site = SockJSFactory(EchoFactory())
self.request = Request(self.path)
@inlineCallbacks
def _load(self):
self.resource = self.site.getResourceFor(self.request)
yield self._render(self.resource, self.request)
def _render(resource, request):
result = resource.render(request)
if isinstance(result, str):
request.write(result)
request.finish()
return succeed(None)
elif result is server.NOT_DONE_YET:
if request.finished:
return succeed(None)
else:
return request.notifyFinish()
else:
raise ValueError("Unexpected return value: %r" % (result,))
class BaseUnitTest(unittest.TestCase):
path = ['']
def setUp(self):
self.site = SockJSFactory(EchoFactory())
self.request = Request(self.path)
@inlineCallbacks
def _load(self):
self.resource = self.site.getResourceFor(self.request)
yield self._render(self.resource, self.request)
def _render(resource, request):
result = resource.render(request)
if isinstance(result, str):
request.write(result)
request.finish()
return succeed(None)
elif result is server.NOT_DONE_YET:
if request.finished:
return succeed(None)
else:
return request.notifyFinish()
else:
raise ValueError("Unexpected return value: %r" % (result, ))
def server_setup(port):
f = SockJSFactory(Factory.forProtocol(TwistedChatConnection))
reactor.listenTCP(port, f)
os.system('open static/index_twisted.html')
reactor.run()
def run_server():
print("Readying Reactor")
factory = protocol.ServerFactory()
factory.protocol = ChatProtocol
factory.clients = []
reactor.listenSSL(
1025, SockJSFactory(factory, options),
ssl.DefaultOpenSSLContextFactory(SSL_KEY_PATH, SSL_CERT_PATH))
reactor.run()
def setUp(self):
self.site = SockJSFactory(EchoFactory())
self.request = Request(self.path)
def makeService(config):
from django.core.handlers.wsgi import WSGIHandler
os.environ['DJANGO_SETTINGS_MODULE'] = 'lisa.server.web.weblisa.settings'
if config['configuration']:
ConfigManagerSingleton.get().setConfiguration(config['configuration'])
configuration = ConfigManagerSingleton.get().getConfiguration()
dir_path = ConfigManagerSingleton.get().getPath()
from lisa.server import libs
# Creating MultiService
multi = service.MultiService()
pool = threadpool.ThreadPool()
tps = ThreadPoolService(pool)
tps.setServiceParent(multi)
# Creating the web stuff
resource_wsgi = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler())
root = static.File('/'.join([dir_path, 'web/frontend/build']))
backendsrc = libs.Root(resource_wsgi)
root.putChild("backend", backendsrc)
staticrsrc = static.File('/'.join([dir_path, 'web/interface/static']))
root.putChild("static", staticrsrc)
socketfactory = SockJSFactory(Factory.forProtocol(libs.WebSocketProtocol))
root.putChild("websocket", socketfactory)
# Configuring servers to launch
if configuration['enable_secure_mode'] or configuration[
'enable_unsecure_mode']:
if configuration['enable_secure_mode']:
SSLContextFactoryEngine = ssl.DefaultOpenSSLContextFactory(
os.path.normpath(dir_path + '/' +
'configuration/ssl/server.key'),
os.path.normpath(dir_path + '/' +
'configuration/ssl/server.crt'))
SSLContextFactoryWeb = ssl.DefaultOpenSSLContextFactory(
os.path.normpath(dir_path + '/' +
'configuration/ssl/server.key'),
os.path.normpath(dir_path + '/' +
'configuration/ssl/server.crt'))
ctx = SSLContextFactoryEngine.getContext()
ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
libs.verifyCallback)
# Since we have self-signed certs we have to explicitly
# tell the server to trust them.
with open(
os.path.normpath(dir_path + '/' +
'configuration/ssl/server.pem'),
'w') as outfile:
for file in os.listdir(
os.path.normpath(dir_path + '/' +
'configuration/ssl/public/')):
with open(
os.path.normpath(dir_path + '/' +
'configuration/ssl/public/' +
file)) as infile:
for line in infile:
outfile.write(line)
ctx.load_verify_locations(
os.path.normpath(dir_path + '/' +
'configuration/ssl/server.pem'))
internet.SSLServer(configuration['lisa_web_port_ssl'],
server.Site(root),
SSLContextFactoryWeb).setServiceParent(multi)
internet.SSLServer(configuration['lisa_engine_port_ssl'],
libs.LisaFactorySingleton.get(),
SSLContextFactoryEngine).setServiceParent(multi)
if configuration['enable_unsecure_mode']:
# Serve it up:
internet.TCPServer(configuration['lisa_web_port'],
server.Site(root)).setServiceParent(multi)
internet.TCPServer(
configuration['lisa_engine_port'],
libs.LisaFactorySingleton.get()).setServiceParent(multi)
configuration['enable_cloud_mode'] = True
#if configuration['enable_cloud_mode']:
# portforward.ProxyClient.dataReceived = client_dataReceived
# portforward.ProxyServer.dataReceived = server_dataReceived
# reactor.listenTCP(1080, portforward.ProxyFactory('localhost', 8000))
else:
exit(1)
libs.scheduler.setServiceParent(multi)
multi.setServiceParent(application)
libs.Initialize()
return multi
def setUp(self):
self.site = SockJSFactory(EchoFactory())
class FactoryUnitTest(BaseUnitTest):
valid_sessions = (['a','a'],['_','_'],['1','1'],['abcdefgh_i-j%20','abcdefgh_i-j%20'])
invalid_sessions = (['',''],['a.','a'],['a','a.'],['.','.'],[''],['','',''])
def setUp(self):
self.site = SockJSFactory(EchoFactory())
def _test(self, path, resource):
req = Request("OPTIONS", path)
# Also tests that OPTIONS requests don't produce upstream connections
res = self.site.getResourceFor(req)
self.assertTrue(isinstance(res, resource))
def _test_wrapper(self, path, resource):
for s in self.valid_sessions:
self._test(s + [path], resource)
self._test(s + [path,''], NoResource)
for s in self.invalid_sessions:
self._test(s + [path], NoResource)
self._test(s + [path,''], NoResource)
def test_greeting(self):
self._test([], SockJSResource)
self._test([''], SockJSResource)
def test_info(self):
self._test(['info'], Info)
self._test(['info',''], NoResource)
def test_iframe(self):
self._test(['iframe.html'], IFrame)
self._test(['iframe-a.html'], IFrame)
self._test(['iframe-.html'], IFrame)
self._test(['iframe-0.1.2.html'], IFrame)
self._test(['iframe-0.1.2abc-dirty.2144.html'], IFrame)
self._test(['iframe.htm'], NoResource)
self._test(['iframe'], NoResource)
self._test(['IFRAME.HTML'], NoResource)
self._test(['IFRAME'], NoResource)
self._test(['iframe.HTML'], NoResource)
self._test(['iframe.xml'], NoResource)
self._test(['iframe-','.html'], NoResource)
def test_rawwebsocket(self):
self._test(['websocket'], RawWebSocket)
self._test(['websocket',''], RawWebSocket)
def test_websocket(self):
self._test_wrapper('websocket', WebSocket)
def test_eventsource(self):
self._test_wrapper('eventsource', EventSource)
def test_htmlfile(self):
self._test_wrapper('htmlfile', HTMLFile)
def test_xhr_stream(self):
self._test_wrapper('xhr_streaming', XHRStream)
def test_xhr(self):
self._test_wrapper('xhr', XHR)
def test_jsonp(self):
self._test_wrapper('jsonp', JSONP)
def test_xhr_send(self):
self._test_wrapper('xhr_send', XHRSend)
def test_jsonp_send(self):
self._test_wrapper('jsonp_send', JSONPSend)
def test_invalid_endpoint(self):
self._test(['a','a','a'], NoResource)
def test_nonexistant_session_write(self):
req = Request("POST", ['a','a','xhr_send'])
res = self.site.getResourceFor(req)
self.assertTrue(isinstance(res, NoResource))
def test_ignore_server_id(self):
# Open session
req = Request("POST", ['000','a','xhr'])
res = self.site.getResourceFor(req)
yield self._render(res, req)
self.assertEqual(req.value(), 'o\n')
# Write data to session
req = Request("POST", ['000','a','xhr_send'])
req.writeContent('["a"]')
res = self.site.getResourceFor(req)
yield self._render(res, req)
# Ensure it appears despite different Server ID
req = Request("POST", ['999','a','xhr'])
res = self.site.getResourceFor(req)
yield self._render(res, req)
self.assertEqual(req.value(), 'a["a"]\n')
# Clean up
for p in self.site.resource._sessions.values():
p.disconnect()
class FactoryUnitTest(BaseUnitTest):
valid_sessions = (["a", "a"], ["_", "_"], ["1", "1"], ["abcdefgh_i-j%20", "abcdefgh_i-j%20"])
invalid_sessions = (["", ""], ["a.", "a"], ["a", "a."], [".", "."], [""], ["", "", ""])
def setUp(self):
self.site = SockJSFactory(EchoFactory())
def _test(self, path, resource):
req = Request("OPTIONS", path)
# Also tests that OPTIONS requests don't produce upstream connections
res = self.site.getResourceFor(req)
self.assertTrue(isinstance(res, resource))
def _test_wrapper(self, path, resource):
for s in self.valid_sessions:
self._test(s + [path], resource)
self._test(s + [path, ""], NoResource)
for s in self.invalid_sessions:
self._test(s + [path], NoResource)
self._test(s + [path, ""], NoResource)
def test_greeting(self):
self._test([], SockJSResource)
self._test([""], SockJSResource)
def test_info(self):
self._test(["info"], Info)
self._test(["info", ""], NoResource)
def test_iframe(self):
self._test(["iframe.html"], IFrame)
self._test(["iframe-a.html"], IFrame)
self._test(["iframe-.html"], IFrame)
self._test(["iframe-0.1.2.html"], IFrame)
self._test(["iframe-0.1.2abc-dirty.2144.html"], IFrame)
self._test(["iframe.htm"], NoResource)
self._test(["iframe"], NoResource)
self._test(["IFRAME.HTML"], NoResource)
self._test(["IFRAME"], NoResource)
self._test(["iframe.HTML"], NoResource)
self._test(["iframe.xml"], NoResource)
self._test(["iframe-", ".html"], NoResource)
def test_rawwebsocket(self):
self._test(["websocket"], RawWebSocket)
self._test(["websocket", ""], RawWebSocket)
def test_websocket(self):
self._test_wrapper("websocket", WebSocket)
def test_eventsource(self):
self._test_wrapper("eventsource", EventSource)
def test_htmlfile(self):
self._test_wrapper("htmlfile", HTMLFile)
def test_xhr_stream(self):
self._test_wrapper("xhr_streaming", XHRStream)
def test_xhr(self):
self._test_wrapper("xhr", XHR)
def test_jsonp(self):
self._test_wrapper("jsonp", JSONP)
def test_xhr_send(self):
self._test_wrapper("xhr_send", XHRSend)
def test_jsonp_send(self):
self._test_wrapper("jsonp_send", JSONPSend)
def test_invalid_endpoint(self):
self._test(["a", "a", "a"], NoResource)
def test_nonexistant_session_write(self):
req = Request("POST", ["a", "a", "xhr_send"])
res = self.site.getResourceFor(req)
self.assertTrue(isinstance(res, NoResource))
def test_ignore_server_id(self):
# Open session
req = Request("POST", ["000", "a", "xhr"])
res = self.site.getResourceFor(req)
yield self._render(res, req)
self.assertEqual(req.value(), "o\n")
# Write data to session
req = Request("POST", ["000", "a", "xhr_send"])
req.writeContent('["a"]')
res = self.site.getResourceFor(req)
yield self._render(res, req)
# Ensure it appears despite different Server ID
req = Request("POST", ["999", "a", "xhr"])
res = self.site.getResourceFor(req)
yield self._render(res, req)
self.assertEqual(req.value(), 'a["a"]\n')
# Clean up
for p in self.site.resource._sessions.values():
p.disconnect()
def listen(self, protocolFactory):
return self._endpoint.listen(
SockJSFactory(protocolFactory, self._options))
def newBullets(self):
"""
A list of all the new bullets to be drawn
"""
new_bullets = []
for p in self.users:
for b in p.new_bullets:
new_bullets.append(b.toObj())
b.broadcasted = True
return new_bullets
w = WorldObjects()
f = GameFactory(w)
s = SockJSFactory(f)
#try to get the port specified, default to 8090
try:
port = int(sys.argv[1])
except:
port = 8090
reactor.listenTCP(port, s)
broadcast = LoopingCall(f.broadcast)
broadcast.start(0.1)
gameloop = LoopingCall(w.update)
gameloop.start(0.016666667)
def sockjs_server(**options):
configure = options.get('configure', False)
port = options.get('port', 8888)
sockjs_options = {
'websocket': True,
'cookie_needed': False,
'heartbeat': 25,
'timeout': 5,
'streaming_limit': 128 * 1024,
'encoding': 'cp1252', # Latin1
'sockjs_url': 'https://d1fxtkz8shb9d2.cloudfront.net/sockjs-0.3.js'
}
zf = ZmqFactory()
endpoint = '%s://localhost:%d' % (settings.FORWARDER_PUB_TRANSPORT,
settings.FORWARDER_PUB_PORT)
e = ZmqEndpoint("connect", endpoint)
subscription = ZmqSubConnection(zf, e)
# Subscripción a todos los mensajes
subscription.subscribe("")
class SockJSProtocol(protocol.Protocol):
DIRECT_FORWARD_MESSAGE_TYPES = ('echo', )
instances = []
def __init__(self, *largs, **kwargs):
print "SockJS"
#protocol.Protocol.__init__(*largs, **kwargs)
SockJSProtocol.instances.append(self)
def dataReceived(self, data_string):
try:
data = json.loads(data_string)
msgtype = data.get('type', None)
if msgtype in self.DIRECT_FORWARD_MESSAGE_TYPES:
self.send_json(data, timestamp=repr(datetime.now()))
except ValueError as e:
print e
self.send_json({'data': data_string, 'type': 'unknown'})
def send_json(self, data=None, **opts):
'''Envia una respuesta en JSON por el websocket'''
if data:
if isinstance(data, dict):
data_safe = copy(data)
data_safe.update(opts)
elif isinstance(data, basestring):
try:
data_safe = json.loads(data)
except ValueError:
raise ValueError("Can't convert %s to json" % data)
else:
data_safe = opts
self.transport.write(json.dumps(data_safe))
def connectionLost(self, reason):
print "Cerrando Socket"
self.instances.remove(self)
protocol.Protocol.connectionLost(self, reason)
@classmethod
def broadcast(cls, data, *largs, **kwargs):
print "Received from forwarder %s" % data
for conn in cls.instances:
try:
conn.send_json(data)
except Exception as e:
print e
subscription.gotMessage = SockJSProtocol.broadcast
factory = protocol.ServerFactory()
factory.protocol = SockJSProtocol
reactor.listenTCP(port, SockJSFactory(factory, sockjs_options))
print "SocketServer running on %d" % port
if not configure:
try:
reactor.run()
except error.ReactorNotRunning:
print "Closing bridge"
def setUp(self):
self.site = SockJSFactory(EchoFactory())
class FactoryUnitTest(BaseUnitTest):
valid_sessions = (['a', 'a'], ['_', '_'], ['1', '1'],
['abcdefgh_i-j%20', 'abcdefgh_i-j%20'])
invalid_sessions = (['', ''], ['a.',
'a'], ['a',
'a.'], ['.',
'.'], [''], ['', '', ''])
def setUp(self):
self.site = SockJSFactory(EchoFactory())
def _test(self, path, resource):
req = Request("OPTIONS", path)
# Also tests that OPTIONS requests don't produce upstream connections
res = self.site.getResourceFor(req)
self.assertTrue(isinstance(res, resource))
def _test_wrapper(self, path, resource):
for s in self.valid_sessions:
self._test(s + [path], resource)
self._test(s + [path, ''], NoResource)
for s in self.invalid_sessions:
self._test(s + [path], NoResource)
self._test(s + [path, ''], NoResource)
def test_greeting(self):
self._test([], SockJSResource)
self._test([''], SockJSResource)
def test_info(self):
self._test(['info'], Info)
self._test(['info', ''], NoResource)
def test_iframe(self):
self._test(['iframe.html'], IFrame)
self._test(['iframe-a.html'], IFrame)
self._test(['iframe-.html'], IFrame)
self._test(['iframe-0.1.2.html'], IFrame)
self._test(['iframe-0.1.2abc-dirty.2144.html'], IFrame)
self._test(['iframe.htm'], NoResource)
self._test(['iframe'], NoResource)
self._test(['IFRAME.HTML'], NoResource)
self._test(['IFRAME'], NoResource)
self._test(['iframe.HTML'], NoResource)
self._test(['iframe.xml'], NoResource)
self._test(['iframe-', '.html'], NoResource)
def test_rawwebsocket(self):
self._test(['websocket'], RawWebSocket)
self._test(['websocket', ''], RawWebSocket)
def test_websocket(self):
self._test_wrapper('websocket', WebSocket)
def test_eventsource(self):
self._test_wrapper('eventsource', EventSource)
def test_htmlfile(self):
self._test_wrapper('htmlfile', HTMLFile)
def test_xhr_stream(self):
self._test_wrapper('xhr_streaming', XHRStream)
def test_xhr(self):
self._test_wrapper('xhr', XHR)
def test_jsonp(self):
self._test_wrapper('jsonp', JSONP)
def test_xhr_send(self):
self._test_wrapper('xhr_send', XHRSend)
def test_jsonp_send(self):
self._test_wrapper('jsonp_send', JSONPSend)
def test_invalid_endpoint(self):
self._test(['a', 'a', 'a'], NoResource)
def test_nonexistant_session_write(self):
req = Request("POST", ['a', 'a', 'xhr_send'])
res = self.site.getResourceFor(req)
self.assertTrue(isinstance(res, NoResource))
def test_ignore_server_id(self):
# Open session
req = Request("POST", ['000', 'a', 'xhr'])
res = self.site.getResourceFor(req)
yield self._render(res, req)
self.assertEqual(req.value(), 'o\n')
# Write data to session
req = Request("POST", ['000', 'a', 'xhr_send'])
req.writeContent('["a"]')
res = self.site.getResourceFor(req)
yield self._render(res, req)
# Ensure it appears despite different Server ID
req = Request("POST", ['999', 'a', 'xhr'])
res = self.site.getResourceFor(req)
yield self._render(res, req)
self.assertEqual(req.value(), 'a["a"]\n')
# Clean up
for p in self.site.resource._sessions.values():
p.disconnect()
def setUp(self):
self.site = SockJSFactory(EchoFactory())
self.request = Request(self.path)
