p2p maison

[InstinctHack]

Bonjour,

J'avais soulevé la question il y a quelque chose et visiblement ça inspire creepy_p0ney, donc voilà je fait un petit thread sur ça.

JE connait pas le p2p, ce thread n'est QUE ma réflexion sur le sujet d'un système similaire.

Comment on prog un truc pareil ? (sujet de réflexion, j'ai pas encore fait)
Déjà, il n'y a qu'un seule programme!!! la notion de client-serveur N'EXISTE PAS, on parle de node. (noeud)
Donc au début, faut en trouver... et là, c'est pas facile, vu qu'on connait personne et que les serveur n'existe pas. faut donc connaitre un node, et cela est obligatoire (sinon comment faire ? )
Une fois l'ip et le port du node renseigné, on créer un thread pour écouter ce que l'autre node as à nous dire, puis on se présente à lui et on lui demande si il connait pas d'autres node, on gère sa réponse et si elle est positive, on remplis notre base de données. et on tente de se connecte à chacun d'autre eux en ouvrant une nouvelle socket sur un autre port (le premier port doit toujours etre disponible pour la connexion avec d'autre nodes, ce port ne sert qu'a communiquer le numéro de port que l'on vas utilisé par la suite) une fois nos connexion établis, on peux demander aux nodes si quelqu'un possède une ressource (uniquement des fichiers texte pour ce que ça soit plus simple) dont le sha1 est [hash] si quelqu'un (ou plusieurs) répond oui,alors on demande à ce qu'il nous l'envoit, donc l'idée serais qu'il nous réponde le nombre de lignes que le fichier contient et qu'on demande à chaque node qui possède le fichier si il possède cette ligne du fichier, si oui, alors il nous l'envoit, sinon il nous répond false et on lui en demande un autre (on pourrais surement améliorer ce systeme en l'inversant par exemple...) et il faut garder à l'esprit qu'un autre node peut également se connecter à nous pour nous demander à nous si on possède la ressouce et si oui quels bouts

Voilà, j'ai sorti tout ça de ma tete, ça fait du bien :p

http://fr.wikipedia.org/wiki/Table_de_ha...ibu%C3%A9e

[b0fh]

Ben, c'est à peu près ça, a part que:

- tu n'est pas obligé d'avoir un socket ouvert par peer, tu peux aussi utiliser UDP, et spécifier individuellement l'addresse de destination pour chaque message (et recevoir au même endroit les messages de tous les pairs, plutot que d'avoir a faire un select ou du polling sur une pétée de descripteurs)

- l'idée de compter le nombre de lignes d'un fichier est totalement superflue. Tu pourrais envoyer la taille en bytes si tu veux préallouer, mais pour la plupart des formats binaires le séparateur de ligne n'a pas de sens. Si les données et les messages de controle sont sur une connexion séparée (donc un socket UDP unique pour le controle, et des connexions TCP éphémères pour le transfert), tu peux utiliser la même technique que le vénérable ftp, a savoir simplement balancer le fichier tel quel dans la connexion tcp, c'est meilleur pour la performance et ça marche tout aussi bien.

- pour le problème du boostrap (découverte du premier noeud) effectivement, il n'y a pas de solution, tu es bien obligé d'avoir un point d'accès initial au réseau. Rien ne peut empêcher a coup sur la fragmentation d'un réseau p2p en plusieurs parties qui s'ignorent mutuellement (sauf si tout le monde utilise une ancre commune en dur)

- garder en mémoire tous les peers du réseau ne scale pas bien du tout. Il existe plusieurs techniques pour résoudre ce problème. La solution les plus simple est probabiliste (a la gnutella), on ne garde qu'une petite sélection de peers au hasard et on demande aux peers de répéter le message a tous les voisins; ou, on utilise un overlay structuré, dans lequel les peers s'organisent de manière formelle; le plus ancien et le plus facile a comprendre est Pastry, il y a aussi CAN et Kademlia qui utilisent des organisations et des métriques différentes.

[InstinctHack]

Voilà un petit code en python qui pourras servir de base :
J'ai essayer de commenter un peu le truc, mais certaines parties reste dégeu et la gestion d'erreurs est loin d'etre parfaite :') c'est du tcp, je vais rtfm pour udp

Code PYTHON :


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

import sys, time, socket,threading

class Node():
        """
                Cette classe représente un node
        """
        def __init__(self,Port):
                """
                        Cette fonction démarre le serveur sur le port 1024, puis se met sur écoute
                """
                print("Création du node...")
                print("\tConfiguration en cours...")

                self.Host = '127.0.0.1'
                self.Port = int(Port)
                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.Nodes=dict()#Dictionnaires qui stockeras les connexions avec les autres nodes
                print("\tConfiguration terminé.")

                try:
                        self.Socket.bind((self.Host,self.Port))#on tente de l'utiliser
                except:
                        print("Creation de la socket impossible")
                        sys.exit()

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

                threading.Thread(None, self.command, None, (), {}).start()#on lance le thread pour pouvoir lancer des commandes
                while True:
                        Connexion, Address = self.Socket.accept() # accepte les connexions de l'exterieur
                        id_connexion=str(Address[0])+":"+str(Address[1])#on créer l'id de connexion (forme : 127.0.0.1:1024)
                        print("Client connecté, adresse IP %s, port %s" % (Address[0],Address[1]))
                        """ Puis on l'ajoute dans notre bdd """
                        self.Nodes[id_connexion]={
                                "Connexion":Connexion,
                                "Address":Address
                        }
                        print(self.Nodes)#on affiche les nodes
                        self.Nodes[id_connexion]["Connexion"].send("bienvenue. Envoyez vos messages.".encode())#on dis bonjour
                        threading.Thread(None, self.recv, None, (), {"Address":Address}).start()#on lance un thread qui écoute ce que le node à as dire

        def recv(self,Address):
                """ Fonction qui ne fait qu'afficher ce que les nodes nous envoit (Cette fonction tourne à x exemplaires (x étant le nombre de node connectés) ) """
                while True:
                        try:
                                msgClient = self.Nodes[str(Address[0])+":"+str(Address[1])]["Connexion"].recv(512)#on tente de recuperer le message
                        except:
                                break#si une erreur survient on arrete d'écouter
                        print("C>", msgClient.decode())#on affiche le message
                        if msgClient.upper() == "FIN" or msgClient =="" or not msgClient:
                                break#si le client peut que ça s'arrete, on break aussi
                self.quit(Address)#la boucle d'écoute est finie, donc c'est qu'on veut couper la connexion

        def command(self):
                """ Simple fonction qui tourne sans fin, et envoye le message au node indiqué en premier mot si il existe (exemple 127.0.0.1:1024 ping) """
                while True:
                        msg_elements=input("").split()
                        node=msg_elements[0]
                        if node in self.Nodes:
                                del msg_elements[0]
                                host=node.split(":")[0]
                                port=int(node.split(":")[1])
                                self.send((host,port)," ".join(msg_elements))
                        else:
                                host=node.split(":")[0]
                                port=int(node.split(":")[1])
                                self.connect((host,port))
                                print("Ce node n'existe pas!")

        def send(self,Address,Msg):
                """ Function qui send les data """
#               try:
                self.Nodes[str(Address[0])+":"+str(Address[1])]["Connexion"].send(Msg.encode())
#               except:
#                       print("Une erreur est survenue pendant l'envoi des données!")

        def quit(self,Address):
                """ Function utilisé pour couper une connexion """
                try:
                        self.send(Address,"Au revoir !")#on dis au revoir
                        self.Nodes[str(Address[0])+":"+str(Address[1])]["Connexion"].close()#on close
                except:
                        pass#on ignore les erreurs (exemple, si le client as déjà fermer la socket de son coté
                del self.Nodes[str(Address[0])+":"+str(Address[1])]#on le supprime de la bdd
                print("Connexion interrompue.")#on l'affiche

        def connect(self,Address):
                Socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                Socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)#Cette ligne corrige un problème de libération de port
                Socket.connect(Address)
                self.Nodes[str(Address[0])+":"+str(Address[1])]=dict()
                self.Nodes[str(Address[0])+":"+str(Address[1])]["Connexion"]=Socket
                threading.Thread(None, self.recv, None, (), {"Address":Address}).start()#on lance un thread qui écoute ce que le node à as dire

Node(input("Mon port seras ? : "))
 

[Creepy_p0ney]