class LogViewWorker(EntityWorker):
def __init__(self, config_address, entity_port, http_port, ws_port):
"""
:param config_address: config进程的监听地址
:param entity_port: entity的服务接口
:param http_port: http的监听端口
:param ws_port: websocket的监听端口
:return:
"""
EntityWorker.__init__(self, "log_view", "log_view", entity_port, config_address)
self._http_port = http_port
self._ws_port = ws_port
self._ws_server = None
self._http_server = None
global WS_PORT
WS_PORT = ws_port
def init_entity(self):
self._ws_server = WebSocketServer(
('', self._ws_port),
Resource(OrderedDict({"/": LogWebSocket}))
)
self._ws_server.start()
self._http_server = HttpConnector(self._http_port)
self._http_server.add_route("/showlog", ShowLog)
self._http_server.add_route("/greplog", GrepLog)
self._http_server.add_route("/nodes", AllNode)
self._http_server.add_route("/nodemanage", NodeManage)
self._http_server.add_route("/addnode", AddNode)
self._http_server.add_route("/delnode", DelNode)
self._http_server.start()
WebSocketManager()
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 server():
s = WebSocketServer(
('0.0.0.0', 8001),
Resource(OrderedDict([('/', WsApplication)]))
)
s.start()
thread = Greenlet.spawn(s.serve_forever)
yield s
s.stop()
thread.kill()
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()
add_peers(PEERS)
from gevent.pywsgi import WSGIServer
apiserver = WSGIServer(('', API_PORT), apiapp)
apiserver.start()
from geventwebsocket import WebSocketServer, WebSocketApplication, Resource
from collections import OrderedDict
class P2PApplication(WebSocketApplication):
def on_open(self):
# 被连接时客户端会立刻把自己的最新块发过来，
# 所以无需给对端发送自己的最新区块。
peers.append(Peer(self.ws))
def on_message(self, message):
chain.handle_msg(message, self.ws)
def on_close(self, reason):
pass
resource = Resource(OrderedDict([('/', P2PApplication)]))
p2pserver = WebSocketServer(('', P2P_PORT), resource)
p2pserver.start()
while True:
gevent.sleep(60)
class APIServer():
_api_prefix = '/api/1'
def __init__(
self,
rest_api: RestAPI,
ws_notifier: RotkiNotifier,
cors_domain_list: List[str] = None,
) -> None:
flask_app = Flask(__name__)
if cors_domain_list:
CORS(flask_app, origins=cors_domain_list)
blueprint = create_blueprint()
flask_api_context = Api(blueprint, prefix=self._api_prefix)
setup_urls(
flask_api_context=flask_api_context,
rest_api=rest_api,
urls=URLS_V1,
)
self.rest_api = rest_api
self.rotki_notifier = ws_notifier
self.flask_app = flask_app
self.blueprint = blueprint
self.wsgiserver: Optional[WSGIServer] = None
self.flask_app.register_blueprint(self.blueprint)
self.ws_server: Optional[WebSocketServer] = None
self.flask_app.errorhandler(HTTPStatus.NOT_FOUND)(
endpoint_not_found) # type: ignore
self.flask_app.register_error_handler(
Exception, self.unhandled_exception) # type: ignore
@staticmethod
def unhandled_exception(exception: Exception) -> Response:
""" Flask.errorhandler when an exception wasn't correctly handled """
log.critical(
'Unhandled exception when processing endpoint request',
exc_info=True,
exception=str(exception),
)
return api_response(wrap_in_fail_result(str(exception)),
HTTPStatus.INTERNAL_SERVER_ERROR)
def run(self,
host: str = '127.0.0.1',
port: int = 5042,
**kwargs: Any) -> None:
"""This is only used for the data faker and not used in production"""
self.flask_app.run(host=host, port=port, **kwargs)
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 stop(self, timeout: int = 5) -> None:
"""Stops the API server. If handlers are running after timeout they are killed"""
if self.wsgiserver is not None:
self.wsgiserver.stop(timeout)
self.wsgiserver = None
if self.ws_server is not None:
self.ws_server.stop(timeout)
self.wsgiserver = None
self.rest_api.stop()
