Java > Open Source Codes > org > objectweb > joram > client > jms > admin > AdminModule


1 /*
2  * JORAM: Java(TM) Open Reliable Asynchronous Messaging
3  * Copyright (C) 2004 - 2006 ScalAgent Distributed Technologies
4  * Copyright (C) 2004 Bull SA
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19  * USA.
20  *
21  * Initial developer(s): Frederic Maistre (Bull SA)
22  * Contributor(s): ScalAgent Distributed Technologies
23  * Benoit Pelletier (Bull SA)
24  */
25 package org.objectweb.joram.client.jms.admin;
26
27 import java.io.Reader ;
28 import java.io.FileReader ;
29 import java.io.File ;
30 import java.io.IOException ;
31 import java.io.InputStream ;
32 import java.io.InputStreamReader ;
33 import java.io.FileNotFoundException ;
34 import java.net.ConnectException ;
35 import java.net.UnknownHostException ;
36 import java.util.Enumeration ;
37 import java.util.Hashtable ;
38 import java.util.List ;
39 import java.util.Properties ;
40 import java.util.Vector ;
41
42 import javax.jms.*;
43
44 import org.objectweb.joram.client.jms.Destination;
45 import org.objectweb.joram.client.jms.Queue;
46 import org.objectweb.joram.client.jms.Topic;
47 import org.objectweb.joram.client.jms.TopicConnectionFactory;
48 import org.objectweb.joram.client.jms.Message;
49 import org.objectweb.joram.client.jms.ha.local.TopicHALocalConnectionFactory;
50 import org.objectweb.joram.client.jms.ha.tcp.TopicHATcpConnectionFactory;
51 import org.objectweb.joram.client.jms.local.TopicLocalConnectionFactory;
52 import org.objectweb.joram.client.jms.tcp.TopicTcpConnectionFactory;
53 import org.objectweb.joram.shared.admin.*;
54
55 import org.objectweb.joram.shared.JoramTracing;
56 import org.objectweb.util.monolog.api.BasicLevel;
57
58 /**
59  * The <code>AdminModule</code> class allows to set an administrator
60  * connection to a given JORAM server, and provides administration and
61  * monitoring methods at a server/platform level.
62  */
63 public class AdminModule {
64   public static final String ADM_NAME_PROPERTY = "JoramAdminXML";
65   public static final String DEFAULT_ADM_NAME = "default";
66
67   public static final String REQUEST_TIMEOUT_PROP =
68       "org.objectweb.joram.client.jms.admin.requestTimeout";
69
70   public static final long DEFAULT_REQUEST_TIMEOUT = 120000;
71
72   /** The identifier of the server the module is connected to. */
73   private static int localServer;
74   /** The host name or IP address this client is connected to. */
75   protected static String localHost;
76   /** The port number of the client connection. */
77   protected static int localPort;
78
79   /** The connection used to link the administrator and the platform. */
80   private static TopicConnection cnx = null;
81
82   /** The requestor for sending the synchronous requests. */
83   private static AdminRequestor requestor;
84
85   /** ObjectMessage sent to the platform. */
86   private static ObjectMessage requestMsg;
87   /** ObjectMessage received from the platform. */
88   private static ObjectMessage replyMsg;
89
90   /** Reply object received from the platform. */
91   protected static AdminReply reply;
92
93   private static int requestCounter;
94
95   private static long requestTimeout =
96       Long.getLong(REQUEST_TIMEOUT_PROP,
97                    DEFAULT_REQUEST_TIMEOUT).longValue();
98
99   /** <code>true</code> if the underlying a JORAM HA server is defined */
100   private static boolean isHa = false;
101
102   /**
103    * This method execute the XML script file that the path is given in
104    * parameter.
105    *
106    * @since 4.3.12
107    */
108   public static void main(String [] args) {
109     try {
110       AdminModule.executeXMLAdmin(args[0]);
111     } catch (Exception exc) {
112       exc.printStackTrace();
113     }
114   }
115
116   /**
117    * Opens a connection dedicated to administering with the Joram server
118    * which parameters are wrapped by a given
119    * <code>TopicConnectionFactory</code>.
120    *
121    * @param cnxFact The TopicConnectionFactory to use for connecting.
122    * @param name Administrator's name.
123    * @param password Administrator's password.
124    *
125    * @exception ConnectException If connecting fails.
126    * @exception AdminException If the administrator identification is
127    * incorrect.
128    */
129   public static void connect(javax.jms.TopicConnectionFactory cnxFact,
130                              String name,
131                              String password)
132     throws ConnectException , AdminException {
133     if (cnx != null)
134       return;
135
136     try {
137       cnx = cnxFact.createTopicConnection(name, password);
138       requestor = new AdminRequestor(cnx);
139
140       cnx.start();
141
142       org.objectweb.joram.client.jms.FactoryParameters params = null;
143
144       if (cnxFact instanceof javax.jms.XATopicConnectionFactory )
145         params = ((org.objectweb.joram.client.jms.XAConnectionFactory)
146                   cnxFact).getParameters();
147       else
148         params = ((org.objectweb.joram.client.jms.ConnectionFactory)
149                   cnxFact).getParameters();
150
151       localHost = params.getHost();
152       localPort = params.getPort();
153
154       // Getting the id of the local server:
155 localServer = requestor.getLocalServerId();
156     } catch (JMSSecurityException exc) {
157       if (JoramTracing.dbgClient.isLoggable(BasicLevel.DEBUG))
158         JoramTracing.dbgClient.log(
159           BasicLevel.DEBUG, "", exc);
160       throw new AdminException(exc.getMessage());
161     } catch (JMSException exc) {
162       if (JoramTracing.dbgClient.isLoggable(BasicLevel.DEBUG))
163         JoramTracing.dbgClient.log(
164           BasicLevel.DEBUG, "", exc);
165       throw new ConnectException ("Connecting failed: " + exc);
166     }
167   }
168
169   /**
170    * Opens a TCP connection with the Joram server running on a given host and
171    * listening to a given port.
172    *
173    * @param host The name or IP address of the host the server is running on.
174    * @param port The number of the port the server is listening to.
175    * @param name Administrator's name.
176    * @param password Administrator's password.
177    * @param cnxTimer Timer in seconds during which connecting to the server
178    * is attempted.
179    *
180    * @exception UnknownHostException If the host is invalid.
181    * @exception ConnectException If connecting fails.
182    * @exception AdminException If the administrator identification is
183    * incorrect.
184    */
185   public static void connect(String hostName,
186                              int port,
187                              String name,
188                              String password,
189                              int cnxTimer)
190     throws UnknownHostException , ConnectException , AdminException {
191     connect(hostName,port,name,password,cnxTimer,
192             "org.objectweb.joram.client.jms.tcp.ReliableTcpClient");
193   }
194
195   /**
196    * Opens a TCP connection with the Joram server running on a given host and
197    * listening to a given port.
198    *
199    * @param host The name or IP address of the host the server is running on.
200    * @param port The number of the port the server is listening to.
201    * @param name Administrator's name.
202    * @param password Administrator's password.
203    * @param cnxTimer Timer in seconds during which connecting to the server
204    * is attempted.
205    * @param reliableClass Reliable class name.
206    *
207    * @exception UnknownHostException If the host is invalid.
208    * @exception ConnectException If connecting fails.
209    * @exception AdminException If the administrator identification is
210    * incorrect.
211    */
212   public static void connect(String hostName,
213                              int port,
214                              String name,
215                              String password,
216                              int cnxTimer,
217                              String reliableClass)
218     throws UnknownHostException , ConnectException , AdminException {
219     javax.jms.TopicConnectionFactory cnxFact =null;
220
221     if (isHa) {
222       String urlHa = "hajoram://" + hostName + ":" + port;
223       cnxFact = TopicHATcpConnectionFactory.create(urlHa);
224
225     } else {
226       cnxFact = TopicTcpConnectionFactory.create(hostName, port, reliableClass);
227     }
228
229     ((org.objectweb.joram.client.jms.ConnectionFactory)
230      cnxFact).getParameters().connectingTimer = cnxTimer;
231
232     connect(cnxFact, name, password);
233   }
234
235   /**
236    * Opens a TCP connection with the Joram server running on the default
237    * "locahost" host and listening to the default 16010 port.
238    *
239    * @param name Administrator's name.
240    * @param password Administrator's password.
241    * @param cnxTimer Timer in seconds during which connecting to the server
242    * is attempted.
243    *
244    * @exception UnknownHostException Never thrown.
245    * @exception ConnectException If connecting fails.
246    * @exception AdminException If the administrator identification is
247    * incorrect.
248    */
249   public static void connect(String name, String password, int cnxTimer)
250     throws UnknownHostException , ConnectException , AdminException {
251       connect("localhost", 16010, name, password, cnxTimer);
252     }
253
254   /**
255    * Opens a TCP connection with the Joram server running on the default
256    * "locahost" host and listening to the default 16010 port.
257    *
258    * @param name Administrator's name.
259    * @param password Administrator's password.
260    * @param cnxTimer Timer in seconds during which connecting to the server
261    * is attempted.
262    * @param reliableClass Reliable class name.
263    *
264    * @exception UnknownHostException Never thrown.
265    * @exception ConnectException If connecting fails.
266    * @exception AdminException If the administrator identification is
267    * incorrect.
268    */
269   public static void connect(String name,
270                              String password,
271                              int cnxTimer,
272                              String reliableClass)
273     throws UnknownHostException , ConnectException , AdminException {
274     connect("localhost", 16010, name, password, cnxTimer, reliableClass);
275   }
276
277   /**
278    * Opens a connection with the collocated JORAM server.
279    *
280    * @param name Administrator's name.
281    * @param password Administrator's password.
282    *
283    * @exception ConnectException If connecting fails.
284    * @exception AdminException If the administrator identification is
285    * incorrect.
286    */
287   public static void collocatedConnect(String name, String password)
288          throws ConnectException , AdminException {
289     JoramTracing.dbgClient.log(BasicLevel.DEBUG, "isHa=" + isHa);
290     if (isHa) {
291       connect(TopicHALocalConnectionFactory.create(), name, password);
292     } else {
293       connect(TopicLocalConnectionFactory.create(), name, password);
294     }
295   }
296
297   /** Closes the administration connection. */
298   public static void disconnect() {
299     try {
300       if (cnx == null) return;
301       
302       cnx.close();
303     } catch (JMSException exc) {}
304
305     cnx = null;
306   }
307
308   /**
309    * Stops a given server of the platform.
310    * <p>
311    * The request fails if the target server does not belong to the platform.
312    *
313    * @param serverId Identifier of the server to stop.
314    *
315    * @exception ConnectException If the connection fails.
316    * @exception AdminException If the request fails.
317    */
318   public static void stopServer(int serverId)
319     throws ConnectException , AdminException {
320     try {
321       doRequest(new StopServerRequest(serverId));
322
323       if (serverId == localServer)
324         cnx = null;
325     } catch (ConnectException exc) {
326       // ConnectException is intercepted if stopped server is local server.
327 if (serverId != localServer) throw exc;
328
329       cnx = null;
330     }
331   }
332
333   /**
334    * Stops the platform local server.
335    *
336    * @exception ConnectException If the connection fails.
337    * @exception AdminException Never thrown.
338    */
339   public static void stopServer() throws ConnectException , AdminException {
340     stopServer(localServer);
341   }
342
343   /**
344    * Adds a server to the platform.
345    *
346    * @param serverId Id of the added server
347    * @param hostName Address of the host where the added server is started
348    * @param domainName Name of the domain where the server is added
349    * @param port Listening port of the server in the specified domain
350    * @param serverName Name of the added server
351    *
352    * @exception ConnectException If the connection fails.
353    * @exception AdminException If the request fails.
354    */
355   public static void addServer(int sid,
356                                String hostName,
357                                String domainName,
358                                int port,
359                                String serverName)
360     throws ConnectException , AdminException {
361     addServer(sid,
362               hostName, domainName, port, serverName,
363               null, null);
364   }
365
366   /**
367    * Adds a server to the platform.
368    *
369    * @param serverId Id of the added server
370    * @param hostName Address of the host where the added server is started
371    * @param domainName Name of the domain where the server is added
372    * @param port Listening port of the server in the specified domain
373    * @param serverName Name of the added server
374    * @param serviceNames Names of the service to start within the server
375    * @param args Services' arguments
376    *
377    * @exception ConnectException If the connection fails.
378    * @exception AdminException If the request fails.
379    */
380   public static void addServer(int sid,
381                                String hostName,
382                                String domainName,
383                                int port,
384                                String serverName,
385                                String [] serviceNames,
386                                String [] serviceArgs)
387     throws ConnectException , AdminException {
388     if (serviceNames != null &&
389         serviceArgs != null) {
390       if (serviceNames.length != serviceArgs.length)
391         throw new AdminException(
392           "Same number of service names and arguments expected");
393     } else {
394       if (serviceNames == null) throw new AdminException(
395         "Expected service names");
396       if (serviceArgs == null) throw new AdminException(
397         "Expected service arguments");
398     }
399     doRequest(new AddServerRequest(
400                 sid,
401                 hostName,
402                 domainName,
403                 port,
404                 serverName,
405                 serviceNames,
406                 serviceArgs));
407   }
408
409   /**
410    * Removes a server from the platform.
411    *
412    * @param sid Id of the removed server
413    *
414    * @exception ConnectException If the connection fails.
415    * @exception AdminException If the request fails.
416    */
417   public static void removeServer(int sid)
418     throws ConnectException , AdminException {
419     doRequest(new RemoveServerRequest(sid));
420   }
421
422   /**
423    * Adds a domain to the platform.
424    *
425    * @param domainName Name of the added domain
426    * @param sid Id of the router server that
427    * gives access to the added domain
428    * @param port Listening port in the added domain of the
429    * router server
430    *
431    * @exception ConnectException If the connection fails.
432    * @exception AdminException If the request fails.
433    */
434   public static void addDomain(String domainName,
435                                int sid,
436                                int port)
437     throws ConnectException , AdminException {
438     doRequest(new AddDomainRequest(
439                 domainName,
440                 sid,
441                 port));
442   }
443
444   /**
445    * Removes a domain from the platform.
446    *
447    * @param domainName Name of the added domain
448    *
449    * @exception ConnectException If the connection fails.
450    * @exception AdminException If the request fails.
451    */
452   public static void removeDomain(String domainName)
453     throws ConnectException , AdminException {
454     doRequest(new RemoveDomainRequest(
455                 domainName));
456   }
457
458   /**
459    * Returns the current servers configuration (a3servers.xml).
460    *
461    * @exception ConnectException If the connection fails.
462    * @exception AdminException If the request fails.
463    */
464   public static String getConfiguration()
465     throws ConnectException , AdminException {
466     return doRequest(new GetConfigRequest()).getInfo();
467   }
468
469   /**
470    * Sets a given dead message queue as the default DMQ for a given server
471    * (<code>null</code> for unsetting previous DMQ).
472    * <p>
473    * The request fails if the target server does not belong to the platform.
474    *
475    * @param serverId The identifier of the server.
476    * @param dmq The dmq to be set as the default one.
477    *
478    * @exception ConnectException If the connection fails.
479    * @exception AdminException If the request fails.
480    */
481   public static void setDefaultDMQ(int serverId, DeadMQueue dmq)
482     throws ConnectException , AdminException
483     {
484       doRequest(new SetDefaultDMQ(serverId, dmq.getName()));
485     }
486
487   /**
488    * Sets a given dead message queue as the default DMQ for the local server
489    * (<code>null</code> for unsetting previous DMQ).
490    *
491    * @param dmq The dmq to be set as the default one.
492    *
493    * @exception ConnectException If the connection fails.
494    * @exception AdminException Never thrown.
495    */
496   public static void setDefaultDMQ(DeadMQueue dmq)
497     throws ConnectException , AdminException
498     {
499       setDefaultDMQ(localServer, dmq);
500     }
501
502   /**
503    * Sets a given value as the default threshold for a given server (-1 for
504    * unsetting previous value).
505    * <p>
506    * The request fails if the target server does not belong to the platform.
507    *
508    * @param serverId The identifier of the server.
509    * @param threshold The threshold value to be set.
510    *
511    * @exception ConnectException If the connection fails.
512    * @exception AdminException If the request fails.
513    */
514   public static void setDefaultThreshold(int serverId, int threshold)
515     throws ConnectException , AdminException
516     {
517       doRequest(new SetDefaultThreshold(serverId, threshold));
518     }
519
520   /**
521    * Sets a given value as the default threshold for the local server (-1 for
522    * unsetting previous value).
523    *
524    * @param threshold The threshold value to be set.
525    *
526    * @exception ConnectException If the connection fails.
527    * @exception AdminException Never thrown.
528    */
529   public static void setDefaultThreshold(int threshold)
530     throws ConnectException , AdminException
531     {
532       setDefaultThreshold(localServer, threshold);
533     }
534
535   /**
536    * Returns the list of the platform's servers' identifiers.
537    *
538    * @exception ConnectException If the connection fails.
539    * @exception AdminException Never thrown.
540    */
541   public static List getServersIds() throws ConnectException , AdminException
542     {
543       return getServersIds(null);
544     }
545
546   /**
547    * Returns the list of the servers' identifiers that belong
548    * to the specified domain
549    *
550    * @exception ConnectException If the connection fails.
551    * @exception AdminException Never thrown.
552    */
553   public static List getServersIds(String domainName)
554     throws ConnectException , AdminException {
555     Monitor_GetServersIds request =
556       new Monitor_GetServersIds(
557         AdminModule.getLocalServerId(),
558         domainName);
559     Monitor_GetServersIdsRep reply =
560       (Monitor_GetServersIdsRep) doRequest(request);
561     int[] serverIds = reply.getIds();
562     Vector res = new Vector ();
563     for (int i = 0; i < serverIds.length; i++) {
564       res.addElement(new Integer (serverIds[i]));
565     }
566     return res;
567   }
568
569   public static Server[] getServers()
570     throws ConnectException , AdminException {
571     return getServers(null);
572   }
573
574   public static Server[] getServers(String domainName)
575     throws ConnectException , AdminException {
576     Monitor_GetServersIds request =
577       new Monitor_GetServersIds(
578         AdminModule.getLocalServerId(),
579         domainName);
580     Monitor_GetServersIdsRep reply =
581       (Monitor_GetServersIdsRep) doRequest(request);
582     int[] serverIds = reply.getIds();
583     String [] serverNames = reply.getNames();
584     String [] serverHostNames = reply.getHostNames();
585     Server[] servers = new Server[serverIds.length];
586     for (int i = 0; i < serverIds.length; i++) {
587       servers[i] = new Server(serverIds[i],
588                               serverNames[i],
589                               serverHostNames[i]);
590     }
591     return servers;
592   }
593
594   public static Server getLocalServer()
595     throws ConnectException , AdminException {
596     GetLocalServerRep reply = (GetLocalServerRep)doRequest(
597       new GetLocalServer());
598     return new Server(reply.getId(),
599                       reply.getName(),
600                       reply.getHostName());
601   }
602
603   /**
604    * Returns the list of the domain names that
605    * contains the specified server.
606    *
607    * @exception ConnectException If the connection fails.
608    * @exception AdminException Never thrown.
609    */
610   public static String [] getDomainNames(int serverId)
611     throws ConnectException , AdminException {
612     GetDomainNames request =
613       new GetDomainNames(serverId);
614     GetDomainNamesRep reply =
615       (GetDomainNamesRep) doRequest(request);
616     return reply.getDomainNames();
617   }
618
619   /**
620    * Returns the default dead message queue for a given server, null if not
621    * set.
622    * <p>
623    * The request fails if the target server does not belong to the platform.
624    *
625    * @exception ConnectException If the connection fails.
626    * @exception AdminException If the request fails.
627    */
628   public static DeadMQueue getDefaultDMQ(int serverId)
629     throws ConnectException , AdminException
630     {
631       Monitor_GetDMQSettings request = new Monitor_GetDMQSettings(serverId);
632       Monitor_GetDMQSettingsRep reply;
633       reply = (Monitor_GetDMQSettingsRep) doRequest(request);
634
635       if (reply.getDMQName() == null)
636         return null;
637       else
638         return new DeadMQueue(reply.getDMQName());
639     }
640
641   /**
642    * Returns the default dead message queue for the local server, null if not
643    * set.
644    *
645    * @exception ConnectException If the connection fails.
646    * @exception AdminException Never thrown.
647    */
648   public static DeadMQueue getDefaultDMQ()
649     throws ConnectException , AdminException
650     {
651       return getDefaultDMQ(localServer);
652     }
653
654   /**
655    * Returns the default threshold value for a given server, -1 if not set.
656    * <p>
657    * The request fails if the target server does not belong to the platform.
658    *
659    * @exception ConnectException If the connection fails.
660    * @exception AdminException If the request fails.
661    */
662   public static int getDefaultThreshold(int serverId)
663     throws ConnectException , AdminException
664     {
665       Monitor_GetDMQSettings request = new Monitor_GetDMQSettings(serverId);
666       Monitor_GetDMQSettingsRep reply;
667       reply = (Monitor_GetDMQSettingsRep) doRequest(request);
668
669       if (reply.getThreshold() == null)
670         return -1;
671       else
672         return reply.getThreshold().intValue();
673     }
674
675   /**
676    * Returns the default threshold value for the local server, -1 if not set.
677    *
678    * @exception ConnectException If the connection fails.
679    * @exception AdminException Never thrown.
680    */
681   public static int getDefaultThreshold()
682     throws ConnectException , AdminException
683     {
684       return getDefaultThreshold(localServer);
685     }
686
687   /**
688    * Returns the list of all destinations that exist on a given server,
689    * or an empty list if none exist.
690    * <p>
691    * The request fails if the target server does not belong to the platform.
692    *
693    * @exception ConnectException If the admin connection is closed or broken.
694    * @exception AdminException If the request fails.
695    */
696   public static List getDestinations(int serverId)
697     throws ConnectException , AdminException
698     {
699       Monitor_GetDestinations request = new Monitor_GetDestinations(serverId);
700       Monitor_GetDestinationsRep reply =
701         (Monitor_GetDestinationsRep) doRequest(request);
702
703       Vector list = new Vector ();
704       String [] ids = reply.getIds();
705       String [] names = reply.getNames();
706       String [] types = reply.getTypes();
707       for (int i = 0; i < types.length; i++) {
708         list.addElement(Destination.newInstance(
709                           ids[i], names[i], types[i]));
710       }
711       return list;
712     }
713
714   /**
715    * Returns the list of all destinations that exist on the local server,
716    * or an empty list if none exist.
717    *
718    * @exception ConnectException If the admin connection is closed or broken.
719    * @exception AdminException Never thrown.
720    */
721   public static List getDestinations() throws ConnectException , AdminException
722     {
723       return getDestinations(localServer);
724     }
725
726   /**
727    * Returns the list of all destinations that exist on a given server,
728    * or an empty list if none exist.
729    * The request is abort after delay.
730    *
731    * @exception ConnectException If the admin connection is closed or broken.
732    * @exception AdminException If the request fails.
733    */
734   public static List getDestinations(int serverId, long delay)
735     throws ConnectException , AdminException {
736
737     Monitor_GetDestinations request = new Monitor_GetDestinations(serverId);
738     Monitor_GetDestinationsRep reply =
739       (Monitor_GetDestinationsRep) doRequest(request,delay);
740
741     Vector list = new Vector ();
742     String [] ids = reply.getIds();
743     String [] names = reply.getNames();
744     String [] types = reply.getTypes();
745     for (int i = 0; i < types.length; i++) {
746       list.addElement(Destination.newInstance(
747                         ids[i], names[i], types[i]));
748     }
749     return list;
750   }
751
752   /**
753    * Returns the list of all users that exist on a given server, or an empty
754    * list if none exist.
755    * <p>
756    * The request fails if the target server does not belong to the platform.
757    *
758    * @exception ConnectException If the connection fails.
759    * @exception AdminException If the request fails.
760    */
761   public static List getUsers(int serverId)
762     throws ConnectException , AdminException
763     {
764       Monitor_GetUsers request = new Monitor_GetUsers(serverId);
765       Monitor_GetUsersRep reply = (Monitor_GetUsersRep) doRequest(request);
766
767       Vector list = new Vector ();
768       Hashtable users = reply.getUsers();
769       String name;
770       for (Enumeration names = users.keys(); names.hasMoreElements();) {
771         name = (String ) names.nextElement();
772         list.add(new User(name, (String ) users.get(name)));
773       }
774       return list;
775     }
776
777   /**
778    * Returns the list of all users that exist on a given server, or an empty
779    * list if none exist.
780    * The request is abort after delay.
781    *
782    * @exception ConnectException If the connection fails.
783    * @exception AdminException If the request fails.
784    */
785   public static List getUsers(int serverId, long delay)
786     throws ConnectException , AdminException {
787
788     Monitor_GetUsers request = new Monitor_GetUsers(serverId);
789     Monitor_GetUsersRep reply = (Monitor_GetUsersRep) doRequest(request,delay);
790
791     Vector list = new Vector ();
792     Hashtable users = reply.getUsers();
793     String name;
794     for (Enumeration names = users.keys(); names.hasMoreElements();) {
795       name = (String ) names.nextElement();
796       list.add(new User(name, (String ) users.get(name)));
797     }
798     return list;
799   }
800
801   /**
802    * Returns the list of all users that exist on the local server, or an empty
803    * list if none exist.
804    *
805    * @exception ConnectException If the connection fails.
806    * @exception AdminException Never thrown.
807    */
808   public static List getUsers() throws ConnectException , AdminException
809     {
810       return getUsers(localServer);
811     }
812
813
814   /**
815    * Returns the identifier of the server the module is connected to.
816    *
817    * @exception ConnectException If the admin connection is not established.
818    */
819   public static int getLocalServerId() throws ConnectException
820     {
821       if (cnx == null)
822         throw new ConnectException ("Administrator not connected.");
823
824       return localServer;
825     }
826
827   /**
828    * Returns the host name of the server the module is connected to.
829    *
830    * @exception ConnectException If the admin connection is not established.
831    */
832   public static String getLocalHost() throws ConnectException
833     {
834       if (cnx == null)
835         throw new ConnectException ("Administrator not connected.");
836
837       return localHost;
838     }
839
840   /**
841    * Returns the port number of the server the module is connected to.
842    *
843    * @exception ConnectException If the admin connection is not established.
844    */
845   public static int getLocalPort() throws ConnectException
846     {
847       if (cnx == null)
848         throw new ConnectException ("Administrator not connected.");
849
850       return localPort;
851     }
852
853   /**
854    * Method actually sending an <