You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@seatunnel.apache.org by gi...@apache.org on 2026/08/26 14:20:13 UTC

(seatunnel) branch gh-readonly-queue/dev/pr-11964-608dda3a737198f0937654205e2ac89ee107a6db created (now cc548bb3f8)

This is an automated email from the ASF dual-hosted git repository.

github-merge-queue[bot] pushed a change to branch gh-readonly-queue/dev/pr-11964-608dda3a737198f0937654205e2ac89ee107a6db
in repository https://gitbox.apache.org/repos/asf/seatunnel.git


      at cc548bb3f8 [Improve][Connector-V2] Migrate Cassandra validation to declarative OptionRule (#11964)

This branch includes the following new commits:

     new cc548bb3f8 [Improve][Connector-V2] Migrate Cassandra validation to declarative OptionRule (#11964)

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(seatunnel) 01/01: [Improve][Connector-V2] Migrate Cassandra validation to declarative OptionRule (#11964)

Posted by gi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

github-merge-queue[bot] pushed a commit to branch gh-readonly-queue/dev/pr-11964-608dda3a737198f0937654205e2ac89ee107a6db
in repository https://gitbox.apache.org/repos/asf/seatunnel.git

commit cc548bb3f8c3181c820c316d2fc6996e46a08dd9
Author: Aryadeepta <38...@users.noreply.github.com>
AuthorDate: Wed Aug 26 14:20:03 2026 +0000

    [Improve][Connector-V2] Migrate Cassandra validation to declarative OptionRule (#11964)
---
 .../cassandra/sink/CassandraSinkFactory.java       |  15 +-
 .../cassandra/source/CassandraSourceFactory.java   |  49 +++++-
 .../seatunnel/cassandra/CassandraFactoryTest.java  | 168 +++++++++++++++++++++
 3 files changed, 228 insertions(+), 4 deletions(-)

diff --git a/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/sink/CassandraSinkFactory.java b/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/sink/CassandraSinkFactory.java
index a9e9d9e4c3..2411b6c0c7 100644
--- a/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/sink/CassandraSinkFactory.java
+++ b/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/sink/CassandraSinkFactory.java
@@ -17,6 +17,7 @@
 
 package org.apache.seatunnel.connectors.seatunnel.cassandra.sink;
 
+import org.apache.seatunnel.api.configuration.util.Conditions;
 import org.apache.seatunnel.api.configuration.util.OptionRule;
 import org.apache.seatunnel.api.table.connector.TableSink;
 import org.apache.seatunnel.api.table.factory.Factory;
@@ -40,6 +41,11 @@ import static org.apache.seatunnel.connectors.seatunnel.cassandra.config.Cassand
 
 @AutoService(Factory.class)
 public class CassandraSinkFactory implements TableSinkFactory {
+
+    private static final String CONSISTENCY_LEVEL_REGEX =
+            "^(ANY|ONE|TWO|THREE|QUORUM|ALL|LOCAL_QUORUM|EACH_QUORUM|SERIAL|LOCAL_SERIAL|LOCAL_ONE)$";
+    private static final String BATCH_TYPE_REGEX = "^(LOGGED|UNLOGGED|COUNTER)$";
+
     @Override
     public String factoryIdentifier() {
         return "Cassandra";
@@ -48,10 +54,15 @@ public class CassandraSinkFactory implements TableSinkFactory {
     @Override
     public OptionRule optionRule() {
         return OptionRule.builder()
-                .required(HOST, KEYSPACE, TABLE)
+                .required(HOST, Conditions.notBlank(HOST))
+                .required(KEYSPACE, Conditions.notBlank(KEYSPACE))
+                .required(TABLE, Conditions.notBlank(TABLE))
                 .bundled(USERNAME, PASSWORD)
+                .optional(DATACENTER, FIELDS, BATCH_SIZE, ASYNC_WRITE)
                 .optional(
-                        DATACENTER, CONSISTENCY_LEVEL, FIELDS, BATCH_SIZE, BATCH_TYPE, ASYNC_WRITE)
+                        CONSISTENCY_LEVEL,
+                        Conditions.matches(CONSISTENCY_LEVEL, CONSISTENCY_LEVEL_REGEX))
+                .optional(BATCH_TYPE, Conditions.matches(BATCH_TYPE, BATCH_TYPE_REGEX))
                 .build();
     }
 
diff --git a/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/source/CassandraSourceFactory.java b/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/source/CassandraSourceFactory.java
index f71f2dc43f..70cfb636aa 100644
--- a/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/source/CassandraSourceFactory.java
+++ b/seatunnel-connectors-v2/connector-cassandra/src/main/java/org/apache/seatunnel/connectors/seatunnel/cassandra/source/CassandraSourceFactory.java
@@ -17,7 +17,11 @@
 
 package org.apache.seatunnel.connectors.seatunnel.cassandra.source;
 
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.configuration.util.ConditionExtension;
+import org.apache.seatunnel.api.configuration.util.Conditions;
 import org.apache.seatunnel.api.configuration.util.OptionRule;
+import org.apache.seatunnel.api.configuration.util.OptionValidationException;
 import org.apache.seatunnel.api.options.ConnectorCommonOptions;
 import org.apache.seatunnel.api.source.SeaTunnelSource;
 import org.apache.seatunnel.api.source.SourceSplit;
@@ -30,6 +34,8 @@ import org.apache.seatunnel.connectors.seatunnel.cassandra.config.CassandraParam
 import com.google.auto.service.AutoService;
 
 import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
 
 import static org.apache.seatunnel.connectors.seatunnel.cassandra.config.CassandraSourceOptions.CONSISTENCY_LEVEL;
 import static org.apache.seatunnel.connectors.seatunnel.cassandra.config.CassandraSourceOptions.CQL;
@@ -41,6 +47,10 @@ import static org.apache.seatunnel.connectors.seatunnel.cassandra.config.Cassand
 
 @AutoService(Factory.class)
 public class CassandraSourceFactory implements TableSourceFactory {
+
+    private static final String CONSISTENCY_LEVEL_REGEX =
+            "^(ANY|ONE|TWO|THREE|QUORUM|ALL|LOCAL_QUORUM|EACH_QUORUM|SERIAL|LOCAL_SERIAL|LOCAL_ONE)$";
+
     @Override
     public String factoryIdentifier() {
         return "Cassandra";
@@ -49,13 +59,48 @@ public class CassandraSourceFactory implements TableSourceFactory {
     @Override
     public OptionRule optionRule() {
         return OptionRule.builder()
-                .required(HOST, KEYSPACE)
+                .required(HOST, Conditions.notBlank(HOST))
+                .required(KEYSPACE, Conditions.notBlank(KEYSPACE))
                 .exclusive(CQL, ConnectorCommonOptions.TABLE_CONFIGS)
                 .bundled(USERNAME, PASSWORD)
-                .optional(DATACENTER, CONSISTENCY_LEVEL)
+                .optional(CQL, Conditions.notBlank(CQL))
+                .optional(
+                        ConnectorCommonOptions.TABLE_CONFIGS,
+                        Conditions.notEmpty(ConnectorCommonOptions.TABLE_CONFIGS),
+                        Conditions.extension(
+                                ConnectorCommonOptions.TABLE_CONFIGS, new TableConfigsValidator()))
+                .optional(DATACENTER)
+                .optional(
+                        CONSISTENCY_LEVEL,
+                        Conditions.matches(CONSISTENCY_LEVEL, CONSISTENCY_LEVEL_REGEX))
                 .build();
     }
 
+    static class TableConfigsValidator implements ConditionExtension<List<Map<String, Object>>> {
+
+        @Override
+        public String description() {
+            return "each 'tables_configs' entry must contain a non-blank 'cql'";
+        }
+
+        @Override
+        public boolean evaluate(ReadonlyConfig config, List<Map<String, Object>> entries)
+                throws OptionValidationException {
+            if (entries == null || entries.isEmpty()) {
+                return true;
+            }
+            for (int i = 0; i < entries.size(); i++) {
+                Map<String, Object> tableConfig = entries.get(i);
+                Object cql = tableConfig == null ? null : tableConfig.get(CQL.key());
+                if (!(cql instanceof String) || ((String) cql).trim().isEmpty()) {
+                    throw new OptionValidationException(
+                            "tables_configs[%d]: 'cql' must not be blank", i);
+                }
+            }
+            return true;
+        }
+    }
+
     @Override
     public <T, SplitT extends SourceSplit, StateT extends Serializable>
             TableSource<T, SplitT, StateT> createSource(TableSourceFactoryContext context) {
diff --git a/seatunnel-connectors-v2/connector-cassandra/src/test/java/org/apache/seatunnel/connectors/seatunnel/cassandra/CassandraFactoryTest.java b/seatunnel-connectors-v2/connector-cassandra/src/test/java/org/apache/seatunnel/connectors/seatunnel/cassandra/CassandraFactoryTest.java
index 9ca2acc2ef..49fb05ab7a 100644
--- a/seatunnel-connectors-v2/connector-cassandra/src/test/java/org/apache/seatunnel/connectors/seatunnel/cassandra/CassandraFactoryTest.java
+++ b/seatunnel-connectors-v2/connector-cassandra/src/test/java/org/apache/seatunnel/connectors/seatunnel/cassandra/CassandraFactoryTest.java
@@ -22,6 +22,7 @@ import org.apache.seatunnel.api.configuration.util.ConfigValidator;
 import org.apache.seatunnel.api.configuration.util.OptionRule;
 import org.apache.seatunnel.api.configuration.util.OptionValidationException;
 import org.apache.seatunnel.api.options.ConnectorCommonOptions;
+import org.apache.seatunnel.connectors.seatunnel.cassandra.config.CassandraSinkOptions;
 import org.apache.seatunnel.connectors.seatunnel.cassandra.config.CassandraSourceOptions;
 import org.apache.seatunnel.connectors.seatunnel.cassandra.sink.CassandraSinkFactory;
 import org.apache.seatunnel.connectors.seatunnel.cassandra.source.CassandraSourceFactory;
@@ -86,6 +87,173 @@ class CassandraFactoryTest {
                 () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(rule));
     }
 
+    @Test
+    void testSourceOptionRuleWithBlankHostThrows() {
+        Map<String, Object> cfg = sourceConfigWithCql();
+        cfg.put(CassandraSourceOptions.HOST.key(), " ");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithBlankKeyspaceThrows() {
+        Map<String, Object> cfg = sourceConfigWithCql();
+        cfg.put(CassandraSourceOptions.KEYSPACE.key(), "\t");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithBlankRootCqlThrows() {
+        Map<String, Object> cfg = baseConfig();
+        cfg.put(CassandraSourceOptions.CQL.key(), "\n");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithEmptyTablesConfigsThrows() {
+        Map<String, Object> cfg = baseConfig();
+        cfg.put(ConnectorCommonOptions.TABLE_CONFIGS.key(), Collections.emptyList());
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithTablesConfigsChildMissingCqlThrows() {
+        Map<String, Object> cfg = baseConfig();
+        cfg.put(
+                ConnectorCommonOptions.TABLE_CONFIGS.key(),
+                Collections.singletonList(Collections.emptyMap()));
+        OptionValidationException exception =
+                Assertions.assertThrows(
+                        OptionValidationException.class,
+                        () ->
+                                ConfigValidator.of(ReadonlyConfig.fromMap(cfg))
+                                        .validate(sourceRule()));
+        Assertions.assertTrue(exception.getMessage().contains("tables_configs[0]: 'cql'"));
+    }
+
+    @Test
+    void testSourceOptionRuleWithTablesConfigsChildBlankCqlThrows() {
+        Map<String, Object> cfg = baseConfig();
+        cfg.put(
+                ConnectorCommonOptions.TABLE_CONFIGS.key(),
+                Collections.singletonList(
+                        Collections.singletonMap(CassandraSourceOptions.CQL.key(), "  ")));
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithInvalidConsistencyLevelThrows() {
+        Map<String, Object> cfg = sourceConfigWithCql();
+        cfg.put(CassandraSourceOptions.CONSISTENCY_LEVEL.key(), "LOCAL_ONE ");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithValidRootCqlPasses() {
+        Assertions.assertDoesNotThrow(
+                () ->
+                        ConfigValidator.of(ReadonlyConfig.fromMap(sourceConfigWithCql()))
+                                .validate(sourceRule()));
+    }
+
+    @Test
+    void testSourceOptionRuleWithValidTablesConfigsChildCqlPasses() {
+        Map<String, Object> cfg = baseConfig();
+        cfg.put(
+                ConnectorCommonOptions.TABLE_CONFIGS.key(),
+                Collections.singletonList(
+                        Collections.singletonMap(
+                                CassandraSourceOptions.CQL.key(), "select * from test.table1")));
+        Assertions.assertDoesNotThrow(
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sourceRule()));
+    }
+
+    @Test
+    void testSinkOptionRuleWithBlankHostThrows() {
+        Map<String, Object> cfg = sinkConfig();
+        cfg.put(CassandraSinkOptions.HOST.key(), " ");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sinkRule()));
+    }
+
+    @Test
+    void testSinkOptionRuleWithBlankKeyspaceThrows() {
+        Map<String, Object> cfg = sinkConfig();
+        cfg.put(CassandraSinkOptions.KEYSPACE.key(), "\t");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sinkRule()));
+    }
+
+    @Test
+    void testSinkOptionRuleWithBlankTableThrows() {
+        Map<String, Object> cfg = sinkConfig();
+        cfg.put(CassandraSinkOptions.TABLE.key(), "\n");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sinkRule()));
+    }
+
+    @Test
+    void testSinkOptionRuleWithInvalidConsistencyLevelThrows() {
+        Map<String, Object> cfg = sinkConfig();
+        cfg.put(CassandraSinkOptions.CONSISTENCY_LEVEL.key(), "invalid");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sinkRule()));
+    }
+
+    @Test
+    void testSinkOptionRuleWithInvalidBatchTypeThrows() {
+        Map<String, Object> cfg = sinkConfig();
+        cfg.put(CassandraSinkOptions.BATCH_TYPE.key(), "BATCHED");
+        Assertions.assertThrows(
+                OptionValidationException.class,
+                () -> ConfigValidator.of(ReadonlyConfig.fromMap(cfg)).validate(sinkRule()));
+    }
+
+    @Test
+    void testSinkOptionRuleWithValidConfigPasses() {
+        Assertions.assertDoesNotThrow(
+                () ->
+                        ConfigValidator.of(ReadonlyConfig.fromMap(sinkConfig()))
+                                .validate(sinkRule()));
+    }
+
+    private OptionRule sourceRule() {
+        return new CassandraSourceFactory().optionRule();
+    }
+
+    private OptionRule sinkRule() {
+        return new CassandraSinkFactory().optionRule();
+    }
+
+    private Map<String, Object> sourceConfigWithCql() {
+        Map<String, Object> cfg = baseConfig();
+        cfg.put(CassandraSourceOptions.CQL.key(), "select * from test.table1");
+        return cfg;
+    }
+
+    private Map<String, Object> sinkConfig() {
+        Map<String, Object> cfg = new HashMap<>();
+        cfg.put(CassandraSinkOptions.HOST.key(), "localhost:9042");
+        cfg.put(CassandraSinkOptions.KEYSPACE.key(), "test");
+        cfg.put(CassandraSinkOptions.TABLE.key(), "table1");
+        return cfg;
+    }
+
     private Map<String, Object> baseConfig() {
         Map<String, Object> cfg = new HashMap<>();
         cfg.put("host", "localhost:9042");