Besoin d'idée conception programme

Version imprimable

15/04/2016, 09h59
Jb_One73

1 pièce(s) jointe(s)

Besoin d'idée conception programme

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 :
Pièce jointe 206999

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.
15/04/2016, 10h45
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.
15/04/2016, 11h09
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 ?
15/04/2016, 11h24
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.
15/04/2016, 11h27
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
15/04/2016, 15h18
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.
15/04/2016, 15h28
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.

Désolé ! Je viens juste de voir ton message après avoir fait les modifs dans ma Classe Routeur. Je sais pas si c'est très propre voir même nul mais je voudrais avoir ton avis sur ce le code que j'ai fait (il fonctionne) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
    private static void start() throws RemoteException {
        keepGoing = true;
 
        // Format message disant que nous attendons
        display("Routeur en attente d'une connexion " + coordinateur.getPort() + ".");
 
        // Routeur racine si aucune IP donnée par le coordinateur
        if(coordinateur.getIpRouteurRacine().equals("")){
            RouteurRacine();
        } else{            
            RouteurSimple();
        }
    }
 
    private static void RouteurRacine(){
        /* Création du socket serveur et attente de la requête de connexion */
        try {
 
            // Le socket utilisé par le serveur
            serverSocket = new ServerSocket(coordinateur.getPort());
 
            display("Je suis le routeur racine et je suis en attente de client et/ou routeur.");
 
            coordinateur.setIpRouteurRacine("0");
 
            // Boucle infinie tant qu'il y a une connexion
            while(keepGoing) {
 
                // On démarre la connexion
                Socket socket = serverSocket.accept();
 
                // Si on a demandé d'arrêter
                if(!keepGoing) break;
            }
 
            Arret();
        }catch (IOException e) {
            String msg = sdf.format(new Date()) + " Erreur sur le nouveau serveur Socket: " + e + "\n";
            display(msg);
        }
    }
 
    private static void RouteurSimple(){
 
        // Essai de ce connecter au serveur
        try {
 
            display("Je suis un autre routeur.");
 
            Socket socket = new Socket("localhost", coordinateur.getPort());
 
            while(true) {
                // Si on a demandé d'arrêter
                if(!keepGoing) break;
            }            
        }
        // Si échec alors erreur
        catch(Exception ec) {
            display("Erreur de connexion au serveur:" + ec);
        }
    }
 
    private static void Arret(){
 
        // Arrêt ?
        try {
            serverSocket.close();
            for(int i = 0; i < al.size(); ++i) {
                Server.ClientThread tc = al.get(i);
                try {
                    tc.sInput.close();
                    tc.sOutput.close();
                    tc.socket.close();
                }
                catch(IOException ioE) {}
                }
        }catch(Exception e) {
                    display("Erreur pour fermer le serveur et les clients: " + e);
        }
    }

Si tu veux que je change ... aucun soucis ! Je suis là pour apprendre.

Merci d'avance pour ton aide

15/04/2016, 16h13
dinobogan

Avant de te lancer dans le code, tu dois expliciter tout le protocole. Dans le code que tu as donné, tu ne peux pas mélanger le code du coordinateur de celui d'un "simple" routeur.
Mon point de vue est que tu devrais générer du code commun pour être serveur et du code commun pour être client à ce serveur.
Tu dois commencé par un brouillon et un stylo et faire la liste exhaustive de tous les cas question/réponse, qui questionne, qui répond.
En programmation, commencer par le code est la pire des idées. Tu dois d'abord avoir les idées claires sur ce que tu veux faire.
L'artiste peintre visualise d'abord son tableau dans son ensemble. Il ne connais pas tous les détails à l'avance, mais il sait ou il veut en venir. Ensuite il fait une esquisse et enfin il met la peinture. En programmation, c'est pareil : papier+crayon. Une fois que tout est clair, on peut commencer à coder.
Ce que je dis toujours : peu importe l'implémentation pourvu qu'il y ai l'algorithme.
18/04/2016, 09h03
Jb_One73

Bonjour dinobogan,

Je répond un peu tard mais j'ai préféré prendre un peu de recul, j'ai un petite question concernant :

Citation:

Mon point de vue est que tu devrais générer du code commun pour être serveur et du code commun pour être client à ce serveur.

Lorsque tu parles de serveur, tu veux dire routeur ?

Là ! Je suis tes conseils, j'ai arrêté de programmer et je suis entrain de mettre sur papier mais je m'interroge sur ta phrase.

Je te remercie d'avance.

Cordialement.
18/04/2016, 12h00
dinobogan

Par serveur je parle du code métier isolé dans une classe unique qui permet de répondre à une demande de dialogue provenant d'un client dans ton protocole de communication.
Et par client, je parle du code métier isolé dans une classe unique qui permet de se connecter à une instance de serveur pour démarrer une conversation.
Durant la phase de conception, la terminologie est primordiale pour être sûr de quoi on parle. N'hésite pas à poser des mots sur des concepts, entre autre pour faire la différence entre un serveur au sens large, un routeur, la partie serveur du routeur, la partie client du routeur et le Client dans ton programme qui se connecte à un routeur.
Bon courage ;)
18/04/2016, 12h12
Jb_One73

Ok ! Merci dinobogan pour ta précision c'est très sympa ! Bon j'ai déjà un bon point car serveur correspond bien à mon code métier pour la communication client et idem pour le client. Maintenant il me reste à déterminer les autres classes de liaison.
J'essai de te communiquer l'ensemble des classes que je vais trouver dans la journée pour que tu me dises ce que tu en penses.

Merci pour ton aide.

Cordialement