Add Scylla Cloud configuration classes

Similarly as in java driver 3.x adds classes representing
Scylla Cloud configuration details along with methods that allow
for using them in driver code.
Adds necessary dependencies to pom files.

Author: Bouncheck

core/pom.xml

@@ -115,6 +115,10 @@
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
     </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.dataformat</groupId>
+      <artifactId>jackson-dataformat-yaml</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.reactivestreams</groupId>
       <artifactId>reactive-streams</artifactId>
@@ -192,6 +196,14 @@
       <artifactId>wiremock</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.bouncycastle</groupId>
+      <artifactId>bcprov-jdk18on</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.bouncycastle</groupId>
+      <artifactId>bcpkix-jdk18on</artifactId>
+    </dependency>
   </dependencies>
   <build>
     <resources>

core/src/main/java/com/datastax/oss/driver/internal/core/config/scyllacloud/ConfigurationBundle.java

@@ -0,0 +1,108 @@
+package com.datastax.oss.driver.internal.core.config.scyllacloud;
+
+import com.datastax.oss.driver.api.core.ssl.SslEngineFactory;
+import com.datastax.oss.driver.internal.core.ssl.SniSslEngineFactory;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+public class ConfigurationBundle {
+  private final KeyStore identity;
+  private final KeyStore trustStore;
+
+  public ConfigurationBundle(KeyStore identity, KeyStore trustStore) {
+    this.identity = identity;
+    this.trustStore = trustStore;
+  }
+
+  public KeyStore getIdentity() {
+    return identity;
+  }
+
+  public KeyStore getTrustStore() {
+    return trustStore;
+  }
+
+  private void writeKeystore(String path, KeyStore ks, char[] password)
+      throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException {
+    File file = new File(path);
+    OutputStream os = new FileOutputStream(file);
+    ks.store(os, password);
+    os.close();
+  }
+
+  public void writeIdentity(String path, char[] password)
+      throws CertificateException, IOException, KeyStoreException, NoSuchAlgorithmException {
+    writeKeystore(path, identity, password);
+  }
+
+  public void writeTrustStore(String path, char[] password)
+      throws CertificateException, IOException, KeyStoreException, NoSuchAlgorithmException {
+    writeKeystore(path, trustStore, password);
+  }
+
+  protected SSLContext getSSLContext() throws IOException, GeneralSecurityException {
+    KeyManagerFactory kmf = createKeyManagerFactory(identity);
+    TrustManagerFactory tmf = createTrustManagerFactory(trustStore);
+    SSLContext sslContext = SSLContext.getInstance("SSL");
+    sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
+    return sslContext;
+  }
+
+  protected SSLContext getInsecureSSLContext() throws IOException, GeneralSecurityException {
+    KeyManagerFactory kmf = createKeyManagerFactory(identity);
+    SSLContext sslContext = SSLContext.getInstance("SSL");
+    TrustManager[] trustManager =
+        new TrustManager[] {
+          new X509TrustManager() {
+            @Override
+            public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
+                throws CertificateException {}
+
+            @Override
+            public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
+                throws CertificateException {}
+
+            @Override
+            public X509Certificate[] getAcceptedIssuers() {
+              return new X509Certificate[0];
+            }
+          }
+        };
+
+    sslContext.init(kmf.getKeyManagers(), trustManager, new SecureRandom());
+    return sslContext;
+  }
+
+  protected KeyManagerFactory createKeyManagerFactory(KeyStore ks)
+      throws IOException, GeneralSecurityException {
+    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    kmf.init(ks, "cassandra".toCharArray());
+    return kmf;
+  }
+
+  protected TrustManagerFactory createTrustManagerFactory(KeyStore ts)
+      throws IOException, GeneralSecurityException {
+    TrustManagerFactory tmf =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    tmf.init(ts);
+    return tmf;
+  }
+
+  public SslEngineFactory getSSLEngineFactory() throws GeneralSecurityException, IOException {
+    return new SniSslEngineFactory(getSSLContext());
+  }
+}

core/src/main/java/com/datastax/oss/driver/internal/core/config/scyllacloud/Parameters.java

@@ -0,0 +1,21 @@
+package com.datastax.oss.driver.internal.core.config.scyllacloud;
+
+import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.DefaultConsistencyLevel;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@SuppressWarnings("unused")
+public class Parameters {
+  private final ConsistencyLevel defaultConsistency;
+  private final ConsistencyLevel defaultSerialConsistency;
+
+  @JsonCreator
+  public Parameters(
+      @JsonProperty(value = "defaultConsistency") DefaultConsistencyLevel defaultConsistency,
+      @JsonProperty(value = "defaultSerialConsistency")
+          DefaultConsistencyLevel defaultSerialConsistency) {
+    this.defaultConsistency = defaultConsistency;
+    this.defaultSerialConsistency = defaultSerialConsistency;
+  }
+}

core/src/main/java/com/datastax/oss/driver/internal/core/config/scyllacloud/ScyllaCloudAuthInfo.java

@@ -0,0 +1,80 @@
+package com.datastax.oss.driver.internal.core.config.scyllacloud;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.io.File;
+
+public class ScyllaCloudAuthInfo {
+  private final byte[] clientCertificateData;
+  private final String clientCertificatePath;
+  private final byte[] clientKeyData;
+  private final String clientKeyPath;
+  private final String username;
+  private final String password;
+
+  @JsonCreator
+  public ScyllaCloudAuthInfo(
+      @JsonProperty(value = "clientCertificateData") byte[] clientCertificateData,
+      @JsonProperty(value = "clientCertificatePath") String clientCertificatePath,
+      @JsonProperty(value = "clientKeyData") byte[] clientKeyData,
+      @JsonProperty(value = "clientKeyPath") String clientKeyPath,
+      @JsonProperty(value = "username") String username,
+      @JsonProperty(value = "password") String password) {
+    this.clientCertificateData = clientCertificateData;
+    this.clientCertificatePath = clientCertificatePath;
+    this.clientKeyData = clientKeyData;
+    this.clientKeyPath = clientKeyPath;
+    this.username = username;
+    this.password = password;
+  }
+
+  public void validate() {
+    if (clientCertificateData == null) {
+      if (clientCertificatePath == null) {
+        throw new IllegalArgumentException(
+            "Either clientCertificateData or clientCertificatePath has to be provided for authInfo.");
+      }
+      File file = new File(clientCertificatePath);
+      if (!file.canRead()) {
+        throw new IllegalArgumentException(
+            "Cannot read file at given clientCertificatePath (" + clientCertificatePath + ").");
+      }
+    }
+
+    if (clientKeyData == null) {
+      if (clientKeyPath == null) {
+        throw new IllegalArgumentException(
+            "Either clientKeyData or clientKeyPath has to be provided for authInfo.");
+      }
+      File file = new File(clientKeyPath);
+      if (!file.canRead()) {
+        throw new IllegalArgumentException(
+            "Cannot read file at given clientKeyPath (" + clientKeyPath + ").");
+      }
+    }
+  }
+
+  public byte[] getClientCertificateData() {
+    return clientCertificateData;
+  }
+
+  public String getClientCertificatePath() {
+    return clientCertificatePath;
+  }
+
+  public byte[] getClientKeyData() {
+    return clientKeyData;
+  }
+
+  public String getClientKeyPath() {
+    return clientKeyPath;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+}