Python 套接字：数据不一致？

Question

这是我与房间进行分散式聊天的代码，如果我两天前刚刚学习了 python 的草率语法，请道歉..

import threading
import socket
import time
import pickle


n = False
global my_node
global peer
HEADER = 64
# SERVER_IP # CHANGE TO PEER FOR CONNECTING IN FUTURE USING INPUT
FORMAT = 'utf-8'
DISCONNECT = "DISCONNECT"
ROOMS = {}
ROOM_MEMBER = {}
ROOM_MEMBER_NODES = {}  # implement check if node current peer goes down, switch to next node in list
current_room = ""


def handle_connect(conn, addr):
    connected = True
    # Add Send ROOM_MEMBER_NODES list , ROOMS TO EACH NODE
    while connected:
        broadcast = ""
        msg_length = conn.recv(HEADER).decode(FORMAT)  # 64 BYTE HEADER MSG CONTAINING LENGTH OF ACTUAL MSG
        if msg_length:  # IF LENGTH IS NOT 0
            msg = conn.recv(int(msg_length)).decode(FORMAT)  # WAIT FOR MSG SIZE MSG_LENGTH

            if msg[0:2] == "!R":
                room = msg[2:len(msg)]
                if room in ROOM_MEMBER:  # CHECK TO SEE IF ROOM IS CREATED IF NOT CREATE IT , ADD ALERT OF JOIN
                    ROOM_MEMBER[room].append(conn)
                else:
                    ROOM_MEMBER[room] = []
                    ROOM_MEMBER[room].append(conn)  # send index to dict for proper disconnects

                if room in ROOMS:
                    for value in ROOMS[room]:
                        h = str(value).encode(FORMAT)
                        h = len(h)
                        h = str(h).encode(FORMAT)
                        h += b' ' * (HEADER - len(h))
                        conn.send(h)
                        conn.send(value.encode(FORMAT))
                else:
                    if peer_addr == server_addr:
                        ROOMS[room] = []
                        logs = "New Room Created! [{}]".format(room)
                        connsend(conn, logs)
                        connsend(conn, "doesnt send")
                        ROOMS[room].append(logs)
                    else:
                        #get_room_data(room)
                        time.sleep(1)
                        for value in ROOMS[room]:
                            h = value.encode(FORMAT)
                            h = len(h)
                            h = str(h).encode(FORMAT)
                            h += b' ' * (HEADER - len(h))
                            conn.send(h)
                            conn.send(value.encode(FORMAT))

            if msg[0:2] == "!G":  # Sent by Another node to retrieve or create ROOMS[room]
                room = msg[2:len(msg)]
                if server_addr == peer_addr:
                    if room in ROOMS:
                        logs = ROOMS[room]
                        logs = pickle.dumps(logs)
                        length = len(logs)
                        length = str(length).encode(FORMAT)
                        length += b' ' * (65 - len(length))
                        conn.send(length)
                        conn.send(logs)
                    else:
                        ROOMS[room] = []
                        logs = "im gay! [{}]".format(room)
                        logs = logs.encode(FORMAT)
                        length = len(logs)
                        length = str(length).encode(FORMAT)
                        length += b' ' * (65 - len(length))
                        conn.send(length)
                        conn.send(logs)
                        ROOMS[room].append(logs.decode(FORMAT))
                #else:
                    #get_room_data(room)

            if msg[0:2] == "!K":
                room = msg[2:len(msg)]
                msg_size = conn.recv(HEADER).decode(FORMAT)
                msg_text = conn.recv(int(msg_size))
                for x in ROOM_MEMBER[room]:
                    if x != conn:
                        x.send(msg_size.encode(FORMAT))
                        x.send(msg_text)
                        ROOMS[room].append(msg_text)


def handle_init():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(server_addr)  # MY IP
    server.listen()
    global n
    n = True
    print(f"[INIT] Server Is Listening on {server_addr} , you must port forward to fully participate in the network..")
    while True:
        conn, addr = server.accept()
        always_connect = threading.Thread(target=handle_connect, args=(conn, addr))
        always_connect.start()
        print(f"[ACTIVE CONNECTIONS] {threading.active_count() - 2}")


def syncwithpeer(peer_addr):
    connect = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    connect.connect(peer_addr)  # change to user input .... should be IP / port of peer
    global peer
    peer = connect
    print("[SYNCED]")

    global n
    if n:
        if server_addr != peer_addr:
            connect = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            connect.connect(server_addr)  # change to user input .... should be IP / port of peer
            global my_node
            my_node = connect


def joined(addr):
    msg = "[{}] Has Joined the Room".format(addr)
    return msg


def receive():
    while True:
        msg_length = peer.recv(HEADER).decode(FORMAT)
        if msg_length:
            data = peer.recv(int(msg_length)).decode(FORMAT)
            print(f"{data}")


def enter_room(room):
    room = room.upper()
    print(f"-----------------[{room}]------------------------------------")
    send("!R" + room)
    global current_room
    current_room = room


def send(msg):
    message = msg.encode(FORMAT)
    msg_length = len(message)
    msg_length = str(msg_length).encode(FORMAT)
    msg_length += b' ' * (HEADER - len(msg_length))
    peer.send(msg_length)
    peer.send(message)


def connsend(conn, msg):
    message = msg.encode(FORMAT)
    msg_length = len(message)
    msg_length = str(msg_length).encode(FORMAT)
    msg_length += b' ' * (HEADER - len(msg_length))
    conn.send(msg_length)
    conn.send(message)


#def get_room_data(room):
 #   send("!G" + room)
  #  data_length = peer.recv(65).decode(FORMAT)
  #  msg_logs = peer.recv(int(data_length))
   # ROOMS[room] = pickle.loads(msg_logs)


v = input("[RUN AS NODE?] [Y/N]")
if v == 'Y' or v == 'y':
    ip = input("[IP TO BIND SERVER INSTANCE] >>> ")
    if ip == "":
        ip = socket.gethostbyname(socket.gethostname())

    port = input("[PORT] >>> ")
    server_addr = (ip, int(port))
    print("[STARTING] Server Is Starting....")
    init = threading.Thread(target=handle_init)
    init.start()
else:
    pass

time.sleep(2)
print("[PEER INFO]")
ip = input("[IP] >>> ")
if ip == "":
    ip = socket.gethostbyname(socket.gethostname())

port = input("[PORT] >>> ")
peer_addr = (ip, int(port))  # change to -> if blank , peer is node server.
print(f"[SYNCING] ::::: [{ip}][{port}]")
syncwithpeer(peer_addr)


always_receive = threading.Thread(target=receive)
always_receive.start()

NAME = input("[Screen Name] >>> ")
ROOM = input("[Room ID] >>> ")
enter_room(ROOM)

while True:
    your_msg = input(">>> ")

    if your_msg == "!D":
        send(DISCONNECT)
    elif your_msg == "!R":
        ROOM = input("[Room ID] >>> ")
        enter_room(ROOM)
    else:
        t = time.localtime()
        current_time = time.strftime("[%H:%M:%S] ", t)
        your_msg = "[{}]".format(NAME) + current_time + your_msg
        room_router = "!K" + current_room
        send(room_router)
        send(your_msg)

所以预期的结果是，当与节点建立新连接时，客户端向节点发送一个 !R 命令，

第一次发生这种情况时，它应该创建一个房间（这是一个包含 msg 列表的 dict），然后每当其他人加入该房间时，服务器就会将列表中每个项目的副本发送给发送 ! R 命令

def handle_connect(conn, addr):
    connected = True
    # Add Send ROOM_MEMBER_NODES list , ROOMS TO EACH NODE
    while connected:
        broadcast = ""
        msg_length = conn.recv(HEADER).decode(FORMAT)  # 64 BYTE HEADER MSG CONTAINING LENGTH OF ACTUAL MSG
        if msg_length:  # IF LENGTH IS NOT 0
            msg = conn.recv(int(msg_length)).decode(FORMAT)  # WAIT FOR MSG SIZE MSG_LENGTH

            if msg[0:2] == "!R":
                room = msg[2:len(msg)]
                if room in ROOM_MEMBER:  # CHECK TO SEE IF ROOM IS CREATED IF NOT CREATE IT , ADD ALERT OF JOIN
                    ROOM_MEMBER[room].append(conn)
                else:
                    ROOM_MEMBER[room] = []
                    ROOM_MEMBER[room].append(conn)  # send index to dict for proper disconnects

                if room in ROOMS:
                    for value in ROOMS[room]:
                        h = str(value).encode(FORMAT)
                        h = len(h)
                        h = str(h).encode(FORMAT)
                        h += b' ' * (HEADER - len(h))
                        conn.send(h)
                        conn.send(value.encode(FORMAT))
                else:
                    if peer_addr == server_addr:
                        ROOMS[room] = []
                        logs = "New Room Created! [{}]".format(room)
                        connsend(conn, logs)
                        connsend(conn, "doesnt send")
                        ROOMS[room].append(logs)
                    else:
                        #get_room_data(room)
                        time.sleep(1)
                        for value in ROOMS[room]:
                            h = value.encode(FORMAT)
                            h = len(h)
                            h = str(h).encode(FORMAT)
                            h += b' ' * (HEADER - len(h))
                            conn.send(h)
                            conn.send(value.encode(FORMAT))

ROOM_MEMBER 是进入房间的 conn 对象的列表...

出于某种原因，每次有人连接到房间时，它都会执行新的房间代码....

但最奇怪的部分是：

                else:
                    if peer_addr == server_addr:
                        ROOMS[room] = []
                        logs = "New Room Created! [{}]".format(room)
                        connsend(conn, logs)
                        connsend(conn, "doesnt send")
                        ROOMS[room].append(logs)

出于某种原因，只有第一个发送适用于与房间的第二个连接，而不是第二个。 如果节点对等体是它自己，它就可以工作