Programme de chat client-serveur basique

Objectif : Créer une application de chat où le serveur accepte plusieurs connexions clients et transfère les messages entrants à tous les participants connectés, à l'expéditeur exclus.

Technolgoies clés : Programmation concurrente avec threads, sockets TCP, gestion d'état partagé.

Outil de développement : Python avec les modules standard socket et threading.

L'implémentation suivante illustre une architecture événementielle avec diffusion centralisée.

Serveur de chat

import socket
import threading

# Ensemble pour stocker les sockets des clients connectés
participants = set()

def gerer_client(sock_client, adr_client):
    """Traite les échanges avec un client spécifique."""
    while True:
        try:
            donnees = sock_client.recv(1024).decode('utf-8')
            if not donnees:
                break
            # Diffusion à tous les autres participants
            for participant in participants.copy():
                if participant is not sock_client:
                    try:
                        participant.send(donnees.encode('utf-8'))
                    except OSError:
                        participants.discard(participant)
                        participant.close()
        except (ConnectionResetError, ConnectionAbortedError):
            break
    participants.discard(sock_client)
    sock_client.close()
    print(f"Connexion terminée : {adr_client}")

def demarrer_serveur(hote='localhost', port=8888):
    """Initialise et exécute le serveur de chat."""
    ecouteur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    ecouteur.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    ecouteur.bind((hote, port))
    ecouteur.listen(10)
    print(f"Serveur actif sur {hote}:{port}")

    while True:
        socket_client, adresse = ecouteur.accept()
        participants.add(socket_client)
        print(f"Nouvelle connexion de {adresse}")
        fil = threading.Thread(target=gerer_client, args=(socket_client, adresse))
        fil.daemon = True
        fil.start()

if __name__ == "__main__":
    demarrer_serveur()

Client de chat

import socket
import threading

def recevoir_messages(sock):
    """Affiche en continu les messages entrants."""
    while True:
        try:
            msg = sock.recv(1024).decode('utf-8')
            if msg:
                print(f"\n[Message reçu] {msg}")
        except OSError:
            print("\nConnexion interrompue.")
            break

def lancer_client(hote='localhost', port=8888):
    """Établit la connexion et gère les interactions utilisateur."""
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((hote, port))

    # Thread pour l'écoute asynchrone
    thread_reception = threading.Thread(target=recevoir_messages, args=(sock,))
    thread_reception.start()

    # Boucle d'envoi de messages
    while True:
        texte = input("Votre message : ")
        if texte.lower() == 'fin':
            break
        sock.send(texte.encode('utf-8'))

    sock.close()
    print("Déconnexion réussie.")

if __name__ == "__main__":
    lancer_client()

Autres concepts de programmation réseau

Transfert de fichiers : Développer un système permettant l'envoi et la réception de fichiers entre client et serveur. Techniques impliquées : sockets, flux de données, vérification d'intégrité.

Serveur HTTP léger : Construire un serveur capable de répondre aux requêtes GET avec du contenu HTML dynamique, comme une page d'accueil personnalisée. Protocoles et outils : HTTP, sockets, analyse des en-têtes.

API REST fonctionnelle : Concevoir une interface de programmation supportant les opérations CRUD pour une ressource donnée, par exemple la gestion de tâches. Frmaeworks courants : Flask, Express.js, Spring Boot.

Chat temps réel avec WebSocket : Implémenter une communication bidirectionnelle persistante pour des mises à jour instantanées. Le serveur maintient toutes les connexions actives et propage les événements. Bibliothèques : websockets (Python), Socket.IO (JavaScript).