Preserving global state in a flask application

Question

I am trying to save a cache dictionary in my flask application.

As far as I understand it, the Application Context, in particular the flask.g object should be used for this.

Setup:

import flask as f

app = f.Flask(__name__)

Now if I do:

with app.app_context():
    f.g.foo = "bar"
    print f.g.foo

It prints bar.

Continuing with the following:

with app.app_context():
    print f.g.foo

AttributeError: '_AppCtxGlobals' object has no attribute 'foo'

I don’t understand it and the docs are not helping at all. If I read them correctly the state should have been preserved.

Another idea I had was to simply use module-wide variables:

cache = {}

def some_function():
    cache['foo'] = "bar"

But it seems like these get reset with every request.

How to do this correctly?

Edit: Flask 10.1

Asked By: Profpatsch

||

Source

Answer 1

This line

with app.app_context():
    f.g.foo = "bar"

Since you are using the “with” keyword, once this loop is executed, it calls the __exit__ method of the AppContext class. See this. So the ‘foo’ is popped out once done. Thats why you don’t have it available again. You can instead try:

ctx = app.app_context()
f.g.foo = 'bar'
ctx.push()

Until you call the following, g.foo should be available

ctx.pop()

I am howver not sure if you want to use this for the purpose of caching.

Answered By: codegeek

Answer 2

Based on your question, I think you’re confused about the definition of “global”.

In a stock Flask setup, you have a Flask server with multiple threads and potentially multiple processes handling requests. Suppose you had a stock global variable like “itemlist = []”, and you wanted to keep adding to it in every request – say, every time someone made a POST request to an endpoint. This is totally possible in theory and practice. It’s also a really bad idea.

The problem is that you can’t easily control which threads and processes “win” – the list could up in a really wonky order, or get corrupted entirely. So now you need to talk about locks, mutexs, and other primitives. This is hard and annoying.

You should keep the webserver itself as stateless as possible. Each request should be totally independent and not share any state in the server. Instead, use a database or caching layer which will handle the state for you. This seems more complicated but is actually simpler in practice. Check out SQLite for example ; it’s pretty simple.

To address the ‘flask.g’ object, that is a global object on a per request basis.

http://flask.pocoo.org/docs/api/#flask.g

It’s “wiped clean” between requests and cannot be used to share state between them.

Answered By: mallyvai

Answer 3

I’ve done something similar to your “module-wide variables” idea that I use in a flask server that I use to integrate two pieces of software where I know I will only ever have one simultaneous “user” (being the sender software).

My app.py looks like this:

from flask import Flask
from flask.json import jsonify
app = Flask(__name__)

cache = {}

@app.route("/create")
def create():
    cache['foo'] = 0
    return jsonify(cache['foo'])

@app.route("/increment")
def increment():
    cache['foo'] = cache['foo'] + 1
    return jsonify(cache['foo'])

@app.route("/read")
def read():
    return jsonify(cache['foo'])

if __name__ == '__main__':
    app.run()

You can test it like this:

import requests

print(requests.get('http://127.0.0.1:5000/create').json())
print(requests.get('http://127.0.0.1:5000/increment').json())
print(requests.get('http://127.0.0.1:5000/increment').json())
print(requests.get('http://127.0.0.1:5000/read').json())
print(requests.get('http://127.0.0.1:5000/increment').json())
print(requests.get('http://127.0.0.1:5000/create').json())
print(requests.get('http://127.0.0.1:5000/read').json())

Outputs:

Use with caution as I expect this to not behave in a proper multi user web server environment.

Answered By: Johan Gov

Preserving global state in a flask application

Question:

Answers: