private void doRPCs(Configuration conf, boolean expectFailure) throws Exception {
SecurityUtil.setPolicy(new ConfiguredPolicy(conf, new TestPolicyProvider()));
Server server = RPC.getServer(new TestImpl(), ADDRESS, 0, 5, true, conf);
TestProtocol proxy = null;
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
try {
proxy = (TestProtocol) RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
if (expectFailure) {
fail("Expect RPC.getProxy to fail with AuthorizationException!");
}
} catch (RemoteException e) {
if (expectFailure) {
assertTrue(e.unwrapRemoteException() instanceof AuthorizationException);
} else {
throw e;
}
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
}
}
// do two RPC that transfers data.
public void run() {
int[] indata = new int[datasize];
int[] outdata = null;
int val = 0;
try {
outdata = proxy.exchange(indata);
val = proxy.add(1, 2);
} catch (IOException e) {
assertTrue("Exception from RPC exchange() " + e, false);
}
assertEquals(indata.length, outdata.length);
assertEquals(val, 3);
for (int i = 0; i < outdata.length; i++) {
assertEquals(outdata[i], i);
}
}
public void run() {
try {
proxy.slowPing(true); // this would hang until two fast pings happened
done = true;
} catch (IOException e) {
assertTrue("SlowRPC ping exception " + e, false);
}
}
public void testSlowRpc() throws Exception {
System.out.println("Testing Slow RPC");
// create a server with two handlers
Server server = RPC.getServer(new TestImpl(), ADDRESS, 0, 2, false, conf);
TestProtocol proxy = null;
try {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
// create a client
proxy = (TestProtocol) RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
SlowRPC slowrpc = new SlowRPC(proxy);
Thread thread = new Thread(slowrpc, "SlowRPC");
thread.start(); // send a slow RPC, which won't return until two fast pings
assertTrue("Slow RPC should not have finished1.", !slowrpc.isDone());
proxy.slowPing(false); // first fast ping
// verify that the first RPC is still stuck
assertTrue("Slow RPC should not have finished2.", !slowrpc.isDone());
proxy.slowPing(false); // second fast ping
// Now the slow ping should be able to be executed
while (!slowrpc.isDone()) {
System.out.println("Waiting for slow RPC to get done.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
System.out.println("Down slow rpc testing");
}
}
public void testCalls() throws Exception {
Server server = RPC.getServer(new TestImpl(), ADDRESS, 0, conf);
TestProtocol proxy = null;
try {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
proxy = (TestProtocol) RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
String stringResult = proxy.echo("foo");
assertEquals(stringResult, "foo");
stringResult = proxy.echo((String) null);
assertEquals(stringResult, null);
String[] stringResults = proxy.echo(new String[] {"foo", "bar"});
assertTrue(Arrays.equals(stringResults, new String[] {"foo", "bar"}));
stringResults = proxy.echo((String[]) null);
assertTrue(Arrays.equals(stringResults, null));
UTF8 utf8Result = (UTF8) proxy.echo(new UTF8("hello world"));
assertEquals(utf8Result, new UTF8("hello world"));
utf8Result = (UTF8) proxy.echo((UTF8) null);
assertEquals(utf8Result, null);
int intResult = proxy.add(1, 2);
assertEquals(intResult, 3);
intResult = proxy.add(new int[] {1, 2});
assertEquals(intResult, 3);
boolean caught = false;
try {
proxy.error();
} catch (IOException e) {
LOG.debug("Caught " + e);
caught = true;
}
assertTrue(caught);
proxy.testServerGet();
// create multiple threads and make them do large data transfers
System.out.println("Starting multi-threaded RPC test...");
server.setSocketSendBufSize(1024);
Thread threadId[] = new Thread[numThreads];
for (int i = 0; i < numThreads; i++) {
Transactions trans = new Transactions(proxy, datasize);
threadId[i] = new Thread(trans, "TransactionThread-" + i);
threadId[i].start();
}
// wait for all transactions to get over
System.out.println("Waiting for all threads to finish RPCs...");
for (int i = 0; i < numThreads; i++) {
try {
threadId[i].join();
} catch (InterruptedException e) {
i--; // retry
}
}
// try some multi-calls
Method echo = TestProtocol.class.getMethod("echo", new Class[] {String.class});
String[] strings =
(String[])
RPC.call(
echo, new String[][] {{"a"}, {"b"}}, new InetSocketAddress[] {addr, addr}, conf);
assertTrue(Arrays.equals(strings, new String[] {"a", "b"}));
Method ping = TestProtocol.class.getMethod("ping", new Class[] {});
Object[] voids =
(Object[])
RPC.call(ping, new Object[][] {{}, {}}, new InetSocketAddress[] {addr, addr}, conf);
assertEquals(voids, null);
} finally {
server.stop();
if (proxy != null) RPC.stopProxy(proxy);
}
}