src/main/java/org/apache/log4j/net/XMLSocketNode.java

///*
// * 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 org.apache.log4j.Logger;
//import org.apache.log4j.helpers.Constants;
//import org.apache.log4j.plugins.Receiver;
//import org.apache.log4j.spi.ComponentBase;
//import org.apache.log4j.spi.Decoder;
//import org.apache.log4j.spi.LoggerRepository;
//import org.apache.log4j.spi.LoggingEvent;
//
//import java.io.IOException;
//import java.io.InputStream;
//import java.net.Socket;
//import java.util.List;
//
//
///**
// * Read {@link LoggingEvent} objects sent from a remote client using XML over
// * Sockets (TCP). These logging events are logged according to local
// * policy, as if they were generated locally.
// * <p>
// * <p>For example, the socket node might decide to log events to a
// * local file and also resent them to a second socket node.
// *
// * @author Scott Deboy &lt;sdeboy@apache.org&gt;;
// * @since 0.8.4
// */
//public class XMLSocketNode extends ComponentBase implements Runnable {
//    Socket socket;
//    Receiver receiver;
//    Decoder decoder;
//    SocketNodeEventListener listener;
//
//    /**
//     * Constructor for socket and logger repository.
//     */
//    public XMLSocketNode(
//        String decoder, Socket socket, LoggerRepository hierarchy) {
//        this.repository = hierarchy;
//        try {
//            Class c = Class.forName(decoder);
//            Object o = c.newInstance();
//
//            if (o instanceof Decoder) {
//                this.decoder = (Decoder) o;
//            }
//        } catch (ClassNotFoundException cnfe) {
//            getLogger().warn("Unable to find decoder", cnfe);
//        } catch (IllegalAccessException | InstantiationException iae) {
//            getLogger().warn("Unable to construct decoder", iae);
//        }
//
//        this.socket = socket;
//    }
//
//    /**
//     * Constructor for socket and reciever.
//     */
//    public XMLSocketNode(String decoder, Socket socket, Receiver receiver) {
//        try {
//            Class c = Class.forName(decoder);
//            Object o = c.newInstance();
//
//            if (o instanceof Decoder) {
//                this.decoder = (Decoder) o;
//            }
//        } catch (ClassNotFoundException cnfe) {
//            getLogger().warn("Unable to find decoder", cnfe);
//        } catch (IllegalAccessException | InstantiationException iae) {
//            getLogger().warn("Unable to construct decoder", iae);
//        }
//
//        this.socket = socket;
//        this.receiver = receiver;
//    }
//
//    /**
//     * Set the event listener on this node.
//     */
//    public void setListener(SocketNodeEventListener _listener) {
//        listener = _listener;
//    }
//
//    public void run() {
//        Logger remoteLogger;
//        Exception listenerException = null;
//        InputStream is;
//
//        if ((this.receiver == null) || (this.decoder == null)) {
//            listenerException =
//                new Exception(
//                    "No receiver or decoder provided.  Cannot process xml socket events");
//            getLogger().error(
//                "Exception constructing XML Socket Receiver", listenerException);
//        }
//
//        try {
//            is = socket.getInputStream();
//        } catch (Exception e) {
//            is = null;
//            listenerException = e;
//            getLogger().error("Exception opening InputStream to " + socket, e);
//        }
//
//        if (is != null) {
//            String hostName = socket.getInetAddress().getHostName();
//            String remoteInfo = hostName + ":" + socket.getPort();
//
//            try {
//                //read data from the socket
//                //it's up to the individual decoder to handle incomplete event data
//                while (true) {
//                    byte[] b = new byte[1024];
//                    int length = is.read(b);
//                    if (length == -1) {
//                        getLogger().info(
//                            "no bytes read from stream - closing connection.");
//                        break;
//                    }
//                    List<LoggingEvent> v = decoder.decodeEvents(new String(b, 0, length));
//
//                    if (v != null) {
//
//                        for (Object aV : v) {
//                            LoggingEvent e = (LoggingEvent) aV;
//                            e.setProperty(Constants.HOSTNAME_KEY, hostName);
//
//                            // store the known remote info in an event property
//                            e.setProperty("log4j.remoteSourceInfo", remoteInfo);
//
//                            // if configured with a receiver, tell it to post the event
//                            if (receiver != null) {
//                                receiver.doPost(e);
//
//                                // else post it via the hierarchy
//                            } else {
//                                // get a logger from the hierarchy. The name of the logger
//                                // is taken to be the name contained in the event.
//                                remoteLogger = repository.getLogger(e.getLoggerName());
//
//                                //event.logger = remoteLogger;
//                                // apply the logger-level filter
//                                if (
//                                    e.getLevel().isGreaterOrEqual(
//                                        remoteLogger.getEffectiveLevel())) {
//                                    // finally log the event as if was generated locally
//                                    remoteLogger.callAppenders(e);
//                                }
//                            }
//                        }
//                    }
//                }
//            } catch (java.io.EOFException e) {
//                getLogger().info("Caught java.io.EOFException closing connection.");
//                listenerException = e;
//            } catch (java.net.SocketException e) {
//                getLogger().info(
//                    "Caught java.net.SocketException closing connection.");
//                listenerException = e;
//            } catch (IOException e) {
//                getLogger().info("Caught java.io.IOException: " + e);
//                getLogger().info("Closing connection.");
//                listenerException = e;
//            } catch (Exception e) {
//                getLogger().error("Unexpected exception. Closing connection.", e);
//                listenerException = e;
//            }
//        }
//
//        // close the socket
//        try {
//            if (is != null) {
//                is.close();
//            }
//        } catch (Exception e) {
//            //logger.info("Could not close connection.", e);
//        }
//
//        // send event to listener, if configured
//        if (listener != null) {
//            listener.socketClosedEvent(listenerException);
//        }
//    }
//}