SwingJS-site.zip update after Wuppertal.
[jalview.git] / unused / srcjar_unused / org / apache / log4j / net / SocketAppender.java
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  * 
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  * 
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 // Contributors: Dan MacDonald <dan@redknee.com>
19
20 package org.apache.log4j.net;
21
22 import java.io.IOException;
23 import java.io.ObjectOutputStream;
24 import java.io.InterruptedIOException;
25 import java.net.InetAddress;
26 import java.net.Socket;
27
28 import org.apache.log4j.AppenderSkeleton;
29 import org.apache.log4j.helpers.LogLog;
30 import org.apache.log4j.spi.ErrorCode;
31 import org.apache.log4j.spi.LoggingEvent;
32
33 /**
34     Sends {@link LoggingEvent} objects to a remote a log server,
35     usually a {@link SocketNode}.
36
37     <p>The SocketAppender has the following properties:
38
39     <ul>
40
41       <p><li>If sent to a {@link SocketNode}, remote logging is
42       non-intrusive as far as the log event is concerned. In other
43       words, the event will be logged with the same time stamp, {@link
44       org.apache.log4j.NDC}, location info as if it were logged locally by
45       the client.
46
47       <p><li>SocketAppenders do not use a layout. They ship a
48       serialized {@link LoggingEvent} object to the server side.
49
50       <p><li>Remote logging uses the TCP protocol. Consequently, if
51       the server is reachable, then log events will eventually arrive
52       at the server.
53
54       <p><li>If the remote server is down, the logging requests are
55       simply dropped. However, if and when the server comes back up,
56       then event transmission is resumed transparently. This
57       transparent reconneciton is performed by a <em>connector</em>
58       thread which periodically attempts to connect to the server.
59
60       <p><li>Logging events are automatically <em>buffered</em> by the
61       native TCP implementation. This means that if the link to server
62       is slow but still faster than the rate of (log) event production
63       by the client, the client will not be affected by the slow
64       network connection. However, if the network connection is slower
65       then the rate of event production, then the client can only
66       progress at the network rate. In particular, if the network link
67       to the the server is down, the client will be blocked.
68
69       <p>On the other hand, if the network link is up, but the server
70       is down, the client will not be blocked when making log requests
71       but the log events will be lost due to server unavailability.
72
73       <p><li>Even if a <code>SocketAppender</code> is no longer
74       attached to any category, it will not be garbage collected in
75       the presence of a connector thread. A connector thread exists
76       only if the connection to the server is down. To avoid this
77       garbage collection problem, you should {@link #close} the the
78       <code>SocketAppender</code> explicitly. See also next item.
79
80       <p>Long lived applications which create/destroy many
81       <code>SocketAppender</code> instances should be aware of this
82       garbage collection problem. Most other applications can safely
83       ignore it.
84
85       <p><li>If the JVM hosting the <code>SocketAppender</code> exits
86       before the <code>SocketAppender</code> is closed either
87       explicitly or subsequent to garbage collection, then there might
88       be untransmitted data in the pipe which might be lost. This is a
89       common problem on Windows based systems.
90
91       <p>To avoid lost data, it is usually sufficient to {@link
92       #close} the <code>SocketAppender</code> either explicitly or by
93       calling the {@link org.apache.log4j.LogManager#shutdown} method
94       before exiting the application.
95
96
97      </ul>
98
99     @author  Ceki G&uuml;lc&uuml;
100     @since 0.8.4 */
101
102 public class SocketAppender extends AppenderSkeleton {
103
104   /**
105      The default port number of remote logging server (4560).
106      @since 1.2.15
107   */
108   static public final int DEFAULT_PORT                 = 4560;
109
110   /**
111      The default reconnection delay (30000 milliseconds or 30 seconds).
112   */
113   static final int DEFAULT_RECONNECTION_DELAY   = 30000;
114
115   /**
116      We remember host name as String in addition to the resolved
117      InetAddress so that it can be returned via getOption().
118   */
119   String remoteHost;
120
121   /**
122    * The MulticastDNS zone advertised by a SocketAppender
123    */
124   public static final String ZONE = "_log4j_obj_tcpconnect_appender.local.";
125
126   InetAddress address;
127   int port = DEFAULT_PORT;
128   ObjectOutputStream oos;
129   int reconnectionDelay = DEFAULT_RECONNECTION_DELAY;
130   boolean locationInfo = false;
131   private String application;
132
133   private Connector connector;
134
135   int counter = 0;
136
137   // reset the ObjectOutputStream every 70 calls
138   //private static final int RESET_FREQUENCY = 70;
139   private static final int RESET_FREQUENCY = 1;
140   private boolean advertiseViaMulticastDNS;
141   private ZeroConfSupport zeroConf;
142
143   public SocketAppender() {
144   }
145
146   /**
147      Connects to remote server at <code>address</code> and <code>port</code>.
148   */
149   public SocketAppender(InetAddress address, int port) {
150     this.address = address;
151     this.remoteHost = address.getHostName();
152     this.port = port;
153     connect(address, port);
154   }
155
156   /**
157      Connects to remote server at <code>host</code> and <code>port</code>.
158   */
159   public SocketAppender(String host, int port) {
160     this.port = port;
161     this.address = getAddressByName(host);
162     this.remoteHost = host;
163     connect(address, port);
164   }
165
166   /**
167      Connect to the specified <b>RemoteHost</b> and <b>Port</b>.
168   */
169   public void activateOptions() {
170     if (advertiseViaMulticastDNS) {
171       zeroConf = new ZeroConfSupport(ZONE, port, getName());
172       zeroConf.advertise();
173     }
174     connect(address, port);
175   }
176
177   /**
178    * Close this appender.  
179    *
180    * <p>This will mark the appender as closed and call then {@link
181    * #cleanUp} method.
182    * */
183   synchronized public void close() {
184     if(closed) {
185         return;
186     }
187
188     this.closed = true;
189     if (advertiseViaMulticastDNS) {
190       zeroConf.unadvertise();
191     }
192
193     cleanUp();
194   }
195
196   /**
197    * Drop the connection to the remote host and release the underlying
198    * connector thread if it has been created 
199    * */
200   public void cleanUp() {
201     if(oos != null) {
202       try {
203         oos.close();
204       } catch(IOException e) {
205           if (e instanceof InterruptedIOException) {
206               Thread.currentThread().interrupt();
207           }
208               LogLog.error("Could not close oos.", e);
209       }
210       oos = null;
211     }
212     if(connector != null) {
213       //LogLog.debug("Interrupting the connector.");
214       connector.interrupted = true;
215       connector = null;  // allow gc
216     }
217   }
218
219   void connect(InetAddress address, int port) {
220     if(this.address == null) {
221         return;
222     }
223     try {
224       // First, close the previous connection if any.
225       cleanUp();
226       oos = new ObjectOutputStream(new Socket(address, port).getOutputStream());
227     } catch(IOException e) {
228       if (e instanceof InterruptedIOException) {
229           Thread.currentThread().interrupt();
230       }
231       String msg = "Could not connect to remote log4j server at ["
232         +address.getHostName()+"].";
233       if(reconnectionDelay > 0) {
234         msg += " We will try again later.";
235         fireConnector(); // fire the connector thread
236       } else {
237           msg += " We are not retrying.";
238           errorHandler.error(msg, e, ErrorCode.GENERIC_FAILURE);
239       } 
240       LogLog.error(msg);
241     }
242   }
243
244
245   public void append(LoggingEvent event) {
246     if(event == null) {
247         return;
248     }
249
250     if(address==null) {
251       errorHandler.error("No remote host is set for SocketAppender named \""+
252                         this.name+"\".");
253       return;
254     }
255
256     if(oos != null) {
257       try {
258          
259         if(locationInfo) {
260            event.getLocationInformation();
261         }
262     if (application != null) {
263         event.setProperty("application", application);
264     }
265     event.getNDC();
266     event.getThreadName();
267     event.getMDCCopy();
268     event.getRenderedMessage();
269     event.getThrowableStrRep();
270     
271         oos.writeObject(event);
272         //LogLog.debug("=========Flushing.");
273         oos.flush();
274         if(++counter >= RESET_FREQUENCY) {
275           counter = 0;
276           // Failing to reset the object output stream every now and
277           // then creates a serious memory leak.
278           //System.err.println("Doing oos.reset()");
279           oos.reset();
280         }
281       } catch(IOException e) {
282           if (e instanceof InterruptedIOException) {
283               Thread.currentThread().interrupt();
284           }
285               oos = null;
286               LogLog.warn("Detected problem with connection: "+e);
287               if(reconnectionDelay > 0) {
288                  fireConnector();
289               } else {
290                  errorHandler.error("Detected problem with connection, not reconnecting.", e,
291                        ErrorCode.GENERIC_FAILURE);
292               }
293       }
294     }
295   }
296
297   public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
298     this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
299   }
300
301   public boolean isAdvertiseViaMulticastDNS() {
302     return advertiseViaMulticastDNS;
303   }
304
305   void fireConnector() {
306     if(connector == null) {
307       LogLog.debug("Starting a new connector thread.");
308       connector = new Connector();
309       connector.setDaemon(true);
310       connector.setPriority(Thread.MIN_PRIORITY);
311       connector.start();
312     }
313   }
314
315   static
316   InetAddress getAddressByName(String host) {
317     try {
318       return InetAddress.getByName(host);
319     } catch(Exception e) {
320       if (e instanceof InterruptedIOException || e instanceof InterruptedException) {
321           Thread.currentThread().interrupt();
322       }
323       LogLog.error("Could not find address of ["+host+"].", e);
324       return null;
325     }
326   }
327
328   /**
329    * The SocketAppender does not use a layout. Hence, this method
330    * returns <code>false</code>.  
331    * */
332   public boolean requiresLayout() {
333     return false;
334   }
335
336   /**
337    * The <b>RemoteHost</b> option takes a string value which should be
338    * the host name of the server where a {@link SocketNode} is
339    * running.
340    * */
341   public void setRemoteHost(String host) {
342     address = getAddressByName(host);
343     remoteHost = host;
344   }
345
346   /**
347      Returns value of the <b>RemoteHost</b> option.
348    */
349   public String getRemoteHost() {
350     return remoteHost;
351   }
352
353   /**
354      The <b>Port</b> option takes a positive integer representing
355      the port where the server is waiting for connections.
356    */
357   public void setPort(int port) {
358     this.port = port;
359   }
360
361   /**
362      Returns value of the <b>Port</b> option.
363    */
364   public int getPort() {
365     return port;
366   }
367
368   /**
369      The <b>LocationInfo</b> option takes a boolean value. If true,
370      the information sent to the remote host will include location
371      information. By default no location information is sent to the server.
372    */
373   public void setLocationInfo(boolean locationInfo) {
374     this.locationInfo = locationInfo;
375   }
376
377   /**
378      Returns value of the <b>LocationInfo</b> option.
379    */
380   public boolean getLocationInfo() {
381     return locationInfo;
382   }
383
384   /**
385    * The <b>App</b> option takes a string value which should be the name of the 
386    * application getting logged.
387    * If property was already set (via system property), don't set here.
388    * @since 1.2.15
389    */
390   public void setApplication(String lapp) {
391     this.application = lapp;
392   }
393
394   /**
395    *  Returns value of the <b>Application</b> option.
396    * @since 1.2.15
397    */
398   public String getApplication() {
399     return application;
400   }
401
402   /**
403      The <b>ReconnectionDelay</b> option takes a positive integer
404      representing the number of milliseconds to wait between each
405      failed connection attempt to the server. The default value of
406      this option is 30000 which corresponds to 30 seconds.
407
408      <p>Setting this option to zero turns off reconnection
409      capability.
410    */
411   public void setReconnectionDelay(int delay) {
412     this.reconnectionDelay = delay;
413   }
414
415   /**
416      Returns value of the <b>ReconnectionDelay</b> option.
417    */
418   public int getReconnectionDelay() {
419     return reconnectionDelay;
420   }
421
422   /**
423      The Connector will reconnect when the server becomes available
424      again.  It does this by attempting to open a new connection every
425      <code>reconnectionDelay</code> milliseconds.
426
427      <p>It stops trying whenever a connection is established. It will
428      restart to try reconnect to the server when previously open
429      connection is droppped.
430
431      @author  Ceki G&uuml;lc&uuml;
432      @since 0.8.4
433   */
434   class Connector extends Thread {
435
436     boolean interrupted = false;
437
438     public
439     void run() {
440       Socket socket;
441       while(!interrupted) {
442         try {
443           sleep(reconnectionDelay);
444           LogLog.debug("Attempting connection to "+address.getHostName());
445           socket = new Socket(address, port);
446           synchronized(this) {
447             oos = new ObjectOutputStream(socket.getOutputStream());
448             connector = null;
449             LogLog.debug("Connection established. Exiting connector thread.");
450             break;
451           }
452         } catch(InterruptedException e) {
453           LogLog.debug("Connector interrupted. Leaving loop.");
454           return;
455         } catch(java.net.ConnectException e) {
456           LogLog.debug("Remote host "+address.getHostName()
457                        +" refused connection.");
458         } catch(IOException e) {
459         if (e instanceof InterruptedIOException) {
460             Thread.currentThread().interrupt();
461         }
462             LogLog.debug("Could not connect to " + address.getHostName()+
463                        ". Exception is " + e);
464         }
465       }
466       //LogLog.debug("Exiting Connector.run() method.");
467     }
468
469     /**
470        public
471        void finalize() {
472        LogLog.debug("Connector finalize() has been called.");
473        }
474     */
475   }
476
477 }