Wie kann ich das implementieren einer benutzerdefinierten error-handler für alle HTTP-Fehler in Fläschchen?

In meinem Kolben-app kann ich problemlos erweitern Sie die Liste der Fehler behandelt, die von einer einzelnen benutzerdefinierten error-handler durch hinzufügen errorhandler Dekorateure für jeden error-code als mit

@application.errorhandler(404)
@application.errorhandler(401)
@application.errorhandler(500)
def http_error_handler(error):
    return flask.render_template('error.html', error=error), error.code

Allerdings erfordert dieser Ansatz eine explizite Dekorateur für jeden Fehlercode. Gibt es eine Möglichkeit, schmücken meine (einzige) http_error_handler - Funktion, so dass es behandelt alle HTTP-Fehler?

InformationsquelleAutor orome | 2015-01-03

5

Du bist nicht die einzige, die eine Problemumgehung wird die Angabe der Liste der http-Fehler-code, den Sie fangen und an den Anwendung.error_handler_spec, und legen Sie die Dekoratoren, wie diese:
```
def http_error_handler(error):
    return flask.render_template('error.html', error=error), error.code

for error in (401, 404, 500): # or with other http code you consider as error
    application.error_handler_spec[None][error] = http_error_handler
```
Nicht ideal und hässlich ich weiß, aber es funktioniert und ich hoffe jemand anderes kann kommen mit einer besseren Lösung. Hoffe, das hilft.
- Ja, danke. Ich hatte das gesehen und wollte vermeiden, (a) die Aufnahme und (b) mit error_handler_spec. Ist das wirklich die einzige Möglichkeit (bis jetzt)?
- Ich komme über das gleiche problem, und nach einiger recherche (wie vermutlich was hast du bereits getan), das ist der einzige Weg, denke ich derzeit. Den anderen Maler Ansatz irgendwie einfach nicht heben, den Fehler, oder Sie müssen gezielt erhöhen die Ausnahme, die sieht noch hässlicher
- Schade. Ich Frage mich, was das design Grund ist (oder wenn es nur zu einer Unterlassung).
- Ich denke, das ist eher das design nach zu urteilen Kolben in seiner form nicht verarbeiten Sie den Fehler-code status-sofern nicht ausdrücklich definiert.
InformationsquelleAutor Anzel
15

Können Sie die errorhandler Dekorator mit einem exception-Klasse eher als ein Fehler-code als argument, wie beschrieben hier. So könnte man versuchen, zum Beispiel
```
@application.errorhandler(HTTPException)
def http_error_handler(error):
```
behandelt werden alle HTTP-Fehler " (was vermutlich bedeutet, dass alle HTTP-Fehler-codes), oder auch
```
@application.errorhandler(Exception)
def http_error_handler(error):
```
behandeln alle nicht abgefangene Ausnahmen

Edit: angeschaut auf der Kolben-source-code, es ist ein 'TRAP_HTTP_EXCEPTIONS' - flag in der config app, die Sie ändern können (indem zum Beispiel app.config['TRAP_HTTP_EXCEPTIONS']=True).

(In etwa), Wenn das flag false ist, Ausnahmen die Instanzen von HTTPException behandelt werden die Funktionen, die Sie haben dekoriert mit errorhandler(n) wo n ist ein HTTP-Fehler-code; und wenn dieses flag true ist, werden alle Instanzen von HTTPException stattdessen behandelt, indem die Funktionen, die Sie haben dekoriert mit errorhandler(c), wobei c eine exception-Klasse.

Damit
```
app.config['TRAP_HTTP_EXCEPTIONS']=True

@application.errorhandler(Exception)
def http_error_handler(error):
```
erreichen, was Sie wollen.

Da es aussieht wie HTTPException hat Unterklassen für jede HTTP-Fehler-code (siehe hier), Einstellung 'TRAP_HTTP_EXCEPTIONS' und dekorieren Sie Ihre Fehler-Handler für exception-Klassen, die nicht Fehler-codes sieht aus wie ein streng flexiblere Art und Weise, Dinge zu tun.

Referenz, mein Kolben error-handling nun aussieht:
```
app.config['TRAP_HTTP_EXCEPTIONS']=True

@app.errorhandler(Exception)
def handle_error(e):
    try:
        if e.code < 400:
            return flask.Response.force_type(e, flask.request.environ)
        elif e.code == 404:
            return make_error_page("Page Not Found", "The page you're looking for was not found"), 404
        raise e
    except:
        return make_error_page("Error", "Something went wrong"), 500
```
Klappt alles was ich will, und scheint, um alle Fehler, sowohl über HTTP als auch interne. Die if e.code < 400 bisschen ist es auf flask ' s Standard-Verhalten für Umleitungen und dergleichen (sonst diejenigen, die am Ende als Fehler 500s, das ist nicht, was Sie wollen)
- Ich habe versucht, dies in Python 3 mit neueste Flasche aus der PIP-repository. Es hat nicht funktioniert. Irgendeine Idee warum ?
- wie es scheint, sollte dies die akzeptierte Antwort.
- In diesem Fall wird eine HTTPException geworfen wird, mit einem code < 400? Ich habe in der Werkzeug-code (github.com/pallets/werkzeug/blob/master/src/werkzeug/...) und alle Ausnahmen Erben HTTPException-code >= 400 ?
- Es ist schon eine lange Zeit, seit ich darüber nachgedacht habe, und es kann sein, dass in der Praxis der Fall des codes < 400 ist unnötig, aber in der Theorie war dies mit Weiterleitungen umgehen und das wie (wie bereits im letzten Absatz der Antwort), die codes 3xx
InformationsquelleAutor McDuffin

Für mich, den folgenden Schnipsel nicht funktioniert :

@app.errorhandler(HTTPException)
def _handle_http_exception(e):
    return make_response(render_template("errors/http_exception.html", code=e.code, description=e.description), e.code)

Aber ändern HTTPException auf die Reale, wie NotFound war, arbeitete. Frag mich nicht warum, ich habe die Antwort nicht finden.

Also habe ich eine alternative gefunden Lösung, die funktioniert ziemlich gut:

from werkzeug.exceptions import default_exceptions

def _handle_http_exception(e):
    return make_response(render_template("errors/http_exception.html", code=e.code, description=e.description), e.code)

for code in default_exceptions:
    app.errorhandler(code)(_handle_http_exception)

(Gefunden bei Github)

InformationsquelleAutor Cyril N.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.