KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jacorb > imr > ImplementationRepositoryImpl


1 /*
2  * JacORB - a free Java ORB
3  *
4  * Copyright (C) 1997-2004 Gerald Brose.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) 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  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the Free
18  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 package org.jacorb.imr;
22
23 import org.apache.avalon.framework.logger.Logger;
24 import org.apache.avalon.framework.configuration.*;
25
26 import org.omg.GIOP.*;
27
28 import org.jacorb.imr.RegistrationPackage.*;
29 import org.jacorb.imr.AdminPackage.*;
30
31 import org.jacorb.orb.*;
32 import org.jacorb.orb.giop.*;
33 import org.jacorb.orb.iiop.*;
34
35 import org.jacorb.poa.util.POAUtil;
36
37 import org.jacorb.util.ObjectUtil;
38
39 import org.omg.PortableServer.*;
40
41 import java.io.*;
42 import java.net.ServerSocket JavaDoc;
43 import java.net.Socket JavaDoc;
44 import java.net.InetAddress JavaDoc;
45 import java.lang.reflect.Method JavaDoc;
46
47 /**
48  * This is the main class of the JacORB implementation repository.
49  * It keeps track of the registered POAs with lifespan policy
50  * PERSISTENT and provides a way for migrating and restarting
51  * the POAS servers.
52  *
53  * @author Nicolas Noffke
54  *
55  * $Id: ImplementationRepositoryImpl.java,v 1.56 2005/02/09 09:54:09 andre.spiegel Exp $
56  */
57
58 public class ImplementationRepositoryImpl
59     extends ImplementationRepositoryPOA
60 {
61     /**
62      * <code>orb</code> is the ORB instance for the IMR.
63      */
64     private org.omg.CORBA.ORB JavaDoc orb;
65
66     private org.jacorb.config.Configuration configuration = null;
67
68     /** the specific logger for this component */
69     private Logger logger = null;
70
71     private String JavaDoc iorFile = null;
72
73     private File table_file;
74     private ServerTable server_table;
75     private File table_file_backup;
76     private SocketListener listener;
77     private Thread JavaDoc listenerThread;
78
79     private int object_activation_retries = 5;
80     private int object_activation_sleep = 50;
81
82     private boolean allow_auto_register = false;
83     private boolean check_object_liveness = false;
84
85     private int connection_timeout = 2000;
86     private long poaActivationTimeout = 120000; //2 min
87
88     private WriteThread wt;
89     private boolean updatePending;
90     private Shutdown JavaDoc shutdownThread;
91     
92
93     /**
94      * The constructor.
95      * It builds up the server table and starts up the SocketListener thread.
96      *
97      * @param table_file the file containing the serialized server table. Also
98      * used for writing the table to on shutdown. If null, an empty table is
99      * created.
100      * @param table_backup the file where backups are written to.
101      * @param new_table set to true, if an empty server table should be created
102      */
103     public ImplementationRepositoryImpl(org.omg.CORBA.ORB JavaDoc orb)
104     {
105         this.orb = orb;
106
107         shutdownThread = new Shutdown JavaDoc ();
108         shutdownThread.setDaemon (true);
109         shutdownThread.setName ("Shutdown Thread");
110         addShutdownHook (shutdownThread);
111     }
112
113     public void configure(Configuration myConfiguration)
114         throws ConfigurationException
115     {
116         configuration = (org.jacorb.config.Configuration)myConfiguration;
117
118         logger = configuration.getNamedLogger("jacorb.imr");
119
120         String JavaDoc defaultTableFile = "table.dat";
121         String JavaDoc tableFileStr = configuration.getAttribute("jacorb.imr.table_file",
122                                                          defaultTableFile);
123
124         //NOTE: deliberate use of ref equivalence check here. I need to find
125 //out if the default case has taken place, in which case, i assume
126 //that the default string ref is just passed through.
127 if (tableFileStr == defaultTableFile)
128         {
129             if (this.logger.isWarnEnabled())
130             {
131                 this.logger.warn("No file for the server table specified! Please configure the property jacorb.imr.table_file!");
132                 this.logger.warn("Will create \"table.dat\" in current directory, if necessary");
133             }
134         }
135
136         table_file = new File(tableFileStr);
137         boolean _new_table = false;
138
139         // try to open table file
140 if (! table_file.exists ())
141         {
142             _new_table = true;
143             if (this.logger.isInfoEnabled())
144             {
145                 this.logger.info("Table file " + tableFileStr +
146                                  " does not exist - autocreating it.");
147             }
148
149             try
150             {
151                 table_file.createNewFile ();
152             }
153             catch (IOException ex)
154             {
155                 throw new ConfigurationException("Failed to create table file", ex);
156             }
157         }
158         else
159         {
160             if (table_file.isDirectory ())
161             {
162                 throw new ConfigurationException("The table file is a directory! Please check " + table_file.getAbsolutePath());
163             }
164
165             if (! table_file.canRead())
166             {
167                 throw new ConfigurationException("The table file is not readable! Please check " + table_file.getAbsolutePath());
168             }
169
170             if (! table_file.canWrite())
171             {
172                 throw new ConfigurationException("The table file is not writable! Please check " + table_file.getAbsolutePath());
173             }
174         }
175
176         try
177         {
178             if (_new_table)
179             {
180                 this.server_table = new ServerTable();
181                 save_server_table(table_file);
182             }
183             else
184             {
185                 try
186                 {
187                     ObjectInputStream _in =
188                         new ObjectInputStream(new FileInputStream(table_file));
189                     server_table = (ServerTable)_in.readObject();
190                     _in.close();
191                 }
192                 catch (Exception JavaDoc ex)
193                 {
194                     this.logger.debug("Failed to read ServerTable", ex);
195
196                     server_table = new ServerTable();
197                     save_server_table(table_file);
198                 }
199             }
200         }
201         catch (FileOpFailed ex)
202         {
203             this.logger.debug("Failed to read ServerTable", ex);
204         }
205
206
207         //should be set. if not, throw
208 this.iorFile = configuration.getAttribute("jacorb.imr.ior_file");
209
210         String JavaDoc _backup_file_str =
211             configuration.getAttribute("jacorb.imr.backup_file", "");
212
213         //set up server table backup file
214 if (_backup_file_str.length() == 0)
215         {
216             this.logger.warn("No backup file specified!. No backup file will be created");
217         }
218
219         if (_backup_file_str.length() > 0)
220         {
221             table_file_backup = new File(_backup_file_str);
222
223             // try to open backup file
224 if ( ! table_file_backup.exists ())
225             {
226                 _new_table = true;
227                 
228                 if (this.logger.isInfoEnabled())
229                 {
230                     this.logger.info("Backup file " + _backup_file_str +
231                                      " does not exist - autocreating it.");
232                 }
233
234                 try
235                 {
236                     table_file_backup.createNewFile();
237                 }
238                 catch (IOException ex)
239                 {
240                     throw new ConfigurationException("Failed to create backup file",
241                                                      ex);
242                 }
243             }
244             else
245             {
246                 if (table_file_backup.isDirectory ())
247                 {
248                     throw new ConfigurationException("The backup file is a directory! Please check " + table_file_backup.getAbsolutePath());
249                 }
250
251                 if (! table_file_backup.canRead())
252                 {
253                     throw new ConfigurationException("The backup file is not readable! Please check " + table_file_backup.getAbsolutePath());
254                 }
255
256                 if (! table_file_backup.canWrite())
257                 {
258                     throw new ConfigurationException("The backup file is not writable! Please check " + table_file_backup.getAbsolutePath());
259                 }
260             }
261         }
262
263         this.object_activation_retries =
264             configuration.getAttributeAsInteger("jacorb.imr.object_activation_retries",
265                                             5);
266
267         this.object_activation_sleep =
268             configuration.getAttributeAsInteger("jacorb.imr.object_activation_sleep",
269                                             50);
270
271         this.allow_auto_register =
272             configuration.getAttributeAsBoolean("jacorb.imr.allow_auto_register",
273                                                 false);
274         this.check_object_liveness =
275             configuration.getAttributeAsBoolean("jacorb.imr.check_object_liveness",
276                                                 false);
277
278         this.connection_timeout =
279             configuration.getAttributeAsInteger("jacorb.imr.connection_timeout",
280                                             2000 );
281
282         this.poaActivationTimeout =
283             configuration.getAttributeAsInteger( "jacorb.imr.timeout", 120000);
284
285         this.listener = new SocketListener();
286         this.listener.configure(configuration);
287         
288         this.listenerThread = new Thread JavaDoc(listener);
289         this.listenerThread.setPriority(Thread.MAX_PRIORITY);
290         this.listenerThread.start();
291
292         this.wt = new WriteThread ();
293         this.wt.setName ("IMR Write Thread");
294         this.wt.setDaemon (true);
295         this.wt.start ();
296     }
297
298     public String JavaDoc getIORFile()
299     {
300         return this.iorFile;
301     }
302
303     // implementation of org.jacorb.imr.RegistrationOperations interface
304
305     /**
306      * This method sets a server down, i.e. not.active. If a request for
307      * that server is encountered, the server is tried to be restarted.
308      *
309      * @param server the servers name.
310      * @exception org.jacorb.imr.UnknownServerName No server with name
311      * <code>server</code> has been registered.
312      */
313     public void set_server_down(String JavaDoc server)
314         throws UnknownServerName
315     {
316         if (this.logger.isDebugEnabled())
317         {
318             this.logger.debug("ImR: server " + server + " is going down... ");
319         }
320
321         ImRServerInfo _server = server_table.getServer(server);
322         _server.setDown();
323     }
324
325
326     /**
327      * This method registers a POA. It has actually two functions:
328      * <ul>
329      * <li> Register a POA that has not yet been registered. It is the added to the
330      * server table. </li>
331      * <li> Reactivating a POA that is not active, but has already an entry
332      * in the server table</li> </ul>
333      * The reason for using only one method for those two tasks is that it is
334      * much more difficult for the ORB, which does the registering, to distinguish
335      * between an newly created POA and a restarted one.
336      *
337      * @param name the POAs name.
338      * @param server the logical server name of the server the running in.
339      * @param host the POAs host.
340      * @param port the POas port.
341      * @exception org.jacorb.imr.RegistrationPackage.IllegalPOAName the POAs name is not valid.
342      * @exception org.jacorb.imr.RegistrationPackage.DuplicatePOAName an active POA with
343      * <code>name</code> is currently registered.
344      * @exception org.jacorb.imr.UnknownServerName The server has not been registered.
345      */
346     public void register_poa(String JavaDoc name, String JavaDoc server, String JavaDoc host, int port)
347         throws IllegalPOAName, DuplicatePOAName, UnknownServerName
348     {
349         ImRServerInfo _server = null;
350         ImRPOAInfo _poa = null;
351         boolean remap = false;
352
353         updatePending = true;
354
355         if (this.logger.isDebugEnabled())
356         {
357             this.logger.debug("ImR: registering poa " + name + " for server: " +
358                               server + " on " + host);
359         }
360
361         if( allow_auto_register &&
362             ! server_table.hasServer( server ))
363         {
364             try
365             {
366                 register_server( server, "", "" );
367             }
368             catch( IllegalServerName isn )
369             {
370                 //ignore
371 }
372             catch( DuplicateServerName dsn )
373             {
374                 //ignore
375 }
376         }
377
378         _server = server_table.getServer(server);
379         _poa = server_table.getPOA(name);
380
381         if (_poa == null)
382         {
383             //New POAInfo is to be created
384 _poa = new ImRPOAInfo(name, host, port, _server,
385                                   poaActivationTimeout);
386             _server.addPOA(_poa);
387             server_table.putPOA(name, _poa);
388
389             this.logger.debug("ImR: new poa registered");
390         }
391         else
392         {
393             // Existing POA is reactivated
394
395             // Need to check whether the old server is alive. if it is then
396 // throw an exception otherwise we can remap the currently
397 // registered name.
398 if ((_poa.active) || (! server.equals(_poa.server.name)))
399             {
400                 byte[] first = _poa.name.getBytes ();
401                 byte[] id = new byte [ first.length + 1];
402                 System.arraycopy (first, 0, id, 0, first.length);
403                 id[first.length] = org.jacorb.poa.POAConstants.OBJECT_KEY_SEP_BYTE;
404
405                 // If host and port are the same then it must be a replacement as
406 // we could not have got to here if the original was running - we
407 // would have got a socket exception.
408 if (_poa.host.equals (host) && _poa.port == port)
409                 {
410                     remap = true;
411                 }
412                 else
413                 {
414                     // Otherwise try a ping
415 remap = ! (checkServerActive (_poa.host, _poa.port, id));
416                 }
417
418                 if (remap == false)
419                 {
420                     throw new DuplicatePOAName
421                     (
422                         "POA " + name +
423                         " has already been registered " +
424                         "for server " + _poa.server.name
425                     );
426                 }
427                 else
428                 {
429                     this.logger.debug("ImR: Remapping server/port");
430                 }
431             }
432
433             _poa.reactivate(host, port);
434             this.logger.debug("ImR: register_poa, reactivated");
435         }
436         try
437         {
438             synchronized (wt)
439             {
440                 wt.notify ();
441             }
442         }
443         catch (IllegalMonitorStateException JavaDoc e)
444         {
445             this.logger.debug("Caught Exception", e);
446         }
447     }
448
449
450     /**
451      * Register a new host with a server startup daemon.
452      * @param host a HostInfo object containing the hosts name and a reference to its
453      * ServerStartupDaemon object.
454      *
455      * @exception org.jacorb.imr.RegistrationPackage.IllegalHostName <code>name</code> is not valid.
456      * @exception org.jacorb.imr.RegistrationPackage.InvalidSSDRef It was impossible to connect
457      * to the daemon.
458      */
459     public void register_host(HostInfo host)
460         throws IllegalHostName, InvalidSSDRef
461     {
462
463         if (host.name == null || host.name.length() == 0)
464             throw new IllegalHostName(host.name);
465
466         try
467         {
468             host.ssd_ref.get_system_load();
469         }
470         catch (Exception JavaDoc e)
471         {
472             this.logger.debug("Caught Exception", e);
473             throw new InvalidSSDRef();
474         }
475         updatePending = true;
476
477         server_table.putHost(host.name, new ImRHostInfo(host));
478
479         try
480         {
481             synchronized (wt)
482             {
483                 wt.notify ();
484             }
485         }
486         catch (IllegalMonitorStateException JavaDoc e)
487         {
488             this.logger.debug("Caught Exception", e);
489         }
490     }
491
492
493     /**
494      * Get host and port (wrapped inside an ImRInfo object) of this repository.
495      * @return the ImRInfo object of this repository.
496      */
497
498     public ImRInfo get_imr_info()
499     {
500         return new ImRInfo(listener.getAddress(), listener.getPort());
501     }
502
503
504     // implementation of org.jacorb.imr.AdminOperations interface
505
506     /**
507      * List all hosts currently registered with this repository.
508      * It is not guaranteed that the references inside the HostInfo
509      * objects are still valid.
510      *
511      * @return an array containing all known hosts.
512      */
513     public HostInfo[] list_hosts()
514     {
515         return server_table.getHosts();
516     }
517
518     /**
519      * List all registered server. The ServerInfo objects contain also
520      * a list of the associated POAs.
521      *
522      * @return an array containing all registered servers.
523      */
524     public ServerInfo[] list_servers()
525     {
526         ServerInfo [] servers;
527
528         if (check_object_liveness)
529         {
530             this.logger.debug("ImR: Checking servers");
531
532             servers = server_table.getServers();
533
534             for (int k=0; k<servers.length; k++)
535             {
536                 if (servers[k].active && servers[k].poas.length > 0)
537                 {
538                     byte[] first = servers[k].poas[0].name.getBytes ();
539                     byte[] id = new byte [ first.length + 1];
540                     System.arraycopy (first, 0, id, 0, first.length);
541                     id[first.length] = org.jacorb.poa.POAConstants.OBJECT_KEY_SEP_BYTE;
542
543                     if ( ! checkServerActive
544                          (servers[k].poas[0].host, servers[k].poas[0].port, id))
545                     {
546                         try
547                         {
548                             if (this.logger.isDebugEnabled())
549                             {
550                                 this.logger.debug("ImR: Setting server " +
551                                                   servers[k].name + " down");
552                             }
553
554                             // Server is not active so set it down
555 server_table.getServer(servers[k].name).setDown();
556
557                             // Save retrieving the list again.
558 servers[k].active = false;
559                         }
560                         catch (UnknownServerName e)
561                         {
562                             if (this.logger.isDebugEnabled())
563                             {
564                                 this.logger.debug("ImR: Internal error - unknown server " + servers[k].name, e);
565                             }
566                         }
567                     }
568                 }
569             }
570         }
571         else
572         {
573             servers = server_table.getServers();
574         }
575
576         return servers;
577     }
578
579     /**
580      * Get the ServerInfo object of a specific server.
581      *
582      * @param server the servers name.
583      * @return the ServerInfo object of the server with name <code>server</code>
584      * @exception UnknownServerName the server <code>server</code> has not been registered.
585      */
586     public ServerInfo get_server_info(String JavaDoc server)
587         throws UnknownServerName
588     {
589         return server_table.getServer(server).toServerInfo();
590     }
591
592     /**
593      * Register a logical server. The logical server corresponds to a process
594      * which has a number of POAs.
595      *
596      * @param name the servers name.
597      * @param command the startup command for this server if it should be restarted
598      * on demand. Has to be empty (NOT null) if the server should not be restarted.
599      * @param host the host on which the server should be restarted. Should not
600      * be null, but is ignored if no startup command is specified.
601      *
602      * @exception org.jacorb.imr.AdminPackage.IllegalServerName the servers name is not valid.
603      * @exception org.jacorb.imr.AdminPackage.DuplicateServerName a server with <code>name</code>
604      * has already been registered.
605      */
606     public void register_server(String JavaDoc name, String JavaDoc command, String JavaDoc host)
607         throws IllegalServerName, DuplicateServerName
608     {
609         updatePending = true;
610
611         ImRServerInfo _server = new ImRServerInfo(name, host, command);
612         server_table.putServer(name, _server);
613
614         if (this.logger.isDebugEnabled())
615         {
616             this.logger.debug("ImR: server " + name + " on " +
617                               host + " registered");
618         }
619
620         try
621         {
622             synchronized (wt)
623             {
624                 wt.notify ();
625             }
626         }
627         catch (IllegalMonitorStateException JavaDoc e)
628         {
629             this.logger.debug("Caught Exception", e);
630         }
631     }
632
633
634     /**
635      * Remove a logical server from the server table. If a server is removed, all of its POAs
636      * are removed as well.
637      *
638      * @param name the servers name.
639      * @exception org.jacorb.imr.UnknownServerName a server with <code>name</code> has not been registered.
640      */
641     public void unregister_server(String JavaDoc name) throws UnknownServerName
642     {
643         updatePending = true;
644
645         ImRServerInfo _server = server_table.getServer(name);
646         String JavaDoc[] _poas = _server.getPOANames();
647
648         // remove POAs
649 for (int _i = 0; _i < _poas.length; _i++)
650             server_table.removePOA(_poas[_i]);
651
652         server_table.removeServer(name);
653
654         if (this.logger.isDebugEnabled())
655         {
656             this.logger.debug("ImR: server " + name + " unregistered");
657         }
658
659         try
660         {
661             synchronized (wt)
662             {
663                 wt.notify ();
664             }
665         }
666         catch (IllegalMonitorStateException JavaDoc e)
667         {
668             this.logger.debug("Caught Exception", e);
669         }
670     }
671
672     /**
673      * Updates the server with a new command and host. For migrating purposes.
674      *
675      * @param name the servers name.
676      * @param command the new startup command for this server.
677      * @param host the new host.
678      * @exception org.jacorb.imr.AdminPackage.UnknownServerName a server with <code>name</code>
679      * has not been registered.
680      */
681     public void edit_server(String JavaDoc name, String JavaDoc command, String JavaDoc host)
682         throws UnknownServerName
683     {
684         updatePending = true;
685
686         ImRServerInfo _server = server_table.getServer(name);
687
688         _server.command = command;
689         _server.host = host;
690
691         if (this.logger.isDebugEnabled())
692         {
693             this.logger.debug("ImR: server " + name + " edited");
694         }
695
696         try
697         {
698             synchronized (wt)
699             {
700                 wt.notify ();
701             }
702         }
703         catch (IllegalMonitorStateException JavaDoc e)
704         {
705             this.logger.debug("Caught Exception", e);
706         }
707     }
708
709
710     /**
711      * Hold a server. This causes all requests for this server to be delayed
712      * until it is released. Holding a server is useful for migrating or
713      * maintaining it. There is not timeout set, so requests might be delayed
714      * indefinetly (or, at least, until the communication layer protests;-).
715      *
716      * @param name the servers name.
717      * @exception org.jacorb.imr.UnknownServerName a server with <code>name</code> has not been registered.
718      */
719     public void hold_server(String JavaDoc name)
720         throws UnknownServerName
721     {
722         ImRServerInfo _server = server_table.getServer(name);
723         _server.holding = true;
724     }
725
726     /**
727      * Release a server from state "holding".
728      *
729      * @param name the servers name.
730      * @exception org.jacorb.imr.UnknownServerName a server with <code>name</code> has not been registered.
731      */
732     public void release_server(String JavaDoc name)
733         throws UnknownServerName
734     {
735         ImRServerInfo _server = server_table.getServer(name);
736         _server.release();
737     }
738
739     /**
740      * Start a server.
741      *
742      * @param name the servers name.
743      * @exception org.jacorb.imr.UnknownServerName a server with <code>name</code>
744      * has not been registered.
745      */
746     public void start_server(String JavaDoc name)
747         throws UnknownServerName, ServerStartupFailed
748     {
749         restartServer(server_table.getServer(name));
750     }
751
752     /**
753      * Save the server table to a backup file.
754      * @exception org.jacorb.imr.AdminPackage.FileOpFailed something went wrong.
755      */
756     public void save_server_table()
757         throws FileOpFailed
758     {
759         if (table_file_backup != null)
760         {
761             save_server_table(table_file_backup);
762         }
763     }
764
765     /**
766      * Shut the repository down orderly, i.e. with saving of the server table.
767      * The actual shutdown is done in the SocketListener thread because, if
768      * done from here, the orb wont shut don correctly because this connection
769      * is still active. (See end of SocketListener.run())
770      *
771      * @param wait wait_for_completion (from ORB.shutdown()). If false, then the ORB
772      * is forced down, ignoring any open connection.
773      */
774     public void shutdown(boolean wait)
775     {
776         synchronized (wt)
777         {
778             wt.shutdown ();
779             wt.notify ();
780         }
781         if (listener != null)
782         {
783             listener.stopListening (wait);
784             try
785             {
786                 synchronized (listener)
787                 {
788                     // Wait at most 5 seconds for the listener to shutdown.
789 listenerThread.join(5000);
790                 }
791             }
792             catch (InterruptedException JavaDoc e)
793             {
794                 this.logger.debug("Caught Exception", e);
795             }
796         }
797         try
798         {
799             save_server_table ();
800         }
801         catch (FileOpFailed f)
802         {
803             this.logger.debug("ImR: Failed to save backup table.", f);
804         }
805         this.logger.debug("ImR: Finished shutting down");
806     }
807
808     /**
809      * Remove a host from the servertable. Hosts are removed
810      * automatically on server startup, if they can't be accessed.
811      *
812      * @param name the hosts name.
813      * @exception no host with that name known.
814      */
815     public void unregister_host(String JavaDoc name)
816         throws UnknownHostName{
817         if (server_table.removeHost(name) == null)
818             throw new UnknownHostName(name);
819     }
820
821     /**
822      * Convenience method which does the actual serialization.
823      *
824      * @param save_to the file where to write to.
825      * @exception sth went wrong.
826      */
827     private void save_server_table(File save_to) throws FileOpFailed {
828         try{
829             ObjectOutputStream _out = new ObjectOutputStream(new FileOutputStream(save_to));
830
831             server_table.table_lock.gainExclusiveLock();
832             _out.writeObject(server_table);
833             server_table.table_lock.releaseExclusiveLock();
834
835             _out.flush();
836             _out.close();
837         }
838         catch (Exception JavaDoc e)
839         {
840             this.logger.debug("Caught Exception", e);
841             throw new FileOpFailed();
842         }
843         updatePending = false;
844     }
845
846
847     /**
848      * Prints the usage screen and exits.
849      */
850     public static void usage ()
851     {
852         System.out.println("Usage: The following properties are useful in conjunction with the \nImplementationRepository:");
853         System.out.println("\t \"jacorb.imr.endpoint_host\" Address to listen on for requests");
854         System.out.println("\t \"jacorb.imr.endpoint_port\" Port to listen on for requests");
855         System.out.println("\t \"jacorb.imr.table_file\" The file to store the server table into");
856         System.out.println("\t \"jacorb.imr.backup_file\" The file to store the server table backup into");
857         System.out.println("\t \"jacorb.imr.ior_file\" The file to store the ImRs IOR into");
858         System.out.println("\t \"jacorb.imr.allow_auto_register\" if set to \"on\", servers that don't \n\talready have an entry on their first call to the imr, will get \n\tautomatically registered. Otherwise, an UnknownServer exception \n\tis thrown.");
859         System.exit(0);
860     }
861
862     /**
863      * The main method. "Parses" the arguments and sets the corresponding
864      * attributes up, creates a new ImplementationRepositoryImpl instance and
865      * runs the ORB.
866      */
867     public static void main(String JavaDoc[] args)
868     {
869         // translate any properties set on the commandline but after the
870 // class name to a properties
871 java.util.Properties JavaDoc argProps = ObjectUtil.argsToProps( args );
872         argProps.setProperty("jacorb.implname", "the_ImR");
873         argProps.setProperty("jacorb.use_imr", "off");
874
875         //Write IOR to file
876 try
877         {
878             org.omg.CORBA.ORB JavaDoc orb = org.omg.CORBA.ORB.init( args, argProps );
879
880             ImplementationRepositoryImpl _imr =
881                 new ImplementationRepositoryImpl(orb);
882             _imr.configure(((org.jacorb.orb.ORB) orb).getConfiguration());
883
884             POA root_poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
885             root_poa.the_POAManager().activate();
886
887             org.omg.CORBA.Policy JavaDoc[] policies = new org.omg.CORBA.Policy JavaDoc[2];
888
889             policies[0] =
890         &