@Override protected Chunk<O> getAdjustedOutputs(Chunk<I> inputs, Chunk<O> outputs) { @SuppressWarnings("unchecked") UserData<O> data = (UserData<O>) inputs.getUserData(); Chunk<O> previous = data.getOutputs(); Chunk<O> next = new Chunk<>(outputs.getItems(), previous.getSkips()); next.setBusy(previous.isBusy()); // Remember for next time if there are skips accumulating data.setOutputs(next); return next; }
public <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, Collection<RetryState> states) throws E, Exception { RetryState batchState = new BatchRetryState(states); return delegate.execute(retryCallback, batchState); }
/** * Overrides the buffering settings in the chunk processor if it is fault tolerant. * @param chunkProcessor the chunk processor that is going to be used in the workers */ private void setNonBuffering(ChunkProcessor<T> chunkProcessor) { if (chunkProcessor instanceof FaultTolerantChunkProcessor<?, ?>) { ((FaultTolerantChunkProcessor<?, ?>) chunkProcessor).setBuffering(false); } }
@Override protected void initializeUserData(Chunk<I> inputs) { @SuppressWarnings("unchecked") UserData<O> data = (UserData<O>) inputs.getUserData(); if (data == null) { data = new UserData<>(); inputs.setUserData(data); data.setOutputs(new Chunk<>()); } else { // BATCH-2663: re-initialize filter count when scanning the chunk if (data.scanning()) { data.filterCount = 0; } } }
/** * @param chunk Chunk to recover */ private void recover(Chunk<String> chunk) throws Exception { for (Chunk<String>.ChunkIterator iterator = chunk.iterator(); iterator.hasNext();) { String string = iterator.next(); try { doWrite(Collections.singletonList(string)); } catch (Exception e) { iterator.remove(e); throw e; } } }
/** * Creates a {@link PassThroughItemProcessor} and uses it to create an * instance of {@link Tasklet}. */ public TestingChunkOrientedTasklet(ItemReader<T> itemReader, ItemProcessor<T, T> itemProcessor, ItemWriter<T> itemWriter, RepeatOperations repeatOperations) { super(new SimpleChunkProvider<>(itemReader, repeatOperations), new SimpleChunkProcessor<>( itemProcessor, itemWriter)); }
public void incrementOffset() { ChunkMonitorData data = getData(); data.offset ++; if (data.offset >= data.chunkSize) { resetOffset(); } }
@Override protected String read(StepContribution contribution, Chunk<String> chunk) throws SkipOverflowException, Exception { chunk.skip(new RuntimeException("Planned")); throw new SkipOverflowException("Overflow"); } };
@Override public Chunk<T> provide(StepContribution contribution) throws Exception { return new Chunk<>(); }
/** * Register some {@link StepListener}s with the handler. Each will get the * callbacks in the order specified at the correct stage. * * @param listeners list of {@link StepListener}s. */ public void setListeners(List<? extends StepListener> listeners) { for (StepListener listener : listeners) { registerListener(listener); } }
/** * Register some {@link StepListener}s with the handler. Each will get the * callbacks in the order specified at the correct stage. * * @param listeners list of {@link StepListener} instances. */ public void setListeners(List<? extends StepListener> listeners) { for (StepListener listener : listeners) { registerListener(listener); } }
@Override protected int getFilterCount(Chunk<I> inputs, Chunk<O> outputs) { @SuppressWarnings("unchecked") UserData<O> data = (UserData<O>) inputs.getUserData(); return data.filterCount; }
/** * Extension point for subclasses that want to store additional data in the * inputs. Default just checks if inputs are empty. * * @param inputs the input chunk * @return true if it is empty * * @see #initializeUserData(Chunk) */ protected boolean isComplete(Chunk<I> inputs) { return inputs.isEmpty(); }
private Object getInputKey(I item) { if (keyGenerator == null) { return item; } return keyGenerator.getKey(item); }
/** * Get an unmodifiable iterator for the underlying items. * @see java.lang.Iterable#iterator() */ @Override public ChunkIterator iterator() { return new ChunkIterator(items); }
public FaultTolerantStepFactoryBeanTests() throws Exception { reader = new SkipReaderStub<>(); processor = new SkipProcessorStub<>(); writer = new SkipWriterStub<>(); }
@Override public void write(List<? extends String> items) { throw new FatalRuntimeException("Ouch!"); } });
public <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback, Collection<RetryState> states) throws E, Exception { RetryState batchState = new BatchRetryState(states); return delegate.execute(retryCallback, recoveryCallback, batchState); }