protected SkipPolicy createSkipPolicy() { SkipPolicy skipPolicy = this.skipPolicy; Map<Class<? extends Throwable>, Boolean> map = new HashMap<>( skippableExceptionClasses); map.put(ForceRollbackForWriteSkipException.class, true); LimitCheckingItemSkipPolicy limitCheckingItemSkipPolicy = new LimitCheckingItemSkipPolicy(skipLimit, map); if (skipPolicy == null) { Assert.state(!(skippableExceptionClasses.isEmpty() && skipLimit > 0), "If a skip limit is provided then skippable exceptions must also be specified"); skipPolicy = limitCheckingItemSkipPolicy; } else if (limitCheckingItemSkipPolicy != null) { skipPolicy = new CompositeSkipPolicy(new SkipPolicy[] { skipPolicy, limitCheckingItemSkipPolicy }); } return skipPolicy; }
@Test public void testNonSkippableException() { assertFalse(failurePolicy.shouldSkip(new FileNotFoundException(), 2)); }
private LimitCheckingItemSkipPolicy getFatalSubsetSkipPolicy() { Map<Class<? extends Throwable>, Boolean> skippableExceptions = new HashMap<>(); skippableExceptions.put(WriteFailedException.class, false); skippableExceptions.put(ItemWriterException.class, true); return new LimitCheckingItemSkipPolicy(1, skippableExceptions); }
/** * condition: fatal < skippable; exception is unclassified * * expected: false; default classification */ @Test public void testFatalSubset_unclassified() { assertFalse(getFatalSubsetSkipPolicy().shouldSkip(new RuntimeException(), 0)); }
private LimitCheckingItemSkipPolicy getSkippableSubsetSkipPolicy() { Map<Class<? extends Throwable>, Boolean> skippableExceptions = new HashMap<>(); skippableExceptions.put(WriteFailedException.class, true); skippableExceptions.put(ItemWriterException.class, false); return new LimitCheckingItemSkipPolicy(1, skippableExceptions); }
/** * condition: skippable < fatal; exception is unclassified * * expected: false; default classification */ @Test public void testSkippableSubset_unclassified() { assertFalse(getSkippableSubsetSkipPolicy().shouldSkip(new RuntimeException(), 0)); }
@Before public void setUp() throws Exception { Map<Class<? extends Throwable>, Boolean> skippableExceptions = new HashMap<>(); skippableExceptions.put(FlatFileParseException.class, true); failurePolicy = new LimitCheckingItemSkipPolicy(1, skippableExceptions); }
@Test public void testLimitExceed() { try { failurePolicy.shouldSkip(new FlatFileParseException("", ""), 2); fail(); } catch (SkipLimitExceededException ex) { // expected } }
/** * Check items causing errors are skipped as expected. */ @Test public void testReadSkipWithPolicy() throws Exception { // Should be ignored factory.setSkipLimit(0); factory.setSkipPolicy(new LimitCheckingItemSkipPolicy(2, Collections .<Class<? extends Throwable>, Boolean> singletonMap(Exception.class, true))); testReadSkip(); }
@Test public void testSkip() { assertTrue(failurePolicy.shouldSkip(new FlatFileParseException("", ""), 0)); }
@Test public void testProvideWithOverflow() throws Exception { provider = new FaultTolerantChunkProvider<>(new ItemReader<String>() { @Override public String read() throws Exception, UnexpectedInputException, ParseException { throw new RuntimeException("Planned"); } }, new RepeatTemplate()); provider.setSkipPolicy(new LimitCheckingItemSkipPolicy(Integer.MAX_VALUE, Collections.<Class<? extends Throwable>,Boolean>singletonMap(Exception.class, Boolean.TRUE))); provider.setMaxSkipsOnRead(10); Chunk<String> chunk = null; chunk = provider.provide(contribution); assertNotNull(chunk); assertEquals(0, chunk.getItems().size()); assertEquals(10, chunk.getErrors().size()); } }
/** * condition: skippable < fatal; exception is fatal * * expected: false */ @Test public void testSkippableSubset_fatal() { assertFalse(getSkippableSubsetSkipPolicy().shouldSkip(new WriterNotOpenException(""), 0)); }
retryPolicy.setMaxAttempts(2); batchRetryTemplate.setRetryPolicy(retryPolicy); processor.setWriteSkipPolicy(new LimitCheckingItemSkipPolicy(1, Collections.<Class<? extends Throwable>, Boolean> singletonMap( IllegalArgumentException.class, true)));
/** * condition: fatal < skippable; exception is skippable * * expected: true */ @Test public void testFatalSubset_skippable() { assertTrue(getFatalSubsetSkipPolicy().shouldSkip(new WriterNotOpenException(""), 0)); }
protected SkipPolicy createSkipPolicy() { SkipPolicy skipPolicy = this.skipPolicy; Map<Class<? extends Throwable>, Boolean> map = new HashMap<Class<? extends Throwable>, Boolean>( skippableExceptionClasses); map.put(ForceRollbackForWriteSkipException.class, true); LimitCheckingItemSkipPolicy limitCheckingItemSkipPolicy = new LimitCheckingItemSkipPolicy(skipLimit, map); if (skipPolicy == null) { Assert.state(!(skippableExceptionClasses.isEmpty() && skipLimit > 0), "If a skip limit is provided then skippable exceptions must also be specified"); skipPolicy = limitCheckingItemSkipPolicy; } else if (limitCheckingItemSkipPolicy != null) { skipPolicy = new CompositeSkipPolicy(new SkipPolicy[] { skipPolicy, limitCheckingItemSkipPolicy }); } return skipPolicy; }
/** * condition: fatal < skippable; exception is fatal * * expected: false */ @Test public void testFatalSubset_fatal() { assertFalse(getFatalSubsetSkipPolicy().shouldSkip(new WriteFailedException(""), 0)); } }
protected SkipPolicy createSkipPolicy() { SkipPolicy skipPolicy = this.skipPolicy; Map<Class<? extends Throwable>, Boolean> map = new HashMap<Class<? extends Throwable>, Boolean>( skippableExceptionClasses); map.put(ForceRollbackForWriteSkipException.class, true); LimitCheckingItemSkipPolicy limitCheckingItemSkipPolicy = new LimitCheckingItemSkipPolicy(skipLimit, map); if (skipPolicy == null) { Assert.state(!(skippableExceptionClasses.isEmpty() && skipLimit > 0), "If a skip limit is provided then skippable exceptions must also be specified"); skipPolicy = limitCheckingItemSkipPolicy; } else if (limitCheckingItemSkipPolicy != null) { skipPolicy = new CompositeSkipPolicy(new SkipPolicy[] { skipPolicy, limitCheckingItemSkipPolicy }); } return skipPolicy; }
/** * condition: skippable < fatal; exception is skippable * * expected: true */ @Test public void testSkippableSubset_skippable() { assertTrue(getSkippableSubsetSkipPolicy().shouldSkip(new WriteFailedException(""), 0)); }
protected SkipPolicy createSkipPolicy() { SkipPolicy skipPolicy = this.skipPolicy; Map<Class<? extends Throwable>, Boolean> map = new HashMap<Class<? extends Throwable>, Boolean>( skippableExceptionClasses); map.put(ForceRollbackForWriteSkipException.class, true); LimitCheckingItemSkipPolicy limitCheckingItemSkipPolicy = new LimitCheckingItemSkipPolicy(skipLimit, map); if (skipPolicy == null) { Assert.state(!(skippableExceptionClasses.isEmpty() && skipLimit > 0), "If a skip limit is provided then skippable exceptions must also be specified"); skipPolicy = limitCheckingItemSkipPolicy; } else if (limitCheckingItemSkipPolicy != null) { skipPolicy = new CompositeSkipPolicy(new SkipPolicy[] { skipPolicy, limitCheckingItemSkipPolicy }); } return skipPolicy; }
/** * @return {@link ChunkProvider} configured for fault-tolerance. */ @Override protected SimpleChunkProvider<T> configureChunkProvider() { if (skipPolicy != null) { if (!skippableExceptionClasses.isEmpty()) { logger.info("Skippable exceptions will be ignored because a SkipPolicy was specified explicitly"); } if (skipLimit > 0) { logger.info("Skip limit will be ignored because a SkipPolicy was specified explicitly"); } } SkipPolicy readSkipPolicy = skipPolicy != null ? skipPolicy : new LimitCheckingItemSkipPolicy(skipLimit, getSkippableExceptionClasses()); readSkipPolicy = getFatalExceptionAwareProxy(readSkipPolicy); FaultTolerantChunkProvider<T> chunkProvider = new FaultTolerantChunkProvider<T>(getItemReader(), getChunkOperations()); chunkProvider.setMaxSkipsOnRead(Math.max(getCommitInterval(), FaultTolerantChunkProvider.DEFAULT_MAX_SKIPS_ON_READ)); chunkProvider.setSkipPolicy(readSkipPolicy); chunkProvider.setRollbackClassifier(getRollbackClassifier()); return chunkProvider; }