Discussion :

[Jb_One73]

Bonjour à tous !

J'aurai besoin de vos idées dans la conception de mon programme, j'ai une application "coordinateur" qui est le cœur du système, son rôle est de distribuer à d'autres applications des paramètres (nombre max de routeurs (nommé "R") pouvant être connectés à un même routeur, nombre max de clients (nommé "D") pouvant être connectés à un même routeur, la profondeur de l'arbre (nommé "P") et pour finir l'adresse du routeur racine ce qui au final donnera un schéma de nommage ZigBee.
Les 2 autres applications "Routeur" et "Client" vont donc avant de se connecter interroger le "Coordinateur" afin de récupérer ces paramètres (pour ce faire j'utilise RMI). Une fois cette étape réalisée les applications pour se connecter vont procéder différemment :

Le routeur :
Il va interroger le routeur racine dont l'adresse a été précédemment par le "Coordinateur" alors ce qu'il faut savoir c'est qu'un routeur ne peut se connecter qu'à un routeur père, si celui-ci a atteint son nombre max de routeurs qui peuvent lui être connecté, le routeur racine va lui communiquer la liste des routeurs et en fonction de cette liste le routeur va rechercher un père de disponible pour si connecter.
Le résultat que je dois obtenir doit être de la forme suivante :


Ce que je pense faire, c'est donc de créer une collection ArrayList (pour des raisons de doublons) qui contiendra la liste ordonnée des adresses des routeurs (schématiquement cela donnerai ceci : colonne 1- l'adresse du père, colonne 2 l'adresse du fils), quand un routeur veut se connecter, il interroge d'abord le routeur racine, si celui-ci n'a pas atteint son quota de connexion, il si connecte, en revanche dans le cas contraire, il récupère la collection contenant la liste des adresses des routeurs pour rechercher un père disponible.

Qu'en pensez-vous ? Je ne vais pas d'écrire le client qui lui est à peut prêt similaire au routeur, je le ferai en deuxième étape, c'est à dire qu'en j'aurai déjà conçu ma classe routeur.

Une petite précision :
Lorsqu'un routeur s'exécute, il doit rester en mode console, donc à chaque fois que je vais exécuter un routeur je devrais avoir une nouvelle console (1 par routeur).

Je vous remercie d'avance à tous pour vos idées ou autres, je précise, c'est pas le code que je veux mais juste vos idées pour concevoir mon programme.

Cordialement.

[dinobogan]

Je trouve vraiment dommage qu'un nouveau routeur soit obligé de parcourir lui-même le réseau pour se trouver une place. Ce n'est pas au petit nouveau de choisir ou il doit aller, mais au réseau de décider ou le nouveau doit se placer.
Cela présente un autre désavantage : si ton réseau devient très grand et quasi-complet, le nouveau routeur risque de devoir parcourir l'intégralité du réseau pour trouver une place. Cela signifie qu'il va produire un grand nombre de communications avec tout les routeurs. Pour un réseau Zigbee sensé limité le volume des communications, je ne trouve pas ça terrible.

Voici une idée possible : elle inverse le paradigme.
Par contre, tu ne donnes pas assez d'infos alors je pose mes suppositions : le routeur "coordinateur" est toujours vivant. Il tourne sur une machine avec suffisamment de RAM pour stocker tous les routeurs possédant encore des places de libres pour un nouveau routeur.
Le "coordinateur" possède une pile (liste spéciale : il faut la voir comme un tas => on ajoute en tête et retire en tête uniquement) des routeurs acceptant une nouvelle connexion fils. Il prend le premier routeur et lui demande s'il accepte un nouveau fils. Si non il le retire de la pile et passe au suivant. Si oui, il donne l'adresse du routeur au nouveau.
Si un routeur perd un fils, il prévient le "coordinateur" qui l'ajoutera dans la pile s'il n'est pas déjà présent.
Ce mécanisme simple (s'il est possible dans ton cas) va grandement limiter le volume des données échangées sur le réseau. De plus, l'ajout d'un nouveau routeur se fera très rapidement.

[Jb_One73]

Bonjour et merci dinobogan pour ta réponse alors je sais pas trop si ta solution serait adaptable dans mon cas car je sais pas si bien compris ce que tu as essayé de me dire. Ce que je pense avoir compris c'est que le coordinateur contient la plage d'adresse disponible a distribuer au futur routeurs qui vont se connecter (ex : 1 à 12). Le routeur se présente et demande au routeur racine si un routeur père est disponible pour qu'il puisse se connecter à lui, pour cela, le routeur consulte la liste, il prend le 1er de celle-ci et lui demande s'il est autorisé à se connecté à lui, si oui, on le retire de la liste mais uniquement si son quota de connexion est plein.

Alors si c'est ça, pour moi c'est ok ! D'ailleurs je viens de le rendre compte que cette solution est parfaite. Quand tu parles de tas, tu veux dire une collection de type ArrayList ? Pour la conception de cette liste, je pense qu'il me faut l'adresse du routeur et son nombre de routeurs connectés.

Tu en pense quoi ?

[dinobogan]

Une pile est comme un tas de carte. Ce serait une java.util.Stack par exemple. On ajoute uniquement en haut et on retire uniquement en haut.

Le nouveau routeur n'accède pas à la liste du coordinateur. Le nouveau fait une simple demande au coordinateur : donne-moi un routeur. C'est le coordinateur qui se débrouille à en trouver un.
Ensuite le nouveau dialogue avec le routeur père pour s'y connecter. Après connexion, si le père n'a plus de place, on s'en fou à ce moment là. C'est uniquement lorsqu'un "nouveau nouveau" va vouloir se connecter, le coordinateur va prendre le premier routeur de la pile et va lui demander s'il à encore de la place. A ce moment, le routeur dit "non, plus de place". Le coordinateur le retire de sa pile et passe au routeur suivant. Ca permet d'économiser du dialogue et simplifie le protocole dans le sens routeur -> coordinateur.
Un routeur communique au coordinateur uniquement lorsqu'il perd un fils. Le coordinateur vérifie si ce routeur est dans sa pile. S'il n'y est pas, il l'ajoute.

L'usage d'une pile pour le stockage des routeur "libre" est une supposition de ma part : j'imagine que tu veux remplir ton arborescence par les feuilles avant d'ajouter une nouvelle branche. Mais libre à toi d'utiliser d'autres stratégies selon tes contraintes.

[Jb_One73]

Mince ! Je viens de me rendre compte qu'il me manque quand même quelque chose, il faut quand même que je parle du client, je ne peux pas l'omettre.
Son rôle est de communiquer avec d'autres client, pour cela, lorsque le client demande à se connecter, il va procéder comme le routeur, c'est à dire demander au coordinateur les paramètres R, D, P et l'adresse du routeur racine. Une fois obtenue, il va interroger le routeur racine pour lui demander s'il peut se connecter à lui (en faite, ça fait un arbre chaîné) si non mais principe que le routeur on cherche un autre routeur disponible.
La plage d'adresse quand à elle va diminuer à chaque fois qu'un routeur et/ou client désire se connecter, ce qui veut dire que l'adresse est unique.

Le résultat final sera qu'un client qui souhaite communiquer avec un ou plusieurs client(s) devra contacter un ou plusieurs routeur(s), ex : si on reprend l'image de mon 1er post on va dire que le client dont l'adresse est le n° 5 (le carré vert à gauche du dessin) veut communiquer avec le client dont l'adresse le n° 10 (le carré vert en bas du dessin), il va donc parcourir une nouvelle liste qui doit contenir les adresses des clients et l'adresse du routeur auquel ils sont rattachés.

Ce qui donnerait :
5 --> 2 --> 1 --> 7 --> 10

2, 1 et 7 sont les routeurs.

Je me rend compte en fait que ce n'est pas aussi simple que ça, je sais que le WE va être long

[Jb_One73]

J'ai une petite question :
Il est noté qu'il y a un routeur racine qui dispose d'un n° de port, cela implique qu'il que j'utilise un SocketServer, faut-il que je créé 2 classes (1 routeur racine et 1 autre routeur qui aura juste la fonction de socket) ? Je ne peux pas intégrer les 2 dans la même classe ?

Merci d'avance.

[dinobogan]

Un routeur est client-serveur. Il doit être en écoute pour la connexion d'un autre routeur ou client. Et il doit être client pour initier la communication avec un serveur.
Si tu te débrouilles bien, tu peux faire une classe qui est serveur et une classe cliente. Ensuite les routeurs, clients et coordinateur utiliseront chacun une instance de la classe Serveur s'il doivent être serveur et une instance de la classe Client s'ils sont client. Dans ces deux classes, tu vas implémenter ton protocole de communication. Les classes utilisatrices de ces objets utiliseront un protocole de plus haut niveau. Par exemple, un client pourra appelée une méthode "connectToRouteur" pour se connecter à un nouveau Routeur.
Je ne connais pas ton protocole donc je ne peux pas en dire plus.