Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.gh.bmd.jrt.routine.DefaultParameterChannel Maven / Gradle / Ivy
/**
* Licensed 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 com.gh.bmd.jrt.routine;
import com.gh.bmd.jrt.builder.InputDeadlockException;
import com.gh.bmd.jrt.builder.RoutineConfiguration;
import com.gh.bmd.jrt.builder.RoutineConfiguration.OrderType;
import com.gh.bmd.jrt.channel.OutputChannel;
import com.gh.bmd.jrt.channel.OutputConsumer;
import com.gh.bmd.jrt.channel.ParameterChannel;
import com.gh.bmd.jrt.common.AbortException;
import com.gh.bmd.jrt.common.InvocationInterruptedException;
import com.gh.bmd.jrt.invocation.Invocation;
import com.gh.bmd.jrt.log.Logger;
import com.gh.bmd.jrt.routine.DefaultExecution.InputIterator;
import com.gh.bmd.jrt.routine.DefaultResultChannel.AbortHandler;
import com.gh.bmd.jrt.runner.Execution;
import com.gh.bmd.jrt.runner.Runner;
import com.gh.bmd.jrt.time.TimeDuration;
import com.gh.bmd.jrt.time.TimeDuration.Check;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import static com.gh.bmd.jrt.time.TimeDuration.ZERO;
import static com.gh.bmd.jrt.time.TimeDuration.fromUnit;
/**
* Default implementation of a parameter input channel.
*
* Created by davide on 9/24/14.
*
* @param the output data type.
*/
class DefaultParameterChannel implements ParameterChannel {
private final ArrayList> mBoundChannels = new ArrayList>();
private final DefaultExecution mExecution;
private final Check mHasInputs;
private final NestedQueue mResultChanel;
private final Runner mRunner;
private Throwable mAbortException;
private int mInputCount;
private TimeDuration mInputDelay = ZERO;
private boolean mIsConsuming;
private boolean mIsPendingExecution;
private int mPendingExecutionCount;
private ChannelState mState = ChannelState.INPUT;
/**
* Constructor.
*
* @param configuration the routine configuration.
* @param manager the invocation manager.
* @param runner the runner instance.
* @param logger the logger instance.
* @throws java.lang.IllegalArgumentException if at least one of the parameter is invalid.
* @throws java.lang.NullPointerException if one of the parameters is null.
*/
DefaultParameterChannel(@Nonnull final RoutineConfiguration configuration,
@Nonnull final InvocationManager manager, @Nonnull final Runner runner,
@Nonnull final Logger logger) {
mLogger = logger.subContextLogger(this);
mRunner = runner;
mMaxInput = configuration.getInputSizeOr(Integer.MAX_VALUE);
mInputTimeout = configuration.getInputTimeoutOr(ZERO);
if (mInputTimeout == null) {
throw new NullPointerException("the input timeout must not be null");
}
final int maxInputSize = mMaxInput;
if (maxInputSize < 1) {
throw new IllegalArgumentException("the input buffer size cannot be 0 or negative");
}
mInputQueue = (configuration.getInputOrderOr(OrderType.DELIVERY) == OrderType.DELIVERY)
? new SimpleNestedQueue(configuration, new AbortHandler() {
@Override
public void onAbort(@Nullable final Throwable reason, final long delay,
@Nonnull final TimeUnit timeUnit) {
final boolean isDone;
synchronized (mMutex) {
if (mState == ChannelState.EXCEPTION) {
mLogger.wrn("avoiding aborting result channel since invocation is aborted");
return;
}
isDone = (mState == ChannelState.RESULT);
if (isDone) {
mLogger.dbg(
"avoiding aborting result channel since invocation is complete");
} else {
mLogger.dbg("aborting result channel");
mAbortException = reason;
mState = ChannelState.EXCEPTION;
}
}
if (isDone) {
mRunner.run(new AbortResultExecution(reason), delay, timeUnit);
} else {
mRunner.run(mExecution.abort(), delay, timeUnit);
}
}
}, runner, logger);
mExecution = new DefaultExecution(manager, new DefaultInputIterator(),
mResultChanel, logger);
}
@Override
public boolean abort() {
return abort(null);
}
@Override
public boolean abort(@Nullable final Throwable reason) {
final TimeDuration delay;
synchronized (mMutex) {
if (!isOpen()) {
mLogger.dbg(reason, "avoiding aborting since channel is closed");
return false;
}
delay = mInputDelay;
if (delay.isZero()) {
mLogger.dbg(reason, "aborting channel");
mAbortException =
(reason instanceof AbortException) ? reason : new AbortException(reason);
mState = ChannelState.EXCEPTION;
}
}
if (delay.isZero()) {
mRunner.run(mExecution.abort(), 0, TimeUnit.MILLISECONDS);
} else {
mRunner.run(new DelayedAbortExecution(reason), delay.time, delay.unit);
}
return true;
}
@Override
public boolean isOpen() {
synchronized (mMutex) {
return (mState == ChannelState.INPUT);
}
}
@Nonnull
@Override
@SuppressWarnings("ConstantConditions")
public ParameterChannel after(@Nonnull final TimeDuration delay) {
synchronized (mMutex) {
verifyOpen();
if (delay == null) {
mLogger.err("invalid null delay");
throw new NullPointerException("the input delay must not be null");
}
mInputDelay = delay;
}
return this;
}
@Nonnull
@Override
public ParameterChannel after(final long delay,
@Nonnull final TimeUnit timeUnit) {
return after(fromUnit(delay, timeUnit));
}
@Nonnull
@Override
public ParameterChannel now() {
return after(ZERO);
}
@Nonnull
@Override
public ParameterChannel pass(@Nullable final OutputChannel pass(@Nullable final Iterable inputs) {
NestedQueue pass(@Nullable final INPUT input) {
NestedQueue pass(@Nullable final INPUT... inputs) {
synchronized (mMutex) {
verifyOpen();
if (inputs == null) {
mLogger.wrn("passing null input array");
return this;
}
}
return pass(Arrays.asList(inputs));
}
@Nonnull
@Override
public OutputChannel result() {
final boolean needsExecution;
synchronized (mMutex) {
verifyOpen();
mLogger.dbg("closing input channel");
mState = ChannelState.OUTPUT;
needsExecution = !mIsPendingExecution && !mIsConsuming;
if (needsExecution) {
++mPendingExecutionCount;
mIsPendingExecution = true;
}
}
if (needsExecution) {
mRunner.run(mExecution, 0, TimeUnit.MILLISECONDS);
}
return mResultChanel.getOutput();
}
private void addInputs(final int count) {
mInputCount += count;
try {
if (!mInputTimeout.waitTrue(mMutex, mHasInputs)) {
throw new InputDeadlockException(
"deadlock while waiting for room in the input channel");
}
} catch (final InterruptedException e) {
throw InvocationInterruptedException.interrupt(e);
}
}
private boolean isInput() {
return ((mState == ChannelState.INPUT) || (mState == ChannelState.OUTPUT));
}
private boolean isInputComplete() {
return (mState == ChannelState.OUTPUT) && (mPendingExecutionCount <= 0) && !mIsConsuming;
}
private void verifyOpen() {
if (mState == ChannelState.EXCEPTION) {
final Throwable throwable = mAbortException;
mLogger.dbg(throwable, "abort exception");
throw RoutineExceptionWrapper.wrap(throwable).raise();
}
if (!isOpen()) {
mLogger.err("invalid call on closed channel");
throw new IllegalStateException("the input channel is closed");
}
}
/**
* Enumeration identifying the channel internal state.
*/
private static enum ChannelState {
INPUT, // input channel is open
OUTPUT, // no more input
RESULT, // result called
EXCEPTION // abort issued
}
/**
* Interface defining an object managing the creation and the recycling of invocation instances.
*
* @param the output data type.
*/
interface InvocationManager {
/**
* Creates and returns a new invocation instance.
*
* @return the invocation instance.
*/
@Nonnull
public Invocation create();
/**
* Discards the specified invocation.
*
* @param invocation the invocation instance.
*/
public void discard(@Nonnull Invocation invocation);
/**
* Recycles the specified invocation.
*
* @param invocation the invocation instance.
*/
public void recycle(@Nonnull Invocation invocation);
}
/**
* Implementation of an execution handling the abortion of the result channel.
*/
private class AbortResultExecution implements Execution {
private Throwable mReason;
/**
* Constructor.
*
* @param reason the reason of the abortion.
*/
private AbortResultExecution(@Nullable final Throwable reason) {
mReason = reason;
}
@Override
public void run() {
mResultChanel.close(mReason);
}
}
/**
* Default implementation of an input iterator.
*/
private class DefaultInputIterator implements InputIterator> channels;
synchronized (mMutex) {
exception = mAbortException;
mLogger.dbg(exception, "aborting bound channels [%d]", mBoundChannels.size());
channels = new ArrayList>(mBoundChannels);
mBoundChannels.clear();
}
for (final OutputChannel channel : channels) {
channel.abort(exception);
}
}
@Override
public boolean onConsumeComplete() {
synchronized (mMutex) {
mIsConsuming = false;
return isInputComplete();
}
}
@Override
public void onConsumeStart() {
synchronized (mMutex) {
if (!isInput()) {
mLogger.wrn("avoiding consuming input since invocation is complete [#%d]",
mPendingExecutionCount);
return;
}
mLogger.dbg("consuming input [#%d]", mPendingExecutionCount);
--mPendingExecutionCount;
mIsPendingExecution = false;
mIsConsuming = true;
}
}
@Override
public void onInvocationComplete() {
synchronized (mMutex) {
if (mState != ChannelState.EXCEPTION) {
mState = ChannelState.RESULT;
}
}
}
}
/**
* Default implementation of an output consumer pushing the consume data into the input
* channel queue.
*/
private class DefaultOutputConsumer implements OutputConsumer
