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()
Beispiel #2
0
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()
Beispiel #3
0
def main():
    """
    ========================================
        Codigo que no se para que sirve
    ========================================
    """

    opt = process_command_line()

    zmq_ctx = zmq.Context()

    # Pasandole el contexto del mensajero, y el nombre de la camara
    came_0 = CameraLink(zmq_ctx, 'cam0')
    came_0.connect(opt.camera_server_address)
    # Si hay mas camaras, se deben seguir asociando con este formato
    camaras = {'cam0': came_0}
    # Actualizando el objeto global
    objects.update(camaras)
    objects['last-image'] = None

    # No existe el metodo motor_debug
    # motor_execution.debug = opt.motor_debug

    motor_execution.restart()
    gevent.spawn(motor_execution.uart_readout_loop)

    # Iniciando el SweepControllet
    controlador = SweepController(camaras,
                                  motor_execution,
                                  sweep_status_broadcast,
                                  debug=True)
    objects['sweep-controller'] = controlador

    # configurando el broadcast de la camara
    came_0_config_broadcast = functools.partial(websockets_broadcast,
                                                identity=came_0.name,
                                                Kind='cfg')
    # devolviendo el estado del broadcast
    came_0_status_broadcast = functools.partial(camera_status_callback,
                                                identity=came_0.name)
    # Inicializando la camara
    came_0.start(came_0_config_broadcast, came_0_status_broadcast)

    resources = OrderedDict()
    # Agregando 2 pares al objeto OrderedDict
    # Equivale a .append
    resources['^/websocket'] = WSApplication
    resources['^/.*'] = app

    # Server de websocket
    server = WebSocketServer(('0.0.0.0', opt.port), Resource(resources))

    # Funcion que apaga el motor
    def shutdown():
        for motor in motor_api.motor_address.keys():
            motor_execution.set_hold_force(motor, False)
            gevent.sleep(0.01)

    motor_execution.set_axes_enabled(False)
    server.stop()
    zmq_ctx.destroy()
    sys.exit()

    gevent.signal(signal.SIGINT, shutdown)
    gevent.signal(signal.SIGTERM, shutdown)
    # Procesando una o varias solicitudes
    server.serve_forever()
Beispiel #4
0
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()