You are viewing a plain text version of this content. The canonical link for it is here.
Posted to common-commits@hadoop.apache.org by vi...@apache.org on 2013/08/12 23:26:02 UTC
svn commit: r1513258 [8/9] - in
/hadoop/common/branches/YARN-321/hadoop-common-project: ./
hadoop-annotations/ hadoop-auth-examples/
hadoop-auth-examples/src/main/webapp/
hadoop-auth-examples/src/main/webapp/annonymous/
hadoop-auth-examples/src/main/we...
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPC.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPC.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPC.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPC.java Mon Aug 12 21:25:49 2013
@@ -18,37 +18,55 @@
package org.apache.hadoop.ipc;
-import org.apache.commons.logging.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
-import org.apache.hadoop.fs.CommonConfigurationKeysPublic;
-import org.apache.hadoop.io.IOUtils;
-import org.apache.hadoop.io.IntWritable;
-import org.apache.hadoop.io.Writable;
-import org.apache.hadoop.io.LongWritable;
-import org.apache.hadoop.ipc.Server.Connection;
-import org.apache.hadoop.util.StringUtils;
-import org.apache.hadoop.net.ConnectTimeoutException;
-import org.apache.hadoop.net.NetUtils;
-
-import java.util.Random;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
-import java.io.File;
import java.io.DataOutput;
+import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
-import javax.net.SocketFactory;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
-import org.junit.Test;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import javax.net.SocketFactory;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.CommonConfigurationKeysPublic;
+import org.apache.hadoop.io.IOUtils;
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Writable;
+import org.apache.hadoop.io.retry.RetryPolicies;
+import org.apache.hadoop.io.retry.RetryProxy;
+import org.apache.hadoop.ipc.Client.ConnectionId;
+import org.apache.hadoop.ipc.RPC.RpcKind;
+import org.apache.hadoop.ipc.Server.Connection;
+import org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto;
+import org.apache.hadoop.net.ConnectTimeoutException;
+import org.apache.hadoop.net.NetUtils;
+import org.apache.hadoop.util.StringUtils;
+import org.junit.Assert;
import org.junit.Assume;
+import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
@@ -83,6 +101,10 @@ public class TestIPC {
private static final File FD_DIR = new File("/proc/self/fd");
private static class TestServer extends Server {
+ // Tests can set callListener to run a piece of code each time the server
+ // receives a call. This code executes on the server thread, so it has
+ // visibility of that thread's thread-local storage.
+ private Runnable callListener;
private boolean sleep;
private Class<? extends Writable> responseClass;
@@ -108,6 +130,9 @@ public class TestIPC {
Thread.sleep(RANDOM.nextInt(PING_INTERVAL) + MIN_SLEEP_TIME);
} catch (InterruptedException e) {}
}
+ if (callListener != null) {
+ callListener.run();
+ }
if (responseClass != null) {
try {
return responseClass.newInstance();
@@ -152,15 +177,54 @@ public class TestIPC {
}
}
+ /**
+ * A RpcInvocationHandler instance for test. Its invoke function uses the same
+ * {@link Client} instance, and will fail the first totalRetry times (by
+ * throwing an IOException).
+ */
+ private static class TestInvocationHandler implements RpcInvocationHandler {
+ private static int retry = 0;
+ private final Client client;
+ private final Server server;
+ private final int total;
+
+ TestInvocationHandler(Client client, Server server, int total) {
+ this.client = client;
+ this.server = server;
+ this.total = total;
+ }
+
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args)
+ throws Throwable {
+ LongWritable param = new LongWritable(RANDOM.nextLong());
+ LongWritable value = (LongWritable) client.call(param,
+ NetUtils.getConnectAddress(server), null, null, 0, conf);
+ if (retry++ < total) {
+ throw new IOException("Fake IOException");
+ } else {
+ return value;
+ }
+ }
+
+ @Override
+ public void close() throws IOException {}
+
+ @Override
+ public ConnectionId getConnectionId() {
+ return null;
+ }
+ }
+
@Test
- public void testSerial() throws Exception {
+ public void testSerial() throws IOException, InterruptedException {
testSerial(3, false, 2, 5, 100);
testSerial(3, true, 2, 5, 10);
}
public void testSerial(int handlerCount, boolean handlerSleep,
int clientCount, int callerCount, int callCount)
- throws Exception {
+ throws IOException, InterruptedException {
Server server = new TestServer(handlerCount, handlerSleep);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
server.start();
@@ -186,7 +250,7 @@ public class TestIPC {
}
@Test
- public void testStandAloneClient() throws Exception {
+ public void testStandAloneClient() throws IOException {
Client client = new Client(LongWritable.class, conf);
InetSocketAddress address = new InetSocketAddress("127.0.0.1", 10);
try {
@@ -286,7 +350,8 @@ public class TestIPC {
Class<? extends LongWritable> clientParamClass,
Class<? extends LongWritable> serverParamClass,
Class<? extends LongWritable> serverResponseClass,
- Class<? extends LongWritable> clientResponseClass) throws Exception {
+ Class<? extends LongWritable> clientResponseClass)
+ throws IOException, InstantiationException, IllegalAccessException {
// start server
Server server = new TestServer(1, false,
@@ -417,7 +482,7 @@ public class TestIPC {
* to the client.
*/
@Test
- public void testSocketFactoryException() throws Exception {
+ public void testSocketFactoryException() throws IOException {
SocketFactory mockFactory = mock(SocketFactory.class);
doThrow(new IOException("Injected fault")).when(mockFactory).createSocket();
Client client = new Client(LongWritable.class, conf, mockFactory);
@@ -439,7 +504,7 @@ public class TestIPC {
* HADOOP-7428.
*/
@Test
- public void testRTEDuringConnectionSetup() throws Exception {
+ public void testRTEDuringConnectionSetup() throws IOException {
// Set up a socket factory which returns sockets which
// throw an RTE when setSoTimeout is called.
SocketFactory spyFactory = spy(NetUtils.getDefaultSocketFactory(conf));
@@ -480,7 +545,7 @@ public class TestIPC {
}
@Test
- public void testIpcTimeout() throws Exception {
+ public void testIpcTimeout() throws IOException {
// start server
Server server = new TestServer(1, true);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
@@ -502,7 +567,7 @@ public class TestIPC {
}
@Test
- public void testIpcConnectTimeout() throws Exception {
+ public void testIpcConnectTimeout() throws IOException {
// start server
Server server = new TestServer(1, true);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
@@ -525,7 +590,7 @@ public class TestIPC {
* Check service class byte in IPC header is correct on wire.
*/
@Test(timeout=60000)
- public void testIpcWithServiceClass() throws Exception {
+ public void testIpcWithServiceClass() throws IOException {
// start server
Server server = new TestServer(5, false);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
@@ -552,7 +617,7 @@ public class TestIPC {
* Make a call from a client and verify if header info is changed in server side
*/
private void callAndVerify(Server server, InetSocketAddress addr,
- int serviceClass, boolean noChanged) throws Exception{
+ int serviceClass, boolean noChanged) throws IOException{
Client client = new Client(LongWritable.class, conf);
client.call(new LongWritable(RANDOM.nextLong()),
@@ -564,7 +629,7 @@ public class TestIPC {
}
@Test(timeout=30000, expected=IOException.class)
- public void testIpcAfterStopping() throws IOException, InterruptedException {
+ public void testIpcAfterStopping() throws IOException {
// start server
Server server = new TestServer(5, false);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
@@ -586,7 +651,7 @@ public class TestIPC {
* and stopping IPC servers.
*/
@Test(timeout=60000)
- public void testSocketLeak() throws Exception {
+ public void testSocketLeak() throws IOException {
Assume.assumeTrue(FD_DIR.exists()); // only run on Linux
long startFds = countOpenFileDescriptors();
@@ -606,31 +671,31 @@ public class TestIPC {
}
@Test
- public void testIpcFromHadoop_0_18_13() throws Exception {
+ public void testIpcFromHadoop_0_18_13() throws IOException {
doIpcVersionTest(NetworkTraces.HADOOP_0_18_3_RPC_DUMP,
NetworkTraces.RESPONSE_TO_HADOOP_0_18_3_RPC);
}
@Test
- public void testIpcFromHadoop0_20_3() throws Exception {
+ public void testIpcFromHadoop0_20_3() throws IOException {
doIpcVersionTest(NetworkTraces.HADOOP_0_20_3_RPC_DUMP,
NetworkTraces.RESPONSE_TO_HADOOP_0_20_3_RPC);
}
@Test
- public void testIpcFromHadoop0_21_0() throws Exception {
+ public void testIpcFromHadoop0_21_0() throws IOException {
doIpcVersionTest(NetworkTraces.HADOOP_0_21_0_RPC_DUMP,
NetworkTraces.RESPONSE_TO_HADOOP_0_21_0_RPC);
}
@Test
- public void testHttpGetResponse() throws Exception {
+ public void testHttpGetResponse() throws IOException {
doIpcVersionTest("GET / HTTP/1.0\r\n\r\n".getBytes(),
Server.RECEIVED_HTTP_REQ_RESPONSE.getBytes());
}
@Test
- public void testConnectionRetriesOnSocketTimeoutExceptions() throws Exception {
+ public void testConnectionRetriesOnSocketTimeoutExceptions() throws IOException {
Configuration conf = new Configuration();
// set max retries to 0
conf.setInt(
@@ -645,8 +710,220 @@ public class TestIPC {
assertRetriesOnSocketTimeouts(conf, 4);
}
+ private static class CallInfo {
+ int id = RpcConstants.INVALID_CALL_ID;
+ int retry = RpcConstants.INVALID_RETRY_COUNT;
+ }
+
+ /**
+ * Test if
+ * (1) the rpc server uses the call id/retry provided by the rpc client, and
+ * (2) the rpc client receives the same call id/retry from the rpc server.
+ */
+ @Test
+ public void testCallIdAndRetry() throws IOException {
+ final CallInfo info = new CallInfo();
+
+ // Override client to store the call info and check response
+ final Client client = new Client(LongWritable.class, conf) {
+ @Override
+ Call createCall(RpcKind rpcKind, Writable rpcRequest) {
+ final Call call = super.createCall(rpcKind, rpcRequest);
+ info.id = call.id;
+ info.retry = call.retry;
+ return call;
+ }
+
+ @Override
+ void checkResponse(RpcResponseHeaderProto header) throws IOException {
+ super.checkResponse(header);
+ Assert.assertEquals(info.id, header.getCallId());
+ Assert.assertEquals(info.retry, header.getRetryCount());
+ }
+ };
+
+ // Attach a listener that tracks every call received by the server.
+ final TestServer server = new TestServer(1, false);
+ server.callListener = new Runnable() {
+ @Override
+ public void run() {
+ Assert.assertEquals(info.id, Server.getCallId());
+ Assert.assertEquals(info.retry, Server.getCallRetryCount());
+ }
+ };
+
+ try {
+ InetSocketAddress addr = NetUtils.getConnectAddress(server);
+ server.start();
+ final SerialCaller caller = new SerialCaller(client, addr, 10);
+ caller.run();
+ assertFalse(caller.failed);
+ } finally {
+ client.stop();
+ server.stop();
+ }
+ }
+
+ /** A dummy protocol */
+ private interface DummyProtocol {
+ public void dummyRun();
+ }
+
+ /**
+ * Test the retry count while used in a retry proxy.
+ */
+ @Test
+ public void testRetryProxy() throws IOException {
+ final Client client = new Client(LongWritable.class, conf);
+
+ final TestServer server = new TestServer(1, false);
+ server.callListener = new Runnable() {
+ private int retryCount = 0;
+ @Override
+ public void run() {
+ Assert.assertEquals(retryCount++, Server.getCallRetryCount());
+ }
+ };
+
+ final int totalRetry = 256;
+ DummyProtocol proxy = (DummyProtocol) Proxy.newProxyInstance(
+ DummyProtocol.class.getClassLoader(),
+ new Class[] { DummyProtocol.class }, new TestInvocationHandler(client,
+ server, totalRetry));
+ DummyProtocol retryProxy = (DummyProtocol) RetryProxy.create(
+ DummyProtocol.class, proxy, RetryPolicies.RETRY_FOREVER);
+
+ try {
+ server.start();
+ retryProxy.dummyRun();
+ Assert.assertEquals(TestInvocationHandler.retry, totalRetry + 1);
+ } finally {
+ Client.setCallIdAndRetryCount(0, 0);
+ client.stop();
+ server.stop();
+ }
+ }
+
+ /**
+ * Test if the rpc server gets the default retry count (0) from client.
+ */
+ @Test
+ public void testInitialCallRetryCount() throws IOException {
+ // Override client to store the call id
+ final Client client = new Client(LongWritable.class, conf);
+
+ // Attach a listener that tracks every call ID received by the server.
+ final TestServer server = new TestServer(1, false);
+ server.callListener = new Runnable() {
+ @Override
+ public void run() {
+ // we have not set the retry count for the client, thus on the server
+ // side we should see retry count as 0
+ Assert.assertEquals(0, Server.getCallRetryCount());
+ }
+ };
+
+ try {
+ InetSocketAddress addr = NetUtils.getConnectAddress(server);
+ server.start();
+ final SerialCaller caller = new SerialCaller(client, addr, 10);
+ caller.run();
+ assertFalse(caller.failed);
+ } finally {
+ client.stop();
+ server.stop();
+ }
+ }
+
+ /**
+ * Test if the rpc server gets the retry count from client.
+ */
+ @Test
+ public void testCallRetryCount() throws IOException {
+ final int retryCount = 255;
+ // Override client to store the call id
+ final Client client = new Client(LongWritable.class, conf);
+ Client.setCallIdAndRetryCount(Client.nextCallId(), 255);
+
+ // Attach a listener that tracks every call ID received by the server.
+ final TestServer server = new TestServer(1, false);
+ server.callListener = new Runnable() {
+ @Override
+ public void run() {
+ // we have not set the retry count for the client, thus on the server
+ // side we should see retry count as 0
+ Assert.assertEquals(retryCount, Server.getCallRetryCount());
+ }
+ };
+
+ try {
+ InetSocketAddress addr = NetUtils.getConnectAddress(server);
+ server.start();
+ final SerialCaller caller = new SerialCaller(client, addr, 10);
+ caller.run();
+ assertFalse(caller.failed);
+ } finally {
+ client.stop();
+ server.stop();
+ }
+ }
+
+ /**
+ * Tests that client generates a unique sequential call ID for each RPC call,
+ * even if multiple threads are using the same client.
+ * @throws InterruptedException
+ */
+ @Test
+ public void testUniqueSequentialCallIds()
+ throws IOException, InterruptedException {
+ int serverThreads = 10, callerCount = 100, perCallerCallCount = 100;
+ TestServer server = new TestServer(serverThreads, false);
+
+ // Attach a listener that tracks every call ID received by the server. This
+ // list must be synchronized, because multiple server threads will add to it.
+ final List<Integer> callIds = Collections.synchronizedList(
+ new ArrayList<Integer>());
+ server.callListener = new Runnable() {
+ @Override
+ public void run() {
+ callIds.add(Server.getCallId());
+ }
+ };
+
+ Client client = new Client(LongWritable.class, conf);
+
+ try {
+ InetSocketAddress addr = NetUtils.getConnectAddress(server);
+ server.start();
+ SerialCaller[] callers = new SerialCaller[callerCount];
+ for (int i = 0; i < callerCount; ++i) {
+ callers[i] = new SerialCaller(client, addr, perCallerCallCount);
+ callers[i].start();
+ }
+ for (int i = 0; i < callerCount; ++i) {
+ callers[i].join();
+ assertFalse(callers[i].failed);
+ }
+ } finally {
+ client.stop();
+ server.stop();
+ }
+
+ int expectedCallCount = callerCount * perCallerCallCount;
+ assertEquals(expectedCallCount, callIds.size());
+
+ // It is not guaranteed that the server executes requests in sequential order
+ // of client call ID, so we must sort the call IDs before checking that it
+ // contains every expected value.
+ Collections.sort(callIds);
+ final int startID = callIds.get(0).intValue();
+ for (int i = 0; i < expectedCallCount; ++i) {
+ assertEquals(startID + i, callIds.get(i).intValue());
+ }
+ }
+
private void assertRetriesOnSocketTimeouts(Configuration conf,
- int maxTimeoutRetries) throws IOException, InterruptedException {
+ int maxTimeoutRetries) throws IOException {
SocketFactory mockFactory = Mockito.mock(SocketFactory.class);
doThrow(new ConnectTimeoutException("fake")).when(mockFactory).createSocket();
Client client = new Client(IntWritable.class, conf, mockFactory);
@@ -663,7 +940,7 @@ public class TestIPC {
private void doIpcVersionTest(
byte[] requestData,
- byte[] expectedResponse) throws Exception {
+ byte[] expectedResponse) throws IOException {
Server server = new TestServer(1, true);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
server.start();
@@ -736,7 +1013,7 @@ public class TestIPC {
"6f 6e 67 00 00 00 00 00 00 00 0a ong..... ... \n");
final static String HADOOP0_18_ERROR_MSG =
- "Server IPC version " + Server.CURRENT_VERSION +
+ "Server IPC version " + RpcConstants.CURRENT_VERSION +
" cannot communicate with client version 2";
/**
@@ -775,7 +1052,7 @@ public class TestIPC {
"00 14 .. \n");
final static String HADOOP0_20_ERROR_MSG =
- "Server IPC version " + Server.CURRENT_VERSION +
+ "Server IPC version " + RpcConstants.CURRENT_VERSION +
" cannot communicate with client version 3";
@@ -790,7 +1067,7 @@ public class TestIPC {
final static String HADOOP0_21_ERROR_MSG =
- "Server IPC version " + Server.CURRENT_VERSION +
+ "Server IPC version " + RpcConstants.CURRENT_VERSION +
" cannot communicate with client version 4";
final static byte[] HADOOP_0_21_0_RPC_DUMP =
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPCServerResponder.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPCServerResponder.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPCServerResponder.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestIPCServerResponder.java Mon Aug 12 21:25:49 2013
@@ -105,17 +105,18 @@ public class TestIPCServerResponder exte
byte[] bytes = new byte[byteSize];
System.arraycopy(BYTES, 0, bytes, 0, byteSize);
Writable param = new BytesWritable(bytes);
- Writable value = client.call(param, address);
+ client.call(param, address);
Thread.sleep(RANDOM.nextInt(20));
} catch (Exception e) {
- LOG.fatal("Caught: " + e);
+ LOG.fatal("Caught Exception", e);
failed = true;
}
}
}
}
- public void testResponseBuffer() throws Exception {
+ public void testResponseBuffer()
+ throws IOException, InterruptedException {
Server.INITIAL_RESP_BUF_SIZE = 1;
conf.setInt(CommonConfigurationKeys.IPC_SERVER_RPC_MAX_RESPONSE_SIZE_KEY,
1);
@@ -123,7 +124,8 @@ public class TestIPCServerResponder exte
conf = new Configuration(); // reset configuration
}
- public void testServerResponder() throws Exception {
+ public void testServerResponder()
+ throws IOException, InterruptedException {
testServerResponder(10, true, 1, 10, 200);
}
@@ -131,7 +133,8 @@ public class TestIPCServerResponder exte
final boolean handlerSleep,
final int clientCount,
final int callerCount,
- final int callCount) throws Exception {
+ final int callCount) throws IOException,
+ InterruptedException {
Server server = new TestServer(handlerCount, handlerSleep);
server.start();
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestMultipleProtocolServer.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestMultipleProtocolServer.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestMultipleProtocolServer.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestMultipleProtocolServer.java Mon Aug 12 21:25:49 2013
@@ -64,7 +64,7 @@ public class TestMultipleProtocolServer
public static final long versionID = 0L;
void hello() throws IOException;
}
- interface Bar extends Mixin, VersionedProtocol {
+ interface Bar extends Mixin {
public static final long versionID = 0L;
int echo(int i) throws IOException;
}
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestProtoBufRpc.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestProtoBufRpc.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestProtoBufRpc.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestProtoBufRpc.java Mon Aug 12 21:25:49 2013
@@ -72,6 +72,10 @@ public class TestProtoBufRpc {
@Override
public EmptyResponseProto ping(RpcController unused,
EmptyRequestProto request) throws ServiceException {
+ // Ensure clientId is received
+ byte[] clientId = Server.getClientId();
+ Assert.assertNotNull(Server.getClientId());
+ Assert.assertEquals(16, clientId.length);
return EmptyResponseProto.newBuilder().build();
}
@@ -147,10 +151,8 @@ public class TestProtoBufRpc {
private static TestRpcService getClient() throws IOException {
// Set RPC engine to protobuf RPC engine
- RPC.setProtocolEngine(conf, TestRpcService.class,
- ProtobufRpcEngine.class);
- return RPC.getProxy(TestRpcService.class, 0, addr,
- conf);
+ RPC.setProtocolEngine(conf, TestRpcService.class, ProtobufRpcEngine.class);
+ return RPC.getProxy(TestRpcService.class, 0, addr, conf);
}
private static TestRpcService2 getClient2() throws IOException {
@@ -187,6 +189,7 @@ public class TestProtoBufRpc {
RemoteException re = (RemoteException)e.getCause();
RpcServerException rse = (RpcServerException) re
.unwrapRemoteException(RpcServerException.class);
+ Assert.assertNotNull(rse);
Assert.assertTrue(re.getErrorCode().equals(
RpcErrorCodeProto.ERROR_RPC_SERVER));
}
@@ -242,6 +245,7 @@ public class TestProtoBufRpc {
.setMessage(shortString).build();
// short message goes through
EchoResponseProto echoResponse = client.echo2(null, echoRequest);
+ Assert.assertEquals(shortString, echoResponse.getMessage());
final String longString = StringUtils.repeat("X", 4096);
echoRequest = EchoRequestProto.newBuilder()
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPC.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPC.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPC.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPC.java Mon Aug 12 21:25:49 2013
@@ -94,12 +94,13 @@ public class TestRPC {
int datasize = 1024*100;
int numThreads = 50;
-
+
public interface TestProtocol extends VersionedProtocol {
public static final long versionID = 1L;
void ping() throws IOException;
void slowPing(boolean shouldSlow) throws IOException;
+ void sleep(long delay) throws IOException, InterruptedException;
String echo(String value) throws IOException;
String[] echo(String[] value) throws IOException;
Writable echo(Writable value) throws IOException;
@@ -146,6 +147,11 @@ public class TestRPC {
}
@Override
+ public void sleep(long delay) throws InterruptedException {
+ Thread.sleep(delay);
+ }
+
+ @Override
public String echo(String value) throws IOException { return value; }
@Override
@@ -323,7 +329,7 @@ public class TestRPC {
}
@Test
- public void testConfRpc() throws Exception {
+ public void testConfRpc() throws IOException {
Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
.setInstance(new TestImpl()).setBindAddress(ADDRESS).setPort(0)
.setNumHandlers(1).setVerbose(false).build();
@@ -350,7 +356,7 @@ public class TestRPC {
}
@Test
- public void testProxyAddress() throws Exception {
+ public void testProxyAddress() throws IOException {
Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
.setInstance(new TestImpl()).setBindAddress(ADDRESS).setPort(0).build();
TestProtocol proxy = null;
@@ -360,8 +366,7 @@ public class TestRPC {
InetSocketAddress addr = NetUtils.getConnectAddress(server);
// create a client
- proxy = (TestProtocol)RPC.getProxy(
- TestProtocol.class, TestProtocol.versionID, addr, conf);
+ proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
assertEquals(addr, RPC.getServerAddress(proxy));
} finally {
@@ -373,7 +378,7 @@ public class TestRPC {
}
@Test
- public void testSlowRpc() throws Exception {
+ public void testSlowRpc() throws IOException {
System.out.println("Testing Slow RPC");
// create a server with two handlers
Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
@@ -388,8 +393,7 @@ public class TestRPC {
InetSocketAddress addr = NetUtils.getConnectAddress(server);
// create a client
- proxy = (TestProtocol)RPC.getProxy(
- TestProtocol.class, TestProtocol.versionID, addr, conf);
+ proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
SlowRPC slowrpc = new SlowRPC(proxy);
Thread thread = new Thread(slowrpc, "SlowRPC");
@@ -420,11 +424,11 @@ public class TestRPC {
}
@Test
- public void testCalls() throws Exception {
+ public void testCalls() throws IOException {
testCallsInternal(conf);
}
- private void testCallsInternal(Configuration conf) throws Exception {
+ private void testCallsInternal(Configuration conf) throws IOException {
Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
.setInstance(new TestImpl()).setBindAddress(ADDRESS).setPort(0).build();
TestProtocol proxy = null;
@@ -432,8 +436,7 @@ public class TestRPC {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
- proxy = (TestProtocol)RPC.getProxy(
- TestProtocol.class, TestProtocol.versionID, addr, conf);
+ proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
@@ -543,7 +546,7 @@ public class TestRPC {
}
- private void doRPCs(Configuration conf, boolean expectFailure) throws Exception {
+ private void doRPCs(Configuration conf, boolean expectFailure) throws IOException {
Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
.setInstance(new TestImpl()).setBindAddress(ADDRESS).setPort(0)
.setNumHandlers(5).setVerbose(true).build();
@@ -557,8 +560,7 @@ public class TestRPC {
InetSocketAddress addr = NetUtils.getConnectAddress(server);
try {
- proxy = (TestProtocol)RPC.getProxy(
- TestProtocol.class, TestProtocol.versionID, addr, conf);
+ proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
if (expectFailure) {
@@ -603,7 +605,7 @@ public class TestRPC {
}
@Test
- public void testAuthorization() throws Exception {
+ public void testAuthorization() throws IOException {
Configuration conf = new Configuration();
conf.setBoolean(CommonConfigurationKeys.HADOOP_SECURITY_AUTHORIZATION,
true);
@@ -630,7 +632,7 @@ public class TestRPC {
* Switch off setting socketTimeout values on RPC sockets.
* Verify that RPC calls still work ok.
*/
- public void testNoPings() throws Exception {
+ public void testNoPings() throws IOException {
Configuration conf = new Configuration();
conf.setBoolean("ipc.client.ping", false);
@@ -642,10 +644,10 @@ public class TestRPC {
/**
* Test stopping a non-registered proxy
- * @throws Exception
+ * @throws IOException
*/
@Test(expected=HadoopIllegalArgumentException.class)
- public void testStopNonRegisteredProxy() throws Exception {
+ public void testStopNonRegisteredProxy() throws IOException {
RPC.stopProxy(null);
}
@@ -654,13 +656,13 @@ public class TestRPC {
* be stopped without error.
*/
@Test
- public void testStopMockObject() throws Exception {
+ public void testStopMockObject() throws IOException {
RPC.stopProxy(MockitoUtil.mockProtocol(TestProtocol.class));
}
@Test
public void testStopProxy() throws IOException {
- StoppedProtocol proxy = (StoppedProtocol) RPC.getProxy(StoppedProtocol.class,
+ StoppedProtocol proxy = RPC.getProxy(StoppedProtocol.class,
StoppedProtocol.versionID, null, conf);
StoppedInvocationHandler invocationHandler = (StoppedInvocationHandler)
Proxy.getInvocationHandler(proxy);
@@ -671,7 +673,7 @@ public class TestRPC {
@Test
public void testWrappedStopProxy() throws IOException {
- StoppedProtocol wrappedProxy = (StoppedProtocol) RPC.getProxy(StoppedProtocol.class,
+ StoppedProtocol wrappedProxy = RPC.getProxy(StoppedProtocol.class,
StoppedProtocol.versionID, null, conf);
StoppedInvocationHandler invocationHandler = (StoppedInvocationHandler)
Proxy.getInvocationHandler(wrappedProxy);
@@ -685,7 +687,7 @@ public class TestRPC {
}
@Test
- public void testErrorMsgForInsecureClient() throws Exception {
+ public void testErrorMsgForInsecureClient() throws IOException {
Configuration serverConf = new Configuration(conf);
SecurityUtil.setAuthenticationMethod(AuthenticationMethod.KERBEROS,
serverConf);
@@ -701,8 +703,7 @@ public class TestRPC {
final InetSocketAddress addr = NetUtils.getConnectAddress(server);
TestProtocol proxy = null;
try {
- proxy = (TestProtocol) RPC.getProxy(TestProtocol.class,
- TestProtocol.versionID, addr, conf);
+ proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.echo("");
} catch (RemoteException e) {
LOG.info("LOGGING MESSAGE: " + e.getLocalizedMessage());
@@ -730,7 +731,7 @@ public class TestRPC {
proxy = null;
try {
UserGroupInformation.setConfiguration(conf);
- proxy = (TestProtocol) RPC.getProxy(TestProtocol.class,
+ proxy = RPC.getProxy(TestProtocol.class,
TestProtocol.versionID, mulitServerAddr, conf);
proxy.echo("");
} catch (RemoteException e) {
@@ -771,7 +772,7 @@ public class TestRPC {
* Test that server.stop() properly stops all threads
*/
@Test
- public void testStopsAllThreads() throws Exception {
+ public void testStopsAllThreads() throws IOException, InterruptedException {
int threadsBefore = countThreads("Server$Listener$Reader");
assertEquals("Expect no Reader threads running before test",
0, threadsBefore);
@@ -802,7 +803,7 @@ public class TestRPC {
}
@Test
- public void testRPCBuilder() throws Exception {
+ public void testRPCBuilder() throws IOException {
// Test mandatory field conf
try {
new RPC.Builder(null).setProtocol(TestProtocol.class)
@@ -838,15 +839,17 @@ public class TestRPC {
}
@Test(timeout=90000)
- public void testRPCInterruptedSimple() throws Exception {
+ public void testRPCInterruptedSimple() throws IOException {
final Configuration conf = new Configuration();
- Server server = RPC.getServer(
- TestProtocol.class, new TestImpl(), ADDRESS, 0, 5, true, conf, null
- );
+ Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
+ .setInstance(new TestImpl()).setBindAddress(ADDRESS)
+ .setPort(0).setNumHandlers(5).setVerbose(true)
+ .setSecretManager(null).build();
+
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
- final TestProtocol proxy = (TestProtocol) RPC.getProxy(
+ final TestProtocol proxy = RPC.getProxy(
TestProtocol.class, TestProtocol.versionID, addr, conf);
// Connect to the server
proxy.ping();
@@ -867,9 +870,10 @@ public class TestRPC {
@Test(timeout=30000)
public void testRPCInterrupted() throws IOException, InterruptedException {
final Configuration conf = new Configuration();
- Server server = RPC.getServer(
- TestProtocol.class, new TestImpl(), ADDRESS, 0, 5, true, conf, null
- );
+ Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class)
+ .setInstance(new TestImpl()).setBindAddress(ADDRESS)
+ .setPort(0).setNumHandlers(5).setVerbose(true)
+ .setSecretManager(null).build();
server.start();
@@ -883,7 +887,7 @@ public class TestRPC {
for (int i = 0; i < numConcurrentRPC; i++) {
final int num = i;
- final TestProtocol proxy = (TestProtocol) RPC.getProxy(
+ final TestProtocol proxy = RPC.getProxy(
TestProtocol.class, TestProtocol.versionID, addr, conf);
Thread rpcThread = new Thread(new Runnable() {
@Override
@@ -927,7 +931,29 @@ public class TestRPC {
assertTrue("rpc got exception " + error.get(), error.get() == null);
}
- public static void main(String[] args) throws Exception {
+ @Test
+ public void testConnectionPing() throws Exception {
+ Configuration conf = new Configuration();
+ int pingInterval = 50;
+ conf.setBoolean(CommonConfigurationKeys.IPC_CLIENT_PING_KEY, true);
+ conf.setInt(CommonConfigurationKeys.IPC_PING_INTERVAL_KEY, pingInterval);
+ final Server server = new RPC.Builder(conf)
+ .setProtocol(TestProtocol.class).setInstance(new TestImpl())
+ .setBindAddress(ADDRESS).setPort(0).setNumHandlers(5).setVerbose(true)
+ .build();
+ server.start();
+
+ final TestProtocol proxy = RPC.getProxy(TestProtocol.class,
+ TestProtocol.versionID, server.getListenerAddress(), conf);
+ try {
+ // this call will throw exception if server couldn't decode the ping
+ proxy.sleep(pingInterval*4);
+ } finally {
+ if (proxy != null) RPC.stopProxy(proxy);
+ }
+ }
+
+ public static void main(String[] args) throws IOException {
new TestRPC().testCallsInternal(conf);
}
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPCCompatibility.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPCCompatibility.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPCCompatibility.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestRPCCompatibility.java Mon Aug 12 21:25:49 2013
@@ -57,7 +57,7 @@ public class TestRPCCompatibility {
void ping() throws IOException;
}
- public interface TestProtocol1 extends VersionedProtocol, TestProtocol0 {
+ public interface TestProtocol1 extends TestProtocol0 {
String echo(String value) throws IOException;
}
@@ -123,7 +123,7 @@ public class TestRPCCompatibility {
}
@After
- public void tearDown() throws IOException {
+ public void tearDown() {
if (proxy != null) {
RPC.stopProxy(proxy.getProxy());
proxy = null;
@@ -278,7 +278,7 @@ System.out.println("echo int is NOT supp
TestProtocol3.class.getMethod("echo_alias", int.class));
assertFalse(intEchoHash == intEchoHashAlias);
- // Make sure that methods with the same returninig type and method name but
+ // Make sure that methods with the same returning type and method name but
// larger number of parameter types have different hash code
int intEchoHash2 = ProtocolSignature.getFingerprint(
TestProtocol3.class.getMethod("echo", int.class, int.class));
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSaslRPC.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSaslRPC.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSaslRPC.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSaslRPC.java Mon Aug 12 21:25:49 2013
@@ -18,14 +18,9 @@
package org.apache.hadoop.ipc;
-import static org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod.KERBEROS;
-import static org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod.SIMPLE;
-import static org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod.TOKEN;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.apache.hadoop.fs.CommonConfigurationKeysPublic.HADOOP_SECURITY_AUTHENTICATION;
+import static org.apache.hadoop.security.SaslRpcServer.AuthMethod.*;
+import static org.junit.Assert.*;
import java.io.DataInput;
import java.io.DataOutput;
@@ -34,6 +29,7 @@ import java.lang.annotation.Annotation;
import java.net.InetSocketAddress;
import java.security.PrivilegedExceptionAction;
import java.security.Security;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Set;
import java.util.regex.Pattern;
@@ -49,8 +45,7 @@ import javax.security.sasl.SaslClient;
import javax.security.sasl.SaslException;
import javax.security.sasl.SaslServer;
-import junit.framework.Assert;
-
+import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.impl.Log4JLogger;
@@ -66,11 +61,11 @@ import org.apache.hadoop.security.SaslPl
import org.apache.hadoop.security.SaslRpcClient;
import org.apache.hadoop.security.SaslRpcServer;
import org.apache.hadoop.security.SaslRpcServer.AuthMethod;
+import org.apache.hadoop.security.SaslRpcServer.QualityOfProtection;
import org.apache.hadoop.security.SecurityInfo;
import org.apache.hadoop.security.SecurityUtil;
import org.apache.hadoop.security.TestUserGroupInformation;
import org.apache.hadoop.security.UserGroupInformation;
-import org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod;
import org.apache.hadoop.security.token.SecretManager;
import org.apache.hadoop.security.token.SecretManager.InvalidToken;
import org.apache.hadoop.security.token.Token;
@@ -81,9 +76,28 @@ import org.apache.log4j.Level;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
/** Unit tests for using Sasl over RPC. */
+@RunWith(Parameterized.class)
public class TestSaslRPC {
+ @Parameters
+ public static Collection<Object[]> data() {
+ Collection<Object[]> params = new ArrayList<Object[]>();
+ for (QualityOfProtection qop : QualityOfProtection.values()) {
+ params.add(new Object[]{ qop });
+ }
+ return params;
+ }
+
+ QualityOfProtection expectedQop;
+
+ public TestSaslRPC(QualityOfProtection qop) {
+ expectedQop = qop;
+ }
+
private static final String ADDRESS = "0.0.0.0";
public static final Log LOG =
@@ -103,6 +117,13 @@ public class TestSaslRPC {
static Boolean forceSecretManager = null;
static Boolean clientFallBackToSimpleAllowed = true;
+ static enum UseToken {
+ NONE(),
+ VALID(),
+ INVALID(),
+ OTHER();
+ }
+
@BeforeClass
public static void setupKerb() {
System.setProperty("java.security.krb5.kdc", "");
@@ -112,10 +133,16 @@ public class TestSaslRPC {
@Before
public void setup() {
+ LOG.info("---------------------------------");
+ LOG.info("Testing QOP:"+expectedQop);
+ LOG.info("---------------------------------");
conf = new Configuration();
- SecurityUtil.setAuthenticationMethod(KERBEROS, conf);
+ conf.set(HADOOP_SECURITY_AUTHENTICATION, KERBEROS.toString());
+ conf.set("hadoop.rpc.protection", expectedQop.name().toLowerCase());
UserGroupInformation.setConfiguration(conf);
enableSecretManager = null;
+ forceSecretManager = null;
+ clientFallBackToSimpleAllowed = true;
}
static {
@@ -148,7 +175,7 @@ public class TestSaslRPC {
}
@Override
public UserGroupInformation getUser() {
- if ("".equals(realUser.toString())) {
+ if (realUser.toString().isEmpty()) {
return UserGroupInformation.createRemoteUser(tokenid.toString());
} else {
UserGroupInformation realUgi = UserGroupInformation
@@ -221,15 +248,16 @@ public class TestSaslRPC {
serverPrincipal = SERVER_PRINCIPAL_KEY)
@TokenInfo(TestTokenSelector.class)
public interface TestSaslProtocol extends TestRPC.TestProtocol {
- public AuthenticationMethod getAuthMethod() throws IOException;
+ public AuthMethod getAuthMethod() throws IOException;
public String getAuthUser() throws IOException;
}
public static class TestSaslImpl extends TestRPC.TestImpl implements
TestSaslProtocol {
@Override
- public AuthenticationMethod getAuthMethod() throws IOException {
- return UserGroupInformation.getCurrentUser().getAuthenticationMethod();
+ public AuthMethod getAuthMethod() throws IOException {
+ return UserGroupInformation.getCurrentUser()
+ .getAuthenticationMethod().getAuthMethod();
}
@Override
public String getAuthUser() throws IOException {
@@ -312,7 +340,7 @@ public class TestSaslRPC {
doDigestRpc(server, sm);
} catch (RemoteException e) {
LOG.info("LOGGING MESSAGE: " + e.getLocalizedMessage());
- assertTrue(ERROR_MESSAGE.equals(e.getLocalizedMessage()));
+ assertEquals(ERROR_MESSAGE, e.getLocalizedMessage());
assertTrue(e.unwrapRemoteException() instanceof InvalidToken);
succeeded = true;
}
@@ -334,10 +362,13 @@ public class TestSaslRPC {
TestSaslProtocol proxy = null;
try {
- proxy = (TestSaslProtocol) RPC.getProxy(TestSaslProtocol.class,
+ proxy = RPC.getProxy(TestSaslProtocol.class,
TestSaslProtocol.versionID, addr, conf);
+ AuthMethod authMethod = proxy.getAuthMethod();
+ assertEquals(TOKEN, authMethod);
//QOP must be auth
- Assert.assertEquals(SaslRpcServer.SASL_PROPS.get(Sasl.QOP), "auth");
+ assertEquals(expectedQop.saslQop,
+ RPC.getConnectionIdForProxy(proxy).getSaslQop());
proxy.ping();
} finally {
server.stop();
@@ -368,28 +399,6 @@ public class TestSaslRPC {
}
@Test
- public void testGetRemotePrincipal() throws Exception {
- try {
- Configuration newConf = new Configuration(conf);
- newConf.set(SERVER_PRINCIPAL_KEY, SERVER_PRINCIPAL_1);
- ConnectionId remoteId = ConnectionId.getConnectionId(
- new InetSocketAddress(0), TestSaslProtocol.class, null, 0, newConf);
- assertEquals(SERVER_PRINCIPAL_1, remoteId.getServerPrincipal());
- // this following test needs security to be off
- SecurityUtil.setAuthenticationMethod(SIMPLE, newConf);
- UserGroupInformation.setConfiguration(newConf);
- remoteId = ConnectionId.getConnectionId(new InetSocketAddress(0),
- TestSaslProtocol.class, null, 0, newConf);
- assertEquals(
- "serverPrincipal should be null when security is turned off", null,
- remoteId.getServerPrincipal());
- } finally {
- // revert back to security is on
- UserGroupInformation.setConfiguration(conf);
- }
- }
-
- @Test
public void testPerConnectionConf() throws Exception {
TestTokenSecretManager sm = new TestTokenSecretManager();
final Server server = new RPC.Builder(conf)
@@ -409,43 +418,50 @@ public class TestSaslRPC {
Configuration newConf = new Configuration(conf);
newConf.set(CommonConfigurationKeysPublic.
HADOOP_RPC_SOCKET_FACTORY_CLASS_DEFAULT_KEY, "");
- newConf.set(SERVER_PRINCIPAL_KEY, SERVER_PRINCIPAL_1);
+ Client client = null;
TestSaslProtocol proxy1 = null;
TestSaslProtocol proxy2 = null;
TestSaslProtocol proxy3 = null;
+ int timeouts[] = {111222, 3333333};
try {
- proxy1 = (TestSaslProtocol) RPC.getProxy(TestSaslProtocol.class,
+ newConf.setInt(CommonConfigurationKeysPublic.IPC_CLIENT_CONNECTION_MAXIDLETIME_KEY, timeouts[0]);
+ proxy1 = RPC.getProxy(TestSaslProtocol.class,
TestSaslProtocol.versionID, addr, newConf);
proxy1.getAuthMethod();
- Client client = WritableRpcEngine.getClient(conf);
+ client = WritableRpcEngine.getClient(newConf);
Set<ConnectionId> conns = client.getConnectionIds();
assertEquals("number of connections in cache is wrong", 1, conns.size());
// same conf, connection should be re-used
- proxy2 = (TestSaslProtocol) RPC.getProxy(TestSaslProtocol.class,
+ proxy2 = RPC.getProxy(TestSaslProtocol.class,
TestSaslProtocol.versionID, addr, newConf);
proxy2.getAuthMethod();
assertEquals("number of connections in cache is wrong", 1, conns.size());
// different conf, new connection should be set up
- newConf.set(SERVER_PRINCIPAL_KEY, SERVER_PRINCIPAL_2);
- proxy3 = (TestSaslProtocol) RPC.getProxy(TestSaslProtocol.class,
+ newConf.setInt(CommonConfigurationKeysPublic.IPC_CLIENT_CONNECTION_MAXIDLETIME_KEY, timeouts[1]);
+ proxy3 = RPC.getProxy(TestSaslProtocol.class,
TestSaslProtocol.versionID, addr, newConf);
proxy3.getAuthMethod();
- ConnectionId[] connsArray = conns.toArray(new ConnectionId[0]);
- assertEquals("number of connections in cache is wrong", 2,
- connsArray.length);
- String p1 = connsArray[0].getServerPrincipal();
- String p2 = connsArray[1].getServerPrincipal();
- assertFalse("should have different principals", p1.equals(p2));
- assertTrue("principal not as expected", p1.equals(SERVER_PRINCIPAL_1)
- || p1.equals(SERVER_PRINCIPAL_2));
- assertTrue("principal not as expected", p2.equals(SERVER_PRINCIPAL_1)
- || p2.equals(SERVER_PRINCIPAL_2));
+ assertEquals("number of connections in cache is wrong", 2, conns.size());
+ // now verify the proxies have the correct connection ids and timeouts
+ ConnectionId[] connsArray = {
+ RPC.getConnectionIdForProxy(proxy1),
+ RPC.getConnectionIdForProxy(proxy2),
+ RPC.getConnectionIdForProxy(proxy3)
+ };
+ assertEquals(connsArray[0], connsArray[1]);
+ assertEquals(connsArray[0].getMaxIdleTime(), timeouts[0]);
+ assertFalse(connsArray[0].equals(connsArray[2]));
+ assertNotSame(connsArray[2].getMaxIdleTime(), timeouts[1]);
} finally {
server.stop();
- RPC.stopProxy(proxy1);
- RPC.stopProxy(proxy2);
- RPC.stopProxy(proxy3);
+ // this is dirty, but clear out connection cache for next run
+ if (client != null) {
+ client.getConnectionIds().clear();
+ }
+ if (proxy1 != null) RPC.stopProxy(proxy1);
+ if (proxy2 != null) RPC.stopProxy(proxy2);
+ if (proxy3 != null) RPC.stopProxy(proxy3);
}
}
@@ -468,7 +484,7 @@ public class TestSaslRPC {
InetSocketAddress addr = NetUtils.getConnectAddress(server);
try {
- proxy = (TestSaslProtocol) RPC.getProxy(TestSaslProtocol.class,
+ proxy = RPC.getProxy(TestSaslProtocol.class,
TestSaslProtocol.versionID, addr, newConf);
proxy.ping();
} finally {
@@ -488,7 +504,7 @@ public class TestSaslRPC {
}
@Test
- public void testSaslPlainServerBadPassword() throws IOException {
+ public void testSaslPlainServerBadPassword() {
SaslException e = null;
try {
runNegotiation(
@@ -599,75 +615,118 @@ public class TestSaslRPC {
private static Pattern KrbFailed =
Pattern.compile(".*Failed on local exception:.* " +
"Failed to specify server's Kerberos principal name.*");
- private static Pattern Denied(AuthenticationMethod method) {
+ private static Pattern Denied(AuthMethod method) {
return Pattern.compile(".*RemoteException.*AccessControlException.*: "
- +method.getAuthMethod() + " authentication is not enabled.*");
+ + method + " authentication is not enabled.*");
+ }
+ private static Pattern No(AuthMethod ... method) {
+ String methods = StringUtils.join(method, ",\\s*");
+ return Pattern.compile(".*Failed on local exception:.* " +
+ "Client cannot authenticate via:\\[" + methods + "\\].*");
}
private static Pattern NoTokenAuth =
Pattern.compile(".*IllegalArgumentException: " +
"TOKEN authentication requires a secret manager");
-
+ private static Pattern NoFallback =
+ Pattern.compile(".*Failed on local exception:.* " +
+ "Server asks us to fall back to SIMPLE auth, " +
+ "but this client is configured to only allow secure connections.*");
+
/*
* simple server
*/
@Test
public void testSimpleServer() throws Exception {
assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE));
- // SASL methods are reverted to SIMPLE, but test setup fails
- assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, SIMPLE));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.OTHER));
+ // SASL methods are normally reverted to SIMPLE
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE));
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.OTHER));
}
@Test
- public void testSimpleServerWithTokensWithNoClientFallbackToSimple()
+ public void testNoClientFallbackToSimple()
throws Exception {
-
clientFallBackToSimpleAllowed = false;
-
- try{
- // Client has a token even though its configs says simple auth. Server
- // is configured for simple auth, but as client sends the token, and
- // server asks to switch to simple, this should fail.
- getAuthMethod(SIMPLE, SIMPLE, true);
- } catch (IOException ioe) {
- Assert
- .assertTrue(ioe.getMessage().contains("Failed on local exception: " +
- "java.io.IOException: java.io.IOException: " +
- "Server asks us to fall back to SIMPLE auth, " +
- "but this client is configured to only allow secure connections"
- ));
- }
+ // tokens are irrelevant w/o secret manager enabled
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.OTHER));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.VALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.INVALID));
+
+ // A secure client must not fallback
+ assertAuthEquals(NoFallback, getAuthMethod(KERBEROS, SIMPLE));
+ assertAuthEquals(NoFallback, getAuthMethod(KERBEROS, SIMPLE, UseToken.OTHER));
+ assertAuthEquals(NoFallback, getAuthMethod(KERBEROS, SIMPLE, UseToken.VALID));
+ assertAuthEquals(NoFallback, getAuthMethod(KERBEROS, SIMPLE, UseToken.INVALID));
// Now set server to simple and also force the secret-manager. Now server
// should have both simple and token enabled.
forceSecretManager = true;
- assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, SIMPLE, true));
- forceSecretManager = false;
- clientFallBackToSimpleAllowed = true;
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.OTHER));
+ assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, SIMPLE, UseToken.VALID));
+ assertAuthEquals(BadToken, getAuthMethod(SIMPLE, SIMPLE, UseToken.INVALID));
+
+ // A secure client must not fallback
+ assertAuthEquals(NoFallback, getAuthMethod(KERBEROS, SIMPLE));
+ assertAuthEquals(NoFallback, getAuthMethod(KERBEROS, SIMPLE, UseToken.OTHER));
+ assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, SIMPLE, UseToken.VALID));
+ assertAuthEquals(BadToken, getAuthMethod(KERBEROS, SIMPLE, UseToken.INVALID));
+
+ // doesn't try SASL
+ assertAuthEquals(Denied(SIMPLE), getAuthMethod(SIMPLE, TOKEN));
+ // does try SASL
+ assertAuthEquals(No(TOKEN), getAuthMethod(SIMPLE, TOKEN, UseToken.OTHER));
+ assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, TOKEN, UseToken.VALID));
+ assertAuthEquals(BadToken, getAuthMethod(SIMPLE, TOKEN, UseToken.INVALID));
+
+ assertAuthEquals(No(TOKEN), getAuthMethod(KERBEROS, TOKEN));
+ assertAuthEquals(No(TOKEN), getAuthMethod(KERBEROS, TOKEN, UseToken.OTHER));
+ assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, TOKEN, UseToken.VALID));
+ assertAuthEquals(BadToken, getAuthMethod(KERBEROS, TOKEN, UseToken.INVALID));
}
@Test
public void testSimpleServerWithTokens() throws Exception {
// Client not using tokens
assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE));
- // SASL methods are reverted to SIMPLE, but test setup fails
- assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, SIMPLE));
+ // SASL methods are reverted to SIMPLE
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE));
// Use tokens. But tokens are ignored because client is reverted to simple
- assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, true));
+ // due to server not using tokens
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.VALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.OTHER));
+ // server isn't really advertising tokens
enableSecretManager = true;
- assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, true));
- assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, true));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.VALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.OTHER));
+
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.VALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.OTHER));
+
+ // now the simple server takes tokens
+ forceSecretManager = true;
+ assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, SIMPLE, UseToken.VALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.OTHER));
+
+ assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, SIMPLE, UseToken.VALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.OTHER));
}
@Test
public void testSimpleServerWithInvalidTokens() throws Exception {
// Tokens are ignored because client is reverted to simple
- assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, false));
- assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, false));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.INVALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.INVALID));
enableSecretManager = true;
- assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, false));
- assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, false));
+ assertAuthEquals(SIMPLE, getAuthMethod(SIMPLE, SIMPLE, UseToken.INVALID));
+ assertAuthEquals(SIMPLE, getAuthMethod(KERBEROS, SIMPLE, UseToken.INVALID));
+ forceSecretManager = true;
+ assertAuthEquals(BadToken, getAuthMethod(SIMPLE, SIMPLE, UseToken.INVALID));
+ assertAuthEquals(BadToken, getAuthMethod(KERBEROS, SIMPLE, UseToken.INVALID));
}
/*
@@ -675,26 +734,29 @@ public class TestSaslRPC {
*/
@Test
public void testTokenOnlyServer() throws Exception {
+ // simple client w/o tokens won't try SASL, so server denies
assertAuthEquals(Denied(SIMPLE), getAuthMethod(SIMPLE, TOKEN));
- assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, TOKEN));
+ assertAuthEquals(No(TOKEN), getAuthMethod(SIMPLE, TOKEN, UseToken.OTHER));
+ assertAuthEquals(No(TOKEN), getAuthMethod(KERBEROS, TOKEN));
+ assertAuthEquals(No(TOKEN), getAuthMethod(KERBEROS, TOKEN, UseToken.OTHER));
}
@Test
public void testTokenOnlyServerWithTokens() throws Exception {
- assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, TOKEN, true));
- assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, TOKEN, true));
+ assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, TOKEN, UseToken.VALID));
+ assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, TOKEN, UseToken.VALID));
enableSecretManager = false;
- assertAuthEquals(NoTokenAuth, getAuthMethod(SIMPLE, TOKEN, true));
- assertAuthEquals(NoTokenAuth, getAuthMethod(KERBEROS, TOKEN, true));
+ assertAuthEquals(NoTokenAuth, getAuthMethod(SIMPLE, TOKEN, UseToken.VALID));
+ assertAuthEquals(NoTokenAuth, getAuthMethod(KERBEROS, TOKEN, UseToken.VALID));
}
@Test
public void testTokenOnlyServerWithInvalidTokens() throws Exception {
- assertAuthEquals(BadToken, getAuthMethod(SIMPLE, TOKEN, false));
- assertAuthEquals(BadToken, getAuthMethod(KERBEROS, TOKEN, false));
+ assertAuthEquals(BadToken, getAuthMethod(SIMPLE, TOKEN, UseToken.INVALID));
+ assertAuthEquals(BadToken, getAuthMethod(KERBEROS, TOKEN, UseToken.INVALID));
enableSecretManager = false;
- assertAuthEquals(NoTokenAuth, getAuthMethod(SIMPLE, TOKEN, false));
- assertAuthEquals(NoTokenAuth, getAuthMethod(KERBEROS, TOKEN, false));
+ assertAuthEquals(NoTokenAuth, getAuthMethod(SIMPLE, TOKEN, UseToken.INVALID));
+ assertAuthEquals(NoTokenAuth, getAuthMethod(KERBEROS, TOKEN, UseToken.INVALID));
}
/*
@@ -702,38 +764,43 @@ public class TestSaslRPC {
*/
@Test
public void testKerberosServer() throws Exception {
- assertAuthEquals(Denied(SIMPLE), getAuthMethod(SIMPLE, KERBEROS));
- assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, KERBEROS));
+ // doesn't try SASL
+ assertAuthEquals(Denied(SIMPLE), getAuthMethod(SIMPLE, KERBEROS));
+ // does try SASL
+ assertAuthEquals(No(TOKEN,KERBEROS), getAuthMethod(SIMPLE, KERBEROS, UseToken.OTHER));
+ // no tgt
+ assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, KERBEROS));
+ assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, KERBEROS, UseToken.OTHER));
}
@Test
public void testKerberosServerWithTokens() throws Exception {
// can use tokens regardless of auth
- assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, KERBEROS, true));
- assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, KERBEROS, true));
- // can't fallback to simple when using kerberos w/o tokens
+ assertAuthEquals(TOKEN, getAuthMethod(SIMPLE, KERBEROS, UseToken.VALID));
+ assertAuthEquals(TOKEN, getAuthMethod(KERBEROS, KERBEROS, UseToken.VALID));
enableSecretManager = false;
- assertAuthEquals(Denied(TOKEN), getAuthMethod(SIMPLE, KERBEROS, true));
- assertAuthEquals(Denied(TOKEN), getAuthMethod(KERBEROS, KERBEROS, true));
+ // shouldn't even try token because server didn't tell us to
+ assertAuthEquals(No(KERBEROS), getAuthMethod(SIMPLE, KERBEROS, UseToken.VALID));
+ assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, KERBEROS, UseToken.VALID));
}
@Test
public void testKerberosServerWithInvalidTokens() throws Exception {
- assertAuthEquals(BadToken, getAuthMethod(SIMPLE, KERBEROS, false));
- assertAuthEquals(BadToken, getAuthMethod(KERBEROS, KERBEROS, false));
+ assertAuthEquals(BadToken, getAuthMethod(SIMPLE, KERBEROS, UseToken.INVALID));
+ assertAuthEquals(BadToken, getAuthMethod(KERBEROS, KERBEROS, UseToken.INVALID));
enableSecretManager = false;
- assertAuthEquals(Denied(TOKEN), getAuthMethod(SIMPLE, KERBEROS, false));
- assertAuthEquals(Denied(TOKEN), getAuthMethod(KERBEROS, KERBEROS, false));
+ assertAuthEquals(No(KERBEROS), getAuthMethod(SIMPLE, KERBEROS, UseToken.INVALID));
+ assertAuthEquals(KrbFailed, getAuthMethod(KERBEROS, KERBEROS, UseToken.INVALID));
}
// test helpers
private String getAuthMethod(
- final AuthenticationMethod clientAuth,
- final AuthenticationMethod serverAuth) throws Exception {
+ final AuthMethod clientAuth,
+ final AuthMethod serverAuth) throws Exception {
try {
- return internalGetAuthMethod(clientAuth, serverAuth, false, false);
+ return internalGetAuthMethod(clientAuth, serverAuth, UseToken.NONE);
} catch (Exception e) {
LOG.warn("Auth method failure", e);
return e.toString();
@@ -741,11 +808,11 @@ public class TestSaslRPC {
}
private String getAuthMethod(
- final AuthenticationMethod clientAuth,
- final AuthenticationMethod serverAuth,
- final boolean useValidToken) throws Exception {
+ final AuthMethod clientAuth,
+ final AuthMethod serverAuth,
+ final UseToken tokenType) throws Exception {
try {
- return internalGetAuthMethod(clientAuth, serverAuth, true, useValidToken);
+ return internalGetAuthMethod(clientAuth, serverAuth, tokenType);
} catch (Exception e) {
LOG.warn("Auth method failure", e);
return e.toString();
@@ -753,19 +820,17 @@ public class TestSaslRPC {
}
private String internalGetAuthMethod(
- final AuthenticationMethod clientAuth,
- final AuthenticationMethod serverAuth,
- final boolean useToken,
- final boolean useValidToken) throws Exception {
-
- String currentUser = UserGroupInformation.getCurrentUser().getUserName();
+ final AuthMethod clientAuth,
+ final AuthMethod serverAuth,
+ final UseToken tokenType) throws Exception {
final Configuration serverConf = new Configuration(conf);
- SecurityUtil.setAuthenticationMethod(serverAuth, serverConf);
+ serverConf.set(HADOOP_SECURITY_AUTHENTICATION, serverAuth.toString());
UserGroupInformation.setConfiguration(serverConf);
- final UserGroupInformation serverUgi =
- UserGroupInformation.createRemoteUser(currentUser + "-SERVER/localhost@NONE");
+ final UserGroupInformation serverUgi = (serverAuth == KERBEROS)
+ ? UserGroupInformation.createRemoteUser("server/localhost@NONE")
+ : UserGroupInformation.createRemoteUser("server");
serverUgi.setAuthenticationMethod(serverAuth);
final TestTokenSecretManager sm = new TestTokenSecretManager();
@@ -793,48 +858,58 @@ public class TestSaslRPC {
});
final Configuration clientConf = new Configuration(conf);
- SecurityUtil.setAuthenticationMethod(clientAuth, clientConf);
+ clientConf.set(HADOOP_SECURITY_AUTHENTICATION, clientAuth.toString());
clientConf.setBoolean(
CommonConfigurationKeys.IPC_CLIENT_FALLBACK_TO_SIMPLE_AUTH_ALLOWED_KEY,
clientFallBackToSimpleAllowed);
UserGroupInformation.setConfiguration(clientConf);
final UserGroupInformation clientUgi =
- UserGroupInformation.createRemoteUser(currentUser + "-CLIENT");
+ UserGroupInformation.createRemoteUser("client");
clientUgi.setAuthenticationMethod(clientAuth);
final InetSocketAddress addr = NetUtils.getConnectAddress(server);
- if (useToken) {
+ if (tokenType != UseToken.NONE) {
TestTokenIdentifier tokenId = new TestTokenIdentifier(
new Text(clientUgi.getUserName()));
- Token<TestTokenIdentifier> token = useValidToken
- ? new Token<TestTokenIdentifier>(tokenId, sm)
- : new Token<TestTokenIdentifier>(
+ Token<TestTokenIdentifier> token = null;
+ switch (tokenType) {
+ case VALID:
+ token = new Token<TestTokenIdentifier>(tokenId, sm);
+ SecurityUtil.setTokenService(token, addr);
+ break;
+ case INVALID:
+ token = new Token<TestTokenIdentifier>(
tokenId.getBytes(), "bad-password!".getBytes(),
tokenId.getKind(), null);
-
- SecurityUtil.setTokenService(token, addr);
+ SecurityUtil.setTokenService(token, addr);
+ break;
+ case OTHER:
+ token = new Token<TestTokenIdentifier>();
+ break;
+ case NONE: // won't get here
+ }
clientUgi.addToken(token);
}
try {
+ LOG.info("trying ugi:"+clientUgi+" tokens:"+clientUgi.getTokens());
return clientUgi.doAs(new PrivilegedExceptionAction<String>() {
@Override
public String run() throws IOException {
TestSaslProtocol proxy = null;
try {
- proxy = (TestSaslProtocol) RPC.getProxy(TestSaslProtocol.class,
+ proxy = RPC.getProxy(TestSaslProtocol.class,
TestSaslProtocol.versionID, addr, clientConf);
proxy.ping();
- // verify sasl completed
- if (serverAuth != SIMPLE) {
- assertEquals(SaslRpcServer.SASL_PROPS.get(Sasl.QOP), "auth");
- }
-
// make sure the other side thinks we are who we said we are!!!
assertEquals(clientUgi.getUserName(), proxy.getAuthUser());
- return proxy.getAuthMethod().toString();
+ AuthMethod authMethod = proxy.getAuthMethod();
+ // verify sasl completed with correct QOP
+ assertEquals((authMethod != SIMPLE) ? expectedQop.saslQop : null,
+ RPC.getConnectionIdForProxy(proxy).getSaslQop());
+ return authMethod.toString();
} finally {
if (proxy != null) {
RPC.stopProxy(proxy);
@@ -847,7 +922,7 @@ public class TestSaslRPC {
}
}
- private static void assertAuthEquals(AuthenticationMethod expect,
+ private static void assertAuthEquals(AuthMethod expect,
String actual) {
assertEquals(expect.toString(), actual);
}
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestServer.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestServer.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestServer.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestServer.java Mon Aug 12 21:25:49 2013
@@ -118,7 +118,7 @@ public class TestServer {
}
@Test
- public void testExceptionsHandler() throws IOException {
+ public void testExceptionsHandler() {
Server.ExceptionsHandler handler = new Server.ExceptionsHandler();
handler.addTerseExceptions(IOException.class);
handler.addTerseExceptions(RpcServerException.class, IpcException.class);
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSocketFactory.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSocketFactory.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSocketFactory.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/ipc/TestSocketFactory.java Mon Aug 12 21:25:49 2013
@@ -35,7 +35,7 @@ import org.junit.Test;
public class TestSocketFactory {
@Test
- public void testSocketFactoryAsKeyInMap() throws Exception {
+ public void testSocketFactoryAsKeyInMap() {
Map<SocketFactory, Integer> dummyCache = new HashMap<SocketFactory, Integer>();
int toBeCached1 = 1;
int toBeCached2 = 2;
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestNativeCodeLoader.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestNativeCodeLoader.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestNativeCodeLoader.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestNativeCodeLoader.java Mon Aug 12 21:25:49 2013
@@ -22,6 +22,9 @@ import static org.junit.Assert.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+import org.apache.hadoop.io.compress.Lz4Codec;
+import org.apache.hadoop.io.compress.SnappyCodec;
+import org.apache.hadoop.io.compress.zlib.ZlibFactory;
import org.apache.hadoop.util.NativeCodeLoader;
public class TestNativeCodeLoader {
@@ -44,6 +47,14 @@ public class TestNativeCodeLoader {
fail("TestNativeCodeLoader: libhadoop.so testing was required, but " +
"libhadoop.so was not loaded.");
}
+ assertFalse(NativeCodeLoader.getLibraryName().isEmpty());
+ // library names are depended on platform and build envs
+ // so just check names are available
+ assertFalse(ZlibFactory.getLibraryName().isEmpty());
+ if (NativeCodeLoader.buildSupportsSnappy()) {
+ assertFalse(SnappyCodec.getLibraryName().isEmpty());
+ }
+ assertFalse(Lz4Codec.getLibraryName().isEmpty());
LOG.info("TestNativeCodeLoader: libhadoop.so is loaded.");
}
}
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestProtoUtil.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestProtoUtil.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestProtoUtil.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestProtoUtil.java Mon Aug 12 21:25:49 2013
@@ -18,12 +18,19 @@
package org.apache.hadoop.util;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
+import java.util.Arrays;
+import org.apache.hadoop.ipc.ClientId;
+import org.apache.hadoop.ipc.RPC.RpcKind;
+import org.apache.hadoop.ipc.RpcConstants;
+import org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto;
+import org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto;
import org.junit.Test;
import com.google.protobuf.CodedOutputStream;
@@ -69,4 +76,13 @@ public class TestProtoUtil {
new ByteArrayInputStream(baos.toByteArray()));
assertEquals(value, ProtoUtil.readRawVarint32(dis));
}
+
+ @Test
+ public void testRpcClientId() {
+ byte[] uuid = ClientId.getClientId();
+ RpcRequestHeaderProto header = ProtoUtil.makeRpcRequestHeader(
+ RpcKind.RPC_PROTOCOL_BUFFER, OperationProto.RPC_FINAL_PACKET, 0,
+ RpcConstants.INVALID_RETRY_COUNT, uuid);
+ assertTrue(Arrays.equals(uuid, header.getClientId().toByteArray()));
+ }
}
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestStringUtils.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestStringUtils.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestStringUtils.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestStringUtils.java Mon Aug 12 21:25:49 2013
@@ -294,7 +294,8 @@ public class TestStringUtils extends Uni
assertArrayEquals(expectedArray, StringUtils.getTrimmedStrings(pathologicalDirList2));
assertArrayEquals(emptyArray, StringUtils.getTrimmedStrings(emptyList1));
- assertArrayEquals(emptyArray, StringUtils.getTrimmedStrings(emptyList2));
+ String[] estring = StringUtils.getTrimmedStrings(emptyList2);
+ assertArrayEquals(emptyArray, estring);
}
@Test (timeout = 30000)
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/resources/testConf.xml
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/resources/testConf.xml?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/resources/testConf.xml (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-common/src/test/resources/testConf.xml Mon Aug 12 21:25:49 2013
@@ -779,15 +779,11 @@
</comparator>
<comparator>
<type>RegexpComparator</type>
- <expected-output>^( |\t)*The owner and group names may only cosists of digits, alphabet,( )*</expected-output>
+ <expected-output>^( |\t)*The owner and group names may only consist of digits, alphabet,( )*</expected-output>
</comparator>
<comparator>
<type>RegexpComparator</type>
- <expected-output>^( |\t)*and any of '-_.@/' i.e. \[-_.@/a-zA-Z0-9\]. The names are case( )*</expected-output>
- </comparator>
- <comparator>
- <type>RegexpComparator</type>
- <expected-output>^( |\t)*sensitive.( )*</expected-output>
+ <expected-output>^( |\t)*and any of .+?. The names are case sensitive.( )*</expected-output>
</comparator>
<comparator>
<type>RegexpComparator</type>
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/pom.xml
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/pom.xml?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/pom.xml (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/pom.xml Mon Aug 12 21:25:49 2013
@@ -20,12 +20,12 @@
<parent>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-project</artifactId>
- <version>2.2.0-SNAPSHOT</version>
+ <version>2.3.0-SNAPSHOT</version>
<relativePath>../../hadoop-project</relativePath>
</parent>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-nfs</artifactId>
- <version>2.2.0-SNAPSHOT</version>
+ <version>2.3.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Apache Hadoop NFS</name>
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountInterface.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountInterface.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountInterface.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountInterface.java Mon Aug 12 21:25:49 2013
@@ -26,14 +26,31 @@ import org.apache.hadoop.oncrpc.XDR;
* requests. See RFC 1094 for more details.
*/
public interface MountInterface {
- public static int MNTPROC_NULL = 0;
- public static int MNTPROC_MNT = 1;
- public static int MNTPROC_DUMP = 2;
- public static int MNTPROC_UMNT = 3;
- public static int MNTPROC_UMNTALL = 4;
- public static int MNTPROC_EXPORT = 5;
- public static int MNTPROC_EXPORTALL = 6;
- public static int MNTPROC_PATHCONF = 7;
+ /** Mount procedures */
+ public static enum MNTPROC {
+ // the order of the values below are significant.
+ NULL,
+ MNT,
+ DUMP,
+ UMNT,
+ UMNTALL,
+ EXPORT,
+ EXPORTALL,
+ PATHCONF;
+
+ /** @return the int value representing the procedure. */
+ public int getValue() {
+ return ordinal();
+ }
+
+ /** @return the procedure corresponding to the value. */
+ public static MNTPROC fromValue(int value) {
+ if (value < 0 || value >= values().length) {
+ return null;
+ }
+ return values()[value];
+ }
+ }
/** MNTPROC_NULL - Do Nothing */
public XDR nullOp(XDR out, int xid, InetAddress client);
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountResponse.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountResponse.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountResponse.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/mount/MountResponse.java Mon Aug 12 21:25:49 2013
@@ -33,7 +33,7 @@ public class MountResponse {
private MountResponse() {
}
- /** Response for RPC call {@link MountInterface#MNTPROC_MNT} */
+ /** Response for RPC call {@link MountInterface.MNTPROC#MNT} */
public static XDR writeMNTResponse(int status, XDR xdr, int xid,
byte[] handle) {
RpcAcceptedReply.voidReply(xdr, xid);
@@ -48,7 +48,7 @@ public class MountResponse {
return xdr;
}
- /** Response for RPC call {@link MountInterface#MNTPROC_DUMP} */
+ /** Response for RPC call {@link MountInterface.MNTPROC#DUMP} */
public static XDR writeMountList(XDR xdr, int xid, List<MountEntry> mounts) {
RpcAcceptedReply.voidReply(xdr, xid);
for (MountEntry mountEntry : mounts) {
@@ -60,7 +60,7 @@ public class MountResponse {
return xdr;
}
- /** Response for RPC call {@link MountInterface#MNTPROC_EXPORT} */
+ /** Response for RPC call {@link MountInterface.MNTPROC#EXPORT} */
public static XDR writeExportList(XDR xdr, int xid, List<String> exports) {
RpcAcceptedReply.voidReply(xdr, xid);
for (String export : exports) {
Modified: hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/nfs/nfs3/Nfs3Constant.java
URL: http://svn.apache.org/viewvc/hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/nfs/nfs3/Nfs3Constant.java?rev=1513258&r1=1513257&r2=1513258&view=diff
==============================================================================
--- hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/nfs/nfs3/Nfs3Constant.java (original)
+++ hadoop/common/branches/YARN-321/hadoop-common-project/hadoop-nfs/src/main/java/org/apache/hadoop/nfs/nfs3/Nfs3Constant.java Mon Aug 12 21:25:49 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.nfs.nfs3;
+
/**
* Some constants for NFSv3
*/
@@ -34,28 +35,58 @@ public class Nfs3Constant {
public final static int VERSION = 3;
// The procedures
- public final static int NFSPROC3_NULL = 0;
- public final static int NFSPROC3_GETATTR = 1;
- public final static int NFSPROC3_SETATTR = 2;
- public final static int NFSPROC3_LOOKUP = 3;
- public final static int NFSPROC3_ACCESS = 4;
- public final static int NFSPROC3_READLINK = 5;
- public final static int NFSPROC3_READ = 6;
- public final static int NFSPROC3_WRITE = 7;
- public final static int NFSPROC3_CREATE = 8;
- public final static int NFSPROC3_MKDIR = 9;
- public final static int NFSPROC3_SYMLINK = 10;
- public final static int NFSPROC3_MKNOD = 11;
- public final static int NFSPROC3_REMOVE = 12;
- public final static int NFSPROC3_RMDIR = 13;
- public final static int NFSPROC3_RENAME = 14;
- public final static int NFSPROC3_LINK = 15;
- public final static int NFSPROC3_READDIR = 16;
- public final static int NFSPROC3_READDIRPLUS = 17;
- public final static int NFSPROC3_FSSTAT = 18;
- public final static int NFSPROC3_FSINFO = 19;
- public final static int NFSPROC3_PATHCONF = 20;
- public final static int NFSPROC3_COMMIT = 21;
+ public static enum NFSPROC3 {
+ // the order of the values below are significant.
+ NULL,
+ GETATTR,
+ SETATTR,
+ LOOKUP,
+ ACCESS,
+ READLINK,
+ READ,
+ WRITE,
+ CREATE(false),
+ MKDIR(false),
+ SYMLINK(false),
+ MKNOD(false),
+ REMOVE(false),
+ RMDIR(false),
+ RENAME(false),
+ LINK(false),
+ READDIR,
+ READDIRPLUS,
+ FSSTAT,
+ FSINFO,
+ PATHCONF,
+ COMMIT;
+
+ private final boolean isIdempotent;
+
+ private NFSPROC3(boolean isIdempotent) {
+ this.isIdempotent = isIdempotent;
+ }
+
+ private NFSPROC3() {
+ this(true);
+ }
+
+ public boolean isIdempotent() {
+ return isIdempotent;
+ }
+
+ /** @return the int value representing the procedure. */
+ public int getValue() {
+ return ordinal();
+ }
+
+ /** @return the procedure corresponding to the value. */
+ public static NFSPROC3 fromValue(int value) {
+ if (value < 0 || value >= values().length) {
+ return null;
+ }
+ return values()[value];
+ }
+ }
// The maximum size in bytes of the opaque file handle.
public final static int NFS3_FHSIZE = 64;
@@ -125,16 +156,13 @@ public class Nfs3Constant {
/** Write call flavors */
public enum WriteStableHow {
- UNSTABLE(0), DATA_SYNC(1), FILE_SYNC(2);
-
- private final int id;
-
- WriteStableHow(int id) {
- this.id = id;
- }
+ // the order of the values below are significant.
+ UNSTABLE,
+ DATA_SYNC,
+ FILE_SYNC;
public int getValue() {
- return id;
+ return ordinal();
}
public static WriteStableHow fromValue(int id) {