FinalProject/Server.py at master · AlexG1031/FinalProject · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import socket
import select
from copy import copy


def get_needed_space(message):
    needed_spaces = 10 - len(
        bytes(str(len(message)), 'utf-8'))  # number of bits needed to be filled with ''
    return ' ' * needed_spaces


def generate_message(message):
    spaces = get_needed_space(message)
    everybody = "Everybody"
    spaces2 = get_needed_space(everybody)
    return {'message_header': bytes(str(len(message)) + spaces, 'utf-8'),
            'message_data': bytes(str(message), 'utf-8'),
            'whom_header': bytes(str(len(everybody))+spaces2, 'utf-8'),
            'whom_data': bytes(str(everybody), 'utf-8')}

def notify_clients(type, actor):
    server_name = "SERVER"
    clients_send = generate_message(clients_str)
    server_send = generate_message(server_name)

    if type == 'client_joined':
        notif_msg = "Client " + actor['message_data'].decode(
            'utf-8').strip() + " has just joined the group chat. Praise the sun!"
        notif_msg = generate_message(notif_msg)
    elif type == 'client_exited':
        notif_msg = "Client " + actor['message_data'].decode(
            'utf-8').strip() + " has just left."
        notif_msg = generate_message(notif_msg)
    else:
        raise Exception('Server: unrecognized notification type')
    for client_socket in clients:
        client_socket.send(server_send['message_header'] + server_send['message_data'] +
                           notif_msg['message_header'] + notif_msg['message_data'] +
                           clients_send['message_header'] + clients_send['message_data'] +
                           server_send['whom_header'] + server_send['whom_data'])

def generate_clients_str(c_dict):
    rtn = "Everybody"
    for key, value in c_dict.items():
        val = value['message_data'].decode('utf-8')
        rtn += " " + val
    return rtn

HEADER_LENGTH = 10

IP = "127.0.0.1"
PORT = 1234

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((IP, PORT))
server_socket.listen()
sockets_list = [server_socket]
clients = {}
clients_str = " everyone"
client_to_socket = {}
print(f'Listening for connections on {IP}:{PORT}...')


def receive_message(client_socket):
    try:
        message_header = client_socket.recv(HEADER_LENGTH)
        if not len(message_header):
            return False
        message_length = int(message_header.decode('utf-8').strip())
        message_data = client_socket.recv(message_length)
        whom_header = client_socket.recv(HEADER_LENGTH)
        whom_length = int(whom_header.decode('utf-8').strip())
        whom_data = client_socket.recv(whom_length)
        return {'message_header': message_header, 'message_data': message_data,
                'whom_header': whom_header, 'whom_data': whom_data}

    except:
        return False


while True:
    read_sockets, _, exception_sockets = select.select(sockets_list, [], sockets_list)

    for notified_socket in read_sockets:

        if notified_socket == server_socket:
            client_socket, client_address = server_socket.accept()
            while True:
                user = receive_message(client_socket)
                if user is False:
                    continue
                if (user['message_data'].decode('utf-8') in clients_str):
                    rejected_username = "Another client already has that username... Please choose another name"
                    rejected_username = generate_message(rejected_username)
                    client_socket.send(rejected_username['message_header'] + rejected_username['message_data'])
                else:
                    accepted_username = "username accepted :)"
                    accepted_username = generate_message(accepted_username)
                    client_socket.send(accepted_username['message_header'] + accepted_username['message_data'])
                    sockets_list.append(client_socket)
                    clients[client_socket] = user
                    clients_str = generate_clients_str(clients)
                    client_to_socket.update({user['message_data'].decode('utf-8'): client_socket})
                    print('Accepted new connection from {}:{}, username: {}'.format(*client_address,
                                                                                    user['message_data'].decode('utf-8')))
                    notify_clients('client_joined', actor=user)
                    break
        else:
            remove_client = copy(clients[notified_socket])
            removed_client_encoded = clients[notified_socket]['message_data'].decode('utf-8')
            message = receive_message(notified_socket)
            if message is False:
                print('Closed connection from: {}'.format(removed_client_encoded))
                # worry about this later
                sockets_list.remove(notified_socket)

                # notify all the clients that someone just exited.
                del clients[notified_socket]
                clients_str = generate_clients_str(clients)
                del client_to_socket[removed_client_encoded]
                notify_clients('client_exited', actor=remove_client)
                continue
            user = clients[notified_socket]
            print(f'Received message from {user["message_data"].decode("utf-8")}: {message["message_data"].decode("utf-8")}')
            clients_send = generate_message(clients_str)
            if message["whom_data"].decode('utf-8').strip() == "Everybody":
                for client_socket in clients:
                    if client_socket != notified_socket:
                        client_socket.send(user['message_header'] + user['message_data'] +
                                           message['message_header'] + message['message_data'] +
                                           clients_send['message_header'] + clients_send['message_data'] +
                                           message['whom_header'] + message['whom_data'])
            else:
                client_socket = client_to_socket.get(message["whom_data"].decode('utf-8').strip())
                client_socket.send(user['message_header'] + user['message_data'] +
                                   message['message_header'] + message['message_data'] +
                                   clients_send['message_header'] + clients_send['message_data'] +
                                   user['message_header'] + user['message_data'])

    for notified_socket in exception_sockets:
        sockets_list.remove(notified_socket)
        del clients[notified_socket]