Warum läuft der Flask Dev Server zweimal selbst?

Ich verwende Flask zum Entwickeln einer Website und während der Entwicklung führe ich flask mit der folgenden Datei aus:

#!/usr/bin/env python
from datetime import datetime
from app import app
import config

if __name__ == '__main__':
    print '################### Restarting @', datetime.utcnow(), '###################'
    app.run(port=4004, debug=config.DEBUG, host='0.0.0.0')

Wenn ich den Server starte oder ihn automatisch neu startet, weil Dateien aktualisiert wurden, wird die Druckzeile immer zweimal angezeigt:

################### Restarting @ 2014-08-26 10:51:49.167062 ###################
################### Restarting @ 2014-08-26 10:51:49.607096 ###################

Obwohl es nicht wirklich ein Problem ist (der Rest funktioniert wie erwartet), frage ich mich einfach, warum es sich so verhält? Irgendwelche Ideen?

Der Werkzeug-Reloader erzeugt einen untergeordneten Prozess, sodass er diesen Prozess jedes Mal neu starten kann, wenn sich Ihr Code ändert. Werkzeug ist die Bibliothek, die Flask beim Aufruf mit dem Entwicklungsserver versorgt app.run().

Siehe restart_with_reloader()Funktionscode ; Ihr Skript wird erneut mit ausgeführt subprocess.call().

Wenn Sie auf einstellen use_reloader, Falsewird das Verhalten verschwinden, aber Sie verlieren auch die Neuladefunktion:

app.run(port=4004, debug=config.DEBUG, host='0.0.0.0', use_reloader=False)

Sie können den Reloader auch deaktivieren, wenn Sie den flask runBefehl verwenden:

FLASK_DEBUG=1 flask run --no-reload

Sie können nach der WERKZEUG_RUN_MAINUmgebungsvariablen suchen , wenn Sie erkennen möchten, wann Sie den untergeordneten Prozess neu laden:

import os
if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
    print '################### Restarting @ {} ###################'.format(
        datetime.utcnow())

Wenn Sie jedoch Modul-Globals einrichten müssen, sollten Sie stattdessen den @app.before_first_requestDekorator für eine Funktion verwenden und diese Funktion solche Globals einrichten lassen. Es wird nur einmal nach jedem Neuladen aufgerufen, wenn die erste Anfrage eingeht:

@app.before_first_request
def before_first_request():
    print '########### Restarted, first request @ {} ############'.format(
        datetime.utcnow())

Berücksichtigen Sie, dass before_first_requestHandler für jeden neuen Unterprozess aufgerufen werden können , wenn Sie dies auf einem vollständigen WSGI-Server ausführen, der Forking oder neue Unterprozesse zur Verarbeitung von Anforderungen verwendet .

Wenn Sie den modernen flask runBefehl verwenden, wird keine der zu app.runverwendenden Optionen verwendet. Um den Reloader vollständig zu deaktivieren, übergeben Sie --no-reload:

FLASK_DEBUG=1 flask run --no-reload

Auch __name__ == '__main__'wird nie wahr sein, weil die App nicht direkt ausgeführt wird. Verwenden Sie die gleichen Ideen aus Martijns Antwort , außer ohne den __main__Block.

if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
    # do something only once, before the reloader

if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
    # do something each reload

Ich hatte das gleiche Problem, und ich es gelöst , indem app.debugan False. Das Einstellen auf führte dazu, Truedass ich __name__ == "__main__"zweimal angerufen wurde.

Von Flask 0.11, ist es empfehlenswert , die App mit laufen , flask runstatt python application.py. Wenn Sie Letzteres verwenden, wird Ihr Code möglicherweise zweimal ausgeführt.

Wie hier angegeben :

... ab Kolben 0.11 wird die Kolbenmethode empfohlen. Der Grund dafür ist, dass es aufgrund der Funktionsweise des Reload-Mechanismus einige bizarre Nebenwirkungen gibt (wie das zweimalige Ausführen bestimmter Codes ...).

Einer der möglichen Gründe, warum die Flask-App zweimal selbst ausgeführt wird, ist die Konfiguration der WEB_CONCURRENCYEinstellungen für Heroku. Zum Einstellen können Sie in die Konsole schreiben heroku config:set WEB_CONCURRENCY=1

Eine Beobachtung zu Threads

Dies ist besonders ärgerlich, wenn Ihre Anwendung Threads verwendet, da diese beim Start zweimal ausgelöst werden. Soweit ich Singletons ausprobiert habe, kann ich das auch nicht beheben (was überraschend ist). Das Hinzufügen einer anfänglichen Verzögerung von einigen Sekunden vor dem Start Ihres Threads kann das Problem jedoch beheben.

Wenn die App schneller neu startet als vor Ablauf Ihrer Verzögerungszeit, wird der angegebene Thread nach dem Neustart nur einmal erzeugt.

Ich hatte das gleiche Problem. Ich habe es gelöst, indem ich mein main geändert und use_reloader = False eingefügt habe. Wenn hier jemand nach einer Problemumgehung für dieses Problem sucht, können Sie mit dem folgenden Code beginnen. Die Funktionalität von Codeänderungen, die von der Anwendung automatisch erkannt werden und neu gestartet wird, funktioniert jedoch nicht. Sie müssen Ihre Anwendung nach jeder Bearbeitung im Code manuell stoppen und neu starten.

if __name__ == '__main__':
    app.run(debug=True, use_reloader=False)