La préservation de l'état global dans un flacon d'application

Je suis en train d'enregistrer un cache dictionnaire dans mon flask application.

Aussi loin que je le comprends, le Le Contexte De L'Application, en particulier la flacon.g objet doit être utilisé pour cela.

De l'installation:

import flask as f

app = f.Flask(__name__)

Maintenant, si je fais:

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

Il imprime bar.

Continue avec les éléments suivants:

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

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

Je ne la comprennent pas et les docs ne sont pas aider du tout. Si je lis correctement l'état doit avoir été conservé.

Une autre idée j'ai eu était de simplement utiliser le module à l'échelle de variables:

cache = {}

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

Mais il semble que ces réinitialisés à chaque requête.

Comment faire cela correctement?

Edit: Flacon 10.1

Avez-vous vérifié Flacon-Cache?
Non, merci pour le lien, mais c'est une tâche simple que j'aimerais garder le dependenies faible atm.
Je pense que je suis allé avec un cookie de navigateur à la fin. Mais vous êtes bien sûr les bienvenus pour poster une solution une fois que vous trouver un.
Session pourrait être une solution, mais la session est conservée par l'utilisateur de sorte qu'il a ses limites. L'autre option est de memcache. C'est simple touche->mémorisation de la valeur qui est facile à configurer et est partagé entre tous les threads et les processus. Cependant, parfois (comme dans mon cas), il est un peu trop de complication, donc je pense simplement utiliser le dictionnaire dans la portée globale. Le risque est de l'intégrité des données (pas un facteur pour moi), mais même dict sera partagée entre les processus.

InformationsquelleAutor Profpatsch | 2013-10-09

58

Basé sur votre question, je pense que vous êtes confus au sujet de la définition de "global".

Dans un stock Flacon de configuration, vous disposez d'un Flacon de serveur avec plusieurs threads et potentiellement plusieurs processus de traitement des demandes. Supposons que vous ayez un stock variable globale comme "itemlist = []", et que vous vouliez continuer à ajouter dans chaque requête - dire, à chaque fois que quelqu'un fait une requête POST à un point de terminaison. C'est tout à fait possible en théorie et en pratique. C'est aussi une très mauvaise idée.

Le problème est que vous ne pouvez pas contrôler facilement les threads et les processus de "gagner" - la liste pourrait dans un très vilain de l'ordre, ou d'obtenir endommagé entièrement. Alors maintenant, vous avez besoin de parler à propos des verrous, mutexs, et d'autres primitives. C'est dur et ennuyeux.

Vous devez garder le serveur web lui-même en tant qu'apatrides que possible. Chaque demande doit être totalement indépendant et ne pas les partager n'importe quel état dans le serveur. Au lieu de cela, utiliser une base de données ou de la couche de mise en cache qui va gérer l'état pour vous. Cela semble plus compliqué mais c'est en fait plus simple en pratique. Découvrez SQLite par exemple ; c'est assez simple.

Pour aborder le " flacon.g' objet, qui est un objet global sur un par demande.

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

C'est "nettoyé" entre les demandes et ne peut pas être utilisé pour partager l'état entre eux.
- Je comprends l'approche de base de données, mais ne sont pas familiers avec la mise en cache des couches. Pourrait vous recommander une certaine couche de mise en cache librairies/frameworks?
- Il semble que dans le Flacon 0.11 flask.g est liée au contexte de l'application. Qu'il ne change quoi que ce soit?
- J'aime SQlite, mais je ne pense pas que vous voulez l'utiliser pour utilisation simultanée , dans les applications qui ont à faire de l'écrit. Écrit verrous de la db. Je pense vraiment que un peu comme redis-server va faire le travail, spécialement pour les inscriptions. Un autre (peut-être stupide) approche pourrait être d'écrire des données séparément dans un dossier. Ainsi, chaque thread va écrire son propre fichier, mais quand u de récupérer des données u lire tous les fichiers. De cette façon, vous obtenez toujours toutes les données, tandis que les non bloquant de nouvelles écritures.
- Ce n'est plus vrai. En commençant par flacon.10 flacon.g est liée au contexte de l'application et de ne pas le contexte de la demande. flask.pocoo.org/docs/0.12/api/#flask.g
- A -1 cette réponse. Il ya des cas où vous voulez mondial les objets qui ne sont pas actualisées entre la demande, par exemple, je veux charger chemin d'accès de certains fichiers dans la mémoire et pas modifier à tout. Si je veux le modifier, je vais redémarrer le serveur. Cette réponse n'aide pas.
- La conception de votre application à ne pas utiliser les threads, uniquement des processus. Vous serez plus heureux.
- Ouais, je suis à la recherche d'chargement d'un grand pré-formés modèle pour l'inférence et le temps de chargement est importante ne peut donc pas être apatrides.
- Un peu de chance encore? Même cas d'utilisation (à moins que votre modèle est dynamique?). Documentation assez incohérentes, et la plupart des questions sur le sujet de l'arrêt comme étant dup..
- Je pense JohanGov est la solution que je n'écris pas pour rien, alors que son OK pour partager une variable globale
- Je pense que vous devriez mettre en surbrillance au Lieu de cela, utiliser une base de données ou de la couche de mise en cache qui va gérer l'état pour vous.
InformationsquelleAutor mallyvai
8

Cette ligne
```
with app.app_context():
    f.g.foo = "bar"
```
Puisque vous utilisez le "par" mot-clé, une fois cette boucle est exécutée, elle appelle la __exit__ méthode de la AppContext classe. Voir cette. Donc, la " foo " est déclenché une fois fait. C'est pourquoi vous ne l'avez pas encore disponibles. Vous pouvez essayer:
```
ctx = app.app_context()
f.g.foo = 'bar'
ctx.push()
```
Jusqu'à ce que vous appelez la suite, g de.foo devrait être disponible
```
ctx.pop()
```
Je suis howver vous ne savez pas si vous voulez l'utiliser pour les fins de mise en cache.
- Que dois-je utiliser alors? Je pensais que c'était le moyen de stocker les valeurs dans une application?
- Le contexte d'application est créée et détruite que le nécessaire. Il ne déplace entre les threads et il ne sera pas partagée entre les demandes. (flask.pocoo.org/docs/appcontext)
InformationsquelleAutor codegeek
7

J'ai fait quelque chose de similaire à votre "module à l'échelle des variables" l'idée que j'utilise dans une fiole serveur que j'utilise pour intégrer les deux morceaux de logiciel où je sais que je ne jamais eu un simultanées "utilisateur" (qui est l'expéditeur du logiciel).

Mon app.py ressemble à ceci:
```
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()
```
Vous pouvez tester de cette façon:
```
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())
```
Sorties:
```
0
1
2
2
3
0
0
```
À utiliser avec prudence que je m'attends à ce que cela ne se comportent pas d'une bonne multi-utilisateur du serveur web.
- Cela permettra de travailler dans des situations où vous avez un SEUL uwsgi travailleur globablly. Vous avez également à vous soucier de multiples accès à la variable, donc vous pouvez avoir à mettre en œuvre des serrures ou similaire en fonction de l'utilisation. Il est un autre outil dans le sac si.
- Attention pour ce type de test... Le test Flacon serveur est mono-thread, et c'est un processus unique, vous ne serez pas en mesure de trouver le multi-threading avec ce test.
InformationsquelleAutor Johan Gov

Vous devez vous connecter pour publier un commentaire.