@Override public HandlerResult retry(byte[] retryData) { currentRetry = retryData; return retry(); }
@Override public HandlerResult onError(BulkWriteFailure entry, DelayableErrorCollector<byte[]> collector) throws Exception { // BWC: Versions before 2.x have no status on failure. In those cases we check the error message contents. boolean legacyRetry = entry.getResponseCode() == -1 && entry.getException().getMessage().contains("EsRejectedExecutionException"); if (legacyRetry || retry.retry(entry.getResponseCode())) { // Negative retry limit? Retry forever. if (retryLimit < 0 || entry.getNumberOfAttempts() <= retryLimit) { return collector.backoffAndRetry(retryTime, TimeUnit.MILLISECONDS); } else { return collector.pass("Document bulk write attempts [" + entry.getNumberOfAttempts() + "] exceeds configured automatic retry limit of [" + retryLimit + "]"); } } else { return collector.pass("Non retryable code [" + entry.getResponseCode() + "] encountered."); } } }
@Override public HandlerResult onError(BulkWriteFailure entry, DelayableErrorCollector<byte[]> collector) throws Exception { return collector.retry(); // NEVER GIVE UP } }
@Test public void retry1() throws Exception { assertEquals(HandlerResult.HANDLED, collector.retry(new byte[]{0, 1, 2, 3, 4, 5})); assertEquals(true, collector.receivedRetries()); assertEquals(null, collector.getAndClearMessage()); assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5}, collector.getAndClearRetryValue()); assertEquals(0L, collector.getDelayTimeBetweenRetries()); assertEquals(false, collector.receivedRetries()); }
@Test public void backoffAndRetry() throws Exception { assertEquals(HandlerResult.HANDLED, collector.backoffAndRetry(100L, TimeUnit.MILLISECONDS)); assertEquals(true, collector.receivedRetries()); assertEquals(null, collector.getAndClearMessage()); assertEquals(null, collector.getAndClearRetryValue()); assertEquals(100L, collector.getDelayTimeBetweenRetries()); assertEquals(false, collector.receivedRetries()); }
@Override public String convert(BulkWriteFailure entry) { return String.format( "Dropping failed bulk entry (response [%s] from server) after [%s] attempts due to error [%s]:%n" + "Entry Contents:%n%s", entry.getResponseCode(), entry.getNumberOfAttempts(), entry.getException().getMessage(), ((FastByteArrayInputStream) entry.getEntryContents()).bytes().toString() ); } }
@Test public void pass() throws Exception { assertEquals(HandlerResult.PASS, collector.pass("Pass reason")); assertEquals(false, collector.receivedRetries()); assertEquals("Pass reason", collector.getAndClearMessage()); assertEquals(null, collector.getAndClearRetryValue()); assertEquals(0L, collector.getDelayTimeBetweenRetries()); }
attemptCount++; if (attemptCount == 1) { assertEquals(1, entry.getNumberOfAttempts()); assertEquals(401, entry.getResponseCode()); return collector.retry(((FastByteArrayInputStream)entry.getEntryContents()).bytes().bytes()); } else if (attemptCount == 2) { assertEquals(2, entry.getNumberOfAttempts()); assertEquals(402, entry.getResponseCode()); return collector.retry(copyDoc); } else if (attemptCount == 3) { assertEquals(3, entry.getNumberOfAttempts()); assertEquals(403, entry.getResponseCode()); return collector.retry(newData.getBytes(Charsets.UTF_8)); } else if (attemptCount == 4) { assertEquals(1, entry.getNumberOfAttempts()); // New document should reset attempt count assertEquals(404, entry.getResponseCode()); return collector.retry(); } else { throw new AssertionError("Invalid attempts");
@Override public HandlerResult onError(BulkWriteFailure entry, DelayableErrorCollector<byte[]> collector) throws Exception { assertEquals(401, entry.getResponseCode()); // Copy the bytes into a byte array and retry the byte array. byte[] copyDoc = copyDocumentBytes(entry); copyDoc[25] = (byte) (copyDoc[25] + 1); return collector.retry(copyDoc); } }
/** * Visible for testing */ @Override public String getRawEvent(BulkWriteFailure event) throws IOException { return IOUtils.asString(event.getEntryContents()); } }
@Before public void setUp() throws Exception { collector = new BulkWriteErrorCollector(); }
/** * Flushes and closes the bulk processor to further writes. */ @Override public void close() { try { if (!hadWriteErrors) { flush(); } else { if (LOG.isDebugEnabled()) { LOG.debug("Dirty close; ignoring last existing write batch..."); } } if (requiresRefreshAfterBulk && executedBulkWrite) { // refresh batch restClient.refresh(resource); if (LOG.isDebugEnabled()) { LOG.debug(String.format("Refreshing index [%s]", resource)); } } } finally { for (IBulkWriteErrorHandler handler : documentBulkErrorHandlers) { handler.close(); } } }
@Test public void retry() throws Exception { assertEquals(HandlerResult.HANDLED, collector.retry()); assertEquals(true, collector.receivedRetries()); assertEquals(null, collector.getAndClearMessage()); assertEquals(null, collector.getAndClearRetryValue()); assertEquals(0L, collector.getDelayTimeBetweenRetries()); assertEquals(false, collector.receivedRetries()); }
@Test public void backoffAndRetry1() throws Exception { assertEquals(HandlerResult.HANDLED, collector.backoffAndRetry(new byte[]{0, 1, 2, 3, 4, 5}, 100L, TimeUnit.MILLISECONDS)); assertEquals(true, collector.receivedRetries()); assertEquals(null, collector.getAndClearMessage()); assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5}, collector.getAndClearRetryValue()); assertEquals(100L, collector.getDelayTimeBetweenRetries()); assertEquals(false, collector.receivedRetries()); }
@Override public HandlerResult backoffAndRetry(byte[] retryData, long timeAmount, TimeUnit timeUnits) { long givenDelayTimeInMillis = timeUnits.toMillis(timeAmount); if (givenDelayTimeInMillis > delayTimeInMillis) { delayTimeInMillis = givenDelayTimeInMillis; } return retry(retryData); }
private static byte[] copyDocumentBytes(BulkWriteFailure entry) throws IOException { InputStream inputStream = entry.getEntryContents(); int docLen = inputStream.available(); byte[] copyDoc = new byte[docLen]; int read = inputStream.read(copyDoc); assertEquals(docLen, read); assertEquals(0, inputStream.available()); assertEquals(-1, inputStream.read()); return copyDoc; } }
@Override public HandlerResult onError(BulkWriteFailure entry, DelayableErrorCollector<byte[]> collector) throws Exception { byte[] data = copyDocumentBytes(entry); byte[] sansNewline = new byte[data.length - 1]; System.arraycopy(data, 0, sansNewline, 0, sansNewline.length); return collector.retry(sansNewline); } }
@Override public HandlerResult backoffAndRetry(long timeAmount, TimeUnit timeUnits) { long givenDelayTimeInMillis = timeUnits.toMillis(timeAmount); if (givenDelayTimeInMillis > delayTimeInMillis) { delayTimeInMillis = givenDelayTimeInMillis; } return retry(); }
@Override public HandlerResult onError(BulkWriteFailure entry, DelayableErrorCollector<byte[]> collector) throws Exception { byte[] garbage = "{\"element\": \"A\"}".getBytes(); return collector.retry(garbage); } }
@Override public HandlerResult onError(BulkWriteFailure entry, DelayableErrorCollector<byte[]> collector) throws Exception { byte[] garbage = "{\"element\": \"A\"}\n".getBytes(); return collector.retry(garbage); } }