TP Graphes : Simulation d’un réseau de routeurs suivant le protocole RIP

Revoir cette page au besoin pour se rafraîchir la mémoire.

On considère le petit réseau ci-contre pour lequel seuls les routeurs figurent ( et pas les machines qui y sont connectées ).

Le but est de simuler la mise à jour des tables de routage de chaque routeur selon le protocole RIP.

Ces tables de routage contiennent normalement les IP associées aux interfaces des routeurs de destination et passerelle, mais pour simplifier, on se contentera d'y faire figurer le nom des routeurs.

Chaque table de routage ne contiendra que les informations : nom routeur de destination, nom du routeur passerelle, nombre de sauts.

Pour cette application, une classe pour modéliser un routeur sera créée, et des fonctions manipuleront des objets instanciés à partir de cette classe pour simuler un réseau de routeurs.

Classe `Routeur`

Attributs

nom: str : le nom du routeur
table: dict : la table de routage sous forme d'un dictionnaire {destination: [passerelle, sauts]}, ce qui permettra de déterminer facilement si une destination se trouve déjà dans la table de routage.

Méthodes

le constructeur associera un nom à chaque routeur, et créera pour lui une table de routage vide.
get_nom() : renvoie le nom du routeur
get_table(): renvoie la table de routage complète du routeur
maj_table(destination: str, passerelle: str, saut: int): écrit simplement une ligne dans la table de routage pour une destination donnée
recevoir_table(routeur: Routeur): reçoit la table de routage d'un routeur voisin et met à jour au besoin la table de routage du routeur en utilisant la méthode maj_table()

La méthode recevoir_table() est la plus délicate : bien revoir le principe du protocole RIP pour identifier toutes les situations pour lesquels une mise à jour de la table est nécessaire.

Écrire le code de la classe Routeur


class Routeur:

	def __init__(self, nom: str):
		pass
		
	def get_nom(self)->str:
		pass
		
	def get_table(self)->dict:
		pass
		
	def maj_table(self, destination: str, passerelle: str, sauts: int):
		pass
	
	def recevoir_table(self, routeur: Routeur):
		pass

class Routeur: def __init__(self, nom: str): pass def get_nom(self)->str: pass def get_table(self)->dict: pass def maj_table(self, destination: str, passerelle: str, sauts: int): pass def recevoir_table(self, routeur: Routeur): pass

SOLUTION

Le réseau de routeurs

Le réseau lui-même sera modélisé par un graphe, dont les sommets seront des objets instanciés à partir de la classe Routeur; les arêtes seront les liens qui existent entre les routeurs.

Après avoir importé votre module graphe créé précédemment, instancier un objet Graphe qui modélisera le réseau.
créer les sommets du graphe, qui correspondent ici à des objets instanciés à partir de la classe Routeur
Créer les arêtes entre les sommets du graphe, correspondant aux liens ( bidirectionnels ! ) entre les routeurs.
écrire une fonction rip() qui met à jour les tables de routage des routeurs du réseau en suivant le protocole RIP.
écrire alors un programme qui simule les mises à jour successives des tables de routage des routeurs; combien de "passes" de ce protocole sont-elles nécessaires pour observer une stabilisation des tables de routage ?

Vous pourrez visualiser le réseau à l'aide de la méthode dessine du module graphe; attention à l'identifiant à afficher pour chaque routeur, les sommets du graphe sont des objets !