mwomack 2002/09/19 22:33:10
Modified: src/java/org/apache/log4j/net SocketNode.java
Added: src/java/org/apache/log4j/net SocketReceiver.java
Log:
SocketReceiver is a matching component for SocketAppender. SocketReceiver receives
remote logging events sent by SocektAppender and "imports" them to the local
LoggerRepository it has been attached to.
Modified SocketNode to add a constructor that takes a Receiver as a parameter, and
then uses it to "post" the received logging events.
Revision Changes Path
1.21 +28 -9 jakarta-log4j/src/java/org/apache/log4j/net/SocketNode.java
Index: SocketNode.java
===================================================================
RCS file: /home/cvs/jakarta-log4j/src/java/org/apache/log4j/net/SocketNode.java,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -r1.20 -r1.21
--- SocketNode.java 9 May 2002 19:53:37 -0000 1.20
+++ SocketNode.java 20 Sep 2002 05:33:10 -0000 1.21
@@ -13,7 +13,6 @@
import java.io.ObjectInputStream;
import java.io.BufferedInputStream;
-
import org.apache.log4j.*;
import org.apache.log4j.spi.*;
@@ -35,12 +34,12 @@
Socket socket;
LoggerRepository hierarchy;
+ Receiver receiver;
ObjectInputStream ois;
static Logger logger = Logger.getLogger(SocketNode.class);
- public
- SocketNode(Socket socket, LoggerRepository hierarchy) {
+ public SocketNode(Socket socket, LoggerRepository hierarchy) {
this.socket = socket;
this.hierarchy = hierarchy;
try {
@@ -51,6 +50,19 @@
logger.error("Could not open ObjectInputStream to "+socket, e);
}
}
+
+ public SocketNode(Socket socket, Receiver receiver) {
+ this.socket = socket;
+ this.receiver = receiver;
+ try {
+ ois = new ObjectInputStream(
+ new BufferedInputStream(socket.getInputStream()));
+ }
+ catch(Exception e) {
+ logger.error("Could not open ObjectInputStream to "+socket, e);
+ }
+ }
+
//public
//void finalize() {
@@ -64,12 +76,19 @@
try {
while(true) {
- event = (LoggingEvent) ois.readObject();
- remoteLogger = hierarchy.getLogger(event.categoryName);
- event.logger = remoteLogger;
- if(event.level.isGreaterOrEqual(remoteLogger.getEffectiveLevel())) {
- remoteLogger.callAppenders(event);
- }
+ event = (LoggingEvent) ois.readObject();
+
+ // if configured with a receiver, tell it to post the event
+ if (receiver != null) {
+ receiver.doPost(event);
+ // else post it via the hierarchy
+ } else {
+ remoteLogger = hierarchy.getLogger(event.categoryName);
+ event.logger = remoteLogger;
+ if(event.level.isGreaterOrEqual(remoteLogger.getEffectiveLevel())) {
+ remoteLogger.callAppenders(event);
+ }
+ }
}
}
catch(java.io.EOFException e) {
1.1 jakarta-log4j/src/java/org/apache/log4j/net/SocketReceiver.java
Index: SocketReceiver.java
===================================================================
/*
* Copyright (C) The Apache Software Foundation. All rights reserved.
*
* This software is published under the terms of the Apache Software
* License version 1.1, a copy of which has been included with this
* distribution in the LICENSE.txt file. */
package org.apache.log4j.net;
import java.util.Vector;
import java.net.Socket;
import java.net.ServerSocket;
import org.apache.log4j.Logger;
import org.apache.log4j.Receiver;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.helpers.LogLog;
/**
SocketReceiver receives a remote logging event on a configured
socket and "posts" it to a LoggerRepository as if the event was
generated locally. This class is designed to receive events from
the SocketAppender class (or classes that send compatible events).
<p>Once the event has been "posted", it will be handled by the
appenders currently configured in the LoggerRespository.
@author Mark Womack
@since 1.3
*/
public class SocketReceiver extends Receiver implements Runnable {
protected int port;
protected boolean active = false;
private ServerSocket serverSocket;
private Vector socketList = new Vector();
public SocketReceiver() { }
public SocketReceiver(int _port) {
port = _port;
}
public SocketReceiver(int _port, LoggerRepository _repository) {
port = _port;
repository = _repository;
}
/**
Get the port to receive logging events on. */
protected int getPort() {
return port;
}
/**
Set the port to receive logging events on. */
protected void setPort(int _port) {
port = _port;
}
/**
Returns true if the receiver is the same class and they are
configured for the same port, logger repository, and name.
This is used when determining if the same receiver is being
configured. */
public boolean equals(Object obj) {
if (obj != null && obj instanceof SocketReceiver) {
SocketReceiver sReceiver = (SocketReceiver)obj;
String sName = sReceiver.getName();
return (repository == sReceiver.getLoggerRepository() &&
port == sReceiver.getPort() &&
((sName != null && sName.equals(sReceiver.getName()) ||
(sName == null && sReceiver.getName() == null))));
}
return false;
}
/**
Returns true if this receiver is active. */
public synchronized boolean isActive() {
return active;
}
/**
Sets the flag to indicate if receiver is active or not. */
protected synchronized void setActive(boolean _active) {
active = _active;
}
/**
Starts the SocketReceiver with the current options. */
public void activateOptions() {
if (!isActive()) {
Thread rThread = new Thread(this);
rThread.setDaemon(true);
rThread.start();
}
}
/**
Called when the receiver should be stopped. Closes the
server socket and all of the open sockets. */
public synchronized void shutdown() {
// mark this as no longer running
active = false;
// close the server socket
try {
if (serverSocket != null)
serverSocket.close();
} catch (Exception e) {
// ignore for now
}
// close all of the accepted sockets
for (int x = 0; x < socketList.size(); x++) {
try {
((Socket)socketList.get(x)).close();
} catch (Exception e) {
// ignore for now
}
}
// clear member variables
serverSocket = null;
socketList.clear();
}
/**
Loop, accepting new socket connections. */
public void run() {
setActive(true);
// start the server socket
try {
serverSocket = new ServerSocket(port);
} catch (Exception e) {
LogLog.error("error starting SocketReceiver (" +
this.getName() + "), receiver did not start", e);
setActive(false);
return;
}
try {
Socket socket = null;
while(isActive()) {
// if we have a socket, start watching it
if (socket != null) {
socketList.add(socket);
SocketNode node = new SocketNode(socket, this);
new Thread(node).start();
socket = null;
}
// wait for a socket to open, then loop to start it
socket = serverSocket.accept();
}
// socket not watched because we a no longer running
// so close it now.
if (socket != null) {
socket.close();
}
} catch (Exception e) {
LogLog.warn("exception while watching socket server in SocketReceiver (" +
this.getName() + "), stopping", e);
}
setActive(false);
}
}
--
To unsubscribe, e-mail: <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>
