Simple Python serveur de processus et des requêtes POST avec JSON

Je suis en train de créer un simple Python serveur afin de tester mon frontend. Il doit être capable de gérer GET et POST demandes. Les données doivent être toujours au format JSON jusqu'à ce qu'ils sont traduits de requête/réponse HTTP. Un script avec un nom correspondant doit être appelé à traiter chaque demande.

server.py

#!/usr/bin/env python

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import SocketServer
import json
import urlparse
import subprocess

class S(BaseHTTPRequestHandler):
    def _set_headers(self):
        self.send_response(200)
        self.send_header('Content-type', 'application/json')
        self.end_headers()

    def do_GET(self):
        self._set_headers()
        parsed_path = urlparse.urlparse(self.path)
        request_id = parsed_path.path
        response = subprocess.check_output(["python", request_id])
        self.wfile.write(json.dumps(response))

    def do_POST(self):
        self._set_headers()
        parsed_path = urlparse.urlparse(self.path)
        request_id = parsed_path.path
        response = subprocess.check_output(["python", request_id])
        self.wfile.write(json.dumps(response))

    def do_HEAD(self):
        self._set_headers()

def run(server_class=HTTPServer, handler_class=S, port=8000):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print 'Starting httpd...'
    httpd.serve_forever()

if __name__ == "__main__":
    from sys import argv

    if len(argv) == 2:
        run(port=int(argv[1]))
    else:
        run()

Exemple de testscript.py pour le traitement des demandes, qui dans ce cas retourne un objet JSON.

#!/usr/bin/env python
return {'4': 5, '6': 7}

Le serveur doit par exemple le retour {'4': 5, '6': 7} pour une réponse en format http://www.domainname.com:8000/testscript.

Mon problème est que je ne peux pas comprendre comment passer des variables entre les deux, et j'ai besoin d'aide pour le faire fonctionner.

Où voulez-vous de passer des variables? pour le serveur ou entre les définitions des classes
Dans cette question principalement de retour variables entre les scripts python. Mais idéalement, je voudrais passer json entre Httprequest -> serveur -> gestionnaire de script -> serveur -> réponse http
Jetez un oeil à ce poste qui fournit un serveur HTTP en fournissant le soutien de POSTE pour Python2.7 stackoverflow.com/questions/31371166/...

OriginalL'auteur Peter Gerhat | 2015-11-12

  1. 9

    Voici un exemple de serveur de client en python. Je suis à l'aide de bouteille bibliothèque pour gérer les demandes vers le serveur et créer un serveur.

    Code Serveur

    import subprocess
from bottle import run, post, request, response, get, route

@route('/<path>',method = 'POST')
def process(path):
    return subprocess.check_output(['python',path+'.py'],shell=True)

run(host='localhost', port=8080, debug=True)

    Il commence server sur localhost:8080. Vous pouvez passer le nom de fichier que vous souhaitez exécuter. Assurez-vous que le fichier est dans le même chemin pour le code ci-dessus à travailler ou changer de chemin de manière appropriée pour exécuter à partir du répertoire différent. Chemin d'accès correspond au nom du fichier et il invoque process fonction lorsque tout le chemin est donné. Si il ne trouve pas le fichier qu'il déclenche l'exception erreur Interne du serveur. Vous pouvez appeler des scripts de sous-répertoires.

    Code Client

    import httplib, subprocess

c = httplib.HTTPConnection('localhost', 8080)
c.request('POST', '/return', '{}')
doc = c.getresponse().read()
print doc

    Il invoque une requête POST à localhost:8080/return

    return.py

    def func():
    print {'4': 5, '6': 7}
func()

    Assurez-vous d'imprimer votre sortie de réaction à l'aide de subprocess.check_output() qu'il attrape seulement des instructions d'impression.

    Utilisation Popen dans subprocess pour ouvrir une connexion continue au lieu de check_output pour passer des arguments à la fonction de serveur

    Cochez cette la documentation sur la façon d'extraire la POSTE ou OBTENIR des valeurs

    @route('/<path>',method = 'GET') def process(path): response.content_type = 'text/html' return 'Hello World GET' est encore de me donner une erreur interne du serveur et il n'y a aucun moyen de le déboguer. votre serveur s'exécute sur le port 800 mais il n'y a aucun signe d'activité, tandis que l'autre serveur est actif.
    Pouvez-vous expliquer votre problème? GET méthode que vous avez posté ne donnent pas toutes les erreurs sur mon serveur, et le serveur s'exécute sur 8080 pas 800
    Oui, il a bien fonctionné à partir de localhost et je n'ai eu que des problèmes d'accès à l'extérieur. Changer host='localhost' à host='0.0.0.0' résolu mon problème et je peux maintenant accéder à partir de sources externes. Tout est bon maintenant.
    oui, c'est dans la documentation de la modifier à 0.0.0.0 va rendre le serveur écoute sur toutes les adresses
    J'ai découvert par le biais du terminal, mais le bon point avec la documentation

    OriginalL'auteur Harwee

  2. 3

    J'utilise ceci:

    https://gist.github.com/earonesty/ab07b4c0fea2c226e75b3d538cc0dc55

    from apiserve import ApiServer, ApiRoute

class MyServer(ApiServer): 
        @ApiRoute("/popup")
        def addbar(req):
            return {"boo":req["bar"]+1}

        @ApiRoute("/baz")
        def justret(req):
            if req:
                 raise ApiError(501,"no data in for baz")
            return {"obj":1}

MyServer("127.0.0.1",8000).serve_forever()

    Ce wrapper vous permet d'écouter sur le port 0 (port élevé aléatoire) dont certains cadres embrouiller. Il gère automatiquement GET/POST demandes pour toutes les routes, et il se fond dans URI arguments avec le haut niveau d'objet JSON arguments. Ce qui est assez bon pour moi dans la plupart des cas.

    C'est beaucoup plus léger que la plupart des cadres. Des cas de Test dans le sens de montrer une meilleure façon dont il fonctionne.

    OriginalL'auteur Erik Aronesty