public RetryPolicy getRetryPolicy() { if (this.retryPolicyName.equals(DowngradingConsistencyRetryPolicy.class.getSimpleName())) { return new LoggingRetryPolicy(DowngradingConsistencyRetryPolicy.INSTANCE); } if (this.retryPolicyName.equals(FallthroughRetryPolicy.class.getSimpleName())) { return FallthroughRetryPolicy.INSTANCE; } if (this.retryPolicyName.equals(DefaultRetryPolicy.class.getSimpleName())) { return DefaultRetryPolicy.INSTANCE; } throw new IllegalArgumentException("Unknown cassandra retry policy " + this.retryPolicyName); }
@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; }
@Test(groups = "short") public void should_call_init_method_on_inner_policy() { RetryPolicy innerPolicyMock = Mockito.mock(RetryPolicy.class); new LoggingRetryPolicy(innerPolicyMock).init(cluster); Mockito.verify(innerPolicyMock).init(cluster); }
@Test(groups = "unit") public void should_call_close_method_on_inner_policy() { RetryPolicy innerPolicyMock = Mockito.mock(RetryPolicy.class); new LoggingRetryPolicy(innerPolicyMock).close(); Mockito.verify(innerPolicyMock).close(); }
@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: String f1 = "Ignoring write timeout (initial consistency: %s, write type: %s, required acknowledgments: %d, received acknowledgments: %d, retries: %d)"; logger.info(String.format(f1, cl, writeType, requiredAcks, receivedAcks, nbRetry)); break; case RETRY: String f2 = "Retrying on write timeout at consistency %s(initial consistency: %s, write type: %s, required acknowledgments: %d, received acknowledgments: %d, retries: %d)"; logger.info(String.format(f2, cl(cl, decision), cl, writeType, requiredAcks, receivedAcks, nbRetry)); break; } return decision; }
@Test(groups = "short") public void should_call_init_method_on_inner_policy() { RetryPolicy innerPolicyMock = Mockito.mock(RetryPolicy.class); new LoggingRetryPolicy(innerPolicyMock).init(cluster); Mockito.verify(innerPolicyMock).init(cluster); }
@Test(groups = "unit") public void should_call_close_method_on_inner_policy() { RetryPolicy innerPolicyMock = Mockito.mock(RetryPolicy.class); new LoggingRetryPolicy(innerPolicyMock).close(); Mockito.verify(innerPolicyMock).close(); }
@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: String f1 = "Ignoring read timeout (initial consistency: %s, required responses: %d, received responses: %d, data retrieved: %b, retries: %d)"; logger.info(String.format(f1, cl, requiredResponses, receivedResponses, dataRetrieved, nbRetry)); break; case RETRY: String f2 = "Retrying on read timeout at consistency %s (initial consistency: %s, required responses: %d, received responses: %d, data retrieved: %b, retries: %d)"; logger.info(String.format(f2, cl(cl, decision), cl, requiredResponses, receivedResponses, dataRetrieved, 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; }
retryPolicy = new LoggingRetryPolicy(retryPolicy);
@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: String f1 = "Ignoring unavailable exception (initial consistency: %s, required replica: %d, alive replica: %d, retries: %d)"; logger.info(String.format(f1, cl, requiredReplica, aliveReplica, nbRetry)); break; case RETRY: String f2 = "Retrying on unavailable exception at consistency %s (initial consistency: %s, required replica: %d, alive replica: %d, retries: %d)"; logger.info(String.format(f2, 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.toString()); break; case RETRY: logDecision( RETRYING_ON_REQUEST_ERROR, host(decision), cl(cl, decision), cl, nbRetry, e.toString()); break; } return decision; }
@BeforeClass(groups = {"short", "unit"}) public void setUpRetryPolicy() { setRetryPolicy(new LoggingRetryPolicy(new CustomRetryPolicy())); }
switch (decision.getType()) { case IGNORE: logDecision( IGNORING_READ_TIMEOUT, cl, break; case RETRY: logDecision( RETRYING_ON_READ_TIMEOUT, host(decision), cl(cl, decision), cl, requiredResponses,
public RetryPolicy getRetryPolicy() { if(this.retryPolicyName.equals(DowngradingConsistencyRetryPolicy.class.getSimpleName())) return new LoggingRetryPolicy(DowngradingConsistencyRetryPolicy.INSTANCE); if(this.retryPolicyName.equals(FallthroughRetryPolicy.class.getSimpleName())) return FallthroughRetryPolicy.INSTANCE; if(this.retryPolicyName.equals(DefaultRetryPolicy.class.getSimpleName())) return DefaultRetryPolicy.INSTANCE; throw new IllegalArgumentException("Unknown cassandra retry policy " + this.retryPolicyName); }
@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 RetryPolicy build() { return new LoggingRetryPolicy(subPolicy.build()); } }
@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 RetryPolicy build() { return new LoggingRetryPolicy(subPolicy.build()); } }
@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; }