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 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 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_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 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 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 gevent_server_get(self, port=7766):
"""
returns a gevent server for j.servers.rack
"""
server = WebSocketServer(("", port), Resource(OrderedDict([("/", GeventGunServer)])))
return server
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 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 __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 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.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_websocket_api():
res_map = OrderedDict({
'/+websocket': WebsocketApi,
})
if WSGI_APP:
res_map['^(?!/+websocket)'] = WSGI_APP
resource = Resource(res_map)
cm = ChannelMgr()
cm.add_channel("status_changes")
return (resource, cm)
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 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 _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 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 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)
def gevent_websocket_server(port, path='/'):
from geventwebsocket import WebSocketServer, WebSocketApplication, Resource
class WebSocketRPCApplication(WebSocketApplication):
def on_open(self):
log.debug('conn open: %s %s', args, kwargs)
def on_message(self, message):
try:
ret = server_call(message, self.ws.send)
log.info('ret=%s', ret)
if isinstance(ret, str):
self.ws.send(ret)
except:
log.info(traceback.format_exc())
def on_close(self, reason):
log.debug('conn close: %s', reason)
srv = WebSocketServer(('0.0.0.0', port), Resource({path: MyApplication}))
log.info('server started at:%d', port)
srv.serve_forever()
log.warn("stopped")
def main():
opt = process_command_line()
print opt
zmq_ctx = zmq.Context()
resources = OrderedDict()
resources['^/websocket'] = WSApplication
resources['^/.*'] = app
server = WebSocketServer(('0.0.0.0', opt.port), Resource(resources))
def shutdown():
print("\nShutting down...")
server.stop()
zmq_ctx.destroy()
sys.exit()
gevent.signal(signal.SIGINT, shutdown)
gevent.signal(signal.SIGTERM, shutdown)
server.serve_forever()
def main():
xmas = WebSocketServer(
('0.0.0.0', 8000),
Resource(
OrderedDict([('/xmas', client.ClientImpl),
('/interface', interface.InterfaceImpl)])))
application_state = State()
application_gui = gui.GuiImpl(application_state,
santa.GaOptimizingSanta(application_state))
""" So that interface can update the packages aswell. """
application_state.add_package = application_gui.add_package
""" Make state reachable throughout all applications """
xmas.state = application_state
try:
application_gui.start()
xmas.start()
xmas.serve_forever()
except KeyboardInterrupt:
pass
application_state.clean()
application_gui.stop()
from gevent import monkey # type: ignore
monkey.patch_all()
try:
from mephisto.abstractions.architects.router.flask.mephisto_flask_blueprint import ( # type: ignore
MephistoRouter, mephisto_router,
)
except:
from mephisto_flask_blueprint import ( # type: ignore
MephistoRouter, mephisto_router,
)
from geventwebsocket import WebSocketServer, Resource # type: ignore
from werkzeug.debug import DebuggedApplication # type: ignore
from flask import Flask # type: ignore
import os
port = int(os.environ.get("PORT", 3000))
flask_app = Flask(__name__)
flask_app.register_blueprint(mephisto_router, url_prefix=r"/")
if __name__ == "__main__":
WebSocketServer(
("", port),
Resource([("^/.*", MephistoRouter),
("^/.*", DebuggedApplication(flask_app))]),
debug=False,
).serve_forever()
'nickname':
message['nickname'],
'message':
message['message'],
'created_at':
datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}))
def on_close(self, reason):
"""
接続が切れた
"""
print("Connection closed! ")
@flask_app.route('/')
def index():
"""
クライアント画面
"""
return render_template('index.html')
if __name__ == '__main__':
args = getargs()
print('Host: {}, Port: {}'.format(args.host, args.port))
WebSocketServer((args.host, args.port),
Resource([('^/', ChatApplication),
('^/.*', DebuggedApplication(flask_app))]),
debug=args.debug).serve_forever()
:param _file: path to file
:return: True for file exists, Raises RuntimeError if doesn't exist
"""
if not os.path.isfile(_file):
raise RuntimeError("The file provided does not exist! {}".format(_file))
return True
if __name__ == '__main__':
args = parse_args()
server_args = []
server_kwargs = dict()
try:
scale = set_scale()
except ValueError:
print "ERROR: Unable to connect to the scale!!"
scale = None
if not args.cert and not args.key:
pass
elif validate_file(args.cert) and validate_file(args.key):
server_kwargs.update({'keyfile': args.key,
'certfile': args.cert})
server_args.append((args.bind, args.port))
server_args.append(
Resource([
('/', static_wsgi_app),
('/data', WeightApp)
])
)
WebSocketServer(*server_args, **server_kwargs).serve_forever()
while True:
gevent.sleep(settings.websocket_timeout)
for uid in wss:
gevent.spawn(send_message, uid, 'ping')
def send_message(uid, message):
try:
wslist = wss[uid]
except KeyError:
return
dead = []
for i, ws in enumerate(wslist):
try:
ws.send(message)
except WebSocketError:
log.debug('WebSocket %s (uid=%s) id dead.' % (ws, uid))
dead.append(i)
wss[uid] = [i for j, i in enumerate(wss[uid]) if j not in dead]
gevent.spawn(ping_sockets)
log.info('ws server')
WebSocketServer((settings.websocket_host, settings.websocket_port),
Resource({settings.websocket_url:
WsApplication})).serve_forever()
