import socket
 
# cette fonction n'est pas très performante puisqu'elle
# ouvre et ferme la socket pour chaque message,
# mais vous voyez le principe.
def envoyer_message(ip, port, message):
 
    # on ouvre une socket TCP / IP, en IP V4
    # la doc contient une liste de constantes avec
    # les protocoles de base supportés
    # (http://docs.python.org/2/library/socket.html)
    # on peut aussi ouvrir des sockets unix, des datagrames...
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((ip, port))
    try:
        # on broadcast le message
        sock.sendall(message)
        # et on lit la réponse cash pistache
        # Tout ça est synchrone, car si on veut
        # faire de l'asynchrone, l'exemple serait
        # vachement moins simple
        response = sock.recv(1024)
        print "Received: {}".format(response)
    except Exception as e:
        print "Impossible de se connecter au serveur: {}".format(e)
    finally:
        # toujours fermer sa socket, même si dans notre cas
        # on a pas besoin de la fermer pour chaque message
        # On pourrait aussi utiliser le context manager closing()
        # pour cette tâche
        sock.close()
 
# petit test qui envoit trois messages
if __name__ == "__main__":
 
    ip, port = "127.0.0.1", 7777
 
    envoyer_message(ip, port, "Hello World 1")
    envoyer_message(ip, port, "Hello World 2")
    envoyer_message(ip, port, "Hello World 3")

 
 
import threading
import SocketServer
 
from datetime import datetime
 
 
# Python vient avec ses serveurs socket tout prêts.
# Tout ce qu'il y a faire c'est créer une classe 
# de handler, c'est à dire l'objet qui va s'occuper
# des messages quand ils arrivent. On hérite du 
# handler de la lib standard, et on redéfinit juste
# handle() qui est la méthode qui va être appelée
# à chaque message.
class RequestHandler(SocketServer.BaseRequestHandler):
 
    def handle(self):
        # on récupère des requêtes, et on répond avec
        # exactement le même message + un timestamp
        data = self.request.recv(1024)
        now = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
        response = "{}: {}".format(now, data)
        self.request.sendall(response)
 
# Pour le serveur, pas grand chose à faire à part le définir
# Ici je fais un serveur threadé pour le Lulz car ça
# ne sert pas à grand chose pour un client avec 3 messages
# synchrones
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass
 
 
 
if __name__ == "__main__":
 
    # on instancie notre server et on lui passe le gestionnaire de
    # requêtes
    server = ThreadedTCPServer(('127.0.0.1', 7777), RequestHandler)
    ip, port = server.server_address
 
    # on start le thread pour le serveur et on le daemonise
    server_thread = threading.Thread(target=server.serve_forever)
 
    server_thread.daemon = True
    server_thread.start()
 
    # si on appuie sur "enter", raw_input() s'arrête et le serveur
    # est stoppé
    raw_input("Hit enter to stop the server")
 
    server.shutdown()