com.datastax.driver.core.WriteType Java Examples

@Test
public void handle_WTEWithCasThrown_ShouldThrowProperExecutionException()
    throws ExecutionException {
  // Arrange
  put = preparePutWithClusteringKey();
  put.withCondition(new PutIfNotExists());
  spy = prepareSpiedInsertStatementHandler();

  WriteTimeoutException toThrow = mock(WriteTimeoutException.class);
  when(toThrow.getWriteType()).thenReturn(WriteType.CAS);
  doThrow(toThrow).when(spy).handleInternal(put);

  // Act Assert
  assertThatThrownBy(
          () -> {
            spy.handle(put);
          })
      .isInstanceOf(RetriableExecutionException.class)
      .hasCause(toThrow);
}
 

@Test
public void
    handle_PutWithConditionGivenAndWTEWithSimpleThrown_ShouldThrowProperExecutionException()
        throws ExecutionException {
  // Arrange
  put = preparePutWithClusteringKey();
  put.withCondition(new PutIfNotExists());
  spy = prepareSpiedInsertStatementHandler();

  WriteTimeoutException toThrow = mock(WriteTimeoutException.class);
  when(toThrow.getWriteType()).thenReturn(WriteType.SIMPLE);
  doThrow(toThrow).when(spy).handleInternal(put);

  // Act Assert
  assertThatThrownBy(
          () -> {
            spy.handle(put);
          })
      .isInstanceOf(ReadRepairableExecutionException.class)
      .hasCause(toThrow);
}
 

@Test
public void
    handle_PutWithoutConditionGivenAndWTEWithSimpleThrown_ShouldThrowProperExecutionException()
        throws ExecutionException {
  // Arrange
  put = preparePutWithClusteringKey();
  spy = prepareSpiedInsertStatementHandler();

  WriteTimeoutException toThrow = mock(WriteTimeoutException.class);
  when(toThrow.getWriteType()).thenReturn(WriteType.SIMPLE);
  doThrow(toThrow).when(spy).handleInternal(put);

  // Act Assert
  assertThatThrownBy(
          () -> {
            spy.handle(put);
          })
      .isInstanceOf(RetriableExecutionException.class)
      .hasCause(toThrow);
}
 

@Test
public void handle_WTEThrownInLoggingInBatchExecution_ShouldThrowRetriableExecutionException() {
  // Arrange
  configureBehavior();
  mutations = prepareConditionalPuts();
  WriteTimeoutException e = mock(WriteTimeoutException.class);
  when(e.getWriteType()).thenReturn(WriteType.BATCH_LOG);
  when(session.execute(any(Statement.class))).thenThrow(e);

  // Act Assert
  assertThatThrownBy(
          () -> {
            batch.handle(mutations);
          })
      .isInstanceOf(RetriableExecutionException.class)
      .hasCause(e);
}
 

@Test
public void handle_WTEThrownInMutationInBatchExecution_ShouldExecuteProperly() {
  // Arrange
  configureBehavior();
  mutations = prepareConditionalPuts();
  WriteTimeoutException e = mock(WriteTimeoutException.class);
  when(e.getWriteType()).thenReturn(WriteType.BATCH);
  when(session.execute(any(Statement.class))).thenThrow(e);

  // Act Assert
  assertThatCode(
          () -> {
            batch.handle(mutations);
          })
      .doesNotThrowAnyException();
}
 

@Test
public void handle_WTEThrownInCasInBatchExecution_ShouldThrowRetriableExecutionException() {
  // Arrange
  configureBehavior();
  mutations = prepareConditionalPuts();
  WriteTimeoutException e = mock(WriteTimeoutException.class);
  when(e.getWriteType()).thenReturn(WriteType.CAS);
  when(session.execute(any(Statement.class))).thenThrow(e);

  // Act Assert
  assertThatThrownBy(
          () -> {
            batch.handle(mutations);
          })
      .isInstanceOf(RetriableExecutionException.class)
      .hasCause(e);
}
 

@Test
public void
    handle_WTEThrownInSimpleWriteInBatchExecution_ShouldThrowRetriableExecutionException() {
  // Arrange
  configureBehavior();
  mutations = prepareConditionalPuts();
  WriteTimeoutException e = mock(WriteTimeoutException.class);
  when(e.getWriteType()).thenReturn(WriteType.SIMPLE);
  when(session.execute(any(Statement.class))).thenThrow(e);

  // Act Assert
  assertThatThrownBy(
          () -> {
            batch.handle(mutations);
          })
      .isInstanceOf(RetriableExecutionException.class)
      .hasCause(e);
}
 

@Test
public void maxTimeRetryOnWriteTimeout_shouldRethrow() throws Exception {
    RetryNTimes retryPolicy = new RetryNTimes(3, 3, 3);
    Statement mockStatement = mock( Statement.class );

    RetryPolicy.RetryDecision retryResult = retryPolicy.onWriteTimeout(mockStatement, ConsistencyLevel.LOCAL_ONE, WriteType.BATCH, 1, 0, 3);
    RetryPolicy.RetryDecision retryExpected = RetryPolicy.RetryDecision.rethrow();
    assertRetryDecisionEquals(retryExpected, retryResult);
}
 

@Test
public void firstTimeRetryOnWriteTimeout_shouldRetry() throws Exception {
    RetryNTimes retryPolicy = new RetryNTimes(3, 3, 3);
    Statement mockStatement = mock( Statement.class );
    RetryPolicy.RetryDecision retryResult = retryPolicy.onWriteTimeout(mockStatement, ConsistencyLevel.LOCAL_ONE, WriteType.BATCH, 1, 0, 0);
    RetryPolicy.RetryDecision retryExpected = RetryPolicy.RetryDecision.retry(ConsistencyLevel.LOCAL_ONE);
    assertRetryDecisionEquals(retryExpected, retryResult);
}
 

@Override
public RetryDecision onWriteTimeout(Statement stmnt, ConsistencyLevel cl,
                                    WriteType wt, int requiredResponses,
                                    int receivedResponses, int wTime) {
    if (wTime < writeAttempts) {
        LOG.info(String.format("Retrying on WriteTimeout: stmnt %s, " +
                               "consistency %s, writeType %s, requiredResponse %d, " +
                               "receivedResponse %d, rTime %d",
                stmnt, cl, wt.toString(), requiredResponses, receivedResponses, wTime));
        return RetryDecision.retry(cl);
    }
    return RetryDecision.rethrow();
}
 

@Override
public RetryDecision onWriteTimeout(final Statement statement, final ConsistencyLevel cl, final WriteType writeType,
                                    final int requiredAcks, final int receivedAcks, final int nbRetry) {

  final RetryDecision decision = delegate.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry);
  for (final TagMetrics c : tagMetrics) {
    c.writeTimeouts.inc();
  }
  return decision;
}
 

@Override
public RetryDecision onWriteTimeout(Statement stmnt, ConsistencyLevel cl, WriteType wt,
    int requiredResponses, int receivedResponses, int wTime) {
  if (wTime >= writeAttempts)
    return RetryDecision.rethrow();

  return RetryDecision.retry(cl);
}
 

@Override
public RetryDecision onWriteTimeout(Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry) {
    if (cl == ConsistencyLevel.ALL) {
        log(statement);
    }
    return DefaultRetryPolicy.INSTANCE.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry);
}
 

@Override
public RetryDecision onWriteTimeout(
    Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks,
    int receivedAcks, int nbRetry
) {
    if (nbRetry != 0) {
        return RetryDecision.rethrow();
    }

    // If the batch log write failed, retry the operation as this might just be we were
    // unlucky at picking candidates
    return writeType == WriteType.BATCH_LOG ? RetryDecision.retry(cl) : RetryDecision.rethrow();
}
 

@Override
public RetryDecision onWriteTimeout(
    Statement stmt,
    ConsistencyLevel cl,
    WriteType type,
    int required,
    int received,
    int retry) {

  Preconditions.checkState(WriteType.CAS != type ||  ConsistencyLevel.SERIAL == cl);

  return null != stmt && !Objects.equals(Boolean.FALSE, stmt.isIdempotent())
      ? WriteType.CAS == type ? RetryDecision.retry(ConsistencyLevel.ONE) : RetryDecision.retry(cl)
      : DefaultRetryPolicy.INSTANCE.onWriteTimeout(stmt, cl, type, required, received, retry);
}
 

@Test
public void testShouldExtractWriteTypes() {
  assertThat(extract(SIMPLE)).isSameAs(WriteType.SIMPLE);
  assertThat(extract(BATCH)).isSameAs(WriteType.BATCH);
  assertThat(extract(UNLOGGED_BATCH)).isSameAs(WriteType.UNLOGGED_BATCH);
  assertThat(extract(COUNTER)).isSameAs(WriteType.COUNTER);
  assertThat(extract(BATCH_LOG)).isSameAs(WriteType.BATCH_LOG);
  assertThat(extract(CAS)).isSameAs(WriteType.CAS);
}
 

@Test
public void testShouldAdaptWriteTypes() {
  assertThat(adapt(WriteType.SIMPLE)).isSameAs(SIMPLE);
  assertThat(adapt(WriteType.BATCH)).isSameAs(BATCH);
  assertThat(adapt(WriteType.UNLOGGED_BATCH)).isSameAs(UNLOGGED_BATCH);
  assertThat(adapt(WriteType.COUNTER)).isSameAs(COUNTER);
  assertThat(adapt(WriteType.BATCH_LOG)).isSameAs(BATCH_LOG);
  assertThat(adapt(WriteType.CAS)).isSameAs(CAS);
}
 

@Override
public RetryDecision onWriteTimeout(Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry)
{
    return DefaultRetryPolicy.INSTANCE.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry);
}
 

@Override
public RetryDecision onWriteTimeout(Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry) {
    return RetryDecision.retry(cl);
}
 

@Test
public void testShouldAdaptExtractWriteTypes() {
  for (WriteType w : WriteType.values()) {
    assertThat(extract(adapt(w))).isSameAs(w);
  }
}