Récupère le corps POST brut dans un flacon Python, quel que soit l'en-tête Content-Type

Question

Donc, tout à l'heure j'ai demandé la même question: Comment obtenir de l'ensemble de la demande de POSTE corps en Python (Flacon)

Et j'ai obtenu une réponse qui en fait flask.request.data est le raw POST CORPS. Mais qui semble fonctionner que si la demande a quelques en-têtes supplémentaires:

headers = {
    'Content-type': 'binary/octet-stream',
    'Content-length': len(postBody),
    'Content-transfer-encoding': 'binary',
}

Si ces en-têtes ne sont pas présents, l' flask.request.data est vide:

from flask import Flask

app = Flask(__name__)
@app.route('/', methods=['POST'])
def parse_request():
    data = flask.request.data # but data will be empty unless the request has the proper content-type header...

Alors maintenant j'ai trouvé la demande est réellement application/x-www-form-urlencoded (qui est par défaut de type mime) ensuite, j'ai pu prendre les données comme ceci:

app = Flask(__name__)
@app.route('/', methods=['POST'])
def parse_request():
    data = flask.request.data # but data will be empty unless the request has the proper content-type header...
    if not data:
        data = request.form.keys()[0]

Mais je ne suis pas sûr que je pouvais compter sur elle...

Alors, est-il un moyen d'être en mesure d'obtenir le raw post corps d'une requête post, quel que soit les en-têtes?

Answer 1

Je suis en utilisant Flacon 0.10.1 l'a, et si vous regardez le code source, il s'avère que vous pouvez appeler

request.get_data()

Pour obtenir les données brutes, indépendamment du type de contenu. Les données de la demande est ensuite mis en cache, et vous pouvez ensuite accéder request.data, request.json, request.form .

Toutefois, si vous accédez request.data tout d'abord, il appellera get_data avec différentes options, où la forme de l'analyse est exécutée en premier, et à la demande de lecture de données à partir du flux n'est jamais stockée; request.form, request.json etc. ensuite, n'a rien à travailler avec.

Answer 2

Il y a request.stream lorsque le type mime n'est pas reconnu.

 data = request.stream.read()
 

Answer 3

Je viens d'avoir ce problème, et je pense que quelques-uns d'entre vous pourraient bénéficier de ma solution. J'ai créé une classe de middleware WSGI qui enregistre le corps POST brut du socket. J'ai enregistré la valeur dans la variable WSGI 'environ' afin de pouvoir l'appeler comme suit: request.environ ['body_copy'] dans mon application Flask.

Vous devez faire attention à ce que les données de publication ne soient pas trop volumineuses, sinon vous pourriez avoir des problèmes de mémoire sur votre serveur.

 class WSGICopyBody(object):
    def __init__(self, application):
        self.application = application

    def __call__(self, environ, start_response):

        from cStringIO import StringIO
        length = environ.get('CONTENT_LENGTH', '0')
        length = 0 if length == '' else int(length)

        body = environ['wsgi.input'].read(length)
        environ['body_copy'] = body
        environ['wsgi.input'] = StringIO(body)

        # Call the wrapped application
        app_iter = self.application(environ, 
                                    self._sr_callback(start_response))

        # Return modified response
        return app_iter

    def _sr_callback(self, start_response):
        def callback(status, headers, exc_info=None):

            # Call upstream start_response
            start_response(status, headers, exc_info)
        return callback

app.wsgi_app = WSGICopyBody(app.wsgi_app)

request.environ['body_copy'] # This is the raw post body you can use in your flask app
 

Answer 4

J'ai finalement compris si je fais ça:

request.environ ['CONTENT_TYPE'] = 'application / quelque chose_Flask_ignores'

Request.data aura alors les données de publication. Cela se produit si vous ne pouvez pas contrôler la demande du client et souhaitez simplement la remplacer sur le serveur.