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"
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()