files - python-m simplehttpserver 8000

¿Cómo escribo un servidor HTTP python para escuchar en múltiples puertos?

Question

Estoy escribiendo un pequeño servidor web en Python, utilizando BaseHTTPServer y una subclase personalizada de BaseHTTPServer.BaseHTTPRequestHandler. ¿Es posible hacer que esto escuche en más de un puerto?

Lo que estoy haciendo ahora

class MyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def doGET
[...]
class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
pass
server = ThreadingHTTPServer((''localhost'', 80), MyRequestHandler)
server.serve_forever()

Answer 1

Yo diría que enhebrar algo así de simple es exagerado. Es mejor utilizar alguna forma de programación asincrónica.

Aquí hay un ejemplo usando Twisted :

from twisted.internet import reactor
from twisted.web import resource, server
class MyResource(resource.Resource):
isLeaf = True
def render_GET(self, request):
return ''gotten''
site = server.Site(MyResource())
reactor.listenTCP(8000, site)
reactor.listenTCP(8001, site)
reactor.run()

También creo que parece mucho más limpio tener cada puerto manejado de la misma manera, en lugar de tener el hilo principal manejar un puerto y un hilo adicional manejar el otro. Podría decirse que se puede arreglar en el ejemplo de la secuencia, pero luego está usando tres hilos.

Answer 2

No es fácil. Puede tener dos instancias de ThreadingHTTPServer, escribir su propia función serve_forever () (no se preocupe, no es una función complicada).

La función existente:

def serve_forever(self, poll_interval=0.5):
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
self.__serving = True
self.__is_shut_down.clear()
while self.__serving:
# XXX: Consider using another file descriptor or
# connecting to the socket to wake this up instead of
# polling. Polling reduces our responsiveness to a
# shutdown request and wastes cpu at all other times.
r, w, e = select.select([self], [], [], poll_interval)
if r:
self._handle_request_noblock()
self.__is_shut_down.set()

Entonces nuestro reemplazo sería algo como:

def serve_forever(server1,server2):
while True:
r,w,e = select.select([server1,server2],[],[],0)
if server1 in r:
server1.handle_request()
if server2 in r:
server2.handle_request()

Answer 3

Por supuesto; simplemente inicie dos servidores diferentes en dos puertos diferentes en dos subprocesos diferentes, cada uno de los cuales usa el mismo controlador. Aquí hay un ejemplo completo y de trabajo que acabo de escribir y probar. Si ejecuta este código, podrá obtener una página web de Hello World en http: // localhost: 1111 / y http: // localhost: 2222 /

from threading import Thread
from SocketServer import ThreadingMixIn
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write("Hello World!")
class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
pass
def serve_on_port(port):
server = ThreadingHTTPServer(("localhost",port), Handler)
server.serve_forever()
Thread(target=serve_on_port, args=[1111]).start()
serve_on_port(2222)