Arguments en ligne de commandes et ordre d'exécution

Version imprimable

04/02/2008, 14h19
ouranos21

Arguments en ligne de commandes et ordre d'exécution

Bonjour,

J'ai un programme qui pourrais se lancer en ligne de commandes de cette manière:

Citation:

java -jar client.jar -huvadsl et_un_nom_d'instance_de_base_de_données

Bon alors, la chaîne de caractère 'huvadsl' représente les actions à prendre sur une éventuelle instance.

Sachant que:

Citation:

h : help
u : unload
v : verbose
a : loadAll
d : showdown
s : status
l : log

Où

-help permet d'obtenir l'aide et la liste des commandes disponibles
-unload permet d'arrêter l'application serveur (c'est une appli client serveur de monitoring de base de données)
-verbose ...
-loadAll crée un thread par instance, thread qui envoi des query à l'instance, simplement.
-showdown permet de lister les instances qui rencontreraient des problèmes
-status permet d'obtenir le status de toute les instances monitorées par un thread. ET se combine éventuellement avec -showdown
-log permet de rediriger l'affichage vers un fichier texte.

Mon soucis ?

Réussir à gèrer tout ça. Recevoir une chaîne de caractère représentant les actions à prendre sur la DB mais bien faire gaffe que certaines combinaisons ne sont pas possible ou logique: -au par exemple est assez stupide comme combinaison.

Enfin je vias essayer de vous établir les règles que j'aimerais mettre en place et les combinaisons de paramètres possible:

-si dans la chaîne de paramètres on trouve un 'h', on affiche l'aide, même si d'autres caractères se trouvent dans la chaîne.
-si il y a un 'u', on peut éventuellement adjoindre un 'v' et un 'l' mais que d'autres paramètres éventuelles ne soient pas pris en compte...
-que le 'v' ne se combine pas avec le 'h'
-que si on entre 'vdsl' l'application reconnaisse que la première lettre à laquelle associer une action soit le 's'. En gros qu'on entre 'vdsl' ou 'sdlv' le résultat soit le même CAD que le status des instances down soit redirigé vers une fichier de log dans sa version verbose.

Voilà plus ou moins. Tout ça me paraît très complexe à faire. Je ne vois pas du tout comment m'y prendre. Le fait que l'ordre des caractères ne doit pas avoir d'importance me bloc complètement dans l'écriture des mes boucles de test.

Vous avez une solution ou un idée ?

(j'espère vous avoir donné assez d'éléments pour que vous m'aidiez et surtout d'avoir été assez clair...)

D'avance merci.
A bientôt

utilise une List pour stocker tes caractères et utilise la methode boolean contains pour vérifier l'existence des caractères

http://java.sun.com/j2se/1.4.2/docs/...va.lang.Object)

Néanmoins je te conseil de travailler avec un type générique
Code:

1 2 3 4 5 6 7 8 List<String> options = null; if(arg[0].startWith("-")) options = new ArrayList<String>(Arrays.asList(arg[0].split(""))); if(options!=null && options.contains("a") && options.contains("u")){ throw new Exception("Incohérent !!!!"); }

Fort intéressant ça.

Merci pour le coup de main, j'avais pas du tout pensé passer par les listes.

Moi je m'amusais à découper une string args[0] en caractères, et comme un cochon en plus:
Code:

1 2 3 4 5 6 7 8 9 10 String param = args[0].toString(); int i = param.length(); param= param.substring(param.indexOf('-') + 1); String[] params=new String[i]; for(int j=0; j<i-1;j++) { String v=String.valueOf(param.charAt(j)); params[j]=v; }
Pas top top hein. Puis bon, avec ça je m'enfonçait dans mon problème en plus.

En tout cas merci.
Je vous tiens au courant ^^

Alors, ta méthode fonctionne très bien, mais avec ce que je dois faire, CAD interdire l'utilisation de certains arguments quand d'autres sont présents dans la liste des arguments, ça me prend quand même 100 lignes à coup de IF-ELSE IF-ELSE...

C'est plus souple que ce dans quoi je m'embarquais. Actuellement tout ce dont je parlais dans mon premier post fonctionne. Mais je me rend compte que cela va être un peu délicat à modifier (aussi chiant en fait que si je l'avais fait avec la que je comptais utiliser avant de poster ici) si on me demande de rajouter 1/2/3 arguments. Et je sais que cette application va évoluer. Seulement actuellement on ne peut pas m'en dire plus... youpie.

Depuis hier je me demande comment optimiser le truc, faire mieux qu'avec une tonne de IF-ELSE IF-ELSE, je planche sur une méthode qui utiliserait des CASE ou en attribuant des points ou des priorités à tel ou tel arguments, selon qu'on est plus ou moins susceptible d'utiliser celui-ci ou celui-là.
Mais ça me paraît fort compliqué tout ça.

Voici ce que je fais pour l'instant:

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
String param2;
            List options = null;
            String param = args[0].toString();
            if(args.length>1)
            {
                param2=args[1];
            }
            else
            {
                param2=null;
            }
            param= param.substring(param.indexOf('-') + 1);
            options = new ArrayList(Arrays.asList(param.split("")));
            System.out.println(options);
            if(args.length>1)
            {
                if(param2!=null)
                {
                    if(options.contains("s"))
                    {
                        if(options.contains("v") && options.contains("l"))
                        {
                            System.out.println("Status d'une instance en verbose et dans le log file");
                        }
                        else if(options.contains("v"))
                        {
                            System.out.println("Status d'une instance en verbose");
                        }
                        else if(options.contains("l"))
                        {
                            System.out.println("Status d'une instance dans le log file");
                        }
                        else
                        {
                            System.out.println("Status de l'instance en normal");
                        }
                    }
                }
                else
                {
                    System.out.println("param2 est null");
                }
                System.exit(0);
            }
            if(options!=null && options.contains("a"))
            {
                if(options.contains("l"))
                {
                    if(options.contains("v"))
                    {
                        System.out.println("LoadAll dans le logfile et en verbose");
                    }
                    else
                    {
                        System.out.println("LoadAll dans le logfile");
                    }
                }
 
                else if(options.contains("v"))
                {
                    if(options.contains("l"))
                    {
                        System.out.println("Loadall en Verbose dans le logfile");
                    }
                    else
                    {
                        System.out.println("LoadAll en verbose");
                    }
                }
                else
                {
                    System.out.println("LoadAll en normal");
                    throw new Exception("Incohérent !!!!");
                }
            }
            else if(options!=null && options.contains("h"))
            {
                help();
            }
            else if(options!=null && options.contains("u"))
            {
                if(options.contains("v"))
                {
                    if(options.contains("l"))
                    {
                        System.out.println("On écris le stop du programme en verbose dans les logs");
                    }
                    else
                    {
                        System.out.println("On affiche le stop en verbose à l'écran");
                    }
                }
                else
                {
                    System.out.println("On stop pas en verbose");
                }
 
            }
            else if(options!=null && options.contains("v") && options.contains("h"))
            {
                System.out.println("Combinaison incompatible");
            }
            else if(options!=null && options.contains("s"))
            {
                if(options.contains("d"))
                {
                    if(options.contains("v"))
                    {
                        if(options.contains("l"))
                        {
                            System.out.println("Status showdown en verbose et dans un fichier de log");
                        }
                        else
                        {
                            System.out.println("Status showdown en verbose");
                        }
                    }
                    else if(options.contains("l"))
                    {
                        if(options.contains("v"))
                        {
                            System.out.println("Status showdown en verbose et dans un fichier de log");
                        }
                        else
                        {
                            System.out.println("Status showdown log file");
                        }
                    }
                    else
                    {
                        System.out.println("Status showdown");
                    }
                }
                else
                {
                    if(options.contains("v"))
                    {
                        if(options.contains("l"))
                        {
                            System.out.println("Status en verbose, de toutes les instances");
                        }
                        else
                        {
                            System.out.println("Status en verbose de toutes les instances");
                        }
                    }
                    else if(options.contains("l"))
                    {
                        System.out.println("Status en log file de toutes les instance");
                    }
                    else
                    {
                        System.out.println("Status");
                    }
                }
 
            }
        }
        catch(IOException e) 
        {
            System.out.println("Erreur : "+e);
            System.out.println("Connexion closed...");
	}
        catch(Exception ed)
        {
            System.out.println("Database name not specified");
            System.exit(0);
        }
 
        finally
        {
            try
            {
                connexion.close();
		System.out.println("Connexion closed...");
            }
            catch(IOException e) 
            { 
                System.out.println("Erreur : "+e);
		System.out.println("Connexion closed...");
            }
        }
    }

Pourquoi je ne peux utiliser cette ligne de code:

Code:

1
2
3
if(options!=null && options.contains("a") && options.contains("u")){
  throw new Exception("Incohérent !!!!");
}

Ca facilite quelques part, oui. Mais les arguments doivent pouvoir être cités/écris dans n'importe quel ordre. Du coup, bhein moi je fais un bloc IF pour chaque probabilité :/
Evidemment c'est très contraignant et tout et tout.

Je suis sûr que vous avez déjà rencontrés ce genre de situations dans vos applications.

Il doit sûrement une autre manière de faire ce que je veux faire. Quelque chose de souple, où l'on ne doit pas (quasi) tout recoder dés qu'on ajoute un argument ou qu'on doit apporter une petite modification.

Enfin je m'en remet à vous. J'ai vraiment du mal là-dessus, plus que sur toutes les questions que j'ai déjà posées :/

Bien à vous.

05/02/2008, 12h23
Tarul

As-tu regardé du coté des api common CLI et args4J?

Elle pourrait t'aider à simplifier la gestion des arguments.
Il y a un tutoriel de leur utilisation sur le site : http://hikage.developpez.com/java/ar...?page=sommaire
05/02/2008, 13h39
ouranos21

Merci de répondre si vite.

J'y regarde de suite.