--- /dev/null
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.net;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.io.ObjectOutputStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.Vector;
+
+import org.apache.log4j.AppenderSkeleton;
+import org.apache.log4j.helpers.CyclicBuffer;
+import org.apache.log4j.helpers.LogLog;
+import org.apache.log4j.spi.LoggingEvent;
+
+/**
+ Sends {@link LoggingEvent} objects to a set of remote log servers,
+ usually a {@link SocketNode SocketNodes}.
+
+ <p>Acts just like {@link SocketAppender} except that instead of
+ connecting to a given remote log server,
+ <code>SocketHubAppender</code> accepts connections from the remote
+ log servers as clients. It can accept more than one connection.
+ When a log event is received, the event is sent to the set of
+ currently connected remote log servers. Implemented this way it does
+ not require any update to the configuration file to send data to
+ another remote log server. The remote log server simply connects to
+ the host and port the <code>SocketHubAppender</code> is running on.
+
+ <p>The <code>SocketHubAppender</code> does not store events such
+ that the remote side will events that arrived after the
+ establishment of its connection. Once connected, events arrive in
+ order as guaranteed by the TCP protocol.
+
+ <p>This implementation borrows heavily from the {@link
+ SocketAppender}.
+
+ <p>The SocketHubAppender has the following characteristics:
+
+ <ul>
+
+ <p><li>If sent to a {@link SocketNode}, logging is non-intrusive as
+ far as the log event is concerned. In other words, the event will be
+ logged with the same time stamp, {@link org.apache.log4j.NDC},
+ location info as if it were logged locally.
+
+ <p><li><code>SocketHubAppender</code> does not use a layout. It
+ ships a serialized {@link LoggingEvent} object to the remote side.
+
+ <p><li><code>SocketHubAppender</code> relies on the TCP
+ protocol. Consequently, if the remote side is reachable, then log
+ events will eventually arrive at remote client.
+
+ <p><li>If no remote clients are attached, the logging requests are
+ simply dropped.
+
+ <p><li>Logging events are automatically <em>buffered</em> by the
+ native TCP implementation. This means that if the link to remote
+ client is slow but still faster than the rate of (log) event
+ production, the application will not be affected by the slow network
+ connection. However, if the network connection is slower then the
+ rate of event production, then the local application can only
+ progress at the network rate. In particular, if the network link to
+ the the remote client is down, the application will be blocked.
+
+ <p>On the other hand, if the network link is up, but the remote
+ client is down, the client will not be blocked when making log
+ requests but the log events will be lost due to client
+ unavailability.
+
+ <p>The single remote client case extends to multiple clients
+ connections. The rate of logging will be determined by the slowest
+ link.
+
+ <p><li>If the JVM hosting the <code>SocketHubAppender</code> exits
+ before the <code>SocketHubAppender</code> is closed either
+ explicitly or subsequent to garbage collection, then there might
+ be untransmitted data in the pipe which might be lost. This is a
+ common problem on Windows based systems.
+
+ <p>To avoid lost data, it is usually sufficient to {@link #close}
+ the <code>SocketHubAppender</code> either explicitly or by calling
+ the {@link org.apache.log4j.LogManager#shutdown} method before
+ exiting the application.
+
+ </ul>
+
+ @author Mark Womack */
+
+public class SocketHubAppender extends AppenderSkeleton {
+
+ /**
+ The default port number of the ServerSocket will be created on. */
+ static final int DEFAULT_PORT = 4560;
+
+ private int port = DEFAULT_PORT;
+ private Vector oosList = new Vector();
+ private ServerMonitor serverMonitor = null;
+ private boolean locationInfo = false;
+ private CyclicBuffer buffer = null;
+ private String application;
+ private boolean advertiseViaMulticastDNS;
+ private ZeroConfSupport zeroConf;
+
+ /**
+ * The MulticastDNS zone advertised by a SocketHubAppender
+ */
+ public static final String ZONE = "_log4j_obj_tcpaccept_appender.local.";
+ private ServerSocket serverSocket;
+
+
+ public SocketHubAppender() { }
+
+ /**
+ Connects to remote server at <code>address</code> and <code>port</code>. */
+ public
+ SocketHubAppender(int _port) {
+ port = _port;
+ startServer();
+ }
+
+ /**
+ Set up the socket server on the specified port. */
+ public
+ void activateOptions() {
+ if (advertiseViaMulticastDNS) {
+ zeroConf = new ZeroConfSupport(ZONE, port, getName());
+ zeroConf.advertise();
+ }
+ startServer();
+ }
+
+ /**
+ Close this appender.
+ <p>This will mark the appender as closed and
+ call then {@link #cleanUp} method. */
+ synchronized
+ public
+ void close() {
+ if(closed) {
+ return;
+ }
+
+ LogLog.debug("closing SocketHubAppender " + getName());
+ this.closed = true;
+ if (advertiseViaMulticastDNS) {
+ zeroConf.unadvertise();
+ }
+ cleanUp();
+
+ LogLog.debug("SocketHubAppender " + getName() + " closed");
+ }
+
+ /**
+ Release the underlying ServerMonitor thread, and drop the connections
+ to all connected remote servers. */
+ public
+ void cleanUp() {
+ // stop the monitor thread
+ LogLog.debug("stopping ServerSocket");
+ serverMonitor.stopMonitor();
+ serverMonitor = null;
+
+ // close all of the connections
+ LogLog.debug("closing client connections");
+ while (oosList.size() != 0) {
+ ObjectOutputStream oos = (ObjectOutputStream)oosList.elementAt(0);
+ if(oos != null) {
+ try {
+ oos.close();
+ } catch(InterruptedIOException e) {
+ Thread.currentThread().interrupt();
+ LogLog.error("could not close oos.", e);
+ } catch(IOException e) {
+ LogLog.error("could not close oos.", e);
+ }
+
+ oosList.removeElementAt(0);
+ }
+ }
+ }
+
+ /**
+ Append an event to all of current connections. */
+ public
+ void append(LoggingEvent event) {
+ if (event != null) {
+ // set up location info if requested
+ if (locationInfo) {
+ event.getLocationInformation();
+ }
+ if (application != null) {
+ event.setProperty("application", application);
+ }
+ event.getNDC();
+ event.getThreadName();
+ event.getMDCCopy();
+ event.getRenderedMessage();
+ event.getThrowableStrRep();
+
+ if (buffer != null) {
+ buffer.add(event);
+ }
+ }
+
+ // if no event or no open connections, exit now
+ if ((event == null) || (oosList.size() == 0)) {
+ return;
+ }
+
+ // loop through the current set of open connections, appending the event to each
+ for (int streamCount = 0; streamCount < oosList.size(); streamCount++) {
+
+ ObjectOutputStream oos = null;
+ try {
+ oos = (ObjectOutputStream)oosList.elementAt(streamCount);
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ // catch this, but just don't assign a value
+ // this should not really occur as this method is
+ // the only one that can remove oos's (besides cleanUp).
+ }
+
+ // list size changed unexpectedly? Just exit the append.
+ if (oos == null) {
+ break;
+ }
+
+ try {
+ oos.writeObject(event);
+ oos.flush();
+ // Failing to reset the object output stream every now and
+ // then creates a serious memory leak.
+ // right now we always reset. TODO - set up frequency counter per oos?
+ oos.reset();
+ }
+ catch(IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ // there was an io exception so just drop the connection
+ oosList.removeElementAt(streamCount);
+ LogLog.debug("dropped connection");
+
+ // decrement to keep the counter in place (for loop always increments)
+ streamCount--;
+ }
+ }
+ }
+
+ /**
+ The SocketHubAppender does not use a layout. Hence, this method returns
+ <code>false</code>. */
+ public
+ boolean requiresLayout() {
+ return false;
+ }
+
+ /**
+ The <b>Port</b> option takes a positive integer representing
+ the port where the server is waiting for connections. */
+ public
+ void setPort(int _port) {
+ port = _port;
+ }
+
+ /**
+ * The <b>App</b> option takes a string value which should be the name of the application getting logged. If property was already set (via system
+ * property), don't set here.
+ */
+ public
+ void setApplication(String lapp) {
+ this.application = lapp;
+ }
+
+ /**
+ * Returns value of the <b>Application</b> option.
+ */
+ public
+ String getApplication() {
+ return application;
+ }
+
+ /**
+ Returns value of the <b>Port</b> option. */
+ public
+ int getPort() {
+ return port;
+ }
+
+ /**
+ * The <b>BufferSize</b> option takes a positive integer representing the number of events this appender will buffer and send to newly connected
+ * clients.
+ */
+ public
+ void setBufferSize(int _bufferSize) {
+ buffer = new CyclicBuffer(_bufferSize);
+ }
+
+ /**
+ * Returns value of the <b>bufferSize</b> option.
+ */
+ public
+ int getBufferSize() {
+ if (buffer == null) {
+ return 0;
+ } else {
+ return buffer.getMaxSize();
+ }
+ }
+
+ /**
+ The <b>LocationInfo</b> option takes a boolean value. If true,
+ the information sent to the remote host will include location
+ information. By default no location information is sent to the server. */
+ public
+ void setLocationInfo(boolean _locationInfo) {
+ locationInfo = _locationInfo;
+ }
+
+ /**
+ Returns value of the <b>LocationInfo</b> option. */
+ public
+ boolean getLocationInfo() {
+ return locationInfo;
+ }
+
+ public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
+ this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
+ }
+
+ public boolean isAdvertiseViaMulticastDNS() {
+ return advertiseViaMulticastDNS;
+ }
+
+ /**
+ Start the ServerMonitor thread. */
+ private
+ void startServer() {
+ serverMonitor = new ServerMonitor(port, oosList);
+ }
+
+ /**
+ * Creates a server socket to accept connections.
+ * @param socketPort port on which the socket should listen, may be zero.
+ * @return new socket.
+ * @throws IOException IO error when opening the socket.
+ */
+ protected ServerSocket createServerSocket(final int socketPort) throws IOException {
+ return new ServerSocket(socketPort);
+ }
+
+ /**
+ This class is used internally to monitor a ServerSocket
+ and register new connections in a vector passed in the
+ constructor. */
+ private class ServerMonitor implements Runnable {
+ private int port;
+ private Vector oosList;
+ private boolean keepRunning;
+ private Thread monitorThread;
+
+ /**
+ Create a thread and start the monitor. */
+ public
+ ServerMonitor(int _port, Vector _oosList) {
+ port = _port;
+ oosList = _oosList;
+ keepRunning = true;
+ monitorThread = new Thread(this);
+ monitorThread.setDaemon(true);
+ monitorThread.setName("SocketHubAppender-Monitor-" + port);
+ monitorThread.start();
+ }
+
+ /**
+ Stops the monitor. This method will not return until
+ the thread has finished executing. */
+ public synchronized void stopMonitor() {
+ if (keepRunning) {
+ LogLog.debug("server monitor thread shutting down");
+ keepRunning = false;
+ try {
+ if (serverSocket != null) {
+ serverSocket.close();
+ serverSocket = null;
+ }
+ } catch (IOException ioe) {}
+
+ try {
+ monitorThread.join();
+ }
+ catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ // do nothing?
+ }
+
+ // release the thread
+ monitorThread = null;
+ LogLog.debug("server monitor thread shut down");
+ }
+ }
+
+ private
+ void sendCachedEvents(ObjectOutputStream stream) throws IOException {
+ if (buffer != null) {
+ for (int i = 0; i < buffer.length(); i++) {
+ stream.writeObject(buffer.get(i));
+ }
+ stream.flush();
+ stream.reset();
+ }
+ }
+
+ /**
+ Method that runs, monitoring the ServerSocket and adding connections as
+ they connect to the socket. */
+ public
+ void run() {
+ serverSocket = null;
+ try {
+ serverSocket = createServerSocket(port);
+ serverSocket.setSoTimeout(1000);
+ }
+ catch (Exception e) {
+ if (e instanceof InterruptedIOException || e instanceof InterruptedException) {
+ Thread.currentThread().interrupt();
+ }
+ LogLog.error("exception setting timeout, shutting down server socket.", e);
+ keepRunning = false;
+ return;
+ }
+
+ try {
+ try {
+ serverSocket.setSoTimeout(1000);
+ }
+ catch (SocketException e) {
+ LogLog.error("exception setting timeout, shutting down server socket.", e);
+ return;
+ }
+
+ while (keepRunning) {
+ Socket socket = null;
+ try {
+ socket = serverSocket.accept();
+ }
+ catch (InterruptedIOException e) {
+ // timeout occurred, so just loop
+ }
+ catch (SocketException e) {
+ LogLog.error("exception accepting socket, shutting down server socket.", e);
+ keepRunning = false;
+ }
+ catch (IOException e) {
+ LogLog.error("exception accepting socket.", e);
+ }
+
+ // if there was a socket accepted
+ if (socket != null) {
+ try {
+ InetAddress remoteAddress = socket.getInetAddress();
+ LogLog.debug("accepting connection from " + remoteAddress.getHostName()
+ + " (" + remoteAddress.getHostAddress() + ")");
+
+ // create an ObjectOutputStream
+ ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
+ if (buffer != null && buffer.length() > 0) {
+ sendCachedEvents(oos);
+ }
+
+ // add it to the oosList. OK since Vector is synchronized.
+ oosList.addElement(oos);
+ } catch (IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ LogLog.error("exception creating output stream on socket.", e);
+ }
+ }
+ }
+ }
+ finally {
+ // close the socket
+ try {
+ serverSocket.close();
+ } catch(InterruptedIOException e) {
+ Thread.currentThread().interrupt();
+ } catch (IOException e) {
+ // do nothing with it?
+ }
+ }
+ }
+ }
+}
+
git://source.jalview.org / jalview.git / blobdiff