You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by be...@apache.org on 2025/03/21 23:27:11 UTC
(cassandra-analytics) branch trunk updated: CASSANALYTICS-7: Add Apache Cassandra Sidecar CDC implementation (#99)
This is an automated email from the ASF dual-hosted git repository.
bernardobotella pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/cassandra-analytics.git
The following commit(s) were added to refs/heads/trunk by this push:
new 75d97e4b CASSANALYTICS-7: Add Apache Cassandra Sidecar CDC implementation (#99)
75d97e4b is described below
commit 75d97e4b5bd8ed0be6f9485c64db734859657f54
Author: jberragan <jb...@gmail.com>
AuthorDate: Fri Mar 21 16:27:07 2025 -0700
CASSANALYTICS-7: Add Apache Cassandra Sidecar CDC implementation (#99)
Patch by James Berragan; Reviewed by Yifan Cai, Bernardo Botella for CASSANALYTICS-7
---
CHANGES.txt | 1 +
cassandra-analytics-cdc-sidecar/build.gradle | 129 ++++++
.../cassandra/cdc/CassandraClientSource.java | 170 ++++++++
.../cdc/sidecar/ClusterConfigProvider.java | 37 +-
.../cdc/sidecar/ReplicationFactorSupplier.java | 55 +++
.../apache/cassandra/cdc/sidecar/SidecarCdc.java | 64 +++
.../cassandra/cdc/sidecar/SidecarCdcBuilder.java | 175 +++++++++
.../cdc/sidecar/SidecarCdcCassandraClient.java | 72 ++++
.../cassandra/cdc/sidecar/SidecarCdcClient.java | 153 ++++++++
.../cdc/sidecar/SidecarCdcCommitLogSegment.java | 157 ++++++++
.../cassandra/cdc/sidecar/SidecarCdcOptions.java | 168 ++++++++
.../cassandra/cdc/sidecar/SidecarCdcStats.java | 277 +++++++++++++
.../cdc/sidecar/SidecarCommitLogProvider.java | 143 +++++++
.../cassandra/cdc/sidecar/SidecarDownMonitor.java | 68 ++++
.../cdc/sidecar/SidecarStatePersister.java | 434 +++++++++++++++++++++
.../cassandra/cdc/CassandraClientSourceTest.java | 112 ++++++
.../cdc/sidecar/SidecarCommitLogProviderTests.java | 196 ++++++++++
.../cdc/sidecar/SidecarStatePersisterTest.java | 118 ++++++
.../main/java/org/apache/cassandra/cdc/Cdc.java | 12 +-
.../java/org/apache/cassandra/cdc/CdcBuilder.java | 18 +-
.../org/apache/cassandra/cdc/CdcKryoRegister.java | 2 +-
.../java/org/apache/cassandra/cdc/TypeCache.java | 117 ++++++
.../apache/cassandra/cdc/msg/jdk/CdcMessage.java | 22 +-
.../java/org/apache/cassandra/cdc/CdcTester.java | 2 +-
.../java/org/apache/cassandra/cdc/CdcTests.java | 4 +-
.../org/apache/cassandra/cdc/TypeCacheTests.java | 85 ++++
.../org/apache/cassandra/cdc/api/CommitLog.java | 8 +-
.../apache/cassandra/cdc/api/CommitLogMarkers.java | 2 +-
.../apache/cassandra/cdc/api/KeyspaceTypeKey.java | 69 ++++
.../cassandra/spark/utils/AsyncExecutor.java | 47 +++
cassandra-analytics-core/build.gradle | 1 +
.../cassandra/clients/AnalyticsSidecarClient.java | 87 +++++
.../spark/bulkwriter/CassandraContext.java | 4 +-
...tion.java => BulkWriterKeyStoreValidation.java} | 28 +-
...on.java => BulkWriterTrustStoreValidation.java} | 28 +-
.../cassandra/clients/SidecarClientConfigTest.java | 4 +-
cassandra-analytics-sidecar-client/build.gradle | 65 +++
.../apache/cassandra/clients/ExecutorHolder.java | 0
.../java/org/apache/cassandra/clients/Sidecar.java | 48 ---
.../clients/SidecarStreamConsumerAdapter.java | 0
.../spark/validation/KeyStoreValidation.java | 24 +-
.../spark/validation/StartupValidation.java | 0
.../spark/validation/StartupValidator.java | 0
.../spark/validation/TrustStoreValidation.java | 24 +-
gradle.properties | 1 +
settings.gradle | 2 +
46 files changed, 3078 insertions(+), 155 deletions(-)
diff --git a/CHANGES.txt b/CHANGES.txt
index f413bb00..f29ef75d 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,4 +1,5 @@
1.0.0
+ * Add Apache Cassandra Sidecar CDC implementation (CASSANALYTICS-7)
* Upgrade sidecar client dependency to 0.1.0 (CASSANALYTICS-16)
* Remove JDK8 support (CASSANALYTICS-17)
* Support CQL duration type (CASSANALYTICS-18)
diff --git a/cassandra-analytics-cdc-sidecar/build.gradle b/cassandra-analytics-cdc-sidecar/build.gradle
new file mode 100644
index 00000000..914fb34c
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/build.gradle
@@ -0,0 +1,129 @@
+import java.nio.file.Paths
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+plugins {
+ id('java-library')
+ id('maven-publish')
+}
+
+configurations {
+ all*.exclude(group: 'org.slf4j', module: 'slf4j-log4j12')
+ all*.exclude(group: 'log4j', module: 'log4j')
+}
+
+java {
+ withJavadocJar()
+ withSourcesJar()
+}
+
+publishing {
+ publications {
+ maven(MavenPublication) {
+ from components.java
+ groupId project.group
+ artifactId "${archivesBaseName}"
+ version System.getenv("CODE_VERSION") ?: "${version}"
+ }
+ }
+}
+
+configurations {
+ fourzero {
+ description = 'Cassandra 4.0 dependency'
+ }
+ fourzerobridge {
+ description = 'Bridge to Cassandra 4.0'
+ }
+ fourzerotypes {
+ description = 'Cassandra 4.0 Data Types'
+ }
+}
+
+dependencies {
+ api(project(':cassandra-bridge'))
+
+ fourzero(project(path: ':cassandra-four-zero', configuration: 'shadow'))
+ fourzerobridge(project(path: ':cassandra-four-zero-bridge'))
+ fourzerotypes(project(path: ':cassandra-four-zero-types'))
+
+ implementation project(":cassandra-analytics-common")
+ implementation project(':cassandra-analytics-cdc')
+ implementation project(':cassandra-analytics-sidecar-client')
+ compileOnlyApi("com.datastax.cassandra:cassandra-driver-core:${project.cassandraDriverVersion}") // Cassandra driver is required only if user supplies the CassandraClientSource
+
+ implementation "com.google.guava:guava:${project.guavaVersion}"
+
+ implementation "org.apache.commons:commons-lang3:${project.commonsLang3Version}"
+ implementation "org.slf4j:slf4j-api:${slf4jApiVersion}"
+ implementation "com.esotericsoftware:kryo-shaded:${kryoVersion}"
+ implementation "com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}"
+ implementation "com.fasterxml.jackson.core:jackson-core:${jacksonVersion}"
+ implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
+
+ testImplementation project(":cassandra-analytics-common")
+
+ // pull in cassandra-bridge so we can re-use TestSchema to generate arbitrary schemas for the cdc tests
+ testImplementation project(":cassandra-bridge")
+ testImplementation("com.datastax.cassandra:cassandra-driver-core:${project.cassandraDriverVersion}")
+ testImplementation(testFixtures(project(':cassandra-bridge')))
+ testImplementation project(":cassandra-four-zero-bridge")
+ testImplementation project(":cassandra-four-zero-types")
+ testImplementation project(path: ':cassandra-four-zero', configuration: 'shadow')
+ testImplementation(group: 'org.quicktheories', name: 'quicktheories', version: "${project.rootProject.quickTheoriesVersion}")
+ testImplementation(group: 'com.google.guava', name: 'guava', version: '31.1-jre')
+ testImplementation(group: 'com.github.luben', name: 'zstd-jni', version: '1.5.0-4')
+ testImplementation(group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.26')
+ testImplementation "org.quicktheories:quicktheories:${project.rootProject.quickTheoriesVersion}"
+ testImplementation "org.junit.jupiter:junit-jupiter-api:${project.junitVersion}"
+ testImplementation "org.junit.jupiter:junit-jupiter-params:${project.junitVersion}"
+ testImplementation "org.junit.jupiter:junit-jupiter-engine:${project.junitVersion}"
+ testImplementation "org.mockito:mockito-core:${project.rootProject.mockitoVersion}"
+ testImplementation "org.mockito:mockito-inline:${project.rootProject.mockitoVersion}"
+}
+
+jar {
+ dependsOn(configurations.fourzero)
+ dependsOn(configurations.fourzerobridge)
+ dependsOn(configurations.fourzerotypes)
+
+ exclude('META-INF/*')
+ into('bridges') {
+ from(configurations.fourzero.singleFile)
+ from(configurations.fourzerobridge.singleFile)
+ from(configurations.fourzerotypes.singleFile)
+ }
+}
+
+test {
+ useJUnitPlatform()
+ reports {
+ def destDir = Paths.get(rootProject.rootDir.absolutePath, "build", "test-reports", "cdc-sidecar").toFile()
+ junitXml {
+ enabled true
+ destination = destDir
+ }
+ html {
+ enabled true
+ destination = destDir
+ }
+ }
+}
+
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/CassandraClientSource.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/CassandraClientSource.java
new file mode 100644
index 00000000..7a7e8b90
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/CassandraClientSource.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.datastax.driver.core.AuthProvider;
+import com.datastax.driver.core.Authenticator;
+import com.datastax.driver.core.BoundStatement;
+import com.datastax.driver.core.PreparedStatement;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.Session;
+import com.datastax.driver.core.exceptions.AuthenticationException;
+import org.apache.cassandra.cdc.api.CassandraSource;
+import org.apache.cassandra.cdc.msg.Value;
+import org.apache.cassandra.spark.data.CassandraTypes;
+
+/**
+ * Optional `CassandraSource` implementation that reads values from the Cassandra cluster using the standard Cassandra client.
+ * This is only used for reading unfrozen lists. In Cassandra, unfrozen lists store the list index as a timeuuid
+ * which is unintelligible for downstream CDC consumers.
+ */
+public class CassandraClientSource implements CassandraSource
+{
+ private static final Logger LOGGER = LoggerFactory.getLogger(CassandraClientSource.class);
+ private static final String READ_QUERY_FORMAT = "SELECT %s from %s.%s where %s";
+ private static final int EXPIRE_AFTER_MINUTES = 60;
+ private final Session session;
+ private final CassandraTypes types;
+ private final Cache<String, PreparedStatement> preparedStatementCache;
+
+ public CassandraClientSource(Session session, CassandraTypes types)
+ {
+ this(session, types, EXPIRE_AFTER_MINUTES);
+ }
+
+ public CassandraClientSource(Session session, CassandraTypes types, int preparedStatementCacheExpireAfterMinutes)
+ {
+ this.session = session;
+ this.types = types;
+ this.preparedStatementCache = CacheBuilder
+ .newBuilder()
+ .expireAfterAccess(preparedStatementCacheExpireAfterMinutes, TimeUnit.MINUTES)
+ .build();
+ }
+
+ @Override
+ public List<ByteBuffer> readFromCassandra(String keyspace, String table,
+ List<String> columnsToFetch,
+ List<Value> primaryKeyColumns)
+ {
+ // Create the read query & prepare statement
+ List<String> primaryKeyColumnNames = getPrimaryKeyColumnNames(primaryKeyColumns);
+ String readQuery = getReadQuery(keyspace, table, columnsToFetch, primaryKeyColumnNames);
+ PreparedStatement preparedStatement;
+ try
+ {
+ preparedStatement = preparedStatementCache.get(readQuery, () -> session.prepare(readQuery));
+ }
+ catch (ExecutionException e)
+ {
+ LOGGER.error("Unable to load prepared statement for query {}", readQuery, e);
+ preparedStatement = session.prepare(readQuery);
+ }
+
+ // Get primaryKey values & execute query
+ BoundStatement boundStatement = preparedStatement.bind(getPrimaryKeyObjects(types, primaryKeyColumns));
+ ResultSet resultSet = session.execute(boundStatement);
+ if (resultSet.isExhausted())
+ {
+ LOGGER.error("The read query {} to C* failed", readQuery);
+ return null;
+ }
+ Row row = resultSet.one(); // There should only be one row
+
+ // Create list of ByteBuffer with values of columns to fetch
+ List<ByteBuffer> result = new ArrayList<>();
+ for (String column : columnsToFetch)
+ {
+ result.add(row.getBytesUnsafe(column));
+ }
+ return result;
+ }
+
+ @VisibleForTesting
+ static String getReadQuery(String keyspace,
+ String table,
+ List<String> columnsToFetch,
+ List<String> primaryKeyColumns)
+ {
+ String columnsToSelect = StringUtils.join(columnsToFetch, ",");
+ String primaryKeyCondition = primaryKeyColumns.stream()
+ .map(primaryKeyColumn -> primaryKeyColumn + " = ?")
+ .collect(Collectors.joining(" , "));
+ return String.format(READ_QUERY_FORMAT, columnsToSelect, keyspace, table, primaryKeyCondition);
+ }
+
+ @VisibleForTesting
+ static Object[] getPrimaryKeyObjects(CassandraTypes types, List<Value> primaryKeyColumns)
+ {
+ return primaryKeyColumns.stream()
+ .map(valueWithMetadata -> types.parseType(valueWithMetadata.columnType).deserializeToJavaType(valueWithMetadata.getValue()))
+ .toArray();
+ }
+
+ private static List<String> getPrimaryKeyColumnNames(List<Value> primaryKeyColumns)
+ {
+ return primaryKeyColumns.stream()
+ .map(valueWithMetadata -> valueWithMetadata.columnName)
+ .collect(Collectors.toList());
+ }
+
+ private static class MtlsAuthProvider implements AuthProvider
+ {
+ @Override
+ public Authenticator newAuthenticator(InetSocketAddress inetSocketAddress, String s) throws AuthenticationException
+ {
+ return new MutualTLSAuthenticator();
+ }
+
+ private static class MutualTLSAuthenticator implements Authenticator
+ {
+ public byte[] initialResponse()
+ {
+ return new byte[]{0, 0};
+ }
+
+ public byte[] evaluateChallenge(byte[] bytes)
+ {
+ return null;
+ }
+
+ public void onAuthenticationSuccess(byte[] bytes)
+ {
+ LOGGER.info("Successfully authenticated with mTLS");
+ }
+ }
+ }
+}
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ClusterConfigProvider.java
similarity index 50%
copy from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
copy to cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ClusterConfigProvider.java
index dbb4df15..8584198d 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ClusterConfigProvider.java
@@ -17,26 +17,33 @@
* under the License.
*/
-package org.apache.cassandra.clients;
+package org.apache.cassandra.cdc.sidecar;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
+import java.util.Set;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.data.partitioner.Partitioner;
/**
- * A class that holds Executors used during the Cassandra Analytics execution
+ * Interface to supply cluster topology information for CDC:
+ * the Cassandra partitioner,
+ * the datacenter where CDC is enabled,
+ * CassandraInstance objects describing the cluster topology.
*/
-public final class ExecutorHolder
+public interface ClusterConfigProvider
{
- // TODO: Make the size configurable
- public static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(64,
- new ThreadFactoryBuilder().setNameFormat("cassandra-analytics-%d")
- .setDaemon(true)
- .build());
+ /**
+ * @return the datacenter name where CDC is enabled.
+ */
+ String dc();
- private ExecutorHolder()
- {
- throw new IllegalStateException(getClass() + " is static utility class and shall not be instantiated");
- }
+ /**
+ * @return set of CassandraInstance objects describing the entire ring topology, including other datacenters.
+ */
+ Set<CassandraInstance> getCluster();
+
+ /**
+ * @return the Cassandra partitioner configured on the cluster.
+ */
+ Partitioner partitioner();
}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ReplicationFactorSupplier.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ReplicationFactorSupplier.java
new file mode 100644
index 00000000..f6616efc
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/ReplicationFactorSupplier.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import com.google.common.collect.ImmutableMap;
+
+import org.apache.cassandra.spark.data.ReplicationFactor;
+
+public interface ReplicationFactorSupplier
+{
+ ReplicationFactorSupplier DEFAULT = new ReplicationFactorSupplier()
+ {
+ @Override
+ public ReplicationFactor getReplicationFactor(String keyspace)
+ {
+ return new ReplicationFactor(ImmutableMap.of(
+ "class", "SimpleStrategy",
+ "replication_factor", "1"));
+ }
+
+ @Override
+ public ReplicationFactor getMaximalReplicationFactor()
+ {
+ return getReplicationFactor("keyspace");
+ }
+ };
+
+ /**
+ * @param keyspace Cassandra keyspace name
+ * @return ReplicationFactor object for provided keyspace
+ */
+ ReplicationFactor getReplicationFactor(String keyspace);
+
+ /**
+ * @return the maximum replication factor across all CDC keyspaces
+ */
+ ReplicationFactor getMaximalReplicationFactor();
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdc.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdc.java
new file mode 100644
index 00000000..6a652f39
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdc.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.Set;
+
+import org.apache.cassandra.cdc.Cdc;
+import org.apache.cassandra.spark.data.CqlTable;
+import org.apache.cassandra.spark.data.ReplicationFactor;
+import org.apache.cassandra.spark.utils.FutureUtils;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * SidecarCdc implementation that uses the Sidecar HTTP APIs to list and stream commit log segments.
+ */
+public class SidecarCdc extends Cdc
+{
+ protected final ClusterConfigProvider clusterConfigProvider;
+
+ protected SidecarCdc(@NotNull SidecarCdcBuilder builder)
+ {
+ super(builder);
+ this.clusterConfigProvider = builder.clusterConfigProvider;
+ initSchema();
+ }
+
+ public void initSchema()
+ {
+ Set<CqlTable> tables = FutureUtils.get(schemaSupplier.getCdcEnabledTables());
+ Optional<ReplicationFactor> rfOp = tables.stream()
+ .map(CqlTable::replicationFactor)
+ .filter(rf -> rf.getOptions().containsKey(dc()))
+ .max(Comparator.comparingInt(rf -> rf.getOptions().get(dc())));
+
+ if (!rfOp.isPresent())
+ {
+ throw new RuntimeException("Could not find replication factor for any keyspace");
+ }
+ }
+
+ public String dc()
+ {
+ return clusterConfigProvider.dc();
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcBuilder.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcBuilder.java
new file mode 100644
index 00000000..b64d1871
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcBuilder.java
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.io.IOException;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.cassandra.cdc.CdcBuilder;
+import org.apache.cassandra.cdc.api.CdcOptions;
+import org.apache.cassandra.cdc.api.EventConsumer;
+import org.apache.cassandra.cdc.api.SchemaSupplier;
+import org.apache.cassandra.cdc.api.TokenRangeSupplier;
+import org.apache.cassandra.cdc.stats.ICdcStats;
+import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.secrets.SecretsProvider;
+import org.apache.cassandra.sidecar.client.SidecarClient;
+import org.apache.cassandra.sidecar.client.SidecarInstancesProvider;
+import org.apache.cassandra.spark.utils.AsyncExecutor;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class SidecarCdcBuilder extends CdcBuilder
+{
+ protected ClusterConfigProvider clusterConfigProvider;
+ protected SidecarCdcClient sidecarCdcClient;
+ protected SidecarDownMonitor downMonitor = SidecarDownMonitor.STUB;
+ protected ReplicationFactorSupplier replicationFactorSupplier = ReplicationFactorSupplier.DEFAULT;
+ protected SidecarCdcStats sidecarCdcStats = SidecarCdcStats.STUB;
+ protected SidecarCdcCassandraClient cassandraClient = SidecarCdcCassandraClient.STUB;
+ protected SidecarCdcOptions sidecarCdcOptions = SidecarCdcOptions.DEFAULT;
+
+ SidecarCdcBuilder(@NotNull String jobId,
+ int partitionId,
+ CdcOptions cdcOptions,
+ ClusterConfigProvider clusterConfigProvider,
+ EventConsumer eventConsumer,
+ SchemaSupplier schemaSupplier,
+ TokenRangeSupplier tokenRangeSupplier,
+ SidecarInstancesProvider sidecarInstancesProvider,
+ Sidecar.ClientConfig clientConfig,
+ SecretsProvider secretsProvider,
+ ICdcStats cdcStats) throws IOException
+ {
+ this(
+ jobId,
+ partitionId,
+ cdcOptions,
+ clusterConfigProvider,
+ eventConsumer,
+ schemaSupplier,
+ tokenRangeSupplier,
+ clientConfig,
+ Sidecar.from(sidecarInstancesProvider, clientConfig, secretsProvider),
+ cdcStats
+ );
+ }
+
+ SidecarCdcBuilder(@NotNull String jobId,
+ int partitionId,
+ CdcOptions cdcOptions,
+ ClusterConfigProvider clusterConfigProvider,
+ EventConsumer eventConsumer,
+ SchemaSupplier schemaSupplier,
+ TokenRangeSupplier tokenRangeSupplier,
+ Sidecar.ClientConfig clientConfig,
+ SidecarClient sidecarClient,
+ ICdcStats cdcStats)
+ {
+ super(jobId, partitionId, eventConsumer, schemaSupplier);
+ this.clusterConfigProvider = clusterConfigProvider;
+ this.sidecarCdcClient = new SidecarCdcClient(clientConfig, sidecarClient, cdcStats);
+ withCdcOptions(cdcOptions);
+ withTokenRangeSupplier(tokenRangeSupplier);
+ }
+
+ public SidecarCdcBuilder withClusterConfigProvider(ClusterConfigProvider clusterConfigProvider)
+ {
+ this.clusterConfigProvider = clusterConfigProvider;
+ return this;
+ }
+
+ public SidecarCdcBuilder withDownMonitor(SidecarDownMonitor downMonitor)
+ {
+ this.downMonitor = downMonitor;
+ return this;
+ }
+
+ public SidecarCdcBuilder withSidecarClient(Sidecar.ClientConfig clientConfig,
+ SidecarClient sidecarClient,
+ ICdcStats cdcStats)
+ {
+ this.sidecarCdcClient = new SidecarCdcClient(clientConfig, sidecarClient, cdcStats);
+ return this;
+ }
+
+ public SidecarCdcBuilder withReplicationFactorSupplier(ReplicationFactorSupplier replicationFactorSupplier)
+ {
+ this.replicationFactorSupplier = replicationFactorSupplier;
+ return this;
+ }
+
+ @Override
+ public CdcBuilder withCdcOptions(@NotNull CdcOptions cdcOptions)
+ {
+ super.withCdcOptions(cdcOptions);
+ return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new cdcOptions
+ }
+
+ public SidecarCdcBuilder withSidecarCdcStats(SidecarCdcStats sidecarCdcStats)
+ {
+ this.sidecarCdcStats = sidecarCdcStats;
+ return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new SidecarCdcStats
+ }
+
+ public SidecarCdcBuilder withSidecarCdcOptions(SidecarCdcOptions sidecarCdcOptions)
+ {
+ this.sidecarCdcOptions = sidecarCdcOptions;
+ return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new SidecarCdcOptions
+ }
+
+ @Override
+ public SidecarCdcBuilder withExecutor(AsyncExecutor asyncExecutor)
+ {
+ super.withExecutor(asyncExecutor);
+ return withSidecarCdcCassandraClient(cassandraClient); // rebuild SidecarStatePersister with new AsyncExecutor
+ }
+
+ public SidecarCdcBuilder withSidecarCdcCassandraClient(SidecarCdcCassandraClient cassandraClient)
+ {
+ this.cassandraClient = cassandraClient;
+ return withSidecarStatePersister(new SidecarStatePersister(sidecarCdcOptions, cdcOptions, sidecarCdcStats, cassandraClient, asyncExecutor));
+ }
+
+ public SidecarCdcBuilder withSidecarStatePersister(SidecarStatePersister statePersister)
+ {
+ withStatePersister(statePersister);
+ return this;
+ }
+
+ @Override
+ public SidecarCdc build()
+ {
+ Preconditions.checkNotNull(clusterConfigProvider, "A ClusterConfigProvider must be supplied");
+ Preconditions.checkNotNull(asyncExecutor, "An AsyncExecutor must be supplied");
+ Preconditions.checkNotNull(eventConsumer, "An event consumer supplier must be supplied");
+ Preconditions.checkNotNull(schemaSupplier, "An schema supplier must be supplied");
+
+ if (this.commitLogProvider == null)
+ {
+ // SidecarCdc should generally use SidecarCommitLogProvider to list and stream commit log segments over Sidecar http API
+ // but the builder is left open if user wishes to provide own implementation
+ this.commitLogProvider = new SidecarCommitLogProvider(clusterConfigProvider, sidecarCdcClient, downMonitor, replicationFactorSupplier);
+ }
+
+ return new SidecarCdc(this);
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCassandraClient.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCassandraClient.java
new file mode 100644
index 00000000..96c90228
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCassandraClient.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+import com.datastax.driver.core.ResultSetFuture;
+import org.apache.cassandra.bridge.TokenRange;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface defining read and write operations to Cassandra used by the `SidecarStatePersister`
+ */
+public interface SidecarCdcCassandraClient
+{
+ SidecarCdcCassandraClient STUB = new SidecarCdcCassandraClient()
+ {
+ @Override
+ public List<ResultSetFuture> storeStateAsync(String jobId, TokenRange range, ByteBuffer buf, long timestamp)
+ {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public Stream<byte[]> loadStateForRange(String jobId, TokenRange range)
+ {
+ return Stream.empty();
+ }
+ };
+
+ /**
+ * Durably store the CDC state
+ *
+ * @param jobId cdc job id
+ * @param range cdc partition token range
+ * @param buf serialized CDC state
+ * @param timestamp timestamp to use in the write mutation
+ * @return list of Cassandra client ResultSetFutures
+ */
+ List<ResultSetFuture> storeStateAsync(@NotNull String jobId,
+ @NotNull TokenRange range,
+ @NotNull ByteBuffer buf,
+ long timestamp);
+
+ /**
+ * @param jobId cdc job id
+ * @param tokenRange cdc partition token range
+ * @return stream of one or more serialized CDC state objects that overlap with the TokenRange
+ */
+ Stream<byte[]> loadStateForRange(String jobId, @Nullable TokenRange tokenRange);
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcClient.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcClient.java
new file mode 100644
index 00000000..16ae3eda
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcClient.java
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import o.a.c.sidecar.client.shaded.common.utils.HttpRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.cdc.stats.ICdcStats;
+import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.sidecar.client.SidecarClient;
+import org.apache.cassandra.sidecar.client.SidecarInstance;
+import org.apache.cassandra.sidecar.client.StreamBuffer;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.exceptions.TransportFailureException;
+import org.apache.cassandra.spark.utils.ThrowableUtils;
+import org.apache.cassandra.spark.utils.streaming.StreamConsumer;
+
+public class SidecarCdcClient
+{
+ final Sidecar.ClientConfig config;
+ final SidecarClient sidecarClient;
+ final ICdcStats stats;
+
+ public SidecarCdcClient(Sidecar.ClientConfig config,
+ SidecarClient sidecarClient,
+ ICdcStats stats)
+ {
+ this.config = config;
+ this.sidecarClient = sidecarClient;
+ this.stats = stats;
+ }
+
+ public CompletableFuture<List<CommitLog>> listCdcCommitLogSegments(CassandraInstance instance)
+ {
+ return sidecarClient.listCdcSegments(toSidecarInstance(instance))
+ .thenApply(
+ response ->
+ response.segmentsInfo()
+ .stream()
+ .map(segment -> (CommitLog) new SidecarCdcCommitLogSegment(this, instance, segment, config))
+ .collect(Collectors.toList())
+ ).exceptionally(throwable -> {
+ Throwable cause = ThrowableUtils.rootCause(throwable);
+ if (cause instanceof TransportFailureException.Nonretryable
+ && ((TransportFailureException.Nonretryable) cause).isNotFound())
+ {
+ // Rescue the 404 not found exception - it is a permitted error
+ return Collections.emptyList();
+ }
+ // Rethrow the other exception
+ if (throwable instanceof Error)
+ {
+ throw (Error) throwable;
+ }
+ throw new RuntimeException(cause);
+ });
+ }
+
+ public void streamCdcCommitLogSegment(CassandraInstance instance, String segment, HttpRange httpRange, StreamConsumer streamConsumer)
+ {
+ sidecarClient.streamCdcSegments(toSidecarInstance(instance), segment, httpRange, new org.apache.cassandra.sidecar.client.StreamConsumer()
+ {
+ @Override
+ public void onRead(StreamBuffer streamBuffer)
+ {
+ streamConsumer.onRead(new org.apache.cassandra.spark.utils.streaming.StreamBuffer()
+ {
+ @Override
+ public void getBytes(int index, ByteBuffer destination, int length)
+ {
+ streamBuffer.copyBytes(index, destination, length);
+ }
+
+ @Override
+ public void getBytes(int index, byte[] destination, int destinationIndex, int length)
+ {
+ streamBuffer.copyBytes(index, destination, destinationIndex, length);
+ }
+
+ @Override
+ public byte getByte(int index)
+ {
+ return streamBuffer.getByte(index);
+ }
+
+ @Override
+ public int readableBytes()
+ {
+ return streamBuffer.readableBytes();
+ }
+
+ @Override
+ public void release()
+ {
+ streamBuffer.release();
+ }
+ });
+ }
+
+ @Override
+ public void onComplete()
+ {
+ streamConsumer.onEnd();
+ }
+
+ @Override
+ public void onError(Throwable throwable)
+ {
+ streamConsumer.onError(throwable);
+ }
+ });
+ }
+
+ protected SidecarInstance toSidecarInstance(CassandraInstance instance)
+ {
+ return new SidecarInstance()
+ {
+ @Override
+ public int port()
+ {
+ return config.effectivePort();
+ }
+
+ @Override
+ public String hostname()
+ {
+ return instance.nodeName();
+ }
+ };
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCommitLogSegment.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCommitLogSegment.java
new file mode 100644
index 00000000..b20ca3e4
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcCommitLogSegment.java
@@ -0,0 +1,157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.time.Duration;
+
+import o.a.c.sidecar.client.shaded.common.response.data.CdcSegmentInfo;
+import o.a.c.sidecar.client.shaded.common.utils.HttpRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.cdc.stats.ICdcStats;
+import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.spark.data.FileType;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.utils.streaming.CassandraFileSource;
+import org.apache.cassandra.spark.utils.streaming.StreamConsumer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * The SidecarCdcCommitLogSegment provides a CommitLog source for reading the
+ * CommitLog segments over the Sidecar HTTP API.
+ */
+public class SidecarCdcCommitLogSegment implements CommitLog
+{
+ private final CassandraInstance instance;
+ private final CdcSegmentInfo segment;
+ private final CassandraFileSource<CommitLog> source;
+ private final ICdcStats stats;
+
+ public SidecarCdcCommitLogSegment(SidecarCdcClient sidecar,
+ CassandraInstance instance,
+ CdcSegmentInfo segment,
+ Sidecar.ClientConfig clientConfig)
+ {
+ this.instance = instance;
+ this.segment = segment;
+ this.stats = sidecar.stats;
+
+ SidecarCdcCommitLogSegment thisLog = this;
+ this.source = new CassandraFileSource<CommitLog>()
+ {
+ public void request(long start, long end, StreamConsumer consumer)
+ {
+ sidecar.streamCdcCommitLogSegment(instance, segment.name, HttpRange.of(start, end), consumer);
+ }
+
+ public CommitLog cassandraFile()
+ {
+ return thisLog;
+ }
+
+ public long maxBufferSize()
+ {
+ return clientConfig.maxBufferSize();
+ }
+
+ public long chunkBufferSize()
+ {
+ return clientConfig.chunkBufferSize(fileType());
+ }
+
+ public FileType fileType()
+ {
+ return FileType.COMMITLOG;
+ }
+
+ public long size()
+ {
+ return segment.idx;
+ }
+
+ @Nullable
+ @Override
+ public Duration timeout()
+ {
+ int timeout = clientConfig.timeoutSeconds();
+ return timeout <= 0 ? null : Duration.ofSeconds(timeout);
+ }
+ };
+ }
+
+ public String name()
+ {
+ return segment.name;
+ }
+
+ public String path()
+ {
+ return "./" + segment.name;
+ }
+
+ public long maxOffset()
+ {
+ return segment.idx;
+ }
+
+ @Override
+ public long length()
+ {
+ return segment.size;
+ }
+
+ @Override
+ public boolean completed()
+ {
+ return segment.completed;
+ }
+
+ public CassandraFileSource<CommitLog> source()
+ {
+ return source;
+ }
+
+ public CassandraInstance instance()
+ {
+ return instance;
+ }
+
+ public ICdcStats stats()
+ {
+ return stats;
+ }
+
+ public void close()
+ {
+
+ }
+
+ @Override
+ public String toString()
+ {
+ return '{' +
+ "\"node\": \"" + instance.nodeName() + "\"," +
+ "\"dc\": \"" + instance.dataCenter() + "\"," +
+ "\"token\": \"" + instance.token() + "\"," +
+ "\"log\": \"" + segment.name + "\"," +
+ "\"idx\": \"" + segment.idx + "\"," +
+ "\"size\": \"" + segment.size + '"' +
+ '}';
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcOptions.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcOptions.java
new file mode 100644
index 00000000..1caa0697
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcOptions.java
@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.time.Duration;
+import java.util.Collections;
+import java.util.Map;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface SidecarCdcOptions
+{
+ String DEFAULT_JOB_ID = "test-job";
+ int DEFAULT_MAX_WATERMARKER_SIZE = 400000;
+
+ SidecarCdcOptions DEFAULT = new SidecarCdcOptions()
+ {
+ };
+
+ enum TopicFormatType
+ {
+ STATIC, KEYSPACE, KEYSPACETABLE, TABLE, MAP
+ }
+
+ @Nullable
+ default String kafkaTopic()
+ {
+ return null;
+ }
+
+ @NotNull
+ default TopicFormatType topicFormat()
+ {
+ return TopicFormatType.STATIC;
+ }
+
+ default boolean cdcEnabled()
+ {
+ return true;
+ }
+
+ default String jobId()
+ {
+ return DEFAULT_JOB_ID;
+ }
+
+ default Map<String, Object> kafkaConfigs()
+ {
+ return Collections.emptyMap();
+ }
+
+ default Map<String, Object> cdcConfigs()
+ {
+ return Collections.emptyMap();
+ }
+
+ default boolean logOnly()
+ {
+ return false;
+ }
+
+ default String dc()
+ {
+ return "DATACENTER1";
+ }
+
+ default Duration watermarkWindow()
+ {
+ return Duration.ofHours(4);
+ }
+
+ /**
+ * @return max Kafka record size in bytes. If value is non-negative then the KafkaPublisher will chunk larger records into multiple messages.
+ */
+ default int maxRecordSizeBytes()
+ {
+ return -1;
+ }
+
+ /**
+ * @return "zstd" to enable compression on large blobs, or null or empty string if disabled.
+ */
+ @Nullable
+ default String compression()
+ {
+ return null;
+ }
+
+ /**
+ * @return true if Kafka publisher should fail if Kafka client returns "record too large" error.
+ */
+ default boolean failOnRecordTooLargeError()
+ {
+ return false;
+ }
+
+ /**
+ * @return true if Kafka publisher should fail if Kafka client returns any other error.
+ */
+ default boolean failOnKafkaError()
+ {
+ return true;
+ }
+
+ /**
+ * Initialization of tables and loading config takes some time, returns if the config
+ * is ready to be loaded or not.
+ *
+ * @return true if config is ready to be read.
+ */
+ default boolean isConfigReady()
+ {
+ return true;
+ }
+
+ default Duration minDelayBetweenMicroBatches()
+ {
+ return Duration.ofMillis(1000);
+ }
+
+ default int maxCommitLogsPerInstance()
+ {
+ return 4;
+ }
+
+ /**
+ * @return the maximum number of entries to hold in the watermarker state for mutations that are have not achieved the consistency level.
+ * Each entry is an MD5 with a byte integer, approximately 30-60 bytes per entry before compression.
+ */
+ default int maxWatermarkerSize()
+ {
+ return DEFAULT_MAX_WATERMARKER_SIZE;
+ }
+
+ /**
+ * @return true if CDC state should be persisted to Cassandra.
+ */
+ default boolean persistEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * @return the delay in millis between persist calls.
+ */
+ default Duration persistDelay()
+ {
+ return Duration.ofMillis(1000);
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcStats.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcStats.java
new file mode 100644
index 00000000..3e029311
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCdcStats.java
@@ -0,0 +1,277 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+public interface SidecarCdcStats
+{
+ SidecarCdcStats STUB = new SidecarCdcStats()
+ {
+ };
+
+ /**
+ * Cdc is enabled.
+ */
+ default void captureCdcEnabled()
+ {
+ }
+
+ /**
+ * Cdc disabled and CdcPublisher will not be started.
+ */
+ default void captureCdcDisabled()
+ {
+ }
+
+ // cdc lifecycle stats
+
+ /**
+ * CdcPublisher started successfully.
+ *
+ * @param numConsumers number of Cdc consumers started
+ */
+ default void captureCdcStarted(int numConsumers)
+ {
+ }
+
+ /**
+ * CdcPublisher failed to start.
+ *
+ * @param t throwable
+ */
+ default void captureCdcStartFailure(Throwable t)
+ {
+ }
+
+ /**
+ * CdcConsumer started.
+ */
+ default void captureCdcConsumerStarted()
+ {
+ }
+
+ /**
+ * CdcConsumer stopped.
+ */
+ default void captureCdcConsumerStopped()
+ {
+ }
+
+ /**
+ * Cdc or Kafka config change resulting in Cdc restart.
+ */
+ default void captureCdcConfigChange()
+ {
+ }
+
+ /**
+ * Cassandra cluster topology changed resulting in Cdc restart.
+ */
+ default void captureCdcClusterTopologyChange()
+ {
+ }
+
+ /**
+ * Cdc gained ownership for a token range.
+ */
+ default void captureCdcTokenRangeGained()
+ {
+ }
+
+ /**
+ * Cdc lost ownership for a token range.
+ */
+ default void captureCdcTokenRangeLost()
+ {
+ }
+
+ /**
+ * CdcPublisher restarted.
+ */
+ default void captureCdcRestart()
+ {
+ }
+
+ /**
+ * CdcPublisher stopped.
+ */
+ default void captureCdcStopped()
+ {
+ }
+
+ /**
+ * CdcPublisher failed to stop gracefully.
+ *
+ * @param t throwable
+ */
+ default void captureCdcStopFailed(Throwable t)
+ {
+ }
+
+ /**
+ * CdcConsumer read from state.
+ *
+ * @param count number of state objects.
+ * @param len byte length of state.
+ */
+ default void captureCdcConsumerReadFromState(int count, int len)
+ {
+ }
+
+ default void captureCdcStateDeserializationFailure()
+ {
+ }
+
+ /**
+ * New blank CdcConsumer initialized.
+ */
+ default void captureNewBlankCdcConsumer()
+ {
+ }
+
+ // cdc consumer stats
+
+ /**
+ * Cdc consumer completed.
+ *
+ * @param epoch epoch number, monotonically increasing 64-bit signed integer.
+ * @param numDownInstances number of down instances
+ * @param numTables number of cached CDC enabled tables
+ * @param runtimeNanos runtime of the previous epoch in nanoseconds
+ */
+ default void captureCdcNextEpoch(long epoch, int numDownInstances, int numTables, long runtimeNanos)
+ {
+
+ }
+
+ /**
+ * Single Cdc event processed.
+ */
+ default void captureCdcEventProcessed()
+ {
+ }
+
+ /**
+ * Recoverable Error detected in the CdcConsumer.
+ */
+ default void captureRecoverableCdcError(Throwable t)
+ {
+ }
+
+ /**
+ * Unrecoverable Error detected in the CdcConsumer causing it to stop.
+ */
+ default void captureUnrecoverableCdcError(Throwable t)
+ {
+ }
+
+ // state persist stats
+
+ /**
+ * Kafka queued events flushed.
+ *
+ * @param timeNanos time taken to flush in nanoseconds.
+ */
+ default void captureKafkaFlushTime(long timeNanos)
+ {
+ }
+
+ /**
+ * State persister backed up and not keeping up with persist cadence.
+ *
+ * @param numTasks number of active flush tasks queued.
+ */
+ default void capturePersistBackedUp(int numTasks)
+ {
+ }
+
+ /**
+ * Persist state request to storage.
+ *
+ * @param len byte length of state
+ */
+ default void capturePersistingCdcStateLength(int len)
+ {
+ }
+
+ /**
+ * Persist request succeeded.
+ *
+ * @param timeNanos time in nanos taken to persist.
+ */
+ default void capturePersistSucceeded(long timeNanos)
+ {
+ }
+
+ /**
+ * Persist failed with error.
+ *
+ * @param t throwable
+ */
+ default void capturePersistFailed(Throwable t)
+ {
+ }
+
+ /**
+ * Schema has been published.
+ */
+ default void capturePublishedSchema()
+ {
+ }
+
+ /**
+ * Cdc state has been written through http api.
+ *
+ * @param len length of the request body
+ */
+ default void captureCdcStatePutRequest(int len)
+ {
+ }
+
+ /**
+ * PutCdcStateHandler failed to write cdc state to store.
+ */
+ default void captureCdcStatePutRequestFailure()
+ {
+ }
+
+ /**
+ * Cdc state has been read through the http api.
+ *
+ * @param count number of Cdc state objects returned
+ * @param len length of the response body
+ */
+ default void captureCdcStateGetRequest(int count, int len)
+ {
+ }
+
+ /**
+ * A Cdc enabled table is not enabled in the Schema.instance singleton, this is a critical alert as the table will skipped when reading the commit log.
+ */
+ default void captureCdcTableNotEnabled()
+ {
+ }
+
+ /**
+ * cdc_on_repair is enabled in the yaml file and should be disabled.
+ */
+ default void captureCdcOnRepairEnabled()
+ {
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProvider.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProvider.java
new file mode 100644
index 00000000..d6954022
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProvider.java
@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.google.common.collect.Range;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.cdc.api.CommitLogProvider;
+import org.apache.cassandra.spark.data.ReplicationFactor;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.data.partitioner.CassandraRing;
+import org.apache.cassandra.spark.data.partitioner.Partitioner;
+import org.apache.cassandra.spark.utils.FutureUtils;
+import org.apache.cassandra.spark.utils.ThrowableUtils;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * The SidecarCommitLogProvider implements a CommitLogProvider for listing and reading
+ * CommitLog segments over the Sidecar HTTP APIs.
+ * This class uses the `CassandraRing` object to only select CassandraInstance objects
+ * that overlap with the TokenRange supplied.
+ */
+public class SidecarCommitLogProvider implements CommitLogProvider
+{
+ private static final Logger LOGGER = LoggerFactory.getLogger(SidecarCommitLogProvider.class);
+
+ private final ClusterConfigProvider clusterConfigProvider;
+ private final SidecarCdcClient sidecarCdcClient;
+ private final SidecarDownMonitor downMonitor;
+ private final Predicate<CassandraInstance> dcFilter;
+ private final ReplicationFactorSupplier replicationFactorSupplier;
+
+ public SidecarCommitLogProvider(ClusterConfigProvider clusterConfigProvider,
+ SidecarCdcClient sidecarCdcClient,
+ SidecarDownMonitor downMonitor,
+ ReplicationFactorSupplier replicationFactorSupplier)
+ {
+ this.clusterConfigProvider = clusterConfigProvider;
+ this.sidecarCdcClient = sidecarCdcClient;
+ this.downMonitor = downMonitor;
+ this.replicationFactorSupplier = replicationFactorSupplier;
+ this.dcFilter = inst -> {
+ String dc = clusterConfigProvider.dc();
+ return dc == null || inst.dataCenter().equalsIgnoreCase(dc);
+ };
+ }
+
+ protected CassandraRing ring()
+ {
+ Set<CassandraInstance> cluster = clusterConfigProvider.getCluster()
+ .stream()
+ .filter(dcFilter)
+ .collect(Collectors.toSet());
+ Partitioner partitioner = clusterConfigProvider.partitioner();
+ ReplicationFactor rf = replicationFactorSupplier.getMaximalReplicationFactor();
+ return new CassandraRing(partitioner, "keyspace", rf, cluster);
+ }
+
+ protected static Range<BigInteger> toGuavaRange(TokenRange range)
+ {
+ return Range.openClosed(range.lowerEndpoint(), range.upperEndpoint());
+ }
+
+ @Override
+ public Stream<CommitLog> logs(@Nullable TokenRange tokenRange)
+ {
+ //TODO: a future improvement could read CommitLog directly from disk if CassandraInstance is local
+ List<CassandraInstance> instances;
+ if (tokenRange != null)
+ {
+ // find only Cassandra instances that overlap with range filter
+ instances = ring().getSubRanges(toGuavaRange(tokenRange)).asMapOfRanges().values().stream()
+ .flatMap(Collection::stream)
+ .collect(Collectors.toList());
+ }
+ else
+ {
+ instances = new ArrayList<>(ring().instances());
+ }
+
+ Set<CassandraInstance> replicas = instances.stream()
+ .filter(dcFilter)
+ .filter(downMonitor::isUp)
+ .collect(Collectors.toSet());
+
+ List<CompletableFuture<List<CommitLog>>> futures = replicas
+ .stream()
+ .map(this::listInstance)
+ .collect(Collectors.toList());
+
+ // block to list replicas
+ List<List<CommitLog>> replicaLogs = FutureUtils.awaitAll(
+ futures,
+ true,
+ (throwable -> LOGGER.warn("Failed to list CDC commit logs on instance", (ThrowableUtils.rootCause(throwable))))
+ );
+
+ return replicaLogs.stream().flatMap(Collection::stream);
+ }
+
+ protected CompletableFuture<List<CommitLog>> listInstance(CassandraInstance instance)
+ {
+ return sidecarCdcClient
+ .listCdcCommitLogSegments(instance)
+ .whenComplete((response, throwable) -> {
+ if (response == null || throwable != null)
+ {
+ LOGGER.warn("Failed to list commit log segments on instance nodeName={}", instance.nodeName(), throwable);
+ downMonitor.hintDown(instance);
+ }
+ });
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarDownMonitor.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarDownMonitor.java
new file mode 100644
index 00000000..8f9370b8
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarDownMonitor.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+
+/**
+ * This interface provides information about the health of other Sidecar instances.
+ * CDC attempts to read from all replicas and is slowed by retrying requests on Sidecar instances that are already known to be DOWN,
+ * therefore we skip DOWN instances and only retry when they are known to be healthy again via some asynchronous mechanism.
+ */
+public interface SidecarDownMonitor
+{
+ SidecarDownMonitor STUB = new SidecarDownMonitor()
+ {
+ @Override
+ public boolean isDown(CassandraInstance instance)
+ {
+ return false;
+ }
+
+ @Override
+ public void hintDown(CassandraInstance instance)
+ {
+
+ }
+ };
+
+ /**
+ * @param instance the CassandraInstance
+ * @return true if the CassandraInstance is known to be not DOWN.
+ */
+ default boolean isUp(CassandraInstance instance)
+ {
+ return !isDown(instance);
+ }
+
+ /**
+ * @param instance the CassandraInstance
+ * @return true if the CassandraInstance is known to be DOWN.
+ */
+ boolean isDown(CassandraInstance instance);
+
+ /**
+ * Pass a hint down to the implementation that the CassandraInstance might be DOWN.
+ * It is up to the implementation to take this as canonical or take further action to detect the health.
+ *
+ * @param instance the CassandraInstance
+ */
+ void hintDown(CassandraInstance instance);
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersister.java b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersister.java
new file mode 100644
index 00000000..ad4c34d5
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/main/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersister.java
@@ -0,0 +1,434 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.google.common.annotations.VisibleForTesting;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.datastax.driver.core.ResultSetFuture;
+import com.datastax.driver.core.ThreadLocalMonotonicTimestampGenerator;
+import org.apache.cassandra.bridge.CdcBridgeFactory;
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.CdcKryoRegister;
+import org.apache.cassandra.cdc.api.CdcOptions;
+import org.apache.cassandra.cdc.api.StatePersister;
+import org.apache.cassandra.cdc.state.CdcState;
+import org.apache.cassandra.spark.utils.AsyncExecutor;
+import org.apache.cassandra.spark.utils.ThrowableUtils;
+import org.apache.cassandra.util.CompressionUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * SidecarStatePersister buffers CDC state and flushes at regular time intervals, so we only write the latest CDC state and don't wastefully write expired data.
+ */
+public class SidecarStatePersister implements StatePersister
+{
+ private static final Logger LOGGER = LoggerFactory.getLogger(SidecarStatePersister.class);
+
+ // group latest state by jobId/token range, so we persist independently
+ protected final ConcurrentHashMap<PersistWrapper.Key, PersistWrapper> latestState = new ConcurrentHashMap<>();
+ protected final ConcurrentLinkedQueue<TimedFutureWrapper> activeFlush = new ConcurrentLinkedQueue<>();
+ private final ThreadLocalMonotonicTimestampGenerator timestampGenerator = new ThreadLocalMonotonicTimestampGenerator();
+ private final SidecarCdcOptions sidecarCdcOptions;
+ private final CdcOptions cdcOptions;
+ private final SidecarCdcCassandraClient cassandraClient;
+ private final SidecarCdcStats sidecarCdcStats;
+ private final AsyncExecutor asyncExecutor;
+ volatile long timerId = -1L;
+
+ public SidecarStatePersister(SidecarCdcOptions sidecarCdcOptions,
+ CdcOptions cdcOptions,
+ SidecarCdcStats sidecarCdcStats,
+ SidecarCdcCassandraClient cassandraClient,
+ AsyncExecutor asyncExecutor)
+ {
+ this.sidecarCdcOptions = sidecarCdcOptions;
+ this.cdcOptions = cdcOptions;
+ this.sidecarCdcStats = sidecarCdcStats;
+ this.cassandraClient = cassandraClient;
+ this.asyncExecutor = asyncExecutor;
+ }
+
+ // StatePersister implemented methods
+
+ @Override
+ public void persist(String jobId, int partitionId, @Nullable TokenRange tokenRange, @NotNull ByteBuffer buf)
+ {
+ PersistWrapper latest = new PersistWrapper(jobId, partitionId, tokenRange, buf, timestampGenerator.next());
+ PersistWrapper.Key key = latest.key();
+ if (!latest.equals(this.latestState.get(key)))
+ {
+ this.latestState.compute(key, (k, prev) -> !latest.equals(prev) ? latest : prev);
+ }
+ }
+
+ @NotNull
+ @Override
+ public List<CdcState> loadState(String jobId, int partitionId, @Nullable TokenRange tokenRange)
+ {
+ CompressionUtil compressionUtil = CdcBridgeFactory.get(cdcOptions.version()).compressionUtil();
+ List<Integer> sizes = new ArrayList<>();
+ // deserialize and merge the CDC state objects into canonical view
+ List<CdcState> result = loadStateForRange(jobId, tokenRange)
+ .peek(bytes -> sizes.add(bytes.length))
+ .map(bytes -> CdcState.deserialize(CdcKryoRegister.kryo(), compressionUtil, bytes))
+ .collect(Collectors.toList());
+ int count = sizes.size();
+ int len = sizes.stream().mapToInt(i -> i).sum();
+ LOGGER.debug("Read CDC state from Cassandra jobId={} start={} end={} stateCount={} stateSize={}",
+ jobId, tokenRange == null ? "null" : tokenRange.lowerEndpoint(), tokenRange == null ? "null" : tokenRange.upperEndpoint(), count, len);
+ sidecarCdcStats.captureCdcConsumerReadFromState(count, len);
+ return result;
+ }
+
+ @VisibleForTesting
+ public Stream<byte[]> loadStateForRange(String jobId, @Nullable TokenRange tokenRange)
+ {
+ return cassandraClient
+ .loadStateForRange(jobId, tokenRange);
+ }
+
+ /**
+ * Start the SidecarStatePersister to flush to Cassandra every `persistDelay()`.
+ */
+ public synchronized void start()
+ {
+ if (timerId >= 0)
+ {
+ // already running
+ return;
+ }
+ this.timerId = asyncExecutor.periodicTimer(this::persistToCassandra, sidecarCdcOptions.persistDelay().toMillis());
+ }
+
+ /**
+ * Stop the SidecarStatePersister gracefully, blocking to await for any pending flushes to complete.
+ */
+ public void stop()
+ {
+ stop(true);
+ }
+
+ public synchronized void stop(boolean flush)
+ {
+ if (this.timerId < 0)
+ {
+ // not running
+ return;
+ }
+
+ asyncExecutor.cancelTimer(this.timerId);
+ this.timerId = -1;
+
+ if (flush)
+ {
+ flush();
+ }
+ }
+
+ // internal methods
+
+ protected void persistToCassandra()
+ {
+ persistToCassandra(false);
+ }
+
+ protected void persistToCassandra(boolean force)
+ {
+ // clean-up finished futures
+ activeFlush.removeIf(wrapper -> {
+ if (wrapper.allDone())
+ {
+ try
+ {
+ wrapper.await();
+ sidecarCdcStats.capturePersistSucceeded(System.nanoTime() - wrapper.startTimeNanos);
+ }
+ catch (InterruptedException e)
+ {
+ LOGGER.warn("Persist failed with InterruptedException", e);
+ Thread.currentThread().interrupt();
+ sidecarCdcStats.capturePersistFailed(e);
+ }
+ catch (Throwable throwable)
+ {
+ LOGGER.warn("Persist failed", throwable);
+ sidecarCdcStats.capturePersistFailed(throwable);
+ }
+ return true;
+ }
+ return false;
+ });
+
+ if (!force && !activeFlush.isEmpty())
+ {
+ // check for active requests so we don't get backed up
+ LOGGER.debug("CDC persist flush backed up, can't persist until active requests complete activeRequests={}", activeFlush.size());
+ sidecarCdcStats.capturePersistBackedUp(activeFlush.size());
+ return;
+ }
+
+ // drain the latestState map, so we don't persist multiple times wastefully
+ List<PersistWrapper> states = this.latestState
+ .keySet()
+ .stream()
+ .map(this.latestState::remove)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+
+ if (states.isEmpty())
+ {
+ // nothing to persist
+ return;
+ }
+
+ states.stream()
+ .map(this::persistToCassandra)
+ .filter(Objects::nonNull)
+ .forEach(activeFlush::add);
+ }
+
+ @Nullable
+ protected TimedFutureWrapper persistToCassandra(@NotNull PersistWrapper state)
+ {
+ TokenRange range = state.tokenRange();
+ if (range == null)
+ {
+ LOGGER.warn("Cannot persist state with null token range");
+ return null;
+ }
+
+ try
+ {
+ LOGGER.debug("Persisting CDC state jobId={} partitionId={} start={} end={} sizeBytes={}",
+ state.jobId,
+ state.partitionId,
+ range.lowerEndpoint(),
+ range.upperEndpoint(),
+ state.buf.remaining());
+
+ sidecarCdcStats.capturePersistingCdcStateLength(state.buf.remaining());
+ return new TimedFutureWrapper(cassandraClient.storeStateAsync(state.jobId, range, state.buf, state.timestamp));
+ }
+ catch (Throwable t)
+ {
+ LOGGER.error("Unexpected error persisting CDC state to Cassandra", t);
+ sidecarCdcStats.capturePersistFailed(t);
+ // we failed to persist, so add back to latestState map if not already overwritten
+ this.latestState.putIfAbsent(state.key(), state);
+ return null;
+ }
+ }
+
+ /**
+ * Flush active state persist calls
+ */
+ protected void flush()
+ {
+ // persist any buffered state and flush in-flight requests
+ persistToCassandra(true);
+ flushActiveSafe();
+ }
+
+ protected void flushActiveSafe()
+ {
+ try
+ {
+ flushActive();
+ }
+ catch (ExecutionException e)
+ {
+ LOGGER.warn("Failed to flush active CDC state", ThrowableUtils.rootCause(e));
+ }
+ catch (InterruptedException e)
+ {
+ Thread.currentThread().interrupt();
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Flush active in-flight persist writes.
+ *
+ * @throws ExecutionException
+ * @throws InterruptedException
+ */
+ protected void flushActive() throws ExecutionException, InterruptedException
+ {
+ for (TimedFutureWrapper wrapper : activeFlush)
+ {
+ wrapper.await();
+ }
+ }
+
+ // helper classes
+
+ protected static class PersistWrapper implements Comparable<PersistWrapper>
+ {
+ final String jobId;
+ final int partitionId;
+ @Nullable
+ final TokenRange tokenRange;
+ final ByteBuffer buf;
+ final long timestamp;
+
+ protected static class Key
+ {
+ private final String jobId;
+ private final TokenRange tokenRange;
+
+ protected Key(String jobId,
+ TokenRange tokenRange)
+ {
+ this.jobId = jobId;
+ this.tokenRange = tokenRange;
+ }
+
+ public int hashCode()
+ {
+ return Objects.hash(jobId, tokenRange);
+ }
+
+ public boolean equals(Object o)
+ {
+ if (this == o)
+ {
+ return true;
+ }
+
+ if (o == null || getClass() != o.getClass())
+ {
+ return false;
+ }
+
+ PersistWrapper.Key other = (PersistWrapper.Key) o;
+ return jobId.equals(other.jobId)
+ && Objects.equals(tokenRange, other.tokenRange);
+ }
+ }
+
+ protected PersistWrapper(String jobId,
+ int partitionId,
+ @Nullable TokenRange tokenRange,
+ ByteBuffer buf,
+ long timestamp)
+ {
+ this.jobId = jobId;
+ this.partitionId = partitionId;
+ this.tokenRange = tokenRange;
+ this.buf = buf;
+ this.timestamp = timestamp;
+ }
+
+ @Nullable
+ public TokenRange tokenRange()
+ {
+ return tokenRange;
+ }
+
+ public Key key()
+ {
+ return new Key(jobId, tokenRange());
+ }
+
+ @Override
+ public int compareTo(@NotNull PersistWrapper o)
+ {
+ return Long.compare(this.timestamp, o.timestamp);
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return Objects.hash(jobId, tokenRange());
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ if (this == o)
+ {
+ return true;
+ }
+
+ if (o == null || getClass() != o.getClass())
+ {
+ return false;
+ }
+
+ PersistWrapper other = (PersistWrapper) o;
+ return jobId.equals(other.jobId)
+ && Objects.equals(tokenRange(), other.tokenRange())
+ && this.buf.equals(other.buf);
+ }
+
+ public static PersistWrapper max(PersistWrapper w1, PersistWrapper w2)
+ {
+ if (w1 == null)
+ {
+ return w2;
+ }
+ else if (w2 == null)
+ {
+ return w1;
+ }
+
+ return w1.compareTo(w2) > 0 ? w1 : w2;
+ }
+ }
+
+ protected static class TimedFutureWrapper
+ {
+ protected final List<ResultSetFuture> futures;
+ protected final long startTimeNanos;
+
+ protected TimedFutureWrapper(List<ResultSetFuture> futures)
+ {
+ this.futures = futures;
+ this.startTimeNanos = System.nanoTime();
+ }
+
+ public void await() throws ExecutionException, InterruptedException
+ {
+ for (ResultSetFuture future : futures)
+ {
+ future.get();
+ }
+ }
+
+ public boolean allDone()
+ {
+ return futures.stream().allMatch(Future::isDone);
+ }
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/CassandraClientSourceTest.java b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/CassandraClientSourceTest.java
new file mode 100644
index 00000000..0a3bbafb
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/CassandraClientSourceTest.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import com.datastax.driver.core.BoundStatement;
+import com.datastax.driver.core.PreparedStatement;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.Session;
+import com.datastax.driver.core.Statement;
+import org.apache.cassandra.bridge.CassandraTypesImplementation;
+import org.apache.cassandra.cdc.msg.Value;
+import org.apache.cassandra.spark.data.CassandraTypes;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class CassandraClientSourceTest
+{
+ private static final CassandraTypes TYPES = new CassandraTypesImplementation();
+
+ @Test
+ public void testGetReadQuery()
+ {
+ String query = CassandraClientSource.getReadQuery("testKeyspace", "testTable", Arrays.asList("a", "b"), Arrays.asList("c", "d", "e"));
+ String expectedQuery = "SELECT a,b from testKeyspace.testTable where c = ? , d = ? , e = ?";
+ assertEquals(expectedQuery, query);
+ }
+
+ @Test
+ public void testGetPrimaryKeyObjects()
+ {
+ List<Value> primaryKeyColumns = Arrays.asList(
+ new TestValue("ks", "a", "int", TYPES.aInt().serialize(1)),
+ new TestValue("ks", "b", "text", ByteBuffer.wrap("test".getBytes(StandardCharsets.UTF_8)))
+ );
+ Object[] primaryKeyValues = CassandraClientSource.getPrimaryKeyObjects(TYPES, primaryKeyColumns);
+ assertEquals(1, primaryKeyValues[0]);
+ assertEquals("test", primaryKeyValues[1]);
+ }
+
+ @Test
+ public void testReadFromCassandra()
+ {
+ CassandraClientSource cassandraSource = new CassandraClientSource(getMockSession(), TYPES);
+
+ // column with name "a" of type int with value 1
+ List<Value> primaryKeyColumns = Collections.singletonList(new TestValue("ks", "a", "int", TYPES.aInt().serialize(1)));
+ List<ByteBuffer> result = cassandraSource.readFromCassandra("testKeyspace", "testTable", Collections.singletonList("b"), primaryKeyColumns);
+ assertEquals(100, result.get(0).getInt(result.get(0).position()));
+ }
+
+ // mock session that returns 100 on execution of query
+ private static Session getMockSession()
+ {
+ Session session = mock(Session.class);
+ // mock row
+ Row row = mock(Row.class);
+ when(row.getBytesUnsafe(anyString())).thenReturn(TYPES.aInt().serialize(100));
+
+ // mock result set
+ ResultSet resultSet = mock(ResultSet.class);
+ when(resultSet.one()).thenAnswer(invocation -> row);
+
+ // mock prepared statement
+ PreparedStatement preparedStatement = mock(PreparedStatement.class);
+ when(preparedStatement.bind(any())).thenAnswer(invocation -> mock(BoundStatement.class));
+
+ // mock session
+ when(session.prepare(anyString())).then(invocation -> preparedStatement);
+ when(session.execute(any(Statement.class))).thenAnswer(invocation -> resultSet);
+ doNothing().when(session).close();
+ return session;
+ }
+
+ private static class TestValue extends Value
+ {
+ private TestValue(String keyspace, String columnName, String columnType, ByteBuffer value)
+ {
+ super(keyspace, columnName, columnType, value);
+ }
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProviderTests.java b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProviderTests.java
new file mode 100644
index 00000000..c4190c42
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarCommitLogProviderTests.java
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import com.google.common.collect.ImmutableMap;
+import org.apache.commons.lang3.mutable.MutableInt;
+import org.junit.jupiter.api.Test;
+
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.api.CommitLog;
+import org.apache.cassandra.spark.data.ReplicationFactor;
+import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
+import org.apache.cassandra.spark.data.partitioner.Partitioner;
+import org.jetbrains.annotations.NotNull;
+import org.mockito.stubbing.Answer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class SidecarCommitLogProviderTests
+{
+ private static final List<CassandraInstance> INSTANCES = Arrays.asList(
+ new CassandraInstance("0", "local1", "DC1"),
+ new CassandraInstance("100", "local2", "DC1"),
+ new CassandraInstance("200", "local3", "DC1"),
+ new CassandraInstance("300", "local4", "DC1"),
+ new CassandraInstance("400", "local5", "DC1"),
+ new CassandraInstance("500", "local6", "DC1"),
+ new CassandraInstance("1", "local7", "DC2"),
+ new CassandraInstance("101", "local8", "DC2"),
+ new CassandraInstance("201", "local9", "DC2"),
+ new CassandraInstance("301", "local10", "DC2"),
+ new CassandraInstance("401", "local11", "DC2"),
+ new CassandraInstance("501", "local12", "DC2")
+ );
+
+ @Test
+ public void testCommitLogProvider()
+ {
+ int aPrimeNumber = 13;
+ CassandraInstance instance1 = INSTANCES.get(0);
+ CassandraInstance instance2 = INSTANCES.get(1);
+ CassandraInstance instance3 = INSTANCES.get(2);
+ CassandraInstance instance4 = INSTANCES.get(3);
+ CassandraInstance instance5 = INSTANCES.get(4);
+ CassandraInstance instance6 = INSTANCES.get(5);
+
+ ClusterConfigProvider clusterConfigProvider = getClusterConfigProvider();
+ SidecarCdcClient sidecarCdcClient = mock(SidecarCdcClient.class);
+ Map<CassandraInstance, Integer> instanceListCount = new HashMap<>();
+ MutableInt segmentIdGenerator = new MutableInt(0);
+ Answer<CompletableFuture<List<CommitLog>>> listCommitLogAnswer = invocation -> {
+ CassandraInstance instance = invocation.getArgument(0, CassandraInstance.class);
+ instanceListCount.compute(instance, (key, prev) -> prev == null ? 1 : prev + 1);
+ int instanceId = Integer.parseInt(instance.nodeName().substring(5));
+ int numLogs = instanceId * 13;
+ List<CommitLog> logs = IntStream.rangeClosed(1, numLogs)
+ .mapToObj(segmentId -> mockCommitLog(instance, segmentIdGenerator.getAndAdd(1)))
+ .collect(Collectors.toList());
+ return CompletableFuture.completedFuture(logs);
+ };
+
+ when(sidecarCdcClient.listCdcCommitLogSegments(any(CassandraInstance.class))).thenAnswer(listCommitLogAnswer);
+ SidecarCommitLogProvider commitLogProvider = getSidecarCommitLogProvider(clusterConfigProvider, sidecarCdcClient);
+
+ // list logs on instance1, instance2, instance3
+ TokenRange tokenRange = TokenRange.openClosed(
+ new BigInteger("-50"),
+ new BigInteger("-10")
+ );
+ List<CommitLog> logs = commitLogProvider
+ .logs(tokenRange)
+ .sorted()
+ .collect(Collectors.toList());
+ int expectedNumberOfLogs = aPrimeNumber + (2 * aPrimeNumber) + (3 * aPrimeNumber);
+ assertEquals(expectedNumberOfLogs, logs.size());
+ IntStream.range(0, logs.size())
+ .forEach(index -> assertEquals(index, logs.get(index).segmentId()));
+ assertEquals(3, instanceListCount.size());
+ assertEquals(1, instanceListCount.get(instance1));
+ assertEquals(1, instanceListCount.get(instance2));
+ assertEquals(1, instanceListCount.get(instance3));
+
+ // list logs on instance4, instance5, instance6
+ TokenRange tokenRange2 = TokenRange.openClosed(
+ new BigInteger("210"),
+ new BigInteger("280")
+ );
+ List<CommitLog> logs2 = commitLogProvider
+ .logs(tokenRange2)
+ .collect(Collectors.toList());
+ expectedNumberOfLogs = (4 * aPrimeNumber) + (5 * aPrimeNumber) + (6 * aPrimeNumber);
+ assertEquals(expectedNumberOfLogs, logs2.size());
+ IntStream.range(0, logs2.size())
+ .forEach(index -> assertEquals(index + logs.size(), logs2.get(index).segmentId()));
+ assertEquals(6, instanceListCount.size());
+ assertEquals(1, instanceListCount.get(instance1));
+ assertEquals(1, instanceListCount.get(instance2));
+ assertEquals(1, instanceListCount.get(instance3));
+ assertEquals(1, instanceListCount.get(instance4));
+ assertEquals(1, instanceListCount.get(instance5));
+ assertEquals(1, instanceListCount.get(instance6));
+ }
+
+ @NotNull
+ private static SidecarCommitLogProvider getSidecarCommitLogProvider(ClusterConfigProvider clusterConfigProvider, SidecarCdcClient sidecarCdcClient)
+ {
+ ReplicationFactorSupplier replicationFactorSupplier = new ReplicationFactorSupplier()
+ {
+ @Override
+ public ReplicationFactor getReplicationFactor(String keyspace)
+ {
+ return new ReplicationFactor(ImmutableMap.of(
+ "class", "org.apache.cassandra.locator.NetworkTopologyStrategy",
+ "DC1", "3",
+ "DC2", "3"));
+ }
+
+ @Override
+ public ReplicationFactor getMaximalReplicationFactor()
+ {
+ return getReplicationFactor("ks");
+ }
+ };
+ return new SidecarCommitLogProvider(
+ clusterConfigProvider,
+ sidecarCdcClient,
+ SidecarDownMonitor.STUB,
+ replicationFactorSupplier
+ );
+ }
+
+ private static CommitLog mockCommitLog(CassandraInstance instance, long segmentId)
+ {
+ CommitLog commitLog = mock(CommitLog.class);
+ when(commitLog.instance()).thenReturn(instance);
+ when(commitLog.name()).thenReturn("CommitLog-6-" + segmentId + ".log");
+ when(commitLog.segmentId()).thenCallRealMethod();
+ return commitLog;
+ }
+
+ @NotNull
+ private static ClusterConfigProvider getClusterConfigProvider()
+ {
+ return new ClusterConfigProvider()
+ {
+ @Override
+ public String dc()
+ {
+ return "DC1";
+ }
+
+ @Override
+ public Set<CassandraInstance> getCluster()
+ {
+ return new HashSet<>(INSTANCES);
+ }
+
+ @Override
+ public Partitioner partitioner()
+ {
+ return Partitioner.Murmur3Partitioner;
+ }
+ };
+ }
+}
diff --git a/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersisterTest.java b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersisterTest.java
new file mode 100644
index 00000000..07468655
--- /dev/null
+++ b/cassandra-analytics-cdc-sidecar/src/test/java/org/apache/cassandra/cdc/sidecar/SidecarStatePersisterTest.java
@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.sidecar;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+
+import com.datastax.driver.core.ResultSetFuture;
+import org.apache.cassandra.bridge.TokenRange;
+import org.apache.cassandra.cdc.api.CdcOptions;
+import org.apache.cassandra.spark.utils.AsyncExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class SidecarStatePersisterTest
+{
+ private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor();
+
+ @Test
+ public void testStatePersister() throws InterruptedException
+ {
+ Map<TokenRange, byte[]> store = new ConcurrentHashMap<>();
+ CountDownLatch writeLatch = new CountDownLatch(1);
+ SidecarCdcCassandraClient cassandraClient = new SidecarCdcCassandraClient()
+ {
+ @Override
+ public List<ResultSetFuture> storeStateAsync(@NotNull String jobId, @NotNull TokenRange range, @NotNull ByteBuffer buf, long timestamp)
+ {
+ byte[] ar = new byte[buf.remaining()];
+ buf.get(ar);
+ store.put(range, ar);
+ ResultSetFuture future = mock(ResultSetFuture.class);
+ when(future.isDone()).thenReturn(true);
+ writeLatch.countDown();
+ return Collections.singletonList(future);
+ }
+
+ @Override
+ public Stream<byte[]> loadStateForRange(String jobId, @Nullable TokenRange tokenRange)
+ {
+ return Stream.of(store.get(tokenRange));
+ }
+ };
+ SidecarCdcOptions sidecarCdcOptions = new SidecarCdcOptions()
+ {
+ @Override
+ public Duration persistDelay()
+ {
+ return Duration.ofMillis(50);
+ }
+ };
+ AsyncExecutor asyncExecutor = AsyncExecutor.wrap(EXECUTOR_SERVICE);
+
+ // build and start SidecarStatePersister
+ SidecarStatePersister statePersister = new SidecarStatePersister(
+ sidecarCdcOptions,
+ CdcOptions.DEFAULT,
+ SidecarCdcStats.STUB,
+ cassandraClient,
+ asyncExecutor
+ );
+ assertEquals(-1, statePersister.timerId);
+ statePersister.start();
+ assertTrue(statePersister.timerId >= 0);
+
+ // write random data
+ byte[] data = new byte[1024];
+ ThreadLocalRandom.current().nextBytes(data);
+ TokenRange tokenRange = TokenRange.openClosed(BigInteger.ONE, BigInteger.valueOf(10L));
+ statePersister.persist("101", 0, tokenRange, ByteBuffer.wrap(data));
+
+ // wait for write to complete and verify data matches
+ writeLatch.await(5, TimeUnit.SECONDS);
+ List<byte[]> result = statePersister.loadStateForRange("101", tokenRange).collect(Collectors.toList());
+ assertEquals(1, result.size());
+ assertArrayEquals(data, result.get(0));
+
+ statePersister.stop();
+ assertEquals(-1, statePersister.timerId);
+ }
+}
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java
index a0b0922c..b3409cdf 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/Cdc.java
@@ -70,12 +70,12 @@ public class Cdc implements Closeable
private final int partitionId;
private final TokenRangeSupplier tokenRangeSupplier;
private final TableIdLookup tableIdLookup;
- private final SchemaSupplier schemaSupplier;
+ protected final SchemaSupplier schemaSupplier;
private final CassandraSource cassandraSource;
private final StatePersister statePersister;
private final CdcOptions cdcOptions;
- private final AsyncExecutor asyncExecutor;
- private final CommitLogProvider commitLogProvider;
+ protected final AsyncExecutor asyncExecutor;
+ protected final CommitLogProvider commitLogProvider;
private final ICdcStats stats;
private final EventConsumer eventConsumer;
@@ -171,7 +171,7 @@ public class Cdc implements Closeable
if (isRunning.get() && isRunning.compareAndSet(true, false))
{
LOGGER.info("Stopping CDC Consumer jobId={} partitionId={}", jobId, partitionId);
- final CompletableFuture<Void> activeFuture = active.get();
+ CompletableFuture<Void> activeFuture = active.get();
if (activeFuture != null && blocking)
{
// block until active future completes
@@ -336,7 +336,7 @@ public class Cdc implements Closeable
protected boolean epochsExceeded()
{
- final int maxEpochs = cdcOptions.maxEpochs();
+ int maxEpochs = cdcOptions.maxEpochs();
return maxEpochs > 0 && this.currentState.epoch >= maxEpochs;
}
@@ -371,7 +371,7 @@ public class Cdc implements Closeable
try
{
- final ByteBuffer buf = serializeStateToBytes();
+ ByteBuffer buf = serializeStateToBytes();
LOGGER.debug("Persisting Iterator state between micro-batch partitionId={} epoch={} size={}",
partitionId, cdcState.epoch, buf.remaining());
statePersister.persist(jobId, partitionId, tokenRange, buf);
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java
index b6e9f3a3..d95315ed 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcBuilder.java
@@ -41,26 +41,28 @@ import org.jetbrains.annotations.Nullable;
public class CdcBuilder
{
@NotNull
- final String jobId;
- final int partitionId;
+ protected final String jobId;
+ protected final int partitionId;
@NotNull
TokenRangeSupplier tokenRangeSupplier = () -> null;
@NotNull
- SchemaSupplier schemaSupplier;
+ protected SchemaSupplier schemaSupplier;
@NotNull
CassandraSource cassandraSource = CassandraSource.DEFAULT;
@NotNull
StatePersister statePersister = StatePersister.STUB;
@NotNull
- CdcOptions cdcOptions = CdcOptions.DEFAULT;
+ protected CdcOptions cdcOptions = CdcOptions.DEFAULT;
@NotNull
ICdcStats stats = ICdcStats.STUB;
+ // asyncExecutor is @Nullable at compile time but required to be @NotNull at runtime to build the Cdc object
+ @SuppressWarnings("NotNullFieldNotInitialized")
+ @NotNull
+ protected AsyncExecutor asyncExecutor = null;
@Nullable
- AsyncExecutor asyncExecutor = null;
- @Nullable
- CommitLogProvider commitLogProvider = null;
+ protected CommitLogProvider commitLogProvider = null;
@NotNull
- EventConsumer eventConsumer;
+ protected EventConsumer eventConsumer;
@NotNull
public TableIdLookup tableIdLookup = TableIdLookup.STUB;
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java
index a74ba3fa..54e73f18 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/CdcKryoRegister.java
@@ -29,7 +29,7 @@ import org.apache.cassandra.spark.data.partitioner.CassandraInstance;
public class CdcKryoRegister
{
private static final ThreadLocal<Kryo> KRYO = ThreadLocal.withInitial(() -> {
- final Kryo kryo = new Kryo();
+ Kryo kryo = new Kryo();
new CdcKryoRegister().registerClasses(kryo);
return kryo;
});
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/TypeCache.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/TypeCache.java
new file mode 100644
index 00000000..7fde0ca3
--- /dev/null
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/TypeCache.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Supplier;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.cassandra.bridge.CassandraVersion;
+import org.apache.cassandra.bridge.CdcBridgeFactory;
+import org.apache.cassandra.cdc.api.KeyspaceTypeKey;
+import org.apache.cassandra.spark.data.CassandraTypes;
+import org.apache.cassandra.spark.data.CqlField;
+
+/**
+ * Caches Cassandra CqlField.CqlType objects, so they don't need to be re-created everytime. Keyed on keyspace and type to permit per keyspace UDT definitions.
+ */
+public class TypeCache
+{
+ private static final Logger LOGGER = LoggerFactory.getLogger(TypeCache.class);
+ protected volatile Cache<KeyspaceTypeKey, CqlField.CqlType> cqlTypeCache = null; // volatile needed for lazy-initialization
+ private static final int CACHE_CAPACITY = 1000;
+ private static final ConcurrentHashMap<CassandraVersion, TypeCache> VERSION_TYPE_CACHE = new ConcurrentHashMap<>(2);
+
+ private final Supplier<CassandraTypes> cassandraTypesSupplier;
+
+ protected TypeCache(Supplier<CassandraTypes> cassandraTypesSupplier)
+ {
+ this.cassandraTypesSupplier = cassandraTypesSupplier;
+ }
+
+ public CqlField.CqlType getType(String keyspace, String typeString)
+ {
+ maybeInit();
+ CqlField.CqlType result;
+ KeyspaceTypeKey key = KeyspaceTypeKey.of(keyspace, typeString);
+ try
+ {
+ result = cqlTypeCache.get(key, () -> getTypes().parseType(keyspace, typeString));
+ }
+ catch (CacheLoader.InvalidCacheLoadException | ExecutionException e)
+ {
+ LOGGER.warn("Unable to get the CQL type from cache.", e);
+ result = getTypes().parseType(typeString);
+ if (result == null)
+ {
+ throw new RuntimeException("Unable to parse type: " + typeString);
+ }
+ cqlTypeCache.put(key, result);
+ }
+ return result;
+ }
+
+ public CassandraTypes getTypes()
+ {
+ return cassandraTypesSupplier.get();
+ }
+
+ public static TypeCache get(CassandraVersion version)
+ {
+ return VERSION_TYPE_CACHE
+ .compute(version,
+ (key, previous) ->
+ new TypeCache(() -> CdcBridgeFactory.get(key).cassandraTypes())
+ );
+ }
+
+ private void maybeInit()
+ {
+ if (cqlTypeCache != null)
+ {
+ return;
+ }
+
+ synchronized (this)
+ {
+ if (cqlTypeCache != null)
+ {
+ return;
+ }
+
+ // using a manual cache since the parser is version dependent, see getCassandraBridge()
+ cqlTypeCache = CacheBuilder.newBuilder()
+ .initialCapacity(CACHE_CAPACITY / 2)
+ .maximumSize(CACHE_CAPACITY)
+ .removalListener(notification -> {
+ // Log at the info level: the event is not expected, but could happen.
+ // With the logs, we can check how frequent it happens.
+ LOGGER.info("Type is evicted from cache. type='{}'", notification.getKey());
+ })
+ .build();
+ }
+ }
+}
diff --git a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java
index b245c6fa..e5cbdbd7 100644
--- a/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java
+++ b/cassandra-analytics-cdc/src/main/java/org/apache/cassandra/cdc/msg/jdk/CdcMessage.java
@@ -79,16 +79,16 @@ public class CdcMessage
@SuppressWarnings("unchecked")
private static Function<String, CqlField.CqlType> typeProvider(CassandraTypes types, CdcEvent event)
{
- final List<Value> cols = ArrayUtils.combine(event.getPartitionKeys(),
- event.getClusteringKeys(),
- event.getStaticColumns(),
- event.getValueColumns());
- final Map<String, CqlField.CqlType> typeMap = cols
- .stream()
- .collect(Collectors
- .toMap(v -> v.columnName,
- v -> types.parseType(event.keyspace, v.columnType)
- ));
+ List<Value> cols = ArrayUtils.combine(event.getPartitionKeys(),
+ event.getClusteringKeys(),
+ event.getStaticColumns(),
+ event.getValueColumns());
+ Map<String, CqlField.CqlType> typeMap = cols
+ .stream()
+ .collect(Collectors
+ .toMap(v -> v.columnName,
+ v -> types.parseType(event.keyspace, v.columnType)
+ ));
return typeMap::get;
}
@@ -134,7 +134,7 @@ public class CdcMessage
.entrySet()
.stream()
.collect(Collectors.toMap(Map.Entry::getKey, entry -> {
- final CqlField.CqlCollection type = (CqlField.CqlCollection) typeProvider.apply(entry.getKey());
+ CqlField.CqlCollection type = (CqlField.CqlCollection) typeProvider.apply(entry.getKey());
return entry.getValue().stream().map(ByteBuffer::duplicate).map(buf -> type.type().deserializeToJavaType(buf)).collect(Collectors.toList());
}));
}
diff --git a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java
index 04e9c88f..6fdcdc32 100644
--- a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java
+++ b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTester.java
@@ -168,7 +168,7 @@ public class CdcTester
// add default writer
this.writers.add((tester, rows, writer) -> {
- final long timestampMicros = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());
+ long timestampMicros = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());
IntStream.range(0, tester.numRows)
.forEach(i -> writer.accept(newUniqueRow(tester.schema, rows), timestampMicros));
});
diff --git a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java
index 28c29c74..459a4e03 100644
--- a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java
+++ b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/CdcTests.java
@@ -221,7 +221,7 @@ public class CdcTests
true);
UUID tableId = Schema.instance.getTableMetadata(table.keyspace(), table.table()).id.asUUID();
SchemaSupplier schemaSupplier = () -> CompletableFuture.completedFuture(ImmutableSet.of(table));
- final AtomicReference<byte[]> state = new AtomicReference<>();
+ AtomicReference<byte[]> state = new AtomicReference<>();
StatePersister statePersister = new StatePersister()
{
public void persist(String jobId, int partitionId, @Nullable TokenRange tokenRange, @NotNull ByteBuffer buf)
@@ -254,7 +254,7 @@ public class CdcTests
CdcTester.testCommitLog.sync();
};
- final long startTime = System.currentTimeMillis();
+ long startTime = System.currentTimeMillis();
try (Cdc cdc = Cdc.builder("101", 0, eventConsumer, schemaSupplier)
.withExecutor(CdcTests.ASYNC_EXECUTOR)
.withStatePersister(statePersister)
diff --git a/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/TypeCacheTests.java b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/TypeCacheTests.java
new file mode 100644
index 00000000..56cf9283
--- /dev/null
+++ b/cassandra-analytics-cdc/src/test/java/org/apache/cassandra/cdc/TypeCacheTests.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc;
+
+import org.junit.jupiter.api.Test;
+
+import org.apache.cassandra.bridge.CassandraVersion;
+import org.apache.cassandra.spark.data.CassandraTypes;
+import org.apache.cassandra.spark.data.CqlField;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class TypeCacheTests
+{
+ @Test
+ public void testTypeCache()
+ {
+ TypeCache typeCache = TypeCache.get(CassandraVersion.FOURZERO);
+ assertNull(typeCache.cqlTypeCache);
+
+ CqlField.CqlType ksBigInt = typeCache.getType("ks", "bigint");
+ assertNotNull(typeCache.cqlTypeCache);
+ assertEquals("bigint", ksBigInt.cqlName());
+ assertEquals(1, typeCache.cqlTypeCache.size());
+ typeCache.getType("ks", "bigint");
+ typeCache.getType("ks", "bigint");
+ typeCache.getType("ks", "bigint");
+ assertEquals(1, typeCache.cqlTypeCache.size());
+
+ CqlField.CqlType ks2BigInt = typeCache.getType("ks2", "bigint");
+ assertEquals("bigint", ks2BigInt.cqlName());
+ assertSame(ksBigInt, ks2BigInt);
+
+ assertSame(typeCache.getType("ks", "int"), typeCache.getType("ks2", "int"));
+ assertSame(typeCache.getType("ks", "text"), typeCache.getType("ks2", "text"));
+ assertSame(typeCache.getType("ks", "boolean"), typeCache.getType("ks2", "boolean"));
+ assertSame(typeCache.getType("ks", "double"), typeCache.getType("ks2", "double"));
+ assertSame(typeCache.getType("ks", "float"), typeCache.getType("ks2", "float"));
+ assertEquals(12, typeCache.cqlTypeCache.size());
+
+ // test collections
+ assertInstanceOf(CqlField.CqlMap.class, typeCache.getType("ks", "map<text, int>"));
+ assertInstanceOf(CqlField.CqlList.class, typeCache.getType("ks", "list<ascii>"));
+ assertInstanceOf(CqlField.CqlSet.class, typeCache.getType("ks", "set<date>"));
+ assertInstanceOf(CqlField.CqlFrozen.class, typeCache.getType("ks", "frozen<set<blob>>"));
+ assertEquals(16, typeCache.cqlTypeCache.size());
+
+ // test udt
+ CassandraTypes cassandraTypes = typeCache.getTypes();
+ cassandraTypes.updateUDTs("ks", cassandraTypes
+ .udt("ks", "my_udt")
+ .withField("a", cassandraTypes.bigint())
+ .withField("b", cassandraTypes.text())
+ .withField("c", cassandraTypes.inet())
+ .withField("d", cassandraTypes.aInt())
+ .build());
+ CqlField.CqlType udtType = typeCache.getType("ks", "my_udt");
+ assertEquals("my_udt", udtType.cqlName());
+ assertEquals(17, typeCache.cqlTypeCache.size());
+
+ assertThrows(RuntimeException.class, () -> assertNull(typeCache.getType("ks2", "my_udt")));
+ }
+}
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java
index 0633d12e..2f0e9024 100644
--- a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLog.java
@@ -41,19 +41,19 @@ public interface CommitLog extends Closeable, CassandraFile, Comparable<CommitLo
// match both legacy and new version of commitlogs Ex: CommitLog-12345.log and CommitLog-6-12345.log.
Pattern COMMIT_LOG_FILE_PATTERN = Pattern.compile("CommitLog(-(\\d+))?-(\\d+).log");
- static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull final CommitLog log)
+ static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull CommitLog log)
{
return extractVersionAndSegmentId(log.name());
}
- static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull final String filename)
+ static Optional<Pair<Integer, Long>> extractVersionAndSegmentId(@NotNull String filename)
{
- final Matcher matcher = CommitLog.COMMIT_LOG_FILE_PATTERN.matcher(filename);
+ Matcher matcher = CommitLog.COMMIT_LOG_FILE_PATTERN.matcher(filename);
if (matcher.matches())
{
try
{
- final int version = matcher.group(2) == null ? 6 : Integer.parseInt(matcher.group(2));
+ int version = matcher.group(2) == null ? 6 : Integer.parseInt(matcher.group(2));
if (version != 6 && version != 7)
{
throw new IllegalStateException("Unknown commitlog version " + version);
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java
index d5d9eb4e..c3ebac7f 100644
--- a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/CommitLogMarkers.java
@@ -59,7 +59,7 @@ public interface CommitLogMarkers extends Serializable
*/
boolean canIgnore(Marker position, BigInteger token);
- static PerInstanceCommitLogMarkers of(@Nullable final Marker marker)
+ static PerInstanceCommitLogMarkers of(@Nullable Marker marker)
{
if (marker == null)
{
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/KeyspaceTypeKey.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/KeyspaceTypeKey.java
new file mode 100644
index 00000000..f2664a78
--- /dev/null
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/cdc/api/KeyspaceTypeKey.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.cdc.api;
+
+import java.util.Objects;
+
+public class KeyspaceTypeKey
+{
+ public final String keyspace;
+ public final String type;
+
+ public KeyspaceTypeKey(String keyspace, String type)
+ {
+ this.keyspace = keyspace;
+ this.type = type;
+ }
+
+ public static KeyspaceTypeKey of(String keyspace, String type)
+ {
+ return new KeyspaceTypeKey(keyspace, type);
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ if (this == o)
+ {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass())
+ {
+ return false;
+ }
+ KeyspaceTypeKey that = (KeyspaceTypeKey) o;
+ return keyspace.equals(that.keyspace) && type.equals(that.type);
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return Objects.hash(keyspace, type);
+ }
+
+ @Override
+ public String toString()
+ {
+ return "KeyspaceTypeKey{" +
+ "keyspace='" + keyspace + '\'' +
+ ", type='" + type + '\'' +
+ '}';
+ }
+}
diff --git a/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java b/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java
index 0a2f8126..10a8bf3b 100644
--- a/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java
+++ b/cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/AsyncExecutor.java
@@ -19,11 +19,15 @@
package org.apache.cassandra.spark.utils;
+import java.util.Map;
import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Supplier;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
@@ -46,6 +50,24 @@ public interface AsyncExecutor
<T> CompletableFuture<Void> schedule(Runnable action, long delayMillis);
+ /**
+ * Set a periodic timer to fire every delay milliseconds with initial delay, at which point handler will be called with the id of the timer.
+ *
+ * @param action runnable action to execute every `delayMillis`
+ * @param delayMillis the delay in milliseconds, after which the timer will fire
+ * @return unique timer id
+ */
+ long periodicTimer(Runnable action, long delayMillis);
+
+ /**
+ * Cancels the timer with the specified id.
+ * true if the timer was successfully cancelled, or false if the timer does not exist.
+ *
+ * @param timerId The id of the timer to cancel
+ * @return true if the timer was successfully cancelled, or false if the timer does not exist.
+ */
+ boolean cancelTimer(long timerId);
+
static AsyncExecutor wrap(ExecutorService executorService)
{
return new ExecutorServiceBased(executorService);
@@ -53,6 +75,8 @@ public interface AsyncExecutor
class ExecutorServiceBased implements AsyncExecutor
{
+ private final AtomicLong timerIds = new AtomicLong(0L);
+ private final Map<Long, ScheduledFuture<?>> timerTasks = new ConcurrentHashMap<>();
private static final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(1,
new ThreadFactoryBuilder()
.setNameFormat("scheduler-%d")
@@ -94,5 +118,28 @@ public interface AsyncExecutor
}, delayMillis, TimeUnit.MILLISECONDS);
return future;
}
+
+ @Override
+ public long periodicTimer(Runnable action, long delayMillis)
+ {
+ long timerId = timerIds.getAndIncrement();
+ ScheduledFuture<?> future = SCHEDULER.scheduleAtFixedRate(action, delayMillis, delayMillis, TimeUnit.MILLISECONDS);
+ if (timerTasks.put(timerId, future) != null)
+ {
+ throw new IllegalStateException("Duplicate timerId: " + timerId);
+ }
+ return timerId;
+ }
+
+ @Override
+ public boolean cancelTimer(long timerId)
+ {
+ ScheduledFuture<?> future = timerTasks.get(timerId);
+ if (future != null)
+ {
+ return future.cancel(true);
+ }
+ return false;
+ }
}
}
diff --git a/cassandra-analytics-core/build.gradle b/cassandra-analytics-core/build.gradle
index 0ead5528..a44519c5 100644
--- a/cassandra-analytics-core/build.gradle
+++ b/cassandra-analytics-core/build.gradle
@@ -65,6 +65,7 @@ dependencies {
api(project(':cassandra-bridge'))
implementation project(":cassandra-analytics-common")
+ implementation project(":cassandra-analytics-sidecar-client")
fourzero(project(path: ':cassandra-four-zero', configuration: 'shadow'))
fourzerobridge(project(path: ':cassandra-four-zero-bridge'))
fourzerotypes(project(path: ':cassandra-four-zero-types'))
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/AnalyticsSidecarClient.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/AnalyticsSidecarClient.java
new file mode 100644
index 00000000..d3d248d4
--- /dev/null
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/AnalyticsSidecarClient.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cassandra.clients;
+
+import o.a.c.sidecar.client.shaded.io.vertx.core.Vertx;
+import o.a.c.sidecar.client.shaded.io.vertx.core.VertxOptions;
+import org.apache.cassandra.sidecar.client.HttpClientConfig;
+import org.apache.cassandra.sidecar.client.SidecarClient;
+import org.apache.cassandra.sidecar.client.SidecarClientConfig;
+import org.apache.cassandra.sidecar.client.SidecarClientConfigImpl;
+import org.apache.cassandra.sidecar.client.SidecarInstancesProvider;
+import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
+import org.apache.cassandra.spark.bulkwriter.DataTransport;
+import org.apache.cassandra.spark.utils.BuildInfo;
+import org.apache.cassandra.spark.validation.BulkWriterKeyStoreValidation;
+import org.apache.cassandra.spark.validation.BulkWriterTrustStoreValidation;
+import org.apache.cassandra.spark.validation.SslValidation;
+import org.apache.cassandra.spark.validation.StartupValidator;
+
+public class AnalyticsSidecarClient
+{
+ private AnalyticsSidecarClient()
+ {
+ }
+
+ public static SidecarClient from(SidecarInstancesProvider sidecarInstancesProvider, BulkSparkConf conf)
+ {
+ Vertx vertx = Vertx.vertx(new VertxOptions().setUseDaemonThread(true)
+ .setWorkerPoolSize(conf.getMaxHttpConnections()));
+
+ String userAgent = transportModeBasedWriterUserAgent(conf.getTransportInfo().getTransport());
+ HttpClientConfig httpClientConfig = new HttpClientConfig.Builder<>()
+ .timeoutMillis(conf.getHttpResponseTimeoutMs())
+ .idleTimeoutMillis(conf.getHttpConnectionTimeoutMs())
+ .userAgent(userAgent)
+ .keyStoreInputStream(conf.getKeyStore())
+ .keyStorePassword(conf.getKeyStorePassword())
+ .keyStoreType(conf.getKeyStoreTypeOrDefault())
+ .trustStoreInputStream(conf.getTrustStore())
+ .trustStorePassword(conf.getTrustStorePasswordOrDefault())
+ .trustStoreType(conf.getTrustStoreTypeOrDefault())
+ .ssl(conf.hasKeystoreAndKeystorePassword())
+ .build();
+
+ StartupValidator.instance().register(new SslValidation(conf));
+ StartupValidator.instance().register(new BulkWriterKeyStoreValidation(conf));
+ StartupValidator.instance().register(new BulkWriterTrustStoreValidation(conf));
+
+ SidecarClientConfig sidecarConfig =
+ SidecarClientConfigImpl.builder()
+ .maxRetries(conf.getSidecarRequestRetries())
+ .retryDelayMillis(conf.getSidecarRequestRetryDelayMillis())
+ .maxRetryDelayMillis(conf.getSidecarRequestMaxRetryDelayMillis())
+ .build();
+
+ return Sidecar.buildClient(sidecarConfig, vertx, httpClientConfig, sidecarInstancesProvider);
+ }
+
+ static String transportModeBasedWriterUserAgent(DataTransport transport)
+ {
+ switch (transport)
+ {
+ case S3_COMPAT:
+ return BuildInfo.WRITER_S3_USER_AGENT;
+ case DIRECT:
+ default:
+ return BuildInfo.WRITER_USER_AGENT;
+ }
+ }
+}
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java
index b5d6fd10..d67981c1 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/bulkwriter/CassandraContext.java
@@ -27,7 +27,7 @@ import com.google.common.base.Preconditions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.apache.cassandra.clients.Sidecar;
+import org.apache.cassandra.clients.AnalyticsSidecarClient;
import org.apache.cassandra.sidecar.client.SidecarClient;
import org.apache.cassandra.sidecar.client.SidecarInstance;
import org.apache.cassandra.sidecar.client.SimpleSidecarInstancesProvider;
@@ -87,7 +87,7 @@ public class CassandraContext implements StartupValidatable, Closeable
protected SidecarClient initializeSidecarClient(BulkSparkConf conf)
{
- return Sidecar.from(new SimpleSidecarInstancesProvider(new ArrayList<>(clusterConfig)), conf);
+ return AnalyticsSidecarClient.from(new SimpleSidecarInstancesProvider(new ArrayList<>(clusterConfig)), conf);
}
protected Set<SidecarInstance> createClusterConfig()
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterKeyStoreValidation.java
similarity index 62%
copy from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
copy to cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterKeyStoreValidation.java
index 3a3c5a82..dd01eff9 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterKeyStoreValidation.java
@@ -19,24 +19,18 @@
package org.apache.cassandra.spark.validation;
-/**
- * An interface that has to be implemented by all startup validations
- */
-@FunctionalInterface
-public interface StartupValidation
-{
- void validate();
+import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
+import org.jetbrains.annotations.NotNull;
- default Throwable perform()
+public class BulkWriterKeyStoreValidation extends KeyStoreValidation
+{
+ public BulkWriterKeyStoreValidation(@NotNull BulkSparkConf configuration)
{
- try
- {
- validate();
- }
- catch (Throwable throwable)
- {
- return throwable;
- }
- return null;
+ super(
+ configuration.hasKeystoreAndKeystorePassword(),
+ configuration.getKeyStoreTypeOrDefault(),
+ configuration.getKeyStorePassword() == null ? null : configuration.getKeyStorePassword().toCharArray(),
+ configuration::getKeyStore
+ );
}
}
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterTrustStoreValidation.java
similarity index 63%
copy from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
copy to cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterTrustStoreValidation.java
index 3a3c5a82..d9a4643e 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
+++ b/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/BulkWriterTrustStoreValidation.java
@@ -19,24 +19,18 @@
package org.apache.cassandra.spark.validation;
-/**
- * An interface that has to be implemented by all startup validations
- */
-@FunctionalInterface
-public interface StartupValidation
-{
- void validate();
+import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
+import org.jetbrains.annotations.NotNull;
- default Throwable perform()
+public class BulkWriterTrustStoreValidation extends TrustStoreValidation
+{
+ public BulkWriterTrustStoreValidation(@NotNull BulkSparkConf configuration)
{
- try
- {
- validate();
- }
- catch (Throwable throwable)
- {
- return throwable;
- }
- return null;
+ super(
+ configuration.hasTruststoreAndTruststorePassword(),
+ configuration.getTrustStoreTypeOrDefault(),
+ configuration.getTrustStorePasswordOrDefault().toCharArray(),
+ configuration::getTrustStore
+ );
}
}
diff --git a/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java b/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java
index bff83f38..54a530a1 100644
--- a/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java
+++ b/cassandra-analytics-core/src/test/java/org/apache/cassandra/clients/SidecarClientConfigTest.java
@@ -108,10 +108,10 @@ public class SidecarClientConfigTest
@Test
public void testTransportModeBasedWriterUserAgent()
{
- String userAgentStr = Sidecar.transportModeBasedWriterUserAgent(DataTransport.DIRECT);
+ String userAgentStr = AnalyticsSidecarClient.transportModeBasedWriterUserAgent(DataTransport.DIRECT);
assertTrue(userAgentStr.endsWith(" writer"));
- userAgentStr = Sidecar.transportModeBasedWriterUserAgent(DataTransport.S3_COMPAT);
+ userAgentStr = AnalyticsSidecarClient.transportModeBasedWriterUserAgent(DataTransport.S3_COMPAT);
assertTrue(userAgentStr.endsWith(" writer-s3"));
}
}
diff --git a/cassandra-analytics-sidecar-client/build.gradle b/cassandra-analytics-sidecar-client/build.gradle
new file mode 100644
index 00000000..1126601b
--- /dev/null
+++ b/cassandra-analytics-sidecar-client/build.gradle
@@ -0,0 +1,65 @@
+import java.nio.file.Paths
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+plugins {
+ id('java-library')
+ id('maven-publish')
+}
+
+configurations {
+ all*.exclude(group: 'org.slf4j', module: 'slf4j-log4j12')
+ all*.exclude(group: 'log4j', module: 'log4j')
+}
+
+publishing {
+ publications {
+ maven(MavenPublication) {
+ from components.java
+ groupId project.group
+ artifactId "${archivesBaseName}"
+ version System.getenv("CODE_VERSION") ?: "${version}"
+ }
+ }
+}
+
+configurations {
+ fourzero {
+ description = 'Cassandra 4.0 dependency'
+ }
+ fourzerobridge {
+ description = 'Bridge to Cassandra 4.0'
+ }
+ fourzerotypes {
+ description = 'Cassandra 4.0 Data Types'
+ }
+}
+
+dependencies {
+ api(project(':cassandra-bridge'))
+
+ compileOnly("com.google.guava:guava:${guavaVersion}")
+ implementation project(":cassandra-analytics-common")
+
+ implementation "org.slf4j:slf4j-api:${slf4jApiVersion}"
+
+ // This dependency must be built by running `scripts/build-dependencies.sh`
+ api(group: "${sidecarClientGroup}", name: "${sidecarClientName}", version: "${sidecarVersion}")
+}
\ No newline at end of file
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/ExecutorHolder.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/Sidecar.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/Sidecar.java
similarity index 86%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/Sidecar.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/Sidecar.java
index fee81161..c0de9c7b 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/Sidecar.java
+++ b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/Sidecar.java
@@ -47,14 +47,11 @@ import org.apache.cassandra.sidecar.client.VertxHttpClient;
import org.apache.cassandra.sidecar.client.VertxRequestExecutor;
import org.apache.cassandra.sidecar.client.retry.ExponentialBackoffRetryPolicy;
import org.apache.cassandra.sidecar.client.retry.RetryPolicy;
-import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
-import org.apache.cassandra.spark.bulkwriter.DataTransport;
import org.apache.cassandra.spark.common.model.CassandraInstance;
import org.apache.cassandra.spark.data.FileType;
import org.apache.cassandra.spark.utils.BuildInfo;
import org.apache.cassandra.spark.utils.MapUtils;
import org.apache.cassandra.spark.validation.KeyStoreValidation;
-import org.apache.cassandra.spark.validation.SslValidation;
import org.apache.cassandra.spark.validation.StartupValidator;
import org.apache.cassandra.spark.validation.TrustStoreValidation;
@@ -122,51 +119,6 @@ public final class Sidecar
return buildClient(sidecarConfig, vertx, httpClientConfig, sidecarInstancesProvider);
}
- static String transportModeBasedWriterUserAgent(DataTransport transport)
- {
- switch (transport)
- {
- case S3_COMPAT:
- return BuildInfo.WRITER_S3_USER_AGENT;
- case DIRECT:
- default:
- return BuildInfo.WRITER_USER_AGENT;
- }
- }
-
- public static SidecarClient from(SidecarInstancesProvider sidecarInstancesProvider, BulkSparkConf conf)
- {
- Vertx vertx = Vertx.vertx(new VertxOptions().setUseDaemonThread(true)
- .setWorkerPoolSize(conf.getMaxHttpConnections()));
-
- String userAgent = transportModeBasedWriterUserAgent(conf.getTransportInfo().getTransport());
- HttpClientConfig httpClientConfig = new HttpClientConfig.Builder<>()
- .timeoutMillis(conf.getHttpResponseTimeoutMs())
- .idleTimeoutMillis(conf.getHttpConnectionTimeoutMs())
- .userAgent(userAgent)
- .keyStoreInputStream(conf.getKeyStore())
- .keyStorePassword(conf.getKeyStorePassword())
- .keyStoreType(conf.getKeyStoreTypeOrDefault())
- .trustStoreInputStream(conf.getTrustStore())
- .trustStorePassword(conf.getTrustStorePasswordOrDefault())
- .trustStoreType(conf.getTrustStoreTypeOrDefault())
- .ssl(conf.hasKeystoreAndKeystorePassword())
- .build();
-
- StartupValidator.instance().register(new SslValidation(conf));
- StartupValidator.instance().register(new KeyStoreValidation(conf));
- StartupValidator.instance().register(new TrustStoreValidation(conf));
-
- SidecarClientConfig sidecarConfig =
- SidecarClientConfigImpl.builder()
- .maxRetries(conf.getSidecarRequestRetries())
- .retryDelayMillis(conf.getSidecarRequestRetryDelayMillis())
- .maxRetryDelayMillis(conf.getSidecarRequestMaxRetryDelayMillis())
- .build();
-
- return buildClient(sidecarConfig, vertx, httpClientConfig, sidecarInstancesProvider);
- }
-
public static SidecarClient buildClient(SidecarClientConfig sidecarConfig,
Vertx vertx,
HttpClientConfig httpClientConfig,
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/clients/SidecarStreamConsumerAdapter.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
similarity index 85%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
index 1e80e17a..cf68ca88 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
+++ b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/KeyStoreValidation.java
@@ -32,7 +32,6 @@ import java.util.Enumeration;
import java.util.function.Supplier;
import org.apache.cassandra.secrets.SecretsProvider;
-import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
import org.apache.cassandra.spark.utils.Throwing;
import org.jetbrains.annotations.NotNull;
@@ -48,18 +47,23 @@ public class KeyStoreValidation implements StartupValidation
public KeyStoreValidation(@NotNull SecretsProvider secrets)
{
- configured = secrets.hasKeyStoreSecrets();
- type = secrets.keyStoreType();
- password = secrets.keyStorePassword();
- stream = Throwing.supplier(secrets::keyStoreInputStream);
+ this(
+ secrets.hasKeyStoreSecrets(),
+ secrets.keyStoreType(),
+ secrets.keyStorePassword(),
+ Throwing.supplier(secrets::keyStoreInputStream)
+ );
}
- public KeyStoreValidation(@NotNull BulkSparkConf configuration)
+ protected KeyStoreValidation(boolean configured,
+ String type,
+ char[] password,
+ Supplier<InputStream> stream)
{
- configured = configuration.hasKeystoreAndKeystorePassword();
- type = configuration.getKeyStoreTypeOrDefault();
- password = configuration.getKeyStorePassword() == null ? null : configuration.getKeyStorePassword().toCharArray();
- stream = configuration::getKeyStore;
+ this.configured = configured;
+ this.type = type;
+ this.password = password;
+ this.stream = stream;
}
@Override
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidation.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java
similarity index 100%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/StartupValidator.java
diff --git a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
similarity index 81%
rename from cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
rename to cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
index ab4fec0f..80f7f3b2 100644
--- a/cassandra-analytics-core/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
+++ b/cassandra-analytics-sidecar-client/src/main/java/org/apache/cassandra/spark/validation/TrustStoreValidation.java
@@ -28,7 +28,6 @@ import java.util.Enumeration;
import java.util.function.Supplier;
import org.apache.cassandra.secrets.SecretsProvider;
-import org.apache.cassandra.spark.bulkwriter.BulkSparkConf;
import org.apache.cassandra.spark.utils.Throwing;
import org.jetbrains.annotations.NotNull;
@@ -44,18 +43,23 @@ public class TrustStoreValidation implements StartupValidation
public TrustStoreValidation(@NotNull SecretsProvider secrets)
{
- configured = secrets.hasTrustStoreSecrets();
- type = secrets.trustStoreType();
- password = secrets.trustStorePassword();
- stream = Throwing.supplier(() -> secrets.trustStoreInputStream());
+ this(
+ secrets.hasTrustStoreSecrets(),
+ secrets.trustStoreType(),
+ secrets.trustStorePassword(),
+ Throwing.supplier(secrets::trustStoreInputStream)
+ );
}
- public TrustStoreValidation(@NotNull BulkSparkConf configuration)
+ protected TrustStoreValidation(boolean configured,
+ String type,
+ char[] password,
+ Supplier<InputStream> stream)
{
- configured = configuration.hasTruststoreAndTruststorePassword();
- type = configuration.getTrustStoreTypeOrDefault();
- password = configuration.getTrustStorePasswordOrDefault().toCharArray();
- stream = () -> configuration.getTrustStore();
+ this.configured = configured;
+ this.type = type;
+ this.password = password;
+ this.stream = stream;
}
@Override
diff --git a/gradle.properties b/gradle.properties
index 6fc08a53..5c792e7f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -38,6 +38,7 @@ guavaVersion=16.0.1
vertxVersion=4.5.1
aswSdkVersion=2.26.12
commonsLang3Version=3.12.0
+cassandraDriverVersion=3.11.3
org.gradle.jvmargs=-Xmx4096m
diff --git a/settings.gradle b/settings.gradle
index 21e19654..5feed863 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -20,6 +20,7 @@
rootProject.name = 'cassandra-analytics-core'
include 'cassandra-analytics-cdc'
+include 'cassandra-analytics-cdc-sidecar'
include 'cassandra-analytics-common'
include 'cassandra-bridge'
include 'cassandra-four-zero'
@@ -29,6 +30,7 @@ include 'cassandra-analytics-core'
include 'cassandra-analytics-core-example'
include 'cassandra-analytics-integration-framework'
include 'cassandra-analytics-integration-tests'
+include 'cassandra-analytics-sidecar-client'
include 'cassandra-analytics-spark-converter'
include 'cassandra-analytics-spark-four-zero-converter'
include 'cassandra-analytics-cdc-codec'
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org