Python TCP服务器接受连接和广播命令

Question

我一直在使用一些Raspberry Pis，Python和一些按钮/开关进行游戏。我的游戏需要一个向多个客户端发布命令的中央服务器。

我不是新来的编程，但是对于Python和较低层次的网络通信来说并不陌生，并且在过去的2天中我已经在杂草中丢失了如何编写我的服务器代码。

客户端程序是一个简单的socket.connect，然后等待数据发送。那里没有问题。

我很难确定如何编写以及如何使服务器工作。

这里是我的服务器代码看起来像此刻：

import socket, time, sys 
import threading 

TCP_IP = '' 
TCP_PORT = 8888 
BUFFER_SIZE = 1024 
CLIENTS = {} 
clientCount = 0 

def listener(): 
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
    s.bind((TCP_IP,TCP_PORT)) 
    s.listen(5) 
    while True: 
     conn, addr = s.accept() 
     print("new connection from:"+ str(addr)) 
     #print(len(CLIENTS)) 
     global clientCount 
     clientCount = clientCount+1 
     print (clientCount) 
     # register client 
     CLIENTS[conn.fileno()] = conn 


def broadcast(): 
    for client in CLIENTS.values(): 
      client.send('this is a broadcats msg') 

if __name__ == '__main__': 
    listener() 

    while clientCount > 0: 
     broadcast() 
     print(len(CLIENTS)) #print out the number of connected clients every 5s 
     time.sleep(5) 

这里的所需流量： 1.服务器启动并等待第一个连接或更多。我相信这个“​​服务器”应该在后台线程上运行？ 2.如果connectionCount > 0启动主程序循环 3.现在主程序循环应该显示连接的客户端的数量并且每5秒向所有客户端广播一条消息。

我有约5个版本的这台服务器。我尝试了异步，select.select和几种线程方法，但不能完全确定我寻求的行为。我应该把服务器放在后台线程中吗？如果是的话如何广播到所有的连接？

我没有尝试过的唯一的事情是Twisted，那是因为我无法将它安装在Windows中......所以我认为这是暂时的optino。如果任何人有一个指向哪里去，我会很感激它！

更新

好吧，基于@Armans建议，以便有一个服务器类，但它仍然执行相同的我已经更新了我的代码。

class server(): 

    def __init__(self): 
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
     s.bind((TCP_IP,TCP_PORT)) 
     s.listen(10) 
     while 1: 
      client_socket, addr = s.accept() 
      print ('Connected with ' + addr[0] + ':' + str(addr[1])) 
      global clientCount 
      clientCount = clientCount+1 
      print (clientCount) 
      # register client 
      CLIENTS[client_socket.fileno()] = client_socket 
      threading.Thread(target=self.handler, args=(client_socket, addr)).start() 



    def handler(self, client_socket, addr): 
     while 1: 
      data = client_socket.recv(BUFFER_SIZE) 
      print ('Data : ' + repr(data) + "\n") 
      data = data.decode("UTF-8") 


    def broadcast(self, message): 
     for c in self.CLIENTS: 
      c.send(message.encode("utf-8")) 

if __name__ == '__main__': 
    s = server() #create new server listening for connections 

    while clientCount > 0: 
     s.broadcast('msg here') 
     print(len(CLIENTS)) #print out the number of connected clients every 5s 
     time.sleep(5) 

我可以连接多个客户端和控制台显示以下内容：

Connected with 10.0.0.194:38406 
1 
Connected with 10.0.0.169:36460 
2 

但在“而clientCount”循环的代码永远不会运行。这是我被卡住了一段时间的区域，所以如果你有更多的想法，我想在这里有任何想法！

Answer 1

终于搞定了！非常感谢@Arman指导我用正确的方向穿线。我终于觉得我明白了一切都是如何运作的！

这是我完整的服务器&客户端代码。希望这可以帮助其他人使用master>客户端设置。 _broadcast（）函数正在工作，因为您会看到它只是广播静态消息，但这应该是一个简单的更新。

如果任何人有任何关于代码清理的建议，使用此代码作为样本的Python最佳实践，我很想听听和了解更多。再次感谢SE！

##Client 

import socket 
import sys 
import json 

#vars 
connected = False 

#connect to server 
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
client_socket.connect(('10.0.0.158',8888)) 
connected = True 

while connected == True: 
    #wait for server commands to do things, now we will just display things 
    data = client_socket.recv(1024)  
    cmd = json.loads(data) #we now only expect json  
    if(cmd['type'] == 'bet'): 
     bet = cmd['value'] 
     print('betting is: '+bet) 
    elif (cmd['type'] == 'result'):   
     print('winner is: '+str(cmd['winner'])) 
     print('payout is: '+str(cmd['payout'])) 


##Server 

import socket, time, sys 
import threading 
import pprint 

TCP_IP = '' 
TCP_PORT = 8888 
BUFFER_SIZE = 1024 

clientCount = 0 

class server(): 

    def __init__(self): 
     self.CLIENTS = []   


    def startServer(self): 
     try: 
      s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
      s.bind((TCP_IP,TCP_PORT)) 
      s.listen(10) 
      while 1: 
       client_socket, addr = s.accept() 
       print ('Connected with ' + addr[0] + ':' + str(addr[1])) 
       global clientCount 
       clientCount = clientCount+1 
       print (clientCount) 
       # register client 
       self.CLIENTS.append(client_socket) 
       threading.Thread(target=self.playerHandler, args=(client_socket,)).start() 
      s.close() 
     except socket.error as msg: 
      print ('Could Not Start Server Thread. Error Code : ') #+ str(msg[0]) + ' Message ' + msg[1] 
      sys.exit() 


    #client handler :one of these loops is running for each thread/player 
    def playerHandler(self, client_socket): 
     #send welcome msg to new client 
     client_socket.send(bytes('{"type": "bet","value": "1"}', 'UTF-8')) 
     while 1: 
      data = client_socket.recv(BUFFER_SIZE) 
      if not data: 
       break 
      #print ('Data : ' + repr(data) + "\n") 
      #data = data.decode("UTF-8") 
      # broadcast 
      for client in self.CLIENTS.values(): 
       client.send(data) 

     # the connection is closed: unregister 
     self.CLIENTS.remove(client_socket) 
     #client_socket.close() #do we close the socket when the program ends? or for ea client thead? 

    def broadcast(self, message): 

     for c in self.CLIENTS: 
      c.send(message.encode("utf-8")) 

    def _broadcast(self):   
     for sock in self.CLIENTS:   
      try : 
       self._send(sock) 
      except socket.error:     
       sock.close() # closing the socket connection 
       self.CLIENTS.remove(sock) # removing the socket from the active connections list 

    def _send(self, sock):   
     # Packs the message with 4 leading bytes representing the message length 
     #msg = struct.pack('>I', len(msg)) + msg 
     # Sends the packed message 
     sock.send(bytes('{"type": "bet","value": "1"}', 'UTF-8')) 


if __name__ == '__main__': 
    s = server() #create new server listening for connections 
    threading.Thread(target=s.startServer).start() 

    while 1:  
     s._broadcast() 
     pprint.pprint(s.CLIENTS) 
     print(len(s.CLIENTS)) #print out the number of connected clients every 5s 
     time.sleep(5) 

Answer 2

我有一个multithread方法在这里：

s.listen(10) 
    while 1: 
     client_socket, addr = s.accept() 
     print ('Connected with ' + addr[0] + ':' + str(addr[1])) 
     threading.Thread(target=self.handler, args=(client_socket, addr)).start()   


def handler(self, client_socket, addr): 
    while 1: 
     data = client_socket.recv(BUFF) 
     print ('Data : ' + repr(data) + "\n") 
     data = data.decode("UTF-8") 

我强烈建议你们俩写Server和Client一类，为每个客户端创建客户端object并将其连接到Server，并存储每个连接的客户端（它的套接字和一个名字例如）到字典中，然后你想要广播一条消息，你可以通过Server所有连接的客户端和你想要的广播消息：

def broadcast(self, client_socket, message): 
     for c in self.clients: 
      c.send(message.encode("utf-8")) 

更新

因为你有运行主一thread你需要另一个thread对正在运行的服务器，我建议你写的服务器start方法，并调用它在thread：现在

def start(self): 
    # all server starts stuff comes here as define socket 
    self.s.listen(10) 
    while 1: 
     client_socket, addr = self.s.accept() 
     print ('Connected with ' + addr[0] + ':' + str(addr[1])) 
     threading.Thread(target=self.handler, args=(client_socket, addr)).start() 

在创建服务器对象后的主要部分或主文件中运行启动线程：

a = server() 
threading.Thread(target=a.start).start()