पायथन: दो बंदरगाहों पर सुनें

Question

import socket 
backlog = 1 #Number of queues 

sk_1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sk_2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

local = {"port":1433} 
internet = {"port":9999} 

sk_1.bind (('', internet["port"])) 
sk_1.listen(backlog) 

sk_2.bind (('', local["port"])) 
sk_2.listen(backlog) 

असल में, मेरे पास यह कोड है। मैं दो बंदरगाहों पर सुनने की कोशिश कर रहा हूं: 1433 और 99 99. लेकिन, ऐसा लगता है कि यह काम नहीं करता है।

मैं एक ही पायथन लिपि के भीतर दो बंदरगाहों पर कैसे सुन सकता हूं ??

Answer 1

कोड अब तक ठीक, जहाँ तक के रूप में यह जाता है (सिवाय 1 का संचित अनावश्यक रूप से सख्त लगता है कि), निश्चित रूप से समस्या आता है जब आप accept या तो सॉकेट सुनने पर एक कनेक्शन करने की कोशिश है, क्योंकि accept सामान्य रूप से एक है अवरुद्ध कॉल (और वैकल्पिक रूप से या तो सॉकेट पर शॉर्ट टाइमआउट के साथ स्वीकार करने की कोशिश करके "मतदान" मशीन चक्र को किसी भी अच्छे उद्देश्य के लिए जला देगा)।

बचाव के लिए select -!) select.select (या बेहतर OS के select.poll या यहाँ तक कि select.epoll या select.kqueue ... लेकिन, अच्छे पुराने select.select काम करता है हर जगह पर - जब आप ऐसा) क्या आप जानते हैं जो सॉकेट तैयार है दूँगी और! accept उचित रूप से कर सकते हैं। इन पंक्तियों के साथ, asyncore और asynchat कुछ और संगठन प्रदान करते हैं (और तीसरे पक्ष के फ्रेमवर्क twisted, निश्चित रूप से, बहुत ऐसी "असीमित" कार्यक्षमता जोड़ते हैं)।

वैकल्पिक रूप से, आप दो श्रवण सॉकेट की सेवा के लिए अलग-अलग धागे समर्पित कर सकते हैं, लेकिन इस मामले में, यदि विभिन्न सॉकेट की कार्यक्षमता को समान साझा डेटा संरचनाओं को प्रभावित करने की आवश्यकता होती है, समन्वय (& सी लॉकिंग) टिक्लिश हो सकता है। मैं निश्चित रूप से पहले एसिंक दृष्टिकोण की कोशिश करने की सिफारिश करता हूं - यह वास्तव में सरल है, साथ ही साथ काफी बेहतर प्रदर्शन की संभावना भी प्रदान करता है! -)

Answer 2

यदि आप पाइथन एसडीडी-lib का उपयोग करना चाहते हैं तो ऐसा करने के लिए फैंसी-पैंट तरीका होगा थ्रेडिंगमिक्सिन के साथ सॉकेटसेवर का उपयोग करने के लिए - हालांकि 'चयन' सुझाव शायद अधिक कुशल है।

भले ही हम केवल एक थ्रेडेड टीसीपीआरक्वेट हैंडलर को परिभाषित करते हैं, आप आसानी से इसका पुन: दावा कर सकते हैं कि प्रत्येक श्रोता के पास इसका अनूठा हैंडलर होता है और सर्वर/थ्रेड सृजन को एक विधि में लपेटने के लिए काफी छोटा होना चाहिए यदि आपको पसंद की तरह की चीज़ ।

#!/usr/bin/python 

import threading 
import time 
import SocketServer 

class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler): 

    def handle(self): 
     self.data = self.request.recv(1024).strip() 
     print "%s wrote: " % self.client_address[0] 
     print self.data 
     self.request.send(self.data.upper()) 

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer): 
    pass 

if __name__ == "__main__": 

    HOST = '' 
    PORT_A = 9999 
    PORT_B = 9876 

    server_A = ThreadedTCPServer((HOST, PORT_A), ThreadedTCPRequestHandler) 
    server_B = ThreadedTCPServer((HOST, PORT_B), ThreadedTCPRequestHandler) 

    server_A_thread = threading.Thread(target=server_A.serve_forever) 
    server_B_thread = threading.Thread(target=server_B.serve_forever) 

    server_A_thread.setDaemon(True) 
    server_B_thread.setDaemon(True) 

    server_A_thread.start() 
    server_B_thread.start() 

    while 1: 
     time.sleep(1)