Starting and stopping flask on demand

Question

I am writing an application, which can expose a simple RPC interface implemented with flask. However I want it to be possible to activate and deactivate that interface. Also it should be possible to have multiple instances of the application running in the same python interpreter, which each have their own RPC interface.

The service is only exposed to localhost and this is a prototype, so I am not worried about security. I am looking for a small and easy solution. The obvious way here seems to use the flask development server, however I can't find a way to shut it down.

I have created a flask blueprint for the functionality I want to expose and now I am trying to write a class to wrap the RPC interface similar to this:

class RPCInterface:
    def __init__(self, creating_app, config):
        self.flask_app = Flask(__name__)
        self.flask_app.config.update(config)
        self.flask_app.my_app = creating_app

        self.flask_app.register_blueprint(my_blueprint)

        self.flask_thread = Thread(target=Flask.run, args=(self.flask_app,),
                                   name='flask_thread', daemon=True)

    def shutdown(self):
        # Seems impossible with the flask server
        raise NotImplemented()

I am using the variable my_app of the current app to pass the instance of my application this RPC interface is working with into the context of the requests.

It can be shut down from inside a request (as described here http://flask.pocoo.org/snippets/67/), so one solution would be to create a shutdown endpoint and send a request with the test client to initiate a shutdown. However that requires a flask endpoint just for this purpose. This is far from clean.

I looked into the source code of flask and werkzeug and figured out the important part (Context at https://github.com/pallets/werkzeug/blob/master/werkzeug/serving.py#L688) looks like this:

def inner():
    try:
        fd = int(os.environ['WERKZEUG_SERVER_FD'])
    except (LookupError, ValueError):
        fd = None
    srv = make_server(hostname, port, application, threaded,
                      processes, request_handler,
                      passthrough_errors, ssl_context,
                      fd=fd)
    if fd is None:
        log_startup(srv.socket)
    srv.serve_forever()

make_server returns an instance of werkzeugs server class, which inherits from pythons http.server class. This in turn is a python BaseSocketServer, which exposes a shutdown method. The problem is that the server created here is just a local variable and thus not accessible from anywhere.

This is where I ran into a dead end. So my question is:

• Does anybody have another idea how to shut down this server easily?
• Is there any other simple server to run flask on? Something which does not require an external process and can just be started and stopped in a few lines of code? Everything listed in the flask doc seems to have a complex setup.

Answer 1

Answering my own question in case this ever happens again to anyone.

The first solution involved switching from flask to klein. Klein is basically flask with less features, but running on top of the twisted reactor. This way the integration is very simple. Basically it works like this:

from klein import Klein
from twisted.internet import reactor

app = Klein()

@app.route('/')
def home(request):
    return 'Some website'

endpoint = serverFromString(reactor, endpoint_string)
endpoint.listen(Site(app.resource()))

reactor.run()

Now all the twisted tools can be used to start and stop the server as needed.

The second solution I switched to further down the road was to get rid of HTTP as a transport protocol. I switched to JSONRPC on top of twisted's LineReceiver protocol. This way everything got even simpler and I didn't use any of the HTTP stuff anyway.