Messagerie sur le principe client/serveur

Commenter

Contenu du snippet

Normalement tout fonctionne, sauf qu'il faut paramétrer le HOST dans le client. Dans le code du serveur ce n'est pas nécessaire. On peut également modifier le port. Si vous êtes derrière un routeur, n'oubliez pas de router le port correspondant pour que les clients puissent se connecter au serveur.
Certes ce n'est graphiquement pas très beau mais c'est fonctionnel :D
C'est mon premier code, dites tout ce que vous avez à dire !

Source / Exemple : 


#Serveur de messagerie pour systeme Unix créé par PGMSmurf alias MOY
# -*- coding: latin1 -*-

from socket import *
from sys import *   
from threading import *

HOST = '' 
PORT = 54725

print "\x1B[1;36;40]"

class ThreadClient(Thread): 
        #Gestion des connexions client#
        def __init__(self, conn):
                Thread.__init__(self)
                self.connexion = conn

        def run(self):
                #Dialogue avec le Client
                nom = self.getName()   #Recuperation du nom du thread
                msgClient = self.connexion.recv(1024)
                #Gestion des pseudos
                self.nick = msgClient[8:]
                nick_dic[nom] = self.nick
                print self.nick + " vient de se connecter !"
                for clef in conn_client:
                        if clef != nom :
                                conn_client[clef].send(self.nick + " vient de se connecter !")
                while 1:
                        msgClient = self.connexion.recv(1024)
                        if msgClient.upper() == '/QUIT' :
                                break
                                sys.exit()
                        message = self.nick + ": %s" % (msgClient)
                        print message
                        #Envoi du message à tous les clients
                        for cle in conn_client:
                                if cle != nom :
                                        conn_client[cle].send(message)
                #Fermeture de la connexion
                self.connexion.close()   #Plus de connexion cote serveur
                del conn_client[nom]     #Plus d'entree dans le dictionnaire
                del nick_dic[nom]
                print "Client %s déconnecté." % nom
                #FIN DU THREAD
#Mise en place du socket
sock = socket(AF_INET, SOCK_STREAM)
try:
        sock.bind((HOST, PORT))
except socket:
        print "La connexion a échouée."
        sys.exit()
print "Attente de connexions clientes"
sock.listen(100)
#Attente de connexions client
conn_client = {}    #Creation du dictionnaire de connexion
nick_dic = {}       #Creation du dictionnaire de pseudos en fonction de la connexion
while 1:
        connexion, adresse = sock.accept()
        #nouveau thread pour la connexion
        th = ThreadClient(connexion)
        th.start()
        #Memorisation de la connexion dans le dictionnaire
        id = th.getName()   #nom du thread
        conn_client[id] = connexion
        #Enregistrement du nick
        print "Client %s connecté, IP %s, port %s." % (id, adresse[0], adresse[1])
        #Dialogue avec le client
        connexion.send("Vous êtes connecté. Vous pouvez communiquer")

#Client Python adapté au serveur sus-cité créé par PGMSmurf alias MOY
# -*- coding: latin1 -*-

from socket import *
from sys import *
from threading import *

HOST = 'ip_du_serveur'
PORT = 54725

print "Entrez votre pseudo :"
nick = raw_input()

class ThreadReception(Thread):
        #Gestion de la reception des messages#
        def __init__(self, conn):
                Thread.__init__(self)
                self.connexion = conn #Socket de connexion

        def run(self):
                while 1:
                        message_recu = self.connexion.recv(1024)
                        if message_recu[-11:-2] == "connecter":
                                print "\x1B[1;32;40m"
                                print "*" + message_recu + "*"
                                print "\x1B[0;37;40m"
                        else:
                                print "\x1B[0;36;40m"
                                print "*" + message_recu + "*"
                                print "\x1B[0;37;40m"
                        if message_recu.upper() == nick + ': /QUIT' or message_recu == "":
                                break
                                sys.exit()
                #Fin du thread de réception
                #Forcer la fermueture du thread
                th_R._Thread__stop()
                print "Client arrêté, connexion imterrompue"
                self.connexion.close()
class ThreadEmission(Thread):
        #Emission de messages
        def __init__(self, conn):
                Thread.__init__(self)
                self.connexion = conn #socket de connexion
        def run(self):
                while 1:
                        message_emis = raw_input()
                        if message_emis != "":
                                self.connexion.send(message_emis)
        #Emission terminée

#Thread Principal
connexion = socket(AF_INET, SOCK_STREAM)
#Connexion au serveur :
try:
        connexion.connect((HOST, PORT))
except socket:
        print "La connexion a echouée"
        sys.exit()
print "Connexion établie !"
connexion.send("nickname" + nick)
#connexion.send(nick +  " vient de se connecter !")

#Lancement des threads
th_E = ThreadEmission(connexion)
th_R = ThreadReception(connexion)
th_E.start()
th_R.start()

Conclusion :


Un bug a été observé : lors d'une connexion par telnet sur le serveur, la commande /quit ne fonctionne pas et le serveur plante lorsque le terminal est fermé. Donc éviter ce mode de fonctionnement pour l'instant.
Je tenterai de mettre à jour ce code qui, à mon avis, est loin d'être achevé.
Si vous voulez des renseignements pgmsmurf@gmail.com
Pour ce qui est du niveau j'ai mis débutant par ignorance ...

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.