/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.flume.api;
import junit.framework.Assert;
import org.apache.avro.ipc.Server;
import org.apache.flume.Event;
import org.apache.flume.EventDeliveryException;
import org.apache.flume.FlumeException;
import org.apache.flume.api.RpcTestUtils.LoadBalancedAvroHandler;
import org.apache.flume.api.RpcTestUtils.OKAvroHandler;
import org.apache.flume.event.EventBuilder;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
public class TestLoadBalancingRpcClient {
private static final Logger LOGGER = LoggerFactory.getLogger(TestLoadBalancingRpcClient.class);
@Test(expected = FlumeException.class)
public void testCreatingLbClientSingleHost() {
Server server1 = null;
RpcClient c = null;
try {
server1 = RpcTestUtils.startServer(new OKAvroHandler());
Properties p = new Properties();
p.put("host1", "127.0.0.1:" + server1.getPort());
p.put("hosts", "host1");
p.put("client.type", "default_loadbalance");
RpcClientFactory.getInstance(p);
} finally {
if (server1 != null) server1.close();
if (c != null) c.close();
}
}
@Test
public void testTwoHostFailover() throws Exception {
Server s1 = null;
Server s2 = null;
RpcClient c = null;
try {
LoadBalancedAvroHandler h1 = new LoadBalancedAvroHandler();
LoadBalancedAvroHandler h2 = new LoadBalancedAvroHandler();
s1 = RpcTestUtils.startServer(h1);
s2 = RpcTestUtils.startServer(h2);
Properties p = new Properties();
p.put("hosts", "h1 h2");
p.put("client.type", "default_loadbalance");
p.put("hosts.h1", "127.0.0.1:" + s1.getPort());
p.put("hosts.h2", "127.0.0.1:" + s2.getPort());
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 100; i++) {
if (i == 20) {
h2.setFailed();
} else if (i == 40) {
h2.setOK();
}
c.append(getEvent(i));
}
Assert.assertEquals(60, h1.getAppendCount());
Assert.assertEquals(40, h2.getAppendCount());
} finally {
if (s1 != null) s1.close();
if (s2 != null) s2.close();
if (c != null) c.close();
}
}
// This will fail without FLUME-1823
@Test(expected = EventDeliveryException.class)
public void testTwoHostFailoverThrowAfterClose() throws Exception {
Server s1 = null;
Server s2 = null;
RpcClient c = null;
try {
LoadBalancedAvroHandler h1 = new LoadBalancedAvroHandler();
LoadBalancedAvroHandler h2 = new LoadBalancedAvroHandler();
s1 = RpcTestUtils.startServer(h1);
s2 = RpcTestUtils.startServer(h2);
Properties p = new Properties();
p.put("hosts", "h1 h2");
p.put("client.type", "default_loadbalance");
p.put("hosts.h1", "127.0.0.1:" + s1.getPort());
p.put("hosts.h2", "127.0.0.1:" + s2.getPort());
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 100; i++) {
if (i == 20) {
h2.setFailed();
} else if (i == 40) {
h2.setOK();
}
c.append(getEvent(i));
}
Assert.assertEquals(60, h1.getAppendCount());
Assert.assertEquals(40, h2.getAppendCount());
if (c != null) c.close();
c.append(getEvent(3));
Assert.fail();
} finally {
if (s1 != null) s1.close();
if (s2 != null) s2.close();
}
}
/**
* Ensure that we can tolerate a host that is completely down.
*
* @throws Exception
*/
@Test
public void testTwoHostsOneDead() throws Exception {
LOGGER.info("Running testTwoHostsOneDead...");
Server s1 = null;
RpcClient c1 = null;
RpcClient c2 = null;
try {
LoadBalancedAvroHandler h1 = new LoadBalancedAvroHandler();
s1 = RpcTestUtils.startServer(h1);
// do not create a 2nd server (assume it's "down")
Properties p = new Properties();
p.put("hosts", "h1 h2");
p.put("client.type", "default_loadbalance");
p.put("hosts.h1", "127.0.0.1:" + 0); // port 0 should always be closed
p.put("hosts.h2", "127.0.0.1:" + s1.getPort());
// test batch API
c1 = RpcClientFactory.getInstance(p);
Assert.assertTrue(c1 instanceof LoadBalancingRpcClient);
for (int i = 0; i < 10; i++) {
c1.appendBatch(getBatchedEvent(i));
}
Assert.assertEquals(10, h1.getAppendBatchCount());
// test non-batch API
c2 = RpcClientFactory.getInstance(p);
Assert.assertTrue(c2 instanceof LoadBalancingRpcClient);
for (int i = 0; i < 10; i++) {
c2.append(getEvent(i));
}
Assert.assertEquals(10, h1.getAppendCount());
} finally {
if (s1 != null) s1.close();
if (c1 != null) c1.close();
if (c2 != null) c2.close();
}
}
@Test
public void testTwoHostFailoverBatch() throws Exception {
Server s1 = null;
Server s2 = null;
RpcClient c = null;
try {
LoadBalancedAvroHandler h1 = new LoadBalancedAvroHandler();
LoadBalancedAvroHandler h2 = new LoadBalancedAvroHandler();
s1 = RpcTestUtils.startServer(h1);
s2 = RpcTestUtils.startServer(h2);
Properties p = new Properties();
p.put("hosts", "h1 h2");
p.put("client.type", "default_loadbalance");
p.put("hosts.h1", "127.0.0.1:" + s1.getPort());
p.put("hosts.h2", "127.0.0.1:" + s2.getPort());
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 100; i++) {
if (i == 20) {
h2.setFailed();
} else if (i == 40) {
h2.setOK();
}
c.appendBatch(getBatchedEvent(i));
}
Assert.assertEquals(60, h1.getAppendBatchCount());
Assert.assertEquals(40, h2.getAppendBatchCount());
} finally {
if (s1 != null) s1.close();
if (s2 != null) s2.close();
if (c != null) c.close();
}
}
@Test
public void testLbDefaultClientTwoHosts() throws Exception {
Server s1 = null;
Server s2 = null;
RpcClient c = null;
try {
LoadBalancedAvroHandler h1 = new LoadBalancedAvroHandler();
LoadBalancedAvroHandler h2 = new LoadBalancedAvroHandler();
s1 = RpcTestUtils.startServer(h1);
s2 = RpcTestUtils.startServer(h2);
Properties p = new Properties();
p.put("hosts", "h1 h2");
p.put("client.type", "default_loadbalance");
p.put("hosts.h1", "127.0.0.1:" + s1.getPort());
p.put("hosts.h2", "127.0.0.1:" + s2.getPort());
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 100; i++) {
c.append(getEvent(i));
}
Assert.assertEquals(50, h1.getAppendCount());
Assert.assertEquals(50, h2.getAppendCount());
} finally {
if (s1 != null) s1.close();
if (s2 != null) s2.close();
if (c != null) c.close();
}
}
@Test
public void testLbDefaultClientTwoHostsBatch() throws Exception {
Server s1 = null;
Server s2 = null;
RpcClient c = null;
try {
LoadBalancedAvroHandler h1 = new LoadBalancedAvroHandler();
LoadBalancedAvroHandler h2 = new LoadBalancedAvroHandler();
s1 = RpcTestUtils.startServer(h1);
s2 = RpcTestUtils.startServer(h2);
Properties p = new Properties();
p.put("hosts", "h1 h2");
p.put("client.type", "default_loadbalance");
p.put("hosts.h1", "127.0.0.1:" + s1.getPort());
p.put("hosts.h2", "127.0.0.1:" + s2.getPort());
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 100; i++) {
c.appendBatch(getBatchedEvent(i));
}
Assert.assertEquals(50, h1.getAppendBatchCount());
Assert.assertEquals(50, h2.getAppendBatchCount());
} finally {
if (s1 != null) s1.close();
if (s2 != null) s2.close();
if (c != null) c.close();
}
}
@Test
public void testLbClientTenHostRandomDistribution() throws Exception {
final int NUM_HOSTS = 10;
final int NUM_EVENTS = 1000;
Server[] s = new Server[NUM_HOSTS];
LoadBalancedAvroHandler[] h = new LoadBalancedAvroHandler[NUM_HOSTS];
RpcClient c = null;
try {
Properties p = new Properties();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < NUM_HOSTS; i++) {
h[i] = new LoadBalancedAvroHandler();
s[i] = RpcTestUtils.startServer(h[i]);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + s[i].getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "random");
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < NUM_EVENTS; i++) {
c.append(getEvent(i));
}
Set<Integer> counts = new HashSet<Integer>();
int total = 0;
for (LoadBalancedAvroHandler handler : h) {
total += handler.getAppendCount();
counts.add(handler.getAppendCount());
}
Assert.assertTrue("Very unusual distribution", counts.size() > 2);
Assert.assertTrue("Missing events", total == NUM_EVENTS);
} finally {
for (int i = 0; i < NUM_HOSTS; i++) {
if (s[i] != null) s[i].close();
}
}
}
@Test
public void testLbClientTenHostRandomDistributionBatch() throws Exception {
final int NUM_HOSTS = 10;
final int NUM_EVENTS = 1000;
Server[] s = new Server[NUM_HOSTS];
LoadBalancedAvroHandler[] h = new LoadBalancedAvroHandler[NUM_HOSTS];
RpcClient c = null;
try {
Properties p = new Properties();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < NUM_HOSTS; i++) {
h[i] = new LoadBalancedAvroHandler();
s[i] = RpcTestUtils.startServer(h[i]);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + s[i].getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "random");
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < NUM_EVENTS; i++) {
c.appendBatch(getBatchedEvent(i));
}
Set<Integer> counts = new HashSet<Integer>();
int total = 0;
for (LoadBalancedAvroHandler handler : h) {
total += handler.getAppendBatchCount();
counts.add(handler.getAppendBatchCount());
}
Assert.assertTrue("Very unusual distribution", counts.size() > 2);
Assert.assertTrue("Missing events", total == NUM_EVENTS);
} finally {
for (int i = 0; i < NUM_HOSTS; i++) {
if (s[i] != null) s[i].close();
}
}
}
@Test
public void testLbClientTenHostRoundRobinDistribution() throws Exception {
final int NUM_HOSTS = 10;
final int NUM_EVENTS = 1000;
Server[] s = new Server[NUM_HOSTS];
LoadBalancedAvroHandler[] h = new LoadBalancedAvroHandler[NUM_HOSTS];
RpcClient c = null;
try {
Properties p = new Properties();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < NUM_HOSTS; i++) {
h[i] = new LoadBalancedAvroHandler();
s[i] = RpcTestUtils.startServer(h[i]);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + s[i].getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "round_robin");
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < NUM_EVENTS; i++) {
c.append(getEvent(i));
}
Set<Integer> counts = new HashSet<Integer>();
int total = 0;
for (LoadBalancedAvroHandler handler : h) {
total += handler.getAppendCount();
counts.add(handler.getAppendCount());
}
Assert.assertTrue("Very unusual distribution", counts.size() == 1);
Assert.assertTrue("Missing events", total == NUM_EVENTS);
} finally {
for (int i = 0; i < NUM_HOSTS; i++) {
if (s[i] != null) s[i].close();
}
}
}
@Test
public void testLbClientTenHostRoundRobinDistributionBatch() throws Exception {
final int NUM_HOSTS = 10;
final int NUM_EVENTS = 1000;
Server[] s = new Server[NUM_HOSTS];
LoadBalancedAvroHandler[] h = new LoadBalancedAvroHandler[NUM_HOSTS];
RpcClient c = null;
try {
Properties p = new Properties();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < NUM_HOSTS; i++) {
h[i] = new LoadBalancedAvroHandler();
s[i] = RpcTestUtils.startServer(h[i]);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + s[i].getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "round_robin");
c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < NUM_EVENTS; i++) {
c.appendBatch(getBatchedEvent(i));
}
Set<Integer> counts = new HashSet<Integer>();
int total = 0;
for (LoadBalancedAvroHandler handler : h) {
total += handler.getAppendBatchCount();
counts.add(handler.getAppendBatchCount());
}
Assert.assertTrue("Very unusual distribution", counts.size() == 1);
Assert.assertTrue("Missing events", total == NUM_EVENTS);
} finally {
for (int i = 0; i < NUM_HOSTS; i++) {
if (s[i] != null) s[i].close();
}
}
}
@Test
public void testRandomBackoff() throws Exception {
Properties p = new Properties();
List<LoadBalancedAvroHandler> hosts =
new ArrayList<LoadBalancedAvroHandler>();
List<Server> servers = new ArrayList<Server>();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < 3; i++) {
LoadBalancedAvroHandler s = new LoadBalancedAvroHandler();
hosts.add(s);
Server srv = RpcTestUtils.startServer(s);
servers.add(srv);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + srv.getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "random");
p.put("backoff", "true");
hosts.get(0).setFailed();
hosts.get(2).setFailed();
RpcClient c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
// TODO: there is a remote possibility that s0 or s2
// never get hit by the random assignment
// and thus not backoffed, causing the test to fail
for (int i = 0; i < 50; i++) {
// a well behaved runner would always check the return.
c.append(EventBuilder.withBody(("test" + String.valueOf(i)).getBytes()));
}
Assert.assertEquals(50, hosts.get(1).getAppendCount());
Assert.assertEquals(0, hosts.get(0).getAppendCount());
Assert.assertEquals(0, hosts.get(2).getAppendCount());
hosts.get(0).setOK();
hosts.get(1).setFailed(); // s0 should still be backed off
try {
c.append(EventBuilder.withBody("shouldfail".getBytes()));
// nothing should be able to process right now
Assert.fail("Expected EventDeliveryException");
} catch (EventDeliveryException e) {
// this is expected
}
Thread.sleep(2500); // wait for s0 to no longer be backed off
for (int i = 0; i < 50; i++) {
// a well behaved runner would always check the return.
c.append(EventBuilder.withBody(("test" + String.valueOf(i)).getBytes()));
}
Assert.assertEquals(50, hosts.get(0).getAppendCount());
Assert.assertEquals(50, hosts.get(1).getAppendCount());
Assert.assertEquals(0, hosts.get(2).getAppendCount());
}
@Test
public void testRoundRobinBackoffInitialFailure() throws EventDeliveryException {
Properties p = new Properties();
List<LoadBalancedAvroHandler> hosts =
new ArrayList<LoadBalancedAvroHandler>();
List<Server> servers = new ArrayList<Server>();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < 3; i++) {
LoadBalancedAvroHandler s = new LoadBalancedAvroHandler();
hosts.add(s);
Server srv = RpcTestUtils.startServer(s);
servers.add(srv);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + srv.getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "round_robin");
p.put("backoff", "true");
RpcClient c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
hosts.get(1).setFailed();
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
hosts.get(1).setOK();
//This time the iterators will never have "1".
//So clients get in the order: 1 - 3 - 1
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
Assert.assertEquals(1 + 2 + 1, hosts.get(0).getAppendCount());
Assert.assertEquals(1, hosts.get(1).getAppendCount());
Assert.assertEquals(1 + 1 + 2, hosts.get(2).getAppendCount());
}
@Test
public void testRoundRobinBackoffIncreasingBackoffs() throws Exception {
Properties p = new Properties();
List<LoadBalancedAvroHandler> hosts =
new ArrayList<LoadBalancedAvroHandler>();
List<Server> servers = new ArrayList<Server>();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < 3; i++) {
LoadBalancedAvroHandler s = new LoadBalancedAvroHandler();
hosts.add(s);
if (i == 1) {
s.setFailed();
}
Server srv = RpcTestUtils.startServer(s);
servers.add(srv);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + srv.getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "round_robin");
p.put("backoff", "true");
RpcClient c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
Assert.assertEquals(0, hosts.get(1).getAppendCount());
Thread.sleep(2100);
// this should let the sink come out of backoff and get backed off for a longer time
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
Assert.assertEquals(0, hosts.get(1).getAppendCount());
hosts.get(1).setOK();
Thread.sleep(2100);
// this time it shouldn't come out of backoff yet as the timeout isn't over
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
Assert.assertEquals(0, hosts.get(1).getAppendCount());
// after this s2 should be receiving events again
Thread.sleep(2500);
int numEvents = 60;
for (int i = 0; i < numEvents; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
Assert.assertEquals(2 + 2 + 1 + (numEvents / 3), hosts.get(0).getAppendCount());
Assert.assertEquals((numEvents / 3), hosts.get(1).getAppendCount());
Assert.assertEquals(1 + 1 + 2 + (numEvents / 3), hosts.get(2).getAppendCount());
}
@Test
public void testRoundRobinBackoffFailureRecovery()
throws EventDeliveryException, InterruptedException {
Properties p = new Properties();
List<LoadBalancedAvroHandler> hosts =
new ArrayList<LoadBalancedAvroHandler>();
List<Server> servers = new ArrayList<Server>();
StringBuilder hostList = new StringBuilder("");
for (int i = 0; i < 3; i++) {
LoadBalancedAvroHandler s = new LoadBalancedAvroHandler();
hosts.add(s);
if (i == 1) {
s.setFailed();
}
Server srv = RpcTestUtils.startServer(s);
servers.add(srv);
String name = "h" + i;
p.put("hosts." + name, "127.0.0.1:" + srv.getPort());
hostList.append(name).append(" ");
}
p.put("hosts", hostList.toString().trim());
p.put("client.type", "default_loadbalance");
p.put("host-selector", "round_robin");
p.put("backoff", "true");
RpcClient c = RpcClientFactory.getInstance(p);
Assert.assertTrue(c instanceof LoadBalancingRpcClient);
for (int i = 0; i < 3; i++) {
c.append(EventBuilder.withBody("recovery test".getBytes()));
}
hosts.get(1).setOK();
Thread.sleep(3000);
int numEvents = 60;
for (int i = 0; i < numEvents; i++) {
c.append(EventBuilder.withBody("testing".getBytes()));
}
Assert.assertEquals(2 + (numEvents / 3), hosts.get(0).getAppendCount());
Assert.assertEquals(0 + (numEvents / 3), hosts.get(1).getAppendCount());
Assert.assertEquals(1 + (numEvents / 3), hosts.get(2).getAppendCount());
}
private List<Event> getBatchedEvent(int index) {
List<Event> result = new ArrayList<Event>();
result.add(getEvent(index));
return result;
}
private Event getEvent(int index) {
return EventBuilder.withBody(("event: " + index).getBytes());
}
}