/*
* 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.channel;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.apache.flume.ChannelException;
import org.apache.flume.Event;
import org.apache.flume.event.EventBuilder;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import com.google.common.base.Preconditions;
public abstract class AbstractBasicChannelSemanticsTest {
protected static List<Event> events;
static {
Event[] array = new Event[7];
for (int i = 0; i < array.length; ++i) {
array[i] = EventBuilder.withBody(("test event " + i).getBytes());
}
events = Collections.unmodifiableList(Arrays.asList(array));
}
protected ExecutorService executor = null;
protected TestChannel channel = null;
protected static class TestChannel extends BasicChannelSemantics {
private Queue<Event> queue = new ArrayDeque<Event>();
public enum Mode {
NORMAL,
THROW_ERROR,
THROW_RUNTIME,
THROW_CHANNEL,
SLEEP
};
private Mode mode = Mode.NORMAL;
private boolean lastTransactionCommitted = false;
private boolean lastTransactionRolledBack = false;
private boolean lastTransactionClosed = false;
public Mode getMode() {
return mode;
}
public void setMode(Mode mode) {
this.mode = mode;
}
public boolean wasLastTransactionCommitted() {
return lastTransactionCommitted;
}
public boolean wasLastTransactionRolledBack() {
return lastTransactionRolledBack;
}
public boolean wasLastTransactionClosed() {
return lastTransactionClosed;
}
@Override
protected BasicTransactionSemantics createTransaction() {
return new TestTransaction();
}
protected class TestTransaction extends BasicTransactionSemantics {
protected void doMode() throws InterruptedException {
switch (mode) {
case THROW_ERROR:
throw new TestError();
case THROW_RUNTIME:
throw new TestRuntimeException();
case THROW_CHANNEL:
throw new ChannelException("test");
case SLEEP:
Thread.sleep(300000);
break;
}
}
@Override
protected void doBegin() throws InterruptedException {
doMode();
}
@Override
protected void doPut(Event event) throws InterruptedException {
doMode();
synchronized (queue) {
queue.add(event);
}
}
@Override
protected Event doTake() throws InterruptedException {
doMode();
synchronized (queue) {
return queue.poll();
}
}
@Override
protected void doCommit() throws InterruptedException {
doMode();
lastTransactionCommitted = true;
}
@Override
protected void doRollback() throws InterruptedException {
lastTransactionRolledBack = true;
doMode();
}
@Override
protected void doClose() {
lastTransactionClosed = true;
Preconditions.checkState(mode != TestChannel.Mode.SLEEP,
"doClose() can't throw InterruptedException, so why SLEEP?");
try {
doMode();
} catch (InterruptedException e) {
Assert.fail();
}
}
}
}
protected static class TestError extends Error {
static final long serialVersionUID = -1;
};
protected static class TestRuntimeException extends RuntimeException {
static final long serialVersionUID = -1;
};
protected void testException(Class<? extends Throwable> exceptionClass,
Runnable test) {
try {
test.run();
Assert.fail();
} catch (Throwable e) {
if (exceptionClass == InterruptedException.class
&& e instanceof ChannelException
&& e.getCause() instanceof InterruptedException) {
Assert.assertTrue(Thread.interrupted());
} else if (!exceptionClass.isInstance(e)) {
throw new AssertionError(e);
}
}
}
protected void testIllegalArgument(Runnable test) {
testException(IllegalArgumentException.class, test);
}
protected void testIllegalState(Runnable test) {
testException(IllegalStateException.class, test);
}
protected void testWrongThread(final Runnable test) throws Exception {
executor.submit(new Runnable() {
public void run() {
testIllegalState(test);
}
}).get();
}
protected void testMode(TestChannel.Mode mode, Runnable test) {
TestChannel.Mode oldMode = channel.getMode();
try {
channel.setMode(mode);
test.run();
} finally {
channel.setMode(oldMode);
}
}
protected void testException(TestChannel.Mode mode,
final Class<? extends Throwable> exceptionClass, final Runnable test) {
testMode(mode, new Runnable() {
public void run() {
testException(exceptionClass, test);
}
});
}
protected void testError(Runnable test) {
testException(TestChannel.Mode.THROW_ERROR, TestError.class, test);
}
protected void testRuntimeException(Runnable test) {
testException(TestChannel.Mode.THROW_RUNTIME, TestRuntimeException.class,
test);
}
protected void testChannelException(Runnable test) {
testException(TestChannel.Mode.THROW_CHANNEL, ChannelException.class, test);
}
protected void testInterrupt(final Runnable test) {
testMode(TestChannel.Mode.SLEEP, new Runnable() {
public void run() {
testException(InterruptedException.class, new Runnable() {
public void run() {
interruptTest(test);
}
});
}
});
}
protected void interruptTest(final Runnable test) {
final Thread mainThread = Thread.currentThread();
Future<?> future = executor.submit(new Runnable() {
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
mainThread.interrupt();
}
});
test.run();
try {
future.get();
} catch (Exception e) {
throw new AssertionError(e);
}
}
protected void testExceptions(Runnable test) throws Exception {
testWrongThread(test);
testBasicExceptions(test);
testInterrupt(test);
}
protected void testBasicExceptions(Runnable test) throws Exception {
testError(test);
testRuntimeException(test);
testChannelException(test);
}
@Before
public void before() {
Preconditions.checkState(channel == null, "test cleanup failed!");
Preconditions.checkState(executor == null, "test cleanup failed!");
channel = new TestChannel();
executor = Executors.newCachedThreadPool();
}
@After
public void after() {
channel = null;
executor.shutdown();
executor = null;
}
}