View Javadoc

    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  package org.apache.log4j.chainsaw;
    18
    19  import java.io.EOFException;
    20  import java.io.IOException;
    21  import java.io.ObjectInputStream;
    22  import java.net.ServerSocket;
    23  import java.net.Socket;
    24  import java.net.SocketException;
    25  import org.apache.log4j.Logger;
    26  import org.apache.log4j.spi.LoggingEvent;
    27
    28  /**
    29   * A daemon thread the processes connections from a
    30   * <code>org.apache.log4j.net.SocketAppender.html</code>.
    31   *
    32   * @author <a href="mailto:oliver@puppycrawl.com">Oliver Burn</a>
    33   */
    34  class LoggingReceiver extends Thread {
    35      /** used to log messages **/
    36      private static final Logger LOG = Logger.getLogger(LoggingReceiver.class);
    37
    38      /**
    39       * Helper that actually processes a client connection. It receives events
    40       * and adds them to the supplied model.
    41       *
    42       * @author <a href="mailto:oliver@puppycrawl.com">Oliver Burn</a>
    43       */
    44      private class Slurper implements Runnable {
    45          /** socket connection to read events from **/
    46          private final Socket mClient;
    47
    48          /**
    49           * Creates a new <code>Slurper</code> instance.
    50           *
    51           * @param aClient socket to receive events from
    52           */
    53          Slurper(Socket aClient) {
    54              mClient = aClient;
    55          }
    56
    57          /** loops getting the events **/
    58          public void run() {
    59              LOG.debug("Starting to get data");
    60              try {
    61                  final ObjectInputStream ois =
    62                      new ObjectInputStream(mClient.getInputStream());
    63                  while (true) {
    64                      final LoggingEvent event = (LoggingEvent) ois.readObject();
    65                      mModel.addEvent(new EventDetails(event));
    66                  }
    67              } catch (EOFException e) {
    68                  LOG.info("Reached EOF, closing connection");
    69              } catch (SocketException e) {
    70                  LOG.info("Caught SocketException, closing connection");
    71              } catch (IOException e) {
    72                  LOG.warn("Got IOException, closing connection", e);
    73              } catch (ClassNotFoundException e) {
    74                  LOG.warn("Got ClassNotFoundException, closing connection", e);
    75              }
    76
    77              try {
    78                  mClient.close();
    79              } catch (IOException e) {
    80                  LOG.warn("Error closing connection", e);
    81              }
    82          }
    83      }
    84
    85      /** where to put the events **/
    86      private MyTableModel mModel;
    87
    88      /** server for listening for connections **/
    89      private ServerSocket mSvrSock;
    90
    91      /**
    92       * Creates a new <code>LoggingReceiver</code> instance.
    93       *
    94       * @param aModel model to place put received into
    95       * @param aPort port to listen on
    96       * @throws IOException if an error occurs
    97       */
    98      LoggingReceiver(MyTableModel aModel, int aPort) throws IOException {
    99          setDaemon(true);
    100         mModel = aModel;
    101         mSvrSock = new ServerSocket(aPort);
    102     }
    103
    104     /** Listens for client connections **/
    105     public void run() {
    106         LOG.info("Thread started");
    107         try {
    108             while (true) {
    109                 LOG.debug("Waiting for a connection");
    110                 final Socket client = mSvrSock.accept();
    111                 LOG.debug("Got a connection from " +
    112                           client.getInetAddress().getHostName());
    113                 final Thread t = new Thread(new Slurper(client));
    114                 t.setDaemon(true);
    115                 t.start();
    116             }
    117         } catch (IOException e) {
    118             LOG.error("Error in accepting connections, stopping.", e);
    119         }
    120     }
    121 }