Remove dependency on Spring Data Cassandra from Actuator components

Motivation:

It is possible to use CassandraAutoConfiguration to create CqlSession
beans in an application with just a dependency on the DataStax Java driver,
without the requirement to also depend on Spring Data Cassandra.

However, it is currently not possible to do so if the application also
needs to create Actuator components. Indeed, both CassandraHealthIndicator
and CassandraReactiveHealthContributorAutoConfiguration have a hard
dependency on Spring Data Cassandra and its CassandraOperations bean.

Modifications:

This commit removes the hard dependency on Spring Data Cassandra from
CassandraHealthIndicator and CassandraReactiveHealthContributorAutoConfiguration,
and replaces all usages of CassandraOperations with direct access to the
underlying CqlSession bean.

Result:

Users are now able to create Actuator health components in their applications,
even if they use just Spring Boot and the DataStax Java driver, without
Spring Data Cassandra.

Author: adutra

spring-boot-project/spring-boot-actuator-autoconfigure/build.gradle

@@ -32,6 +32,7 @@ dependencies {
 
 	optional(platform(project(":spring-boot-project:spring-boot-dependencies")))
 	optional("ch.qos.logback:logback-classic")
+	optional("com.datastax.oss:java-driver-core")
 	optional("com.fasterxml.jackson.dataformat:jackson-dataformat-xml")
 	optional("com.github.ben-manes.caffeine:caffeine")
 	optional("com.hazelcast:hazelcast")
@@ -93,7 +94,6 @@ dependencies {
 	optional("org.springframework:spring-webflux")
 	optional("org.springframework:spring-webmvc")
 	optional("org.springframework.amqp:spring-rabbit")
-	optional("org.springframework.data:spring-data-cassandra")
 	optional("org.springframework.data:spring-data-couchbase")
 	optional("org.springframework.data:spring-data-ldap")
 	optional("org.springframework.data:spring-data-mongodb")

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/cassandra/CassandraHealthContributorAutoConfiguration.java

@@ -30,32 +30,30 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.data.cassandra.core.CassandraOperations;
 
 /**
  * {@link EnableAutoConfiguration Auto-configuration} for
  * {@link CassandraHealthIndicator}.
  *
  * @author Julien Dubois
  * @author Stephane Nicoll
+ * @author Alexandre Dutra
  * @since 2.1.0
  */
 @Configuration(proxyBeanMethods = false)
-@ConditionalOnClass({ CqlSession.class, CassandraOperations.class })
-@ConditionalOnBean(CassandraOperations.class)
+@ConditionalOnClass(CqlSession.class)
+@ConditionalOnBean(CqlSession.class)
 @ConditionalOnEnabledHealthIndicator("cassandra")
-@AutoConfigureAfter({ CassandraAutoConfiguration.class, CassandraDataAutoConfiguration.class,
-		CassandraReactiveHealthContributorAutoConfiguration.class })
+@AutoConfigureAfter({ CassandraAutoConfiguration.class, CassandraReactiveHealthContributorAutoConfiguration.class })
 public class CassandraHealthContributorAutoConfiguration
-		extends CompositeHealthContributorConfiguration<CassandraHealthIndicator, CassandraOperations> {
+		extends CompositeHealthContributorConfiguration<CassandraHealthIndicator, CqlSession> {
 
 	@Bean
 	@ConditionalOnMissingBean(name = { "cassandraHealthIndicator", "cassandraHealthContributor" })
-	public HealthContributor cassandraHealthContributor(Map<String, CassandraOperations> cassandraOperations) {
-		return createContributor(cassandraOperations);
+	public HealthContributor cassandraHealthContributor(Map<String, CqlSession> sessions) {
+		return createContributor(sessions);
 	}
 
 }

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/cassandra/CassandraReactiveHealthContributorAutoConfiguration.java

@@ -26,35 +26,34 @@
 import org.springframework.boot.actuate.health.ReactiveHealthContributor;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.data.cassandra.core.ReactiveCassandraOperations;
 
 /**
  * {@link EnableAutoConfiguration Auto-configuration} for
  * {@link CassandraReactiveHealthIndicator}.
  *
  * @author Artsiom Yudovin
  * @author Stephane Nicoll
+ * @author Alexandre Dutra
  * @since 2.1.0
  */
 @Configuration(proxyBeanMethods = false)
-@ConditionalOnClass({ CqlSession.class, ReactiveCassandraOperations.class, Flux.class })
-@ConditionalOnBean(ReactiveCassandraOperations.class)
+@ConditionalOnClass({ CqlSession.class, Flux.class })
+@ConditionalOnBean(CqlSession.class)
 @ConditionalOnEnabledHealthIndicator("cassandra")
-@AutoConfigureAfter(CassandraReactiveDataAutoConfiguration.class)
-public class CassandraReactiveHealthContributorAutoConfiguration extends
-		CompositeReactiveHealthContributorConfiguration<CassandraReactiveHealthIndicator, ReactiveCassandraOperations> {
+@AutoConfigureAfter(CassandraAutoConfiguration.class)
+public class CassandraReactiveHealthContributorAutoConfiguration
+		extends CompositeReactiveHealthContributorConfiguration<CassandraReactiveHealthIndicator, CqlSession> {
 
 	@Bean
 	@ConditionalOnMissingBean(name = { "cassandraHealthIndicator", "cassandraHealthContributor" })
-	public ReactiveHealthContributor cassandraHealthContributor(
-			Map<String, ReactiveCassandraOperations> reactiveCassandraOperations) {
-		return createContributor(reactiveCassandraOperations);
+	public ReactiveHealthContributor cassandraHealthContributor(Map<String, CqlSession> sessions) {
+		return createContributor(sessions);
 	}
 
 }

spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/cassandra/CassandraHealthContributorAutoConfigurationTests.java

@@ -16,16 +16,13 @@
 
 package org.springframework.boot.actuate.autoconfigure.cassandra;
 
+import com.datastax.oss.driver.api.core.CqlSession;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.boot.actuate.autoconfigure.health.HealthContributorAutoConfiguration;
 import org.springframework.boot.actuate.cassandra.CassandraHealthIndicator;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.autoconfigure.AutoConfigureBefore;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.data.cassandra.core.CassandraOperations;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
@@ -38,8 +35,8 @@
 class CassandraHealthContributorAutoConfigurationTests {
 
 	private ApplicationContextRunner contextRunner = new ApplicationContextRunner()
-			.withConfiguration(AutoConfigurations.of(CassandraConfiguration.class,
-					CassandraHealthContributorAutoConfiguration.class, HealthContributorAutoConfiguration.class));
+			.withBean(CqlSession.class, () -> mock(CqlSession.class)).withConfiguration(AutoConfigurations
+					.of(CassandraHealthContributorAutoConfiguration.class, HealthContributorAutoConfiguration.class));
 
 	@Test
 	void runShouldCreateIndicator() {
@@ -52,15 +49,4 @@ void runWhenDisabledShouldNotCreateIndicator() {
 				.run((context) -> assertThat(context).doesNotHaveBean(CassandraHealthIndicator.class));
 	}
 
-	@Configuration(proxyBeanMethods = false)
-	@AutoConfigureBefore(CassandraHealthContributorAutoConfiguration.class)
-	static class CassandraConfiguration {
-
-		@Bean
-		CassandraOperations cassandraOperations() {
-			return mock(CassandraOperations.class);
-		}
-
-	}
-
 }

spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/cassandra/CassandraReactiveHealthContributorAutoConfigurationTests.java

@@ -16,15 +16,14 @@
 
 package org.springframework.boot.actuate.autoconfigure.cassandra;
 
+import com.datastax.oss.driver.api.core.CqlSession;
 import org.junit.jupiter.api.Test;
 
-import org.springframework.boot.actuate.autoconfigure.cassandra.CassandraHealthContributorAutoConfigurationTests.CassandraConfiguration;
 import org.springframework.boot.actuate.autoconfigure.health.HealthContributorAutoConfiguration;
 import org.springframework.boot.actuate.cassandra.CassandraHealthIndicator;
 import org.springframework.boot.actuate.cassandra.CassandraReactiveHealthIndicator;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.data.cassandra.core.ReactiveCassandraOperations;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
@@ -38,7 +37,7 @@
 class CassandraReactiveHealthContributorAutoConfigurationTests {
 
 	private ApplicationContextRunner contextRunner = new ApplicationContextRunner()
-			.withBean(ReactiveCassandraOperations.class, () -> mock(ReactiveCassandraOperations.class))
+			.withBean(CqlSession.class, () -> mock(CqlSession.class))
 			.withConfiguration(AutoConfigurations.of(CassandraReactiveHealthContributorAutoConfiguration.class,
 					HealthContributorAutoConfiguration.class));
 
@@ -50,9 +49,7 @@ void runShouldCreateIndicator() {
 
 	@Test
 	void runWithRegularIndicatorShouldOnlyCreateReactiveIndicator() {
-		this.contextRunner
-				.withConfiguration(AutoConfigurations.of(CassandraConfiguration.class,
-						CassandraHealthContributorAutoConfiguration.class))
+		this.contextRunner.withConfiguration(AutoConfigurations.of(CassandraHealthContributorAutoConfiguration.class))
 				.run((context) -> assertThat(context).hasSingleBean(CassandraReactiveHealthIndicator.class)
 						.hasBean("cassandraHealthContributor").doesNotHaveBean(CassandraHealthIndicator.class));
 	}

spring-boot-project/spring-boot-actuator/build.gradle

@@ -14,6 +14,7 @@ dependencies {
 	implementation(project(":spring-boot-project:spring-boot"))
 
 	optional(platform(project(":spring-boot-project:spring-boot-dependencies")))
+	optional("com.datastax.oss:java-driver-core")
 	optional("com.fasterxml.jackson.core:jackson-databind")
 	optional("com.github.ben-manes.caffeine:caffeine")
 	optional("com.hazelcast:hazelcast")
@@ -53,7 +54,6 @@ dependencies {
 	optional("org.springframework:spring-web")
 	optional("org.springframework:spring-webmvc")
 	optional("org.springframework.amqp:spring-rabbit")
-	optional("org.springframework.data:spring-data-cassandra")
 	optional("org.springframework.data:spring-data-couchbase")
 	optional("org.springframework.data:spring-data-ldap")
 	optional("org.springframework.data:spring-data-mongodb")

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/cassandra/CassandraHealthIndicator.java

@@ -17,12 +17,13 @@
 package org.springframework.boot.actuate.cassandra;
 
 import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 
 import org.springframework.boot.actuate.health.AbstractHealthIndicator;
 import org.springframework.boot.actuate.health.Health;
 import org.springframework.boot.actuate.health.HealthIndicator;
-import org.springframework.data.cassandra.core.CassandraOperations;
 import org.springframework.util.Assert;
 
 /**
@@ -38,25 +39,24 @@ public class CassandraHealthIndicator extends AbstractHealthIndicator {
 	private static final SimpleStatement SELECT = SimpleStatement
 			.newInstance("SELECT release_version FROM system.local").setConsistencyLevel(ConsistencyLevel.LOCAL_ONE);
 
-	private CassandraOperations cassandraOperations;
-
-	public CassandraHealthIndicator() {
-		super("Cassandra health check failed");
-	}
+	private final CqlSession session;
 
 	/**
 	 * Create a new {@link CassandraHealthIndicator} instance.
-	 * @param cassandraOperations the Cassandra operations
+	 * @param session the {@link CqlSession}.
 	 */
-	public CassandraHealthIndicator(CassandraOperations cassandraOperations) {
+	public CassandraHealthIndicator(CqlSession session) {
 		super("Cassandra health check failed");
-		Assert.notNull(cassandraOperations, "CassandraOperations must not be null");
-		this.cassandraOperations = cassandraOperations;
+		Assert.notNull(session, "session must not be null");
+		this.session = session;
 	}
 
 	@Override
 	protected void doHealthCheck(Health.Builder builder) throws Exception {
-		String version = this.cassandraOperations.getCqlOperations().queryForObject(SELECT, String.class);
+		Row row = this.session.execute(SELECT).one();
+		Assert.notNull(row, "system.local should always return one row");
+		String version = row.getString(0);
+		Assert.notNull(version, "release_version should never be null");
 		builder.up().withDetail("version", version);
 	}
 

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/cassandra/CassandraReactiveHealthIndicator.java

@@ -15,43 +15,47 @@
  */
 package org.springframework.boot.actuate.cassandra;
 
+import java.util.Objects;
+
 import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import reactor.core.publisher.Mono;
 
 import org.springframework.boot.actuate.health.AbstractReactiveHealthIndicator;
 import org.springframework.boot.actuate.health.Health;
 import org.springframework.boot.actuate.health.ReactiveHealthIndicator;
-import org.springframework.data.cassandra.core.ReactiveCassandraOperations;
 import org.springframework.util.Assert;
 
 /**
  * A {@link ReactiveHealthIndicator} for Cassandra.
  *
  * @author Artsiom Yudovin
+ * @author Alexandre Dutra
  * @since 2.1.0
  */
 public class CassandraReactiveHealthIndicator extends AbstractReactiveHealthIndicator {
 
 	private static final SimpleStatement SELECT = SimpleStatement
 			.newInstance("SELECT release_version FROM system.local").setConsistencyLevel(ConsistencyLevel.LOCAL_ONE);
 
-	private final ReactiveCassandraOperations reactiveCassandraOperations;
+	private final CqlSession session;
 
 	/**
 	 * Create a new {@link CassandraHealthIndicator} instance.
-	 * @param reactiveCassandraOperations the Cassandra operations
+	 * @param session the {@link CqlSession}.
 	 */
-	public CassandraReactiveHealthIndicator(ReactiveCassandraOperations reactiveCassandraOperations) {
+	public CassandraReactiveHealthIndicator(CqlSession session) {
 		super("Cassandra health check failed");
-		Assert.notNull(reactiveCassandraOperations, "ReactiveCassandraOperations must not be null");
-		this.reactiveCassandraOperations = reactiveCassandraOperations;
+		Assert.notNull(session, "session must not be null");
+		this.session = session;
 	}
 
 	@Override
 	protected Mono<Health> doHealthCheck(Health.Builder builder) {
-		return this.reactiveCassandraOperations.getReactiveCqlOperations().queryForObject(SELECT, String.class)
-				.map((version) -> builder.up().withDetail("version", version).build()).single();
+		return Mono.from(this.session.executeReactive(SELECT))
+				.map((row) -> Objects.requireNonNull(row.getString(0), "release_version should never be null"))
+				.map((version) -> builder.up().withDetail("version", version).build());
 	}
 
 }

spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/cassandra/CassandraHealthIndicatorTests.java

@@ -16,27 +16,26 @@
 
 package org.springframework.boot.actuate.cassandra;
 
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.cql.ResultSet;
+import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.boot.actuate.health.Health;
 import org.springframework.boot.actuate.health.Status;
-import org.springframework.data.cassandra.CassandraInternalException;
-import org.springframework.data.cassandra.core.CassandraOperations;
-import org.springframework.data.cassandra.core.cql.CqlOperations;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 
 /**
  * Tests for {@link CassandraHealthIndicator}.
  *
  * @author Oleksii Bondar
- * @author Stephane Nicoll
+ * @author Alexandre Dutra
  */
 class CassandraHealthIndicatorTests {
 
@@ -46,26 +45,30 @@ void createWhenCassandraOperationsIsNullShouldThrowException() {
 	}
 
 	@Test
-	void healthWithCassandraUp() {
-		CassandraOperations cassandraOperations = mock(CassandraOperations.class);
-		CqlOperations cqlOperations = mock(CqlOperations.class);
-		CassandraHealthIndicator healthIndicator = new CassandraHealthIndicator(cassandraOperations);
-		given(cassandraOperations.getCqlOperations()).willReturn(cqlOperations);
-		given(cqlOperations.queryForObject(any(SimpleStatement.class), eq(String.class))).willReturn("1.0.0");
+	void verifyHealthStatusWhenExhausted() {
+		CqlSession session = mock(CqlSession.class);
+		ResultSet resultSet = mock(ResultSet.class);
+		CassandraHealthIndicator healthIndicator = new CassandraHealthIndicator(session);
+		given(session.execute(any(SimpleStatement.class))).willReturn(resultSet);
+		given(resultSet.isFullyFetched()).willReturn(true);
 		Health health = healthIndicator.health();
 		assertThat(health.getStatus()).isEqualTo(Status.UP);
-		assertThat(health.getDetails().get("version")).isEqualTo("1.0.0");
 	}
 
 	@Test
-	void healthWithCassandraDown() {
-		CassandraOperations cassandraOperations = mock(CassandraOperations.class);
-		given(cassandraOperations.getCqlOperations()).willThrow(new CassandraInternalException("Connection failed"));
-		CassandraHealthIndicator healthIndicator = new CassandraHealthIndicator(cassandraOperations);
+	void verifyHealthStatusWithVersion() {
+		CqlSession session = mock(CqlSession.class);
+		ResultSet resultSet = mock(ResultSet.class);
+		Row row = mock(Row.class);
+		CassandraHealthIndicator healthIndicator = new CassandraHealthIndicator(session);
+		given(session.execute(any(SimpleStatement.class))).willReturn(resultSet);
+		given(resultSet.isFullyFetched()).willReturn(false);
+		given(resultSet.one()).willReturn(row);
+		String expectedVersion = "1.0.0";
+		given(row.getString(0)).willReturn(expectedVersion);
 		Health health = healthIndicator.health();
-		assertThat(health.getStatus()).isEqualTo(Status.DOWN);
-		assertThat(health.getDetails().get("error"))
-				.isEqualTo(CassandraInternalException.class.getName() + ": Connection failed");
+		assertThat(health.getStatus()).isEqualTo(Status.UP);
+		assertThat(health.getDetails().get("version")).isEqualTo(expectedVersion);
 	}
 
 }