Serveur multi-client en python

[InstinctHack]

Bonjour!

J'aimerais créer un mini serveur en python, cela uniquement dans un but :
Permet à plusieurs programmes locals (mais des distants peuvent aussi, je suis pas contre :p)
J'ai deux exigences, un code assez simple et qui permettent à plusieurs programmes en même temps d'envoyer du texte (environ 50 caractères par envoi)
En même temps, ça veut dire que le serveur n'est pas limité à un seul client

Voilà mon fichier pour un système de ping/pong entre deux machine (l'une doit toujours attente le message de l'autre et il ne doit pas être totalement fini mais je m'en fout, parce que je veut aller plus loin après )

Code PYTHON :


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys, time, socket,threading

class Server():
        def __init__(self):
                print("Création du serveur...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = 1024
                self.Socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                self.Socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)#Cette ligne corrige un problème de libération de port
                self.Active=False
                print("\tConfiguration terminé.")
                print("\tBoucle de tentation de connexion...")

                while self.Active is not True:#Quand que le serveur n'as pas trouver de port utilisable
                        try:
                                self.Socket.bind((self.Host,self.Port))#on tente de l'utiliser
                        except:
                                self.Port+=1#Si ça marche pas, on incremente le port
                        else:
                                self.Active=True
                                print("\t\tConnexion réussie sur le port n° "+str(self.Port))

                print("\tBoucle terminé.")
                print("\tMise sur écoute.")
                self.Socket.listen(1)
                print("\tAttente de connexion.")

                while True:
                        self.Connexion, self.Adress = self.Socket.accept() # accepte les connexions de l'exterieur
                        print("Client connecté, adresse IP %s, port %s" % (self.Adress[0],self.Adress[1]))
                        self.Connexion.send("bienvenue. Envoyez vos messages.".encode())

                        msgClient = self.Connexion.recv(512)
                        while True:
                                print("C>", msgClient.decode())
                                if msgClient.upper() == "FIN" or msgClient =="":
                                        break
                                msgServeur = input("S> ")
                                self.Connexion.send(msgServeur.encode())
                                msgClient = self.Connexion.recv(512)

                        self.Connexion.send("Au revoir !")
                        print("Connexion interrompue.")
                        self.Connexion.close()

                        if input("<R>ecommencer <T>erminer ? ").upper()=="T":
                                break

class Client():
        def __init__(self):
                print("Création du client...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = 1024
                self.Active=False
                self.Socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                print("\tConfiguration terminé.")
                print("\tTentation de connexion...")
                try:
                        self.Socket.connect((self.Host,self.Port))
                except: #socket.error
                        print("\t\tLa connexion au serveur a échouée.")
                else:
                        print("\t\tConnexion établie avec le serveur.")
                        self.Active=True

                print("\tTentation de connexion terminé.")

                if self.Active is True:
                        self.Msg_serveur = self.Socket.recv(512)
                        while True:
                                if self.Msg_serveur.upper() == "FIN" or self.Msg_serveur =="":
                                        break
                                print("S>", self.Msg_serveur.decode())

                                self.Socket.send(input('C> ').encode())
                                self.Msg_serveur = self.Socket.recv(512)

                        print("Connexion interrompue.")
                        self.Socket.close()


if len(sys.argv)>1 and sys.argv[1]=="server":
        Server()
if len(sys.argv)>1 and sys.argv[1]=="client":
        Client()
else:
        print("Usage: "+sys.argv[0]+" [OPTION]")
        print("OPTION : server, client")
 

Ce nouveau code permet d'envoie de message dans les deux sens, en quitant le système envoie/reponse et en utilisant des threads (des beugs existent, affichage, erreur pendant la connexion etc... mais ça fonctionne )

Code PYTHON :


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys, time, socket,threading

class Server():
        def __init__(self):
                print("Création du serveur...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = 1024
                self.Socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                self.Socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)#Cette ligne corrige un problème de libération de port
                self.Active=False
                print("\tConfiguration terminé.")
                print("\tBoucle de tentation de connexion...")

                while self.Active is not True:#Quand que le serveur n'as pas trouver de port utilisable
                        try:
                                self.Socket.bind((self.Host,self.Port))#on tente de l'utiliser
                        except:
                                self.Port+=1#Si ça marche pas, on incremente le port
                        else:
                                self.Active=True
                                print("\t\tConnexion réussie sur le port n° "+str(self.Port))

                print("\tBoucle terminé.")
                print("\tMise sur écoute.")
                self.Socket.listen(1)
                print("\tAttente de connexion.")
                print("Création du serveur terminé.")
                print("\n\n")

                while True:
                        self.Connexion, self.Adress = self.Socket.accept() # accepte les connexions de l'exterieur
                        print("Client connecté, adresse IP %s, port %s" % (self.Adress[0],self.Adress[1]))
                        self.Connexion.send("bienvenue. Envoyez vos messages.".encode())

                        self.Thread_recv=threading.Thread(None, self.recv, None, (), {})
                        self.Thread_send=threading.Thread(None, self.send, None, (), {})
                        self.Thread_recv.start()
                        self.Thread_send.start()

        def recv(self):
                while self.Active:
                        msgClient = self.Connexion.recv(512)
                        print("C>", msgClient.decode())
                        if msgClient.upper() == "FIN" or msgClient =="" or not msgClient:
                                self.Active=False
                                self.quit()

        def send(self):
                while self.Active:
                        msg_server=input("S> envoie ici")
                        if self.Active is True:
                                self.Connexion.send(msg_server.encode())


        def quit(self):
                self.Connexion.send("Au revoir !".encode())
                print("Connexion interrompue.")
                self.Connexion.close()

class Client():
        def __init__(self):
                print("Création du client...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = 1024
                self.Active=True
                self.Connexion = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                print("\tConfiguration terminé.")
                print("\tTentation de connexion...")
                try:
                        self.Connexion.connect((self.Host,self.Port))
                except: #socket.error
                        print("\t\tLa connexion au serveur a échouée.")
                else:
                        print("\t\tConnexion établie avec le serveur.")
                        self.Active=True

                print("\tTentation de connexion terminé.")

                if self.Active:
                        self.Thread_recv=threading.Thread(None, self.recv, None, (), {})
                        self.Thread_send=threading.Thread(None, self.send, None, (), {})
                        self.Thread_recv.start()
                        self.Thread_send.start()

        def recv(self):
                print("test")
                while self.Active:
                        msgClient = self.Connexion.recv(512)
                        print("C>", msgClient.decode())
                        if msgClient.upper() == "FIN" or msgClient =="" or not msgClient:
                                self.Active=False
                                self.quit()

        def send(self):
                print("test")
                while self.Active:
                        msg_server=input("S> envoie ici")
                        if self.Active is True:
                                self.Connexion.send(msg_server.encode())

        def quit(self):
                self.Connexion.close()


if len(sys.argv)>1 and sys.argv[1]=="server":
        Server()
if len(sys.argv)>1 and sys.argv[1]=="client":
        Client()
else:
        print("Usage: "+sys.argv[0]+" [OPTION]")
        print("OPTION : server, client")
 

Ces codes marchent très bien avec un seul client, mais pas plus :/
Comment corriger cela ?

Code PYTHON :


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys, time, socket,threading

class Server():
        def __init__(self):
                print("Création du serveur...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = 1024
                self.Socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                self.Socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)#Cette ligne corrige un problème de libération de port
                self.Active=False
                self.Connexions_dict=dict()
                print("\tConfiguration terminé.")
                print("\tBoucle de tentation de connexion...")

                while self.Active is not True:#Quand que le serveur n'as pas trouver de port utilisable
                        try:
                                self.Socket.bind((self.Host,self.Port))#on tente de l'utiliser
                        except:
                                self.Port+=1#Si ça marche pas, on incremente le port
                        else:
                                self.Active=True
                                print("\t\tConnexion réussie sur le port n° "+str(self.Port))

                print("\tBoucle terminé.")
                print("\tMise sur écoute.")
                self.Socket.listen(1)
                print("\tAttente de connexion.")
                print("Création du serveur terminé.")
                print("\n\n")

                self.Thread_send=threading.Thread(None, self.send, None, (), {})
                self.Thread_send.start()
                while True:
                        Connexion, Adress = self.Socket.accept() # accepte les connexions de l'exterieur
                        id_connexion=str(Adress[0])+":"+str(Adress[1])
                        print("Client connecté, adresse IP %s, port %s" % (Adress[0],Adress[1]))
                        self.Connexions_dict[id_connexion]={
                                "Connexion":Connexion,
                                "Adress":Adress
                        }
                        for element_key,element in enumerate(self.Connexions_dict):
                                print("Client n°"+str(element_key+1)+" connecter via "+element)
                        self.Connexions_dict[id_connexion]["Connexion"].send("bienvenue. Envoyez vos messages.".encode())

                        self.Thread_recv=threading.Thread(None, self.recv, None, (), {"Connexion"elf.Connexions_dict[id_connexion]["Connexion"]})
                        self.Thread_recv.start()

        def recv(self,Connexion):
                while self.Active:
                        msgClient = Connexion.recv(512)
                        print("C>", msgClient.decode())
                        if msgClient.upper() == "FIN" or msgClient =="" or not msgClient:
                                self.Active=False
                                self.quit(Connexion)

        def send(self):
                while self.Active:
                        msg_server=input("")
                        if self.Active is True:
                                if msg_server.split()[0] in self.Connexions_dict:
                                        msg_list=msg_server.split()
                                        channel=msg_list[0]
                                        del msg_list[0]
                                        self.Connexions_dict[channel]["Connexion"].send(" ".join(msg_list).encode())


        def quit(self,Connexion):
                Connexion.send("Au revoir !".encode())
                print("Connexion interrompue.")
                Connexion.close()

class Client():
        def __init__(self):
                print("Création du client...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = 1024
                self.Active=True
                self.Connexion = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                print("\tConfiguration terminé.")
                print("\tTentation de connexion...")
                try:
                        self.Connexion.connect((self.Host,self.Port))
                except: #socket.error
                        print("\t\tLa connexion au serveur a échouée.")
                else:
                        print("\t\tConnexion établie avec le serveur.")
                        self.Active=True

                print("\tTentation de connexion terminé.")

                if self.Active:
                        self.Thread_recv=threading.Thread(None, self.recv, None, (), {})
                        self.Thread_send=threading.Thread(None, self.send, None, (), {})
                        self.Thread_recv.start()
                        self.Thread_send.start()

        def recv(self):
                while self.Active:
                        msgClient = self.Connexion.recv(512)
                        print("C>", msgClient.decode())
                        if msgClient.upper() == "FIN" or msgClient =="" or not msgClient:
                                self.Active=False
                                self.quit()

        def send(self):
                while self.Active:
                        msg_server=input("S>")
                        if self.Active is True:
                                self.Connexion.send(msg_server.encode())

        def quit(self):
                self.Connexion.close()

if len(sys.argv)>1 and sys.argv[1]=="server":
        Server()
if len(sys.argv)>1 and sys.argv[1]=="client":
        Client()
else:
        print("Usage: "+sys.argv[0]+" [OPTION]")
        print("OPTION : server, client")
 

EDIT : j'ai trouver ça et je vais lire :> http://fr.wikibooks.org/wiki/Apprendre_%...%C3%A9seau

EDIT 2 : j'ai mis mon premier code fonctionnel si ça interesse des gens...

EDIT 3 : j'ai rajouter mon deuxième code

Dernier EDIT : J'ai finalement obtenu ce que je désirais, un programme capable de recevoir des data en provenance d'autres programmes et meme d'autres machines! Il marche dans les deux sens également
Il suffit de le lancer ainsi:
sercli.py server

puis pour créer un client :
sercli.py client

la console du client vous donne la possibilité d'envoyer un texte au server à l'infinie
et la console du server fait l'inverse, mais il faudras faire précéder le message de l'identifiant du client qui est sous cette forme {ip}:{port}
donc un message type pourrais être
127.0.0.1:59485 pong

D'autres fonctionnalitées verront le jour probablement comme l'authentification, le chiffrement, le message public (venant d'un user pour faire comme irc, ou venant du serveur pour faire une annonce), également des processus fils pourrait être créer ou des sockets asynchrones... bref
petit lien sur le sujet : http://squirl.nightmare.com/medusa/async_sockets.html

VIVE LE PARTAGE!

[ark]

Thanks pour le code, pas mal de trucs intéressants, je lirais ça sérieusement quand j'aurais un peu de temps. :)

[notfound]

Très sympa ce code Khaled !
Juste pour information purement orthographique, on dit "tentative de connexion" et non pas "tentation de connexion" ...

[InstinctHack]

Merci notfound
Faute corrigée (dans mon hdd)

Je tiens cependant à préciser que ces codes sont publiés sous licence.
plus d'informations sur la licence utilisée : http://fr.m.wikipedia.org/wiki/WTF_Public_License

[belley]

Trés interessant poste!
J'y jeterais un oeil ce soir je pense.

[WizOut]

Ah merci, même si je sais utilisé les sockets en général, c'était juste pour le module du threading que je ne sais pas encore gérer. Il y a bien la méthode select() pour accueillir plusieurs connexions mais le soucis avec celui ci c'est lors de l'envoi d'un message spécifique de la part de l'utilisateur (coté serveur), il bloque à l'approche d'un 'input' quand un client se connecte la meilleur solution reste celle avec l'utilisation des threads (comme tu as fait) qui fait ça parallèlement. Bref merci +1 au passage!

[InstinctHack]

@WizOut, tu peux mettre select en non-bloquant, et aussi t'intéresser à (e)pool qui permettent de gérer BIEN BIEN plus de clients que ce code merdique :p

[WizOut]

@WizOut, tu peux mettre select en non-bloquant, et aussi t'intéresser à (e)pool qui permettent de gérer BIEN BIEN plus de clients que ce code merdique :p

Je sais bien mais je n'ai pas encore appris à gérer pool() , donc je vais m'orienter sur du select / threading sans pool() mais il y a plein de façon différente de faire , à la fin c'est limite embrouillant...

1. Asyncore - threading
2. Select - threading
3. framework python : Twisted
4. Le module eventlet - socket

Il doit y en avoir encore d'autre...

[0pc0deFR]

Je vais étudier ça dès que j'ai un peu de temps car c'est super intéressant

Je te mets un +1 car tu le mérites.