@Test(groups = "unit") public void should_expose_decision_properties() throws Throwable { RetryDecision retryAtOne = RetryDecision.retry(ONE); assertThat(retryAtOne.getType()).isEqualTo(RETRY); assertThat(retryAtOne.getRetryConsistencyLevel()).isEqualTo(ONE); assertThat(retryAtOne.isRetryCurrent()).isTrue(); assertThat(retryAtOne.toString()).isEqualTo("Retry at ONE on same host."); RetryDecision tryNextAtOne = RetryDecision.tryNextHost(ONE); assertThat(tryNextAtOne.getType()).isEqualTo(RETRY); assertThat(tryNextAtOne.getRetryConsistencyLevel()).isEqualTo(ONE); assertThat(tryNextAtOne.isRetryCurrent()).isFalse(); assertThat(tryNextAtOne.toString()).isEqualTo("Retry at ONE on next host."); RetryDecision rethrow = RetryDecision.rethrow(); assertThat(rethrow.getType()).isEqualTo(RETHROW); assertThat(rethrow.toString()).isEqualTo("Rethrow"); RetryDecision ignore = RetryDecision.ignore(); assertThat(ignore.getType()).isEqualTo(IGNORE); assertThat(ignore.toString()).isEqualTo("Ignore"); } }
private void processRetryDecision( RetryPolicy.RetryDecision retryDecision, Connection connection, Exception exceptionToReport) { switch (retryDecision.getType()) { case RETRY: retriesByPolicy++; if (logger.isDebugEnabled()) logger.debug( "[{}] Doing retry {} for query {} at consistency {}", id, retriesByPolicy, statement, retryDecision.getRetryConsistencyLevel()); if (metricsEnabled()) metrics().getErrorMetrics().getRetries().inc(); // log error for the current host if we are switching to another one if (!retryDecision.isRetryCurrent()) logError(connection.address, exceptionToReport); retry(retryDecision.isRetryCurrent(), retryDecision.getRetryConsistencyLevel()); break; case RETHROW: setFinalException(connection, exceptionToReport); break; case IGNORE: if (metricsEnabled()) metrics().getErrorMetrics().getIgnores().inc(); setFinalResult(connection, new Responses.Result.Void()); break; } }
if (exception instanceof OperationTimedOutException) { metrics().getErrorMetrics().getClientTimeouts().inc(); if (decision.getType() == Type.RETRY) metrics().getErrorMetrics().getRetriesOnClientTimeout().inc(); if (decision.getType() == Type.IGNORE) metrics().getErrorMetrics().getIgnoresOnClientTimeout().inc(); } else if (exception instanceof ConnectionException) { metrics().getErrorMetrics().getConnectionErrors().inc(); if (decision.getType() == Type.RETRY) metrics().getErrorMetrics().getRetriesOnConnectionError().inc(); if (decision.getType() == Type.IGNORE) metrics().getErrorMetrics().getIgnoresOnConnectionError().inc(); } else { metrics().getErrorMetrics().getOthers().inc(); if (decision.getType() == Type.RETRY) metrics().getErrorMetrics().getRetriesOnOtherErrors().inc(); if (decision.getType() == Type.IGNORE) metrics().getErrorMetrics().getIgnoresOnOtherErrors().inc();
@Override public RetryDecision onRequestError(Statement statement, ConsistencyLevel cl, DriverException e, int nbRetry) { RetryDecision decision = policy.onRequestError(statement, cl, e, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_REQUEST_ERROR, cl, nbRetry, e); break; case RETRY: logDecision(RETRYING_ON_REQUEST_ERROR, host(decision), cl(cl, decision), cl, nbRetry, e); break; } return decision; }
@Override public RetryDecision onWriteTimeout(Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry) { RetryDecision decision = policy.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_WRITE_TIMEOUT, cl, writeType, requiredAcks, receivedAcks, nbRetry); break; case RETRY: logDecision(RETRYING_ON_WRITE_TIMEOUT, host(decision), cl(cl, decision), cl, writeType, requiredAcks, receivedAcks, nbRetry); break; } return decision; }
@Override public RetryDecision onUnavailable(Statement statement, ConsistencyLevel cl, int requiredReplica, int aliveReplica, int nbRetry) { RetryDecision decision = policy.onUnavailable(statement, cl, requiredReplica, aliveReplica, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_UNAVAILABLE, cl, requiredReplica, aliveReplica, nbRetry); break; case RETRY: logDecision(RETRYING_ON_UNAVAILABLE, host(decision), cl(cl, decision), cl, requiredReplica, aliveReplica, nbRetry); break; } return decision; }
@Override public RetryDecision onWriteTimeout(Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry) { RetryDecision decision = policy.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_WRITE_TIMEOUT, cl, writeType, requiredAcks, receivedAcks, nbRetry); break; case RETRY: logDecision(RETRYING_ON_WRITE_TIMEOUT, host(decision), cl(cl, decision), cl, writeType, requiredAcks, receivedAcks, nbRetry); break; } return decision; }
@Override public RetryDecision onWriteTimeout(Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry) { RetryDecision decision = policy.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_WRITE_TIMEOUT, cl, writeType, requiredAcks, receivedAcks, nbRetry); break; case RETRY: logDecision(RETRYING_ON_WRITE_TIMEOUT, host(decision), cl(cl, decision), cl, writeType, requiredAcks, receivedAcks, nbRetry); break; } return decision; }
@Override public RetryDecision onReadTimeout(Statement statement, ConsistencyLevel cl, int requiredResponses, int receivedResponses, boolean dataRetrieved, int nbRetry) { RetryDecision decision = policy.onReadTimeout(statement, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_READ_TIMEOUT, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); break; case RETRY: logDecision(RETRYING_ON_READ_TIMEOUT, host(decision), cl(cl, decision), cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); break; } return decision; }
@Override public RetryDecision onUnavailable(Statement statement, ConsistencyLevel cl, int requiredReplica, int aliveReplica, int nbRetry) { RetryDecision decision = policy.onUnavailable(statement, cl, requiredReplica, aliveReplica, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_UNAVAILABLE, cl, requiredReplica, aliveReplica, nbRetry); break; case RETRY: logDecision(RETRYING_ON_UNAVAILABLE, host(decision), cl(cl, decision), cl, requiredReplica, aliveReplica, nbRetry); break; } return decision; }
@Override public RetryDecision onRequestError(Statement statement, ConsistencyLevel cl, DriverException e, int nbRetry) { RetryDecision decision = policy.onRequestError(statement, cl, e, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_REQUEST_ERROR, cl, nbRetry, e); break; case RETRY: logDecision(RETRYING_ON_REQUEST_ERROR, host(decision), cl(cl, decision), cl, nbRetry, e); break; } return decision; }
@Override public RetryDecision onReadTimeout(Statement statement, ConsistencyLevel cl, int requiredResponses, int receivedResponses, boolean dataRetrieved, int nbRetry) { RetryDecision decision = policy.onReadTimeout(statement, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_READ_TIMEOUT, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); break; case RETRY: logDecision(RETRYING_ON_READ_TIMEOUT, host(decision), cl(cl, decision), cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); break; } return decision; }
@Override public RetryDecision onRequestError(Statement statement, ConsistencyLevel cl, DriverException e, int nbRetry) { RetryDecision decision = policy.onRequestError(statement, cl, e, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_REQUEST_ERROR, cl, nbRetry, e); break; case RETRY: logDecision(RETRYING_ON_REQUEST_ERROR, host(decision), cl(cl, decision), cl, nbRetry, e); break; } return decision; }
@Override public RetryDecision onReadTimeout(Statement statement, ConsistencyLevel cl, int requiredResponses, int receivedResponses, boolean dataRetrieved, int nbRetry) { RetryDecision decision = policy.onReadTimeout(statement, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_READ_TIMEOUT, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); break; case RETRY: logDecision(RETRYING_ON_READ_TIMEOUT, host(decision), cl(cl, decision), cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); break; } return decision; }
@Override public RetryDecision onUnavailable(Statement statement, ConsistencyLevel cl, int requiredReplica, int aliveReplica, int nbRetry) { RetryDecision decision = policy.onUnavailable(statement, cl, requiredReplica, aliveReplica, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_UNAVAILABLE, cl, requiredReplica, aliveReplica, nbRetry); break; case RETRY: logDecision(RETRYING_ON_UNAVAILABLE, host(decision), cl(cl, decision), cl, requiredReplica, aliveReplica, nbRetry); break; } return decision; }
if (metricsEnabled()) { metrics().getErrorMetrics().getReadTimeouts().inc(); if (retry.getType() == Type.RETRY) metrics().getErrorMetrics().getRetriesOnReadTimeout().inc(); if (retry.getType() == Type.IGNORE) metrics().getErrorMetrics().getIgnoresOnReadTimeout().inc(); if (retry.getType() == Type.RETRY) metrics().getErrorMetrics().getRetriesOnWriteTimeout().inc(); if (retry.getType() == Type.IGNORE) metrics().getErrorMetrics().getIgnoresOnWriteTimeout().inc(); if (metricsEnabled()) { metrics().getErrorMetrics().getUnavailables().inc(); if (retry.getType() == Type.RETRY) metrics().getErrorMetrics().getRetriesOnUnavailable().inc(); if (retry.getType() == Type.IGNORE) metrics().getErrorMetrics().getIgnoresOnUnavailable().inc();
policy.onReadTimeout( statement, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(
@Override public RetryDecision onUnavailable( Statement statement, ConsistencyLevel cl, int requiredReplica, int aliveReplica, int nbRetry) { RetryDecision decision = policy.onUnavailable(statement, cl, requiredReplica, aliveReplica, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_UNAVAILABLE, cl, requiredReplica, aliveReplica, nbRetry); break; case RETRY: logDecision( RETRYING_ON_UNAVAILABLE, host(decision), cl(cl, decision), cl, requiredReplica, aliveReplica, nbRetry); break; } return decision; }
@Override public RetryDecision onWriteTimeout( Statement statement, ConsistencyLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbRetry) { RetryDecision decision = policy.onWriteTimeout(statement, cl, writeType, requiredAcks, receivedAcks, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_WRITE_TIMEOUT, cl, writeType, requiredAcks, receivedAcks, nbRetry); break; case RETRY: logDecision( RETRYING_ON_WRITE_TIMEOUT, host(decision), cl(cl, decision), cl, writeType, requiredAcks, receivedAcks, nbRetry); break; } return decision; }
@Override public RetryDecision onRequestError( Statement statement, ConsistencyLevel cl, DriverException e, int nbRetry) { RetryDecision decision = policy.onRequestError(statement, cl, e, nbRetry); switch (decision.getType()) { case IGNORE: logDecision(IGNORING_REQUEST_ERROR, cl, nbRetry, e.toString()); break; case RETRY: logDecision( RETRYING_ON_REQUEST_ERROR, host(decision), cl(cl, decision), cl, nbRetry, e.toString()); break; } return decision; }