</target>
<target name="compile" depends="init">
- <javac srcdir="${src}" destdir="${build}" source="1.5" debug="true"/>
+ <javac srcdir="${src}" destdir="${build}" source="1.5" debug="true" classpath="${cpath}" />
</target>
<target name="javadoc" depends="init">
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
+import org.apache.log4j.Logger;
import org.apache.thrift.TByteArrayOutputStream;
import org.apache.thrift.TException;
serverTransport_.listen();
return true;
} catch (TTransportException ttx) {
- LOGGER.log(Level.SEVERE, "Failed to start listening on server socket!", ttx);
+ LOGGER.error("Failed to start listening on server socket!", ttx);
return false;
}
}
selectThread_.start();
return true;
} catch (IOException e) {
- LOGGER.log(Level.SEVERE, "Failed to start selector thread!", e);
+ LOGGER.error("Failed to start selector thread!", e);
return false;
}
}
// deal with writes
handleWrite(key);
} else {
- LOGGER.log(Level.WARNING, "Unexpected state in select! " + key.interestOps());
+ LOGGER.warn("Unexpected state in select! " + key.interestOps());
}
}
} catch (IOException e) {
- LOGGER.log(Level.WARNING, "Got an IOException while selecting!", e);
+ LOGGER.warn("Got an IOException while selecting!", e);
}
}
clientKey.attach(frameBuffer);
} catch (TTransportException tte) {
// something went wrong accepting.
- LOGGER.log(Level.WARNING, "Exception trying to accept!", tte);
+ LOGGER.warn("Exception trying to accept!", tte);
tte.printStackTrace();
if (clientKey != null) cleanupSelectionkey(clientKey);
if (client != null) client.close();
// pull out the frame size as an integer.
int frameSize = buffer_.getInt(0);
if (frameSize <= 0) {
- LOGGER.severe("Read an invalid frame size of " + frameSize
+ LOGGER.error("Read an invalid frame size of " + frameSize
+ ". Are you using TFramedTransport on the client side?");
return false;
}
// if this frame will always be too large for this server, log the
// error and close the connection.
if (frameSize + 4 > MAX_READ_BUFFER_BYTES) {
- LOGGER.severe("Read a frame size of " + frameSize
+ LOGGER.error("Read a frame size of " + frameSize
+ ", which is bigger than the maximum allowable buffer size for ALL connections.");
return false;
}
}
// if we fall through to this point, then the state must be invalid.
- LOGGER.severe("Read was called but state is invalid (" + state_ + ")");
+ LOGGER.error("Read was called but state is invalid (" + state_ + ")");
return false;
}
return false;
}
} catch (IOException e) {
- LOGGER.log(Level.WARNING, "Got an IOException during write!", e);
+ LOGGER.warn("Got an IOException during write!", e);
return false;
}
return true;
}
- LOGGER.severe("Write was called, but state is invalid (" + state_ + ")");
+ LOGGER.error("Write was called, but state is invalid (" + state_ + ")");
return false;
}
close();
selectionKey_.cancel();
} else {
- LOGGER.severe(
+ LOGGER.error(
"changeSelectInterest was called, but state is invalid ("
+ state_ + ")");
}
responseReady();
return;
} catch (TException te) {
- LOGGER.log(Level.WARNING, "Exception while invoking!", te);
+ LOGGER.warn("Exception while invoking!", te);
} catch (Exception e) {
- LOGGER.log(Level.SEVERE, "Unexpected exception while invoking!", e);
+ LOGGER.error("Unexpected exception while invoking!", e);
}
// This will only be reached when there is an exception.
state_ = AWAITING_CLOSE;
}
return true;
} catch (IOException e) {
- LOGGER.log(Level.WARNING, "Got an IOException in internalRead!", e);
+ LOGGER.warn("Got an IOException in internalRead!", e);
return false;
}
}
package org.apache.thrift.server;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
import org.apache.thrift.TException;
import org.apache.thrift.TProcessor;
import org.apache.thrift.TProcessorFactory;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportFactory;
import org.apache.thrift.transport.TTransportException;
+import org.apache.log4j.Logger;
/**
* Simple singlethreaded server for testing.
try {
serverTransport_.listen();
} catch (TTransportException ttx) {
- LOGGER.log(Level.SEVERE, "Error occurred during listening.", ttx);
+ LOGGER.error("Error occurred during listening.", ttx);
return;
}
// Client died, just move on
} catch (TException tx) {
if (!stopped_) {
- LOGGER.log(Level.SEVERE, "Thrift error occurred during processing of message.", tx);
+ LOGGER.error("Thrift error occurred during processing of message.", tx);
}
} catch (Exception x) {
if (!stopped_) {
- LOGGER.log(Level.SEVERE, "Error occurred during processing of message.", x);
+ LOGGER.error("Error occurred during processing of message.", x);
}
}
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.TTransportFactory;
+import org.apache.log4j.Logger;
+import org.apache.log4j.Level;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
try {
serverTransport_.listen();
} catch (TTransportException ttx) {
- LOGGER.log(Level.SEVERE, "Error occurred during listening.", ttx);
+ LOGGER.error("Error occurred during listening.", ttx);
return;
}
} catch (TTransportException ttx) {
if (!stopped_) {
++failureCount;
- LOGGER.log(Level.WARNING, "Transport error occurred during acceptance of message.", ttx);
+ LOGGER.warn("Transport error occurred during acceptance of message.", ttx);
}
}
}
} catch (TTransportException ttx) {
// Assume the client died and continue silently
} catch (TException tx) {
- LOGGER.log(Level.SEVERE, "Thrift error occurred during processing of message.", tx);
+ LOGGER.error("Thrift error occurred during processing of message.", tx);
} catch (Exception x) {
- LOGGER.log(Level.SEVERE, "Error occurred during processing of message.", x);
+ LOGGER.error("Error occurred during processing of message.", x);
}
if (inputTransport != null) {
package org.apache.thrift.transport;
+import org.apache.log4j.Logger;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
* This is the most commonly used base transport. It takes an InputStream
try {
inputStream_.close();
} catch (IOException iox) {
- LOGGER.log(Level.WARNING, "Error closing input stream.", iox);
+ LOGGER.warn("Error closing input stream.", iox);
}
inputStream_ = null;
}
try {
outputStream_.close();
} catch (IOException iox) {
- LOGGER.log(Level.WARNING, "Error closing output stream.", iox);
+ LOGGER.warn("Error closing output stream.", iox);
}
outputStream_ = null;
}
package org.apache.thrift.transport;
+import org.apache.log4j.Logger;
+
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
* Wrapper around ServerSocket for Thrift.
try {
serverSocket_.setSoTimeout(0);
} catch (SocketException sx) {
- LOGGER.log(Level.WARNING, "Could not set socket timeout.", sx);
+ LOGGER.error("Could not set socket timeout.", sx);
}
}
}
try {
serverSocket_.close();
} catch (IOException iox) {
- LOGGER.log(Level.WARNING, "Could not close server socket.", iox);
+ LOGGER.warn("Could not close server socket.", iox);
}
serverSocket_ = null;
}
package org.apache.thrift.transport;
+import org.apache.log4j.Logger;
+
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
* Socket implementation of the TTransport interface. To be commented soon!
socket_.setSoLinger(false, 0);
socket_.setTcpNoDelay(true);
} catch (SocketException sx) {
- LOGGER.log(Level.WARNING, "Could not configure socket.", sx);
+ LOGGER.warn("Could not configure socket.", sx);
}
if (isOpen()) {
socket_.setTcpNoDelay(true);
socket_.setSoTimeout(timeout_);
} catch (SocketException sx) {
- LOGGER.log(Level.WARNING, "Could not configure socket.", sx);
+ LOGGER.error("Could not configure socket.", sx);
}
}
try {
socket_.setSoTimeout(timeout);
} catch (SocketException sx) {
- LOGGER.log(Level.WARNING, "Could not set socket timeout.", sx);
+ LOGGER.warn("Could not set socket timeout.", sx);
}
}
try {
socket_.close();
} catch (IOException iox) {
- LOGGER.log(Level.WARNING, "Could not close socket.", iox);
+ LOGGER.warn("Could not close socket.", iox);
}
socket_ = null;
}