Serveur de chat

a marqué ce sujet comme résolu.

bonjour j'aimerais vous presenter mon software de chat en python, pour l'instant très basique. J'ai un code serveur, un code client et un code appelé manager qui enregistre le client dans une base de données SQLITE3 avec un nom d'utilisateur et un mdp. J'instaurerai dans le code client un bloc de vérification pour voir si le client est bien enregistré dans la base de données.

Mais j'ai quelques questions, comment faire pour qu'un client se connecte à mon serveur d'une autre machine ??? Il n'entrera pas '127.0.0.1' mais une autre adresse ip que je ne connais pas, qui devrait être celle qui run mon serveur mais comment savoir laquelle est-ce ? Je suis sur mac et j'avais déjà posté un sujet sur sa mais après plus personne ne m'a répondu.

Deuxièmement Comment faire pour que le client s'enregistre sur une base de données à la quelle que moi ai-je accès ? Par exemple dans mon dossier la base de données sqlite3 est dans ma machine mais si un clients 'inscrit d'une autre machine je ne veux pas qu'il enregistre ses données sur une base où il aura accès. Alors ma deuxième question est : 'Est-ce-que je peux faire communiquer le script client pour qu'il enregistre ses données dans une base de données présente sur la machine hôte du serveur ?? Comme dans les système des jeux-vidéos ect.

Quelqu'un peut m'éclairer ?

Voici mes codes si sa vous interesse: serveur:

 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
import socket
import sys
import threading
import select

_HOST = '127.0.0.1'
_PORT = 4567
_BUFFER = 1024
_RUNNING = True
_USERS = []

print('/--------- HAXOR CHAT SERVER ----------')


class Server(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.host = socket.gethostbyname(_HOST)
        self.port = int(_PORT)
        self.buffer = _BUFFER
        self.run = _RUNNING
        self.users = _USERS
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def broadcast_data(self, sock, data):
        for sockt in self.users:
            if sockt != self.sock and sockt != sock:
                try:
                    sockt.send(data.encode())
                except:
                    sockt.close()
                    self.users.remove(sockt)

    def main(self):
        try:
            self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.sock.bind((self.host, self.port))
            self.sock.listen(10)
            self.users.append(self.sock)
        except socket.error:
            print('Unable to connect ot the remote host: {0}'.format(self.host))
            sys.exit()
        print('Chat server started on port: ' + str(self.port) + '\r')

        while 1:

            read_sockets, write_sockets, in_error = select.select(self.users, [], [])

            for sockp in read_sockets:
                if sockp == self.sock:

                    sockfd, addr = self.sock.accept()
                    self.users.append(sockfd)
                    print('Client ({0}) connected\n'.format(addr))
                    self.broadcast_data(sockfd, '[{0}] entered the chatroom\n'.format(addr))

                else:

                    try:
                        data = sockp.recv(self.buffer).decode()
                        if data:
                            print('\r' + str(sockp.getpeername()) + data)
                            self.broadcast_data(sockp, '\r' + '(' + str(sockp.getpeername()) + ')' + data)
                    except socket.error:
                        self.broadcast_data(sockp, 'Client({0}) is offline\n'.format(addr))
                        print('Client({0}) is offline\n'.format(addr))
                        sockp.close()
                        try:
                            self.users.remove(sockp)
                        except socket.error:
                            print('\r')
                            continue
                        continue
        self.sock.close()

if __name__ == '__main__':
    server = Server()
    server.main()

client: qui est le code que je rendrai téléchargeable

 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
import sqlite3
import sys
import socket
import select
import hashlib

if len(sys.argv) < 3:
    print('[usage] python client.py <hostname> <port> <nickname>')
    sys.exit()

HOST = str(sys.argv[1])
PORT = int(sys.argv[2])
USERNAME = str(sys.argv[3])
PASSWORD = hashlib.md5(sys.argv[4].encode()).hexdigest()

conn = sqlite3.connect('users_database')
cursor = conn.cursor()

cursor.execute('SELECT username FROM users')
c = cursor.fetchall()
print(c)


class Client:
    def __init__(self):
        self.host = HOST
        self.port = PORT
        self.run = True
        self.buff = 1024
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.settimeout(2)

    def prompt(self):
        sys.stdout.write('<you> ')
        sys.stdout.flush()

    def main(self):
        try:
            self.sock.connect((self.host, self.port))
        except socket.error:
            print('Unable to connect to the remote host: {0}'.format(self.host))
            sys.exit()

        print('connected to the remote host. Start sending messages')
        self.prompt()

        while 1:
            rlist = [sys.stdin, self.sock]

            read_list, write_list, error_list = select.select(rlist, [], [])

            for sock in read_list:

                if sock == self.sock:
                    data = self.sock.recv(self.buff).decode()
                    if not data:
                        print('\nDisconnected from chat server')
                        sys.exit()
                    if data:
                        sys.stdout.write(data)
                        self.prompt()
                else:
                    data = sys.stdin.readline()
                    self.sock.send(data.encode())
                    self.prompt()

if __name__ == '__main__':
    client = Client()
    client.main()

fichier pour s'inscrire dans la base de données sqlite:

 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
import sqlite3
import hashlib
import sys

conn = sqlite3.connect('database.db')
cursor = conn.cursor()

if len(sys.argv) < 3:
    print('[Usage] python manager.py <username> <password>')
    sys.exit()

USERNAME = sys.argv[1]
PASSWORD = hashlib.md5(sys.argv[2].encode()).hexdigest()


class Register:
    def __init__(self):
        self.user = USERNAME
        self.password = PASSWORD
        self.conn = sqlite3.connect('users_database')
        self.cursor = self.conn.cursor()

    def checker(self, username, password):
        with self.conn:
            try:
                self.cursor.execute('CREATE TABLE IF NOT EXISTS users '
                                    '(username TEXT NOT NULL UNIQUE,'
                                    ' password TEXT NOT NULL)')
                data = (username, password)
                self.cursor.execute('INSERT INTO users VALUES(?, ?)', data)
                self.cursor.execute('SELECT * FROM users')
                c = self.cursor.fetchall()
                print(c)
            except sqlite3.IntegrityError:
                print('This username already exists choose another one please...')
                sys.exit()

    def main(self):
        self.checker(self.user, self.password)

if __name__ == '__main__':
    register = Register()
    register.main()

voilà j'éspère avoir de bonnes réponses. Bonne soirée

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte