def run(self):
if self._ssl_path:
self.ws = WebSocketServer((self._address, self._port),
Resource({
'/api/bridge': PytoWebSocketApp,
'/api/device*': self.api_app,
'/api/voice': self.api_app,
'/': self.http_file_app
}),
pre_start_hook=auth_hook,
keyfile=self._ssl_path + '/server.key',
certfile=self._ssl_path + '/server.crt')
else:
self.ws = WebSocketServer((self._address, self._port),
Resource({
'/api/bridge': PytoWebSocketApp,
'/api/device*': self.api_app,
'/api/voice': self.api_app,
'/': self.http_file_app
}),
pre_start_hook=auth_hook)
print "Serving WebSocket Connection on", self._address, "port", self._port, "..."
StateDevice.onStateChangedGlobal(self.broadcast_state)
self.ws.serve_forever()
def startServer(self):
"""Starts the server"""
if not self.certfile:
server = WebSocketServer((self.host, self.port), self.handleClient)
else:
server = WebSocketServer((self.host, self.port), self.handleClient,
self.certfile)
server.serve_forever()
def start(
self,
host: str = '127.0.0.1',
rest_port: int = 5042,
websockets_port: int = 5043,
) -> None:
"""This is used to start the API server in production"""
wsgi_logger = logging.getLogger(__name__ + '.pywsgi')
self.wsgiserver = WSGIServer(
listener=(host, rest_port),
application=self.flask_app,
log=wsgi_logger,
error_log=wsgi_logger,
)
msg = f'rotki REST API server is running at: {host}:{rest_port}'
print(msg)
log.info(msg)
self.wsgiserver.start()
self.ws_server = WebSocketServer(
listener=(host, websockets_port),
application=WebsocketResource([
('^/', RotkiWSApp),
]),
debug=False,
environ={'rotki_notifier': self.rotki_notifier},
)
msg = f'rotki Websockets API server is running at: {host}:{websockets_port}'
print(msg)
log.info(msg)
self.ws_server.start()
def run_web_servers(port):
resource = Resource(
OrderedDict([('/ws', ClientConnection), ('.*', static_file_server)]))
server = WebSocketServer(("", port), resource, debug=False)
print "Now listening on port %d" % port
server.serve_forever()
def server(self):
if not self._server:
if self.ssl:
self._server = WebSocketServer(
("0.0.0.0", self.port),
Resource(OrderedDict([("/", Application)])),
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
)
else:
self._server = WebSocketServer(
("0.0.0.0", self.port),
Resource(OrderedDict([("/", Application)])))
return self._server
def run(self):
self.green_monitor()
gevent.signal(signal.SIGTERM, self.kill)
gevent.signal(signal.SIGUSR1, self.pdb)
Application.middleware = self
wsserver = WebSocketServer(
('127.0.0.1', 6000),
Resource(OrderedDict([
('/websocket', Application),
])))
restful_api = RESTfulAPI(self)
apidocs_app.middleware = self
apidocsserver = WSGIServer(('127.0.0.1', 8001), apidocs_app)
restserver = WSGIServer(('127.0.0.1', 8002), restful_api.get_app())
fileserver = WSGIServer(('127.0.0.1', 8003), FileApplication(self))
self.__server_threads = [
gevent.spawn(wsserver.serve_forever),
gevent.spawn(apidocsserver.serve_forever),
gevent.spawn(restserver.serve_forever),
gevent.spawn(fileserver.serve_forever),
gevent.spawn(self.__jobs.run),
]
self.logger.debug('Accepting connections')
gevent.joinall(self.__server_threads)
def test_high_level_echo(self):
data = []
data.append("")
data.append("0123456789")
data.append("0123456789" * 20)
data.append("0123456789" * 2000)
data.append("0123456789" * 20000)
data.append("0123456789" * 200000)
data.append(b"")
data.append(b"0123456789")
data.append(b"0123456789" * 20)
data.append(b"0123456789" * 2000)
data.append(b"0123456789" * 20000)
data.append(b"0123456789" * 200000)
class EchoApplication(WebSocketApplication):
def on_open(self):
server.logger.info("Connection opened")
def on_message(self, message):
if message is None:
return
server.logger.info("Message received %s", len(message))
self.ws.send(message)
def on_close(self, reason):
server.logger.info("Connection closed %s", reason)
server = WebSocketServer(self.s_socket, Resource(OrderedDict([('/', EchoApplication)])), debug=True)
server.start()
self.server = server
try:
self.server_thread = Thread(target=self.start_server)
self.server_thread.start()
ws = create_connection("ws://%s:%s/" % (self.server.environ["SERVER_NAME"],
self.server.environ["SERVER_PORT"]))
try:
for i in range(2):
if i == 1:
ws.set_mask_key(lambda _: b'1234')
for d in data:
if isinstance(d, bytes):
ws.send_binary(d)
else:
ws.send(d)
self.assertEqual(ws.recv(), d)
ws.ping("ping")
pong = ws.recv_data_frame(10)
self.assertEqual(pong[0], pong[1].OPCODE_PONG)
self.assertEqual(pong[1].data, b'ping')
self.assertFalse(self.err)
finally:
ws.close(timeout=10)
finally:
server.close()
def start():
print("Starting pycaserver.")
#host = "127.0.0.1"
#host = "10.6.100.199"
host = "0.0.0.0"
port = 8888
server = WebSocketServer((host, port), wsgi_app)
server.serve_forever()
def gevent_server_get(self, port=7766):
"""
returns a gevent server for j.servers.rack
"""
server = WebSocketServer(("", port), Resource(OrderedDict([("/", GeventGunServer)])))
return server
def server():
s = WebSocketServer(('0.0.0.0', 8001),
Resource(OrderedDict([('/', TestApplication)])))
s.start()
thread = Greenlet.spawn(s.serve_forever)
yield s
s.stop()
thread.kill()
def startMonitorServer(port=9000):
logging.info("Starting monitor server in port {}".format(port))
WebSocketServer(('0.0.0.0', port),
Resource({
'^/monitor_socket': MonitorSocket,
'^/.*': flask_app
}),
debug=False).serve_forever()
def run(ip='127.0.0.1', port=63482, jobq_thread_count=10):
JobdWebSocketApplication.jobq_mgr = jobq.JobManager([(_parse_request,
jobq_thread_count)])
WebSocketServer(
(ip, port),
Resource(OrderedDict({'/': JobdWebSocketApplication})),
).serve_forever()
def serve_forever(self, server):
self.wss = WebSocketServer(
(self.address, self.port),
ServerResource(self.apps, server),
**self.kwargs
)
self.wss.serve_forever()
def start_service(self):
port = self.options["service_port"]
ip = self.options["service_ip"]
print("[+]Service Started")
WebSocketServer(
(ip, port),
Resource(OrderedDict([('/', EchoApplication)]))).serve_forever()
self.HTTPServerThread.stop()
def __init__(self, ssl_args, port, application=WSRpcApplication):
self.port = port
self.application = application
patterns = {'/websocket': application}
res = Resource(
collections.OrderedDict(
sorted(patterns.items(), key=lambda t: t[0])))
self.server = WebSocketServer(('', port), res, **ssl_args)
self.protocol = PT_WEB_SOCKET
def _run(self):
"""启动监听器\n
"""
log.msg('WebSocketServer on %s' % self.port)
self.factory = WebSocketServer(self.getHost(),
Resource([(i, self.apps)
for i in self.urls]),
debug=self.debug,
**self.ssl_options)
self.factory.serve_forever()
def run_forever(self, host='0.0.0.0', debug=False):
try:
dealer_server = WebSocketServer(
(host, 8080),
Resource(OrderedDict({'/': DealerApplication})),
debug=debug)
dealer_server.serve_forever()
except KeyboardInterrupt:
dealer_server.close()
raise KeyboardInterrupt
def serve(port, addr=''):
def ws_app(env, start):
try:
loop_ws( env.get("wsgi.websocket") )
return []
except KeyError:
start('500 ' + msg, [('Content-type', 'text/html')])
return ['Not a Websocket\n']
print("Serving port %s..." % port)
WebSocketServer((addr, int(port)), ws_app).serve_forever()
def __init__(self, ssl_args, port, application=WSRpcApplication):
self.application = application
patterns = {'/': application}
res = Resource(
collections.OrderedDict(
sorted(patterns.items(), key=lambda t: t[0])))
super(WsRpcServer,
self).__init__(PT_WEB_SOCKET, port,
WebSocketServer(('', port), res, **ssl_args))
def init():
from settings import config
host = config.get('restAPI', 'host', fallback='0.0.0.0')
port = config.getint('restAPI', 'port', fallback=5000)
debug = config.getboolean('restAPI', 'debug', fallback=False)
app.debug = debug
global server
server = WebSocketServer((host, port), app, handler_class=WebSocketHandler)
server.serve_forever()
def websocket():
"""
Run websocket flask application, SSL handled by nginx
"""
http_server_ws = WebSocketServer(
('127.0.0.1',
8890),
Resource(OrderedDict([('/websocket/', HandlerWS)]))
)
http_server_ws.serve_forever()
def __init__(self,
session_store,
apps=None,
certfile=None,
keyfile=None,
host='localhost',
port=8002,
route=None,
auth_fn=None,
auth_timeout=60):
super(DynoQdbClientServer, self).__init__(session_store, host, port,
route, auth_fn, auth_timeout)
if certfile is not None and keyfile is not None:
self._server = WebSocketServer((host, port),
self.handle_client,
certfile=certfile,
keyfile=keyfile)
else:
self._server = WebSocketServer((host, port), self.handle_client)
self.apps = apps if apps else {}
def websocket():
from ._app import WebSocketInfer
from collections import OrderedDict
from geventwebsocket import WebSocketServer, Resource
port = int(os.getenv("PORT", "8080"))
host = os.getenv("HOST", "0.0.0.0")
WebSocketServer(
(host, port), Resource(OrderedDict([("/infer", WebSocketInfer)]))
).serve_forever()
def main():
args = parse_args()
async_mode = 'gevent' # eventlet, gevent_uwsgi, gevent, threading
logger.info('Running automate version {}', Env.version)
from utils.io import delete_old_files
delete_old_files(Env.tmp)
# -------------------------------------------------------------------------
if args.debug:
async_mode = 'threading'
Env.debug_mode = True
else:
from gevent import monkey
monkey.patch_all()
# -------------------------------------------------------------------------
from flask_socketio import SocketIO
import flask
from www import app
# -------------------------------------------------------------------------
socketio = SocketIO(app,
json=flask.json,
async_mode=async_mode,
ping_interval=100 * 1000)
register_routes(app, socketio)
# -------------------------------------------------------------------------
if args.backdoor:
from www import backdoor
backdoor.register_routes(app, socketio)
# -------------------------------------------------------------------------
logger.info('Listening on {host}:{port} (debug={debug})', **vars(args))
Env.dump_info('Configuration in env.py')
logger.info('removing old files from {}', Env.tmp)
# -------------------------------------------------------------------------
if args.debug:
app.run(debug=args.debug, host=args.host, port=args.port)
else:
from geventwebsocket import WebSocketServer
http_server = WebSocketServer((args.host, args.port), app)
http_server.serve_forever()
return app, args
def run(self):
resource = collections.OrderedDict()
resource['/api/bridge'] = PytoWebSocketApp
resource['/api/device*'] = self.api_app
resource['/api/voice'] = self.api_app
resource['/'] = self.http_file_app
if self._ssl_path:
self.ws = WebSocketServer((self._address, self._port),
Resource(resource),
pre_start_hook=auth_hook,
keyfile=self._ssl_path + '/server.key',
certfile=self._ssl_path + '/server.crt')
else:
self.ws = WebSocketServer((self._address, self._port),
Resource(resource),
pre_start_hook=auth_hook)
print("Serving WebSocket Connection on", self._address, "port",
self._port, "...")
StateDevice.onStateChangedGlobal(self.broadcast_state)
self.ws.serve_forever()
def main():
""
host = config.get("HOSTDIVULGER")
port = config.get("PORTDIVULGER")
print(u"serving on {host}:{port}".format(**locals()))
server = WebSocketServer(
(host, port),
Resource(OrderedDict({
"^/divulge/.+/": DivulgeApplication,
})),
debug=False,
)
server.serve_forever()
def run(address='', port=6060, endpoint='/', static=False, debug=False):
"""
Run our websocket server with configured urls.
"""
resources = [('/ws', GuacamoleApp)]
if static:
# we need to serve static webapp as well
resources += get_webapp_resources(debug)
WebSocketServer(
(address, int(port)),
Resource(resources),
debug=debug
).serve_forever()
def run(self):
Application.middleware = self
wsserver = WebSocketServer(('127.0.0.1', 6000), Resource(OrderedDict([
('/websocket', Application),
])))
restful_api = RESTfulAPI(self)
apidocs_app.middleware = self
apidocsserver = WSGIServer(('127.0.0.1', 8001), apidocs_app)
restserver = WSGIServer(('127.0.0.1', 8002), restful_api.get_app())
server_threads = [
gevent.spawn(wsserver.serve_forever),
gevent.spawn(apidocsserver.serve_forever),
gevent.spawn(restserver.serve_forever),
gevent.spawn(self.__jobs.run),
]
self.logger.debug('Accepting connections')
gevent.joinall(server_threads)
def run(self):
self.online = True
manager = self
class MainApplication(WebSocketApplication):
def on_open(self):
print("Connection opened")
manager.setContext(self.ws)
def on_message(self, message):
print(message)
data = json.loads(message)
cmd = data["cmd"]
if "args" in data:
args = data["args"]
else:
args = None
if cmd == 'goto':
print('I will goto', data["args"]["x"], data["args"]["y"])
executor = InputExecutor(manager.robot, [data["args"]["y"], data["args"]["x"], 20, True])
executor.start()
elif cmd == 'stop':
print('Stop command received')
manager.robot.cancelOperations()
manager.robot.stopMotors()
print('STOOOOP')
elif cmd == 'reset_pos':
print('Reset pos command')
manager.robot.positionWatcher.reset()
elif cmd == 'start_position_trace':
print('LOG# > Enabled position trace')
elif cmd == 'stop_position_trace':
print('LOG# > Disabled position trace')
else:
print("Command not recognized")
print('Start a websocket server on 0.0.0.0:8080')
WebSocketServer(
('0.0.0.0', 8080),
Resource(OrderedDict([('/', MainApplication)]))
).serve_forever()
def websocket_server_add(self, name="websocket", port=4444, appclass=None):
from geventwebsocket import WebSocketServer, WebSocketApplication, Resource
from collections import OrderedDict
if not appclass:
class EchoApplication(WebSocketApplication):
def on_open(self):
print("Connection opened")
def on_message(self, message):
self.ws.send(message)
def on_close(self, reason):
print(reason)
appclass = EchoApplication
server = WebSocketServer(("0.0.0.0", port), Resource(OrderedDict([("/", appclass)])))
self.add(name=name, server=server)
