Java > Open Source Codes > de > qfs > apps > qflog > Start


1 // {{{ copyright
2
3 /********************************************************************
4  *
5  * $Id: Start.java,v 1.29 2000/07/05 14:07:43 gs Exp $
6  *
7  * The contents of this file are subject to the Mozilla Public
8  * License Version 1.1 (the "License"); you may not use this file
9  * except in compliance with the License. You may obtain a copy of
10  * the License at http://www.mozilla.org/MPL/
11  *
12  * Software distributed under the License is distributed on an "AS
13  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14  * implied. See the License for the specific language governing
15  * rights and limitations under the License.
16  *
17  * The Original Code is qfs.de code.
18  *
19  * The Initial Developer of the Original Code is Gregor Schmid.
20  * Portions created by Gregor Schmid are
21  * Copyright (C) 1999 Quality First Software, Gregor Schmid.
22  * All Rights Reserved.
23  *
24  * Contributor(s):
25  *
26  *******************************************************************/
27
28 // }}}
29
30 package de.qfs.apps.qflog;
31
32 // {{{ imports
33
34 import java.io.File ;
35 import java.io.FileInputStream ;
36 import java.io.IOException ;
37
38 import java.net.InetAddress ;
39 import java.net.UnknownHostException ;
40
41 import java.rmi.AccessException ;
42 import java.rmi.ConnectException ;
43 import java.rmi.NotBoundException ;
44 import java.rmi.RemoteException ;
45 import java.rmi.ServerException ;
46 import java.rmi.registry.Registry ;
47 import java.rmi.registry.LocateRegistry ;
48
49 import java.util.Hashtable ;
50
51 import javax.swing.BorderFactory ;
52 import javax.swing.Icon ;
53 import javax.swing.JFrame ;
54 import javax.swing.JLabel ;
55 import javax.swing.UIManager ;
56 import javax.swing.SwingUtilities ;
57
58 import de.qfs.lib.config.Configuration;
59 import de.qfs.lib.config.Configurator;
60 import de.qfs.lib.gui.EventQueue;
61 import de.qfs.lib.gui.Message;
62 import de.qfs.lib.gui.SplashWindow;
63 import de.qfs.lib.gui.SwingUtil;
64 import de.qfs.lib.log.Log;
65 import de.qfs.lib.log.Logger;
66 import de.qfs.lib.logrmi.LogClient;
67 import de.qfs.lib.logrmi.RemoteLogFilter;
68 import de.qfs.lib.option.Option;
69 import de.qfs.lib.util.ArgsParser;
70 import de.qfs.lib.util.MapResourceBundle;
71 import de.qfs.lib.util.MissingParameterException;
72 import de.qfs.lib.util.UnexpectedParameterException;
73 import de.qfs.lib.util.UnknownOptionException;
74
75 import de.qfs.apps.qflog.logview.LogFrame;
76 import de.qfs.apps.qflog.command.CommandFileOpen;
77 import de.qfs.apps.qflog.command.CommandFileSaveAs;
78
79 // }}}
80
81 /**
82  * Main entry for the logserver.
83  *
84  * @author Gregor Schmid
85  * @version $Revision: 1.29 $
86  */
87 public class Start
88 {
89     // {{{ variables
90
91     /**
92      * The Logger used for logging.
93      */
94     private final static Logger logger = new Logger (Start.class);
95
96     /**
97      * File name for the config file.
98      */
99     private final static String CFG_NAME =
100         System.getProperty ("user.home") +
101         File.separator + ".qflog" + File.separator + "config";
102
103     /**
104      * Default RMI registry host name.
105      */
106     // private final static String SERVER_HOST = "localhost";
107
108     /**
109      * Default name for the log server.
110      */
111     private final static String SERVER_NAME = "qflog";
112
113     /**
114      * The command line options.
115      */
116     private static Hashtable options;
117
118     /**
119      * The main Configurator for the application.
120      */
121     private static Configurator cfg;
122
123     /**
124      * The first non option argument.
125      */
126     private static int argstart;
127
128     // }}}
129
130     // {{{ main
131
132     /**
133      * Main point of entry for the logserver.
134      *
135      * @param args The arguments for the server.
136      */
137     public static void main(final String [] args)
138     {
139         Log.setQueueing(false);
140         Log.setOutputLevel(2);
141
142         // play it safe
143 new JDK11BugThread ().start();
144
145         // for the tab hack
146 EventQueue.install();
147
148         new Splash(App.getResources());
149
150         // Resources may be needed to handle errors from now on
151 Message.setResources(App.getResources());
152         Option.setResources(App.getResources());
153
154         // get the options and patch them up
155 getOpts(args);
156
157         if (options.containsKey("noquery")) {
158             // override
159 options.remove("query");
160         } else if (! options.containsKey("query")) {
161             // set default value
162 options.put("query", "");
163         }
164
165         // check for -version
166 if (options.containsKey("version")) {
167             Version.main(new String [0]);
168             System.exit(0);
169         }
170
171         // set Look and Feel
172 try {
173             UIManager.setLookAndFeel
174                 (UIManager.getSystemLookAndFeelClassName());
175         } catch (Exception ex) {
176             if (logger.level >= Log.ERR) {
177                 logger.log ("main(String[])", ex);
178             }
179         }
180
181         SwingUtil.prepareKeymaps();
182
183         if (options.containsKey("logserver")) {
184             try {
185                 String ls = (String ) options.get("logserver");
186                 RemoteLogFilter.logRemote(ls, "qflog");
187                 Log.setPreQueueLevel(10);
188             } catch (Exception ex) {
189                 // Log.setLevel(10);
190 // Log.setPreQueueLevel(10);
191 if (logger.level >= Log.WRN) {
192                     logger.log(Log.WRN, "main(String[])", ex);
193                 }
194             }
195         } else {
196             // Log.setLevel(10);
197 // Log.setPreQueueLevel(10);
198 // Log.setQueueing(false);
199 }
200         Logger.setLogLevels(options);
201
202         // restore Configuration
203 String configFile = CFG_NAME;
204         if (options.containsKey("configfile")) {
205             configFile = (String ) options.get("configfile");
206         } else {
207             // Create ~/.qflog if necessary
208 File tmp = new File
209                 (System.getProperties().getProperty("user.home") +
210                  File.separator + ".qflog");
211             if (tmp.exists()) {
212                 if (!tmp.isDirectory()) {
213                     // not perfect - but so what
214 File xtmp = new File
215                         (System.getProperties().getProperty("user.home") +
216                          File.separator + ".xqflogx");
217                     // try {
218 tmp.renameTo(xtmp);
219                         tmp.mkdir();
220                         xtmp.renameTo(new File (tmp, "config"));
221                     // } catch (IOException ex) {
222 // if (logger.level >= Log.ERR) {
223 // logger.log("main(String[])", ex);
224 // }
225 // }
226 }
227             } else {
228                 // try {
229 tmp.mkdir();
230                 // } catch (IOException ex) {
231 // if (logger.level >= Log.ERR) {
232 // logger.log("main(String[])", ex);
233 // }
234 // }
235 }
236         }
237         try {
238             FileInputStream fis = new FileInputStream (configFile);
239             Configuration.instance().restore (fis);
240             fis.close();
241         } catch (Exception ex) {
242             if (logger.level >= Log.ERR) {
243                 logger.log("main(String[])", ex);
244             }
245         }
246
247         // get the server hostname
248 String serverhost;
249         if (options.containsKey("serverhost")) {
250             serverhost = (String ) options.get("serverhost");
251         } else {
252             try {
253                 serverhost = InetAddress.getLocalHost().getHostName();
254             } catch (UnknownHostException ex) {
255                 if (logger.level >= Log.ERR) {
256                     logger.log("main(String[])", ex);
257                 }
258                 // this should still work locally
259 serverhost = "";
260             }
261         }
262         if (options.containsKey("port")) {
263             serverhost = serverhost + ":" + options.get("port");
264         }
265
266         // get the server name
267 String servername = SERVER_NAME;
268         if (options.containsKey("servername")) {
269             servername = (String ) options.get("servername");
270         }
271
272         LogServerImpl server = null;
273         if (!options.containsKey("noserver")
274             || options.containsKey("query")) {
275             try {
276                 server = new LogServerImpl();
277             } catch (RemoteException ex) {
278                 // shouldn't happen
279 if (logger.level >= Log.ERR) {
280                     logger.log("main(String[])", ex);
281                 }
282             }
283         }
284
285         // start the RMI server
286 Registry reg = null;
287         if (!options.containsKey("noserver")) {
288             registerServer(server, servername, options);
289         }
290
291         // initialize the App
292 App.instance().setConfigFile(new File (configFile));
293         // make server name known
294 App.instance().setServerHost(serverhost);
295         App.instance().setServerName(servername);
296
297         // workaround for very weird class load deadlock
298 // doesn't really help much, but doesn't hurt either
299 new javax.swing.JScrollPane ();
300
301         Model model = Model.instance();
302         cfg = new Configurator("top");
303
304         // YASDP - Yet Another Stupid Deadlock Prevention
305 App.getResources().getIcon("logServer.icon", null);
306
307         SwingUtil.invokeAndWait(new Runnable () {
308             public void run() {
309                 final MainFrame frame = new MainFrame ();
310                 frame.init();
311                 cfg.add(frame.getConfigurator());
312                 frame.pack();
313                 cfg.register ();
314                 frame.setVisible(true);
315                 boolean load = argstart < args.length;
316                 for (;argstart < args.length; argstart++) {
317                     App.getCommandDistributor().assignCommand
318                         (new CommandFileOpen (frame, frame,
319                                               new File (args[argstart])));
320                 }
321                 if (load) {
322                     frame.getTable().setRowSelectionInterval(0, 0);
323                     frame.getTable().requestFocus();
324                 }
325                 SplashWindow.getLastSplashWindow().remove();
326             }
327         });
328
329         // Query for waiting clients
330 if (server != null && options.containsKey("query")) {
331             queryClients(server, options);
332         }
333     }
334
335     // }}}
336
337     //----------------------------------------------------------------------
338 // helper methods
339 //----------------------------------------------------------------------
340 // {{{ getOpts
341
342     /**
343      * Parse the options from the command line arguments.
344      *
345      * @param args The arguments.
346      */
347     private static void getOpts (String [] args)
348     {
349         if (logger.level >= Log.MTD) {
350             logger.log(Log.MTD, "getOpts(String[])",
351                        logger.level < Log.MTDDETAIL ? "" :
352                        "args: " + args);
353         }
354         ArgsParser ap = new ArgsParser (new String [] {
355             "+configfile",
356             "+logserver",
357             "-nocreateregistry",
358             "-noquery",
359             "-noserver",
360             "+optionfile",
361             "+port",
362             "m?query",
363             "+serverhost",
364             "+servername",
365             "-version"
366         });
367         ap.setDefaultOption("optionfile");
368         try {
369             argstart = ap.parse(args);
370             options = ap.getOptions();
371         } catch (MissingParameterException ex) {
372             System.err.println(Message.format("error.args.missingParameter",
373                                               new Object [] {ex.getOption()}));
374             System.err.println(App.getResources().getString
375                                ("error.args.usage", ""));
376             System.exit(1);
377         } catch (UnexpectedParameterException ex) {
378             System.err.println(Message.format("error.args.unexpectedParamter",
379                                               new Object [] {ex.getOption()}));
380             System.err.println(App.getResources().getString
381                                ("error.args.usage", ""));
382             System.exit(1);
383         } catch (UnknownOptionException ex) {
384             System.err.println(Message.format("error.args.unknownOption",
385                                               new Object [] {ex.getOption()}));
386             System.err.println(App.getResources().getString
387                                ("error.args.usage", ""));
388             System.exit(1);
389         }
390     }
391
392     // }}}
393 // {{{ registerServer
394
395     /**
396      * Register the server with the registry.
397      *
398      * @param server The LogServer to bind.
399      * @param servername The name to bind under.
400      * @param options The command line options.
401      */
402     private static void registerServer(LogServerImpl server,
403                                        String servername, Hashtable options)
404     {
405         Registry reg = null;
406         try {
407             int port = Registry.REGISTRY_PORT;
408             if (options.containsKey("port")) {
409                 port = Integer.parseInt((String ) options.get("port"));
410             }
411             server = new LogServerImpl();
412             try {
413                 reg = LocateRegistry.getRegistry(port);
414                 reg.rebind(servername, server);
415                 if (logger.level >= Log.MSG) {
416                     logger.log(Log.MSG, "main(String[])",
417                                "LogServer bound");
418                 }
419             } catch (RemoteException ex) {
420                 if (logger.level >= Log.ERR) {
421                     logger.log("main(String[])", ex);
422                 }
423                 if (! options.containsKey("nocreateregistry")) {
424                     try {
425                         reg = LocateRegistry.createRegistry(port);
426                         if (logger.level >= Log.DBG) {
427                             logger.log(Log.DBG, "main(String[])",
428                                        "registry created at port " + port);
429                         }
430                         if (reg != null) {
431                             reg.rebind(servername, server);
432                             if (logger.level >= Log.MSG) {
433                                 logger.log(Log.MSG, "main(String[])",
434                                            "LogServer bound");
435                             }
436                         }
437                     } catch (RemoteException ex2) {
438                         if (logger.level >= Log.ERR) {
439                             logger.log("main(String[])", ex2);
440                         }
441                     }
442                 }
443             }
444         } catch (Exception ex) {
445             if (logger.level >= Log.ERR) {
446                 logger.log("main(String[])", ex);
447             }
448         }
449     }
450
451     // }}}
452 // {{{ queryClients
453
454     /**
455      * Query the RMI-Registries for clients.
456      *
457      * @param server The LogServer to pass to the clients.
458      * @param options The command line options.
459      */
460     private static void queryClients (LogServerImpl server, Hashtable options)
461     {
462         Object opt = options.get("query");
463         String [] query =
464             (opt instanceof String [])
465             ? (String []) opt
466             : new String [] {(String ) opt};
467
468         for (int i = 0; i < query.length; i++) {
469             try {
470                 int pStart = query[i].indexOf(':');
471                 String host = query[i].length() > 0 ? query[i] : null;
472                 int port = -1;
473                 if (pStart >= 0) {
474                     host = pStart == 0 ? null : query[i].substring(0, pStart);
475                     try {
476                         port = Integer.parseInt
477                             (query[i].substring(pStart + 1));
478                     } catch (NumberFormatException ex) {
479                     }
480                 }
481                 Registry reg = LocateRegistry.getRegistry(host, port);
482
483                 // check registry for waiting clients
484 String [] names = reg.list();
485                 for (int j = 0; j < names.length; j++) {
486                     if (names[j].startsWith(LogClient.REGISTRY_BASE_NAME)) {
487                         try {
488                             LogClient client = (LogClient)
489                                 reg.lookup(names[j]);
490                             client.connect(server);
491                         } catch (ServerException ex) {
492                             if (logger.level >= Log.ERR) {
493                                 logger.log("main(String[])", ex);
494                             }
495                         } catch (ConnectException ex) {
496                             if (logger.level >= Log.ERR) {
497                                 logger.log("main(String[])", ex);
498                             }
499                             // stale client
500 try {
501                                 reg.unbind(names[j]);
502                             } catch (RemoteException ex2) {
503                                 // maybe non-local, so be it
504 } catch (NotBoundException ex2) {
505                                 // that would be amazing, but it's possible
506 }
507                         } catch (Exception ex) {
508                             if (logger.level >= Log.ERR) {
509                                 logger.log("main(String[])", ex);
510                             }
511                         }
512                     }
513                 }
514             } catch (Exception ex) {
515                 if (logger.level >= Log.ERR) {
516                     logger.log("main(String[])", ex);
517                 }
518             }
519         }
520     }
521
522     // }}}
523
524     // {{{ class JDK11BugThread
525
526     /**
527      * This class helps avoid a garbage collection bug in JDK 1.1.
528      */
529     private static class JDK11BugThread extends Thread
530     {
531         Class bug5 = de.qfs.apps.qflog.logview.LogFrame.class;
532         Class bug6 = de.qfs.lib.gui.Message.class;
533
534         public JDK11BugThread()
535         {
536             setDaemon(true);
537             setName("JDK1.1 Bug Workaroud Thread");
538         }
539
540         public void run () {
541             while (true) {
542                 try {
543                     // Sleep one hour at a time
544 sleep(3600000);
545                 } catch (InterruptedException ex) {
546                 }
547             }
548         }
549
550     }
551
552     // }}}
553
554     // {{{ class Splash
555
556     /**
557      * Splash Window for qflog.
558      */
559     private static class Splash
560         extends SplashWindow
561     {
562         // {{{ Splash
563
564         /**
565          * Create a new Splash window.
566          *
567          * @param rb The resources to get the icon from.
568          */
569         public Splash(MapResourceBundle rb)
570         {
571             super(100, 100);
572             Icon icon = rb.getIcon ("qflog.splash.icon", null);
573             if (icon != null) {
574                 panel.setBorder(BorderFactory.createRaisedBevelBorder());
575                 panel.add(new JLabel (icon));
576                 panel.remove(bar);
577                 setSize(panel.getPreferredSize());
578                 SwingUtil.centerWindow(this);
579                 show();
580             } else {
581                 remove();
582             }
583         }
584
585         // }}}
586 }
587
588     // }}}
589 }
590

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags