एकाधिक बंदरगाहों को सुनने के लिए मैं एक पायथन HTTP सर्वर कैसे लिखूं?

Question

मैं बेसहॉट में एक छोटा वेब सर्वर लिख रहा हूं, बेसएचटीटीपीएसरवर और बेसएचटीटीपीएसरवर का एक कस्टम उप-वर्ग। बेसहेटीपीआरक्वैस्ट हैंडलर। क्या यह एक से अधिक बंदरगाहों पर सुनना संभव है?

क्या मैं अब कर रहा हूँ:

class MyRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): 
    def doGET 
    [...] 

class ThreadingHTTPServer(ThreadingMixIn, HTTPServer): 
    pass 

server = ThreadingHTTPServer(('localhost', 80), MyRequestHandler) 
server.serve_forever() 

Answer 1

ज़रूर; दो अलग-अलग बंदरगाहों पर दो अलग-अलग बंदरगाहों पर दो अलग-अलग सर्वरों को शुरू करें जो प्रत्येक एक ही हैंडलर का उपयोग करते हैं। यहां एक पूर्ण, कामकाजी उदाहरण है जिसे मैंने अभी लिखा और परीक्षण किया। आप इस कोड को चलाने के हैं तो आप http://localhost:1111/ और 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) 

Answer 2

नहीं आसानी से दोनों पर एक नमस्ते विश्व वेबपेज प्राप्त करने में सक्षम हो जाएगा। आपके पास दो थ्रेडिंग एचटीटीपीएस सर्वर उदाहरण हो सकते हैं, अपना स्वयं का Serv_forever() फ़ंक्शन लिखें (चिंता न करें यह एक जटिल कार्य नहीं है)।

मौजूदा समारोह:

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() 

इसलिए हमारे प्रतिस्थापन होगा कुछ की तरह:

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

मैं कहूँगा कि कुछ इस सरल के लिए सूत्रण overkill है। आप असीमित प्रोग्रामिंग के कुछ रूपों का उपयोग कर बेहतर हैं।

यहाँ एक उदाहरण 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() 

मैं भी सोचता है कि यह प्रत्येक बंदरगाह के बजाय मुख्य थ्रेड एक बंदरगाह और एक अतिरिक्त धागा संभाल होने के, एक ही तरह से नियंत्रित किया जाना है करने के लिए एक बहुत क्लीनर लग रहा है दूसरे को संभालें। तर्कसंगत है कि थ्रेड उदाहरण में तय किया जा सकता है, लेकिन फिर आप तीन धागे का उपयोग कर रहे हैं।