/*
* KitchenSync-core Java Library Copyright (C) 2014 Burton Alexander
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option) any later
* version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
package com.github.mrstampy.kitchensync.stream;
import static com.github.mrstampy.kitchensync.util.KiSyUtils.await;
import io.netty.channel.ChannelFuture;
import io.netty.util.concurrent.GenericFutureListener;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Observable;
import rx.Scheduler;
import rx.Subscription;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.schedulers.Schedulers;
import com.github.mrstampy.kitchensync.netty.channel.KiSyChannel;
import com.github.mrstampy.kitchensync.stream.footer.EndOfMessageFooter;
import com.github.mrstampy.kitchensync.stream.footer.Footer;
import com.github.mrstampy.kitchensync.stream.header.ChunkProcessor;
import com.github.mrstampy.kitchensync.stream.header.NoProcessChunkProcessor;
import com.github.mrstampy.kitchensync.stream.header.SequenceHeaderPrepender;
import com.github.mrstampy.kitchensync.stream.inbound.EndOfMessageInboundMessageHandler;
import com.github.mrstampy.kitchensync.util.KiSyUtils;
/**
* An abstract implementation of the {@link Streamer} interface.
*
* @param <MSG>
* the generic type
*/
public abstract class AbstractStreamer<MSG> implements Streamer<MSG> {
private static final Logger log = LoggerFactory.getLogger(AbstractStreamer.class);
/** The Constant DEFAULT_ACK_AWAIT, 1 second. */
public static final int DEFAULT_ACK_AWAIT = 1;
/**
* The Enum StreamerType.
*/
//@formatter:off
protected enum StreamerType {
FULL_THROTTLE,
CHUNKS_PER_SECOND,
ACK_REQUIRED;
}
//@formatter:on
private KiSyChannel channel;
private int chunkSize;
private InetSocketAddress destination;
/** The streaming indicator. */
protected AtomicBoolean streaming = new AtomicBoolean(false);
/** The complete indicator. */
protected AtomicBoolean complete = new AtomicBoolean(false);
/** The sent. */
protected AtomicLong sent = new AtomicLong(0);
private long size;
/** The streamer listener. */
protected StreamerListener streamerListener = new StreamerListener();
/** The future. */
protected StreamerFuture future;
/** The svc. */
protected Scheduler svc = Schedulers.from(Executors.newCachedThreadPool());
/** The active subscription. */
protected Subscription sub;
private int chunksPerSecond = -1;
/** The list of keys awaiting {@link #ackReceived(long)}. */
protected List<Long> ackKeys = new ArrayList<Long>();
/** The ack latch. */
protected CountDownLatch latch;
/** The start. */
protected long start;
/** The type. */
protected StreamerType type = StreamerType.FULL_THROTTLE;
private int concurrentThreads = DEFAULT_CONCURRENT_THREADS;
private int ackAwait = DEFAULT_ACK_AWAIT;
private TimeUnit ackAwaitUnit = TimeUnit.SECONDS;
private boolean processChunk = concurrentThreads > 1;
/** The sequence. */
protected AtomicLong sequence = new AtomicLong(0);
private boolean eomOnFinish = false;
private ChunkProcessor chunkProcessor = new SequenceHeaderPrepender();
private ChunkProcessor noProcessing = new NoProcessChunkProcessor();
private Footer footer = new EndOfMessageFooter();
private int throttle = 0;
/**
* The Constructor.
*
* @param channel
* the channel
* @param destination
* the destination
* @param chunkSize
* the chunk size
*/
protected AbstractStreamer(KiSyChannel channel, InetSocketAddress destination, int chunkSize) {
setChannel(channel);
setChunkSize(chunkSize);
setDestination(destination);
future = new StreamerFuture(this);
}
/**
* Implement to return the next byte array chunk from the message. An empty
* array indicates the end of the stream while a null value indicates the
* streaming should automatically pause.
*
* @return the chunk
* @throws Exception
* the exception
* @see #processChunk(byte[])
*/
protected abstract byte[] getChunk() throws Exception;
/**
* Gets the chunk with header.
*
* @return the chunk with header
* @throws Exception
* the exception
*/
protected byte[] getChunkWithHeader() throws Exception {
byte[] chunk = getChunk();
if (chunk == null || chunk.length == 0) return chunk;
incrementSequence();
return getEffectiveChunkProcessor().process(this, chunk);
}
/**
* Returns the effective chunk processor, if {@link #isProcessChunk()} then
* {@link #getChunkProcessor()}, else the implementation of
* {@link NoProcessChunkProcessor}.
*
* @return the effective chunk processor
*/
protected ChunkProcessor getEffectiveChunkProcessor() {
return isProcessChunk() ? getChunkProcessor() : noProcessing;
}
/**
* Prepare the specified message for streaming.
*
* @param message
* the message
* @throws Exception
* the exception
*/
protected abstract void prepareForSend(MSG message) throws Exception;
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#pause()
*/
@Override
public void pause() {
if (!isStreaming()) return;
if (sub != null) sub.unsubscribe();
streaming.set(false);
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#size()
*/
@Override
public long size() {
return size;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#sent()
*/
@Override
public long sent() {
return sent.get();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getFuture()
*/
@Override
public ChannelFuture getFuture() {
return future;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#isComplete()
*/
@Override
public boolean isComplete() {
return complete.get();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#isStreaming()
*/
@Override
public boolean isStreaming() {
return streaming.get();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#cancel()
*/
@Override
public void cancel() {
cancelFuture();
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#stream(java.lang.Object)
*/
@Override
public ChannelFuture stream(MSG message) throws Exception {
if (isStreaming()) throw new IllegalStateException("Cannot send message, already streaming");
init();
prepareForSend(message);
return stream();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#stream()
*/
@Override
public ChannelFuture stream() {
if (isStreaming()) return getFuture();
if (isComplete()) throw new IllegalStateException("Streaming is complete");
streaming.set(true);
if (sent() == 0) start = System.nanoTime();
switch (type) {
case ACK_REQUIRED:
// Necessary for multiple use in testing
KiSyUtils.snooze(0);
sendAndAwaitAck();
break;
case CHUNKS_PER_SECOND:
scheduledService();
break;
case FULL_THROTTLE:
fullThrottleService();
break;
default:
break;
}
return getFuture();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#fullThrottle()
*/
@Override
public void fullThrottle() {
if (isStreaming()) throw new IllegalStateException("Cannot switch to full throttle when streaming");
this.chunksPerSecond = -1;
type = StreamerType.FULL_THROTTLE;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#isFullThrottle()
*/
@Override
public boolean isFullThrottle() {
return type == StreamerType.FULL_THROTTLE;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setChunksPerSecond(int)
*/
@Override
public void setChunksPerSecond(int chunksPerSecond) {
if (isStreaming()) throw new IllegalStateException("Cannot set chunksPerSecond when streaming");
if (chunksPerSecond <= 0) throw new IllegalArgumentException("chunksPerSecond must be > 0: " + chunksPerSecond);
this.chunksPerSecond = chunksPerSecond;
type = StreamerType.CHUNKS_PER_SECOND;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getChunksPerSecond()
*/
@Override
public int getChunksPerSecond() {
return chunksPerSecond;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#isChunksPerSecond()
*/
@Override
public boolean isChunksPerSecond() {
return getChunksPerSecond() > 0;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#ackRequired()
*/
@Override
public void ackRequired() {
if (isStreaming()) throw new IllegalStateException("Cannot set ackRequired when streaming");
if (getChannel().isMulticastChannel()) {
log.warn("Requiring acknowledgement for multicast messages.");
}
this.chunksPerSecond = -1;
type = StreamerType.ACK_REQUIRED;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#isAckRequired()
*/
@Override
public boolean isAckRequired() {
return type == StreamerType.ACK_REQUIRED;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#ackReceived(int)
*/
@Override
public void ackReceived(long sumOfBytesInChunk) {
if (!isAckRequired()) return;
byte[] ackChunk = StreamerAckRegister.getChunk(sumOfBytesInChunk, getChannel().getPort());
if (ackChunk == null) log.warn("No last chunk to acknowledge");
if (latch != null) latch.countDown();
}
/**
* Sets the size.
*
* @param size
* the size
*/
protected void setSize(long size) {
this.size = size;
}
/**
* Cancel future.
*/
protected void cancelFuture() {
future.setCancelled(true);
streaming.set(true);
finish(false, null);
}
/**
* Convenience method for subclasses to create the byte array for the next
* chunk given the remaining number of bytes. Factors in the header size if
* {@link #isProcessChunk()}.
*
* @param remaining
* the remaining
* @return the byte[]
*/
protected byte[] createByteArray(int remaining) {
int chunkSize = getEffectiveChunkSize();
chunkSize = remaining > chunkSize ? chunkSize : remaining;
return new byte[chunkSize];
}
/**
* The service activated when StreamerType is CHUNKS_PER_SECOND.
*/
protected void scheduledService() {
BigDecimal secondsPerChunk = BigDecimal.ONE.divide(new BigDecimal(chunksPerSecond), 6, RoundingMode.HALF_UP);
BigDecimal microsPerChunk = secondsPerChunk.multiply(KiSyUtils.ONE_MILLION);
unsubscribe();
sub = svc.createWorker().schedulePeriodically(new Action0() {
@Override
public void call() {
if (isStreaming()) {
fullThrottleServiceImpl();
}
}
}, 0, microsPerChunk.longValue(), TimeUnit.MICROSECONDS);
}
/**
* The service activated when StreamerType is FULL_THROTTLE.
*/
protected void fullThrottleService() {
unsubscribe();
if (getThrottle() > 0) {
sub = svc.createWorker().schedulePeriodically(new Action0() {
@Override
public void call() {
if (isStreaming()) {
fullThrottleServiceImpl();
} else {
sub.unsubscribe();
}
}
}, 0, getThrottle(), TimeUnit.MICROSECONDS);
} else {
sub = svc.createWorker().schedule(new Action0() {
@Override
public void call() {
while (isStreaming()) {
fullThrottleServiceImpl();
}
}
});
}
}
private void fullThrottleServiceImpl() {
try {
int latchCount = 0;
if (isAsync()) {
latchCount = sendChunksAsync();
} else {
byte[] chunk = writeOnce();
if (chunk != null && chunk.length > 0) latchCount++;
}
awaitLatchIfRequired(latchCount);
} catch (Exception e) {
log.error("Unexpected exception", e);
finish(false, e);
}
}
private void awaitLatchIfRequired(int latchCount) {
if (latchCount > 0 && isFullThrottle()) await(latch, 50, TimeUnit.MILLISECONDS);
}
/**
* The service activated when StreamerType is ACK_REQUIRED.
*/
protected void sendAndAwaitAck() {
unsubscribe();
sub = svc.createWorker().schedule(new Action0() {
@Override
public void call() {
try {
sendAndAwaitAckImpl();
} catch (Exception e) {
log.error("Unexpected exception", e);
}
}
});
}
private void sendAndAwaitAckImpl() throws Exception {
if (!isStreaming()) return;
int count = 0;
if (isAsync()) {
count = sendChunksAsync();
} else {
byte[] ackChunk = writeOnce();
if (ackChunk == null) return;
count++;
}
if (count > 0) awaitAck();
}
private boolean isAsync() {
return getConcurrentThreads() > 1;
}
private int sendChunksAsync() throws Exception {
List<byte[]> chunks = new ArrayList<byte[]>();
for (int i = 0; i < getConcurrentThreads(); i++) {
byte[] chunk = getChunkWithHeader();
if (chunk == null || chunk.length == 0) break;
chunks.add(chunk);
}
if (chunks.isEmpty()) {
pause();
return 0;
}
int latchCount = getLatchCount(chunks);
if (latchCount > 0) latch = new CountDownLatch(latchCount);
processChunks(chunks);
return latchCount;
}
/**
* The service activated when the last chunk has not been acknowledged.
*/
protected void resendLast() {
if (!isStreaming()) return;
unsubscribe();
sub = svc.createWorker().schedule(new Action0() {
@Override
public void call() {
if (!isStreaming() || ackKeys.isEmpty()) return;
List<byte[]> chunks = new ArrayList<byte[]>();
for (Long ackKey : ackKeys) {
byte[] ackChunk = StreamerAckRegister.getChunk(ackKey, getChannel().getPort());
if (ackChunk == null) {
log.warn("No last chunk found in the registry");
} else {
chunks.add(ackChunk);
sent.addAndGet(-ackChunk.length);
}
}
int latchCount = getLatchCount(chunks);
processChunks(chunks);
if (latchCount > 0) awaitAck();
}
});
}
/**
* The service activated to await acknowledgement and to invoke another send
* and wait or a resend of the last message.
*/
protected void awaitAck() {
final boolean ok = await(latch, ackAwait, ackAwaitUnit);
if (getThrottle() > 0) {
svc.createWorker().schedule(new Action0() {
@Override
public void call() {
nextAckChunk(ok);
}
}, getThrottle(), TimeUnit.MICROSECONDS);
} else {
nextAckChunk(ok);
}
}
private void nextAckChunk(final boolean ok) {
if (ok) {
sendAndAwaitAck();
} else {
log.warn("No ack received for last packet, resending");
resendLast();
}
}
/**
* Unsubscribe.
*/
protected void unsubscribe() {
if (sub != null) sub.unsubscribe();
}
/**
* Profile.
*/
protected void profile() {
if (!log.isDebugEnabled() || size() == 0) return;
long elapsed = System.nanoTime() - start;
BigDecimal megabytesPerSecond = new BigDecimal(size()).multiply(new BigDecimal(1000)).divide(
new BigDecimal(elapsed), 3, RoundingMode.HALF_UP);
log.debug("{} bytes sent in {} ms at a rate of {} megabytes/sec", size(), KiSyUtils.toMillis(elapsed),
megabytesPerSecond.toPlainString());
}
/**
* Write once.
*
* @return the byte[]
*/
protected byte[] writeOnce() {
try {
return writeImpl();
} catch (Exception e) {
log.error("Unexpected exception", e);
pause();
finish(false, e);
return null;
}
}
private byte[] writeImpl() throws Exception {
byte[] chunk = getChunkWithHeader();
if (!isStreaming()) return null;
if (chunk != null && chunk.length > 0) latch = new CountDownLatch(1);
processChunk(chunk);
return chunk;
}
/**
* Process chunks.
*
* @param chunks
* the chunks
*/
protected void processChunks(List<byte[]> chunks) {
Observable.from(chunks, svc).subscribe(new Action1<byte[]>() {
@Override
public void call(byte[] t1) {
if (isStreaming()) processChunk(t1);
}
});
}
/**
* Gets the latch count.
*
* @param chunks
* the chunks
* @return the latch count
*/
protected int getLatchCount(List<byte[]> chunks) {
int i = 0;
for (byte[] b : chunks) {
if (b.length > 0) i++;
}
return i;
}
/**
* Sends the chunk to the destination with two trigger value function
* exceptions. A null value will {@link #pause()} streaming and return. A call
* to {@link #stream()} will resume streaming at the point of pause. An empty
* (length == 0) array indicates that streaming is complete and will invoke
* finalization around message streaming.<br>
* <br>
*
* These functions are triggered from the value returned from the
* implementation of {@link #getChunk()}. Override as necessary.
*
* @param chunk
* the chunk
*/
protected void processChunk(byte[] chunk) {
// null chunk == autopause
if (chunk == null) {
pause();
return;
}
// empty chunk == EOM
if (chunk.length == 0) {
finish(true, null);
} else {
sendChunk(chunk);
}
KiSyUtils.snooze(0); // necessary for packet fidelity when @ full throttle
}
/**
* Writes the bytes to the {@link #getChannel()}. Invoked from
* {@link #processChunk(byte[])}, override if necessary.
*
* @param chunk
* the chunk
*/
protected void sendChunk(byte[] chunk) {
if (isAckRequired()) ackKeys.add(StreamerAckRegister.add(chunk, this));
ChannelFuture cf = channel.send(chunk, destination);
if (isFullThrottle()) cf.addListener(streamerListener);
sent.addAndGet(chunk.length - getEffectiveChunkProcessor().sizeInBytes(this));
}
/**
* Implementation method to send an end of message message.
*
* @see EndOfMessageRegister
* @see EndOfMessageInboundMessageHandler
* @see EndOfMessageListener
* @see #isEomOnFinish()
* @see #setEomOnFinish(boolean)
* @see #setFooter(Footer)
*/
public void sendEndOfMessage() {
await(latch, 100, TimeUnit.MILLISECONDS);
latch = new CountDownLatch(1);
ChannelFuture cf = channel.send(getFooter().createFooter(), destination);
cf.addListener(streamerListener);
await(latch, 50, TimeUnit.MILLISECONDS);
}
/**
* Initialzes the state of the streamer.
*/
protected void init() {
sent.set(0);
sequence.set(0);
complete.set(false);
unsubscribe();
countdownLatch();
resetChunkProcessor();
resetFooter();
}
/**
* Counts down {@link #latch}.
*/
protected void countdownLatch() {
if (latch != null) latch.countDown();
}
/**
* Invoked when streaming is complete, an error has occurred or streaming has
* been {@link #cancel()}led.
*
* @param success
* the success
* @param t
* the exception, null if not applicable
*/
protected synchronized void finish(boolean success, Throwable t) {
if (!isStreaming()) return;
streaming.set(false);
complete.set(true);
if (isEomOnFinish()) sendEndOfMessage();
future.finished(success, t);
future = new StreamerFuture(this);
if (latch != null) {
long count = latch.getCount();
for (long i = 0; i < count; i++) {
latch.countDown();
}
latch = null;
}
unsubscribe();
profile();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getChannel()
*/
@Override
public KiSyChannel getChannel() {
return channel;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setChannel(com.github.mrstampy
* .kitchensync.netty.channel.KiSyChannel)
*/
@Override
public void setChannel(KiSyChannel channel) {
this.channel = channel;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getChunkSize()
*/
@Override
public int getChunkSize() {
return chunkSize;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#setChunkSize(int)
*/
@Override
public void setChunkSize(int chunkSize) {
this.chunkSize = chunkSize;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getDestination()
*/
@Override
public InetSocketAddress getDestination() {
return destination;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setDestination(java.net
* .InetSocketAddress)
*/
@Override
public void setDestination(InetSocketAddress destination) {
this.destination = destination;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getConcurrentThreads()
*/
public int getConcurrentThreads() {
return concurrentThreads;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setConcurrentThreads(int)
*/
public void setConcurrentThreads(int concurrentThreads) {
if (concurrentThreads < 1) throw new IllegalArgumentException("Must be > 0: " + concurrentThreads);
this.concurrentThreads = concurrentThreads;
if (concurrentThreads > 1) setProcessChunk(true);
}
/**
* If true then {@link #getChunkProcessor()} is used to process chunks, else
* the implementation of {@link NoProcessChunkProcessor}.
*
* @return true, if checks if is process chunk
*/
public boolean isProcessChunk() {
return processChunk;
}
/**
* If set to true then {@link #getChunkProcessor()} is used to process chunks,
* else the implementation of {@link NoProcessChunkProcessor}. Throws an
* {@link IllegalStateException} should {@link Streamer#isStreaming()}.
*
* @param processChunk
* the process chunk
*/
public void setProcessChunk(boolean processChunk) {
if (isStreaming()) throw new IllegalStateException("Cannot change header state when streaming");
this.processChunk = processChunk;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getSequence()
*/
public long getSequence() {
return sequence.get();
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#resetSequence(long)
*/
public void resetSequence(long sequence) {
if (isStreaming()) throw new IllegalStateException("Cannot reset sequence when streaming");
BigDecimal bd = new BigDecimal(getEffectiveChunkSize()).multiply(new BigDecimal(sequence));
resetPosition(bd.intValue());
}
private int getEffectiveChunkSize() {
return getChunkSize() - getEffectiveChunkProcessor().sizeInBytes(this);
}
/**
* Reset sequence from position.
*
* @param position
* the position
*/
protected void resetSequenceFromPosition(int position) {
sent.set(position);
if (position == 0) {
sequence.set(0);
return;
}
BigDecimal bd = new BigDecimal(position).divide(new BigDecimal(getEffectiveChunkSize()), 3, RoundingMode.HALF_UP);
sequence.set(bd.longValue());
}
/**
* Next sequence.
*
*/
protected void incrementSequence() {
sequence.incrementAndGet();
}
/**
* Sets the time to await acknowledgements of {@link #isAckRequired()}
* messages before resending. Defaults to 1 second.
*
* @param time
* the value
* @param unit
* the units
*/
public void setAckAwait(int time, TimeUnit unit) {
if (time < 0) throw new IllegalArgumentException("Ack Await must be >= 0: " + time);
if (unit == null) throw new IllegalArgumentException("unit must be specified");
this.ackAwait = time;
this.ackAwaitUnit = unit;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#isEomOnFinish()
*/
public boolean isEomOnFinish() {
return eomOnFinish;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setEomOnFinish(boolean)
*/
public void setEomOnFinish(boolean eomOnFinish) {
this.eomOnFinish = eomOnFinish;
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getFooter()
*/
public Footer getFooter() {
return footer;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setFooter(com.github.mrstampy
* .kitchensync.stream.footer.Footer)
*/
public void setFooter(Footer footer) {
this.footer = footer;
}
/**
* The Class StreamerListener.
*/
protected class StreamerListener implements GenericFutureListener<ChannelFuture> {
/*
* (non-Javadoc)
*
* @see
* io.netty.util.concurrent.GenericFutureListener#operationComplete(io.netty
* .util.concurrent.Future)
*/
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) pause();
if (latch != null) latch.countDown();
}
}
/*
* (non-Javadoc)
*
* @see com.github.mrstampy.kitchensync.stream.Streamer#getChunkProcessor()
*/
public ChunkProcessor getChunkProcessor() {
return chunkProcessor;
}
/*
* (non-Javadoc)
*
* @see
* com.github.mrstampy.kitchensync.stream.Streamer#setChunkProcessor(com.github
* .mrstampy.kitchensync.stream.header.ChunkProcessor)
*/
public void setChunkProcessor(ChunkProcessor chunkProcessor) {
this.chunkProcessor = chunkProcessor;
}
/**
* Invoked from {@link #init()} and invokes {@link ChunkProcessor#reset()}.
*/
protected void resetChunkProcessor() {
if (getChunkProcessor() == null) return;
getChunkProcessor().reset();
}
/**
* Invoked from {@link #init()} and invokes {@link Footer#reset()}.
*/
protected void resetFooter() {
if (getFooter() == null) return;
getFooter().reset();
}
/**
* Returns the microseconds to wait between receiving an acknowledgement and
* sending the next chunk, or between sending chunks when at
* {@link #fullThrottle()}. Values ≤ 0 indicate no throttling. Default of
* zero.
*
* @return the value used to throttle
* @see #isAckRequired()
* @see #awaitAck()
*/
public int getThrottle() {
return throttle;
}
/**
* Sets the microseconds to wait between receiving an acknowledgement and
* sending the next chunk, or between sending chunks when at
* {@link #fullThrottle()}. Values ≤ 0 indicate no throttling. Setting
* while streaming at full throttle has no effect.
*
* @param throttle
* the value used to throttle
* @see #isAckRequired()
* @see #awaitAck()
*/
public void setThrottle(int throttle) {
if (isStreaming() && isFullThrottle()) {
log.warn("Setting the throttle while streaming at full throttle has no effect");
}
this.throttle = throttle;
}
}