View difference between Paste ID: 1E45Exsy and

-
+import threading, socket, Queue, sys, pickle
 import SocketServer
 
 comm = None
 uid = 0
 
 def log(location, msg):
     sys.stderr.write("LOG::thread %s::%s::%s\n" %(threading.current_thread().name, location, msg.encode("string_escape")))
 
 class communicator():
 
     def __init__(self):
         self.client_q = Queue.Queue()
         self.stdin_q = {}
         self.stdin_q_lock = threading.Lock()
 
     def stdin_q_put(self, client, msg):
         log("stdin_q_put", "acquiring stdin_q lock")
         self.stdin_q_lock.acquire()
         log("stdin_q_put", "got stdin_q lock")
         if not self.stdin_q.has_key(client):
             log("stdin_q_put", "stdin queue for client %s not found, creating" % client)
             self.stdin_q[client] = Queue.Queue()
         self.stdin_q_lock.release()
         log("stdin_q_put", "released stdin_q lock")
         self.stdin_q[client].put(msg)
         log("stdin_q_put", "sent message '%s' on stdin_q %s" %(msg, client))
 
     def stdin_q_get(self, client):
         log("stdin_q_get", "acquiring stdin_q lock")
         self.stdin_q_lock.acquire()
         log("stdin_q_get", "got stdin_q lock")
         if not self.stdin_q.has_key(client):
             log("stdin_q_get", "stdin queue for client %s not found, creating" % client)
             self.stdin_q[client] = Queue.Queue()
         self.stdin_q_lock.release()
         log("stdin_q_get", "released stdin_q lock")
         log("stdin_q_get", "waiting for message on stdin queue %s" % client)
         msg = self.stdin_q[client].get()
         log("stdin_q_get", "got message %s" % msg)
         return msg
 
 
     def send_msg(self, client, msg):
         self.client_q.put((client, msg))
 
     def recv_msg(self, client):
         return self.stdin_q_get(client)
 
     def serve_client(self):
         log("communicator serve client", "starting serve_client")
         while True:
             client, msg = self.client_q.get()
             log("communicator serve client", "got data: cid='%s', msg='%s'" %(client, msg))
             sys.stdout.write(pickle.dumps((client, msg)).encode("string_escape") + "\n")
             log("communicator serve client", "wrote to stdout")
 
     def serve_stdin(self):
         log("communicator serve stdin", "starting serve_stdin")
         while True:
             line = sys.stdin.readline()
             client, msg = pickle.loads(line[0:-1].decode("string_escape"))
             log("communicator serve stdin", "got data: cid='%s', msg='%s'" %(client, msg))
             self.stdin_q_put(client, msg)
             log("communicator serve stdin", "wrote to stdin_q")
 
 
 
 
 class tcp_server():
 
 
     def __init__(self, host, port):
         self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.s.bind((host, port))
         self.s.listen(5)
 
     def send_stream(self, cid, s):
         log("send_stream", "send stream started")
         while True:
             msg = s.recv(1024)
             log("send_stream", "got message from client: '%s'" %msg)
             comm.send_msg(cid, msg)
 
     def recv_stream(self, cid, s):
         log("recv_stream", "recv stream started")
         while True:
             msg = comm.recv_msg(cid)
             log("recv_stream", "got message '%s'" % msg)
             s.sendall(msg)
             log("recv_stream", "sent message to client %s" % cid)
 
 
 
     def serve_forever(self):
         while True:
             clientsocket, address = self.s.accept()
             global uid
             cid = uid
             uid += 1
             threading.current_thread().name = "client creation thread %s" %cid
             log("incoming connection", "got socket '%s' from address '%s'" %(clientsocket, address))
             t1 = threading.Thread(target = self.send_stream, args = (cid, clientsocket))
             t1.name = "tcp_send_stream %s" % cid
             t1.start()
             log("incoming connection", "send_stream thread started")
             t2 = threading.Thread(target = self.recv_stream, args = (cid, clientsocket))
             t2.name = "tcp_recv_stream %s" % cid
             t2.start()
             log("incoming connettion", "recv_stream started")
 
 
 if __name__ == "__main__":
 
     log("init", "program launched")
 
     if len(sys.argv) < 2:
         log("ERR", "Usage: python singleconn.py port [host]")
         exit()
 
     PORT = int(sys.argv[1])
     if len(sys.argv) > 2:
         HOST = sys.argv[2]
     else:
         HOST = "localhost"
     log("init", "PORT: %s, HOST: %s" %(PORT, HOST))
     svr = tcp_server(HOST, PORT)
 
     log("init", "TCP server initalised")
 
     comm = communicator()
     log("init", "communicator intitalised")
     t1 = threading.Thread(target = comm.serve_client)
     t1.name = "communicator_serve_client"
     t1.start()
     log("init", "communicator serve_client started")
     t2 = threading.Thread(target = comm.serve_stdin)
     t2.name = "communicator_serve_stdin"
     t2.start()
     log("init", "about to serve TCP server")
     svr.serve_forever()