Some new stuff

Author: nviliunov-evolution-throwaway

scassandra/src/main/scala/com/evolutiongaming/scassandra/CassandraConfig.scala

@@ -77,7 +77,15 @@ object CassandraConfig {
 
   implicit val configReaderCompression: ConfigReader[Compression] = ConfigReaderFromEnum(Compression.values())
 
-  implicit val configReaderProtocolVersion: ConfigReader[ProtocolVersion] = ConfigReaderFromEnum(ProtocolVersion.values())
+  implicit val configReaderProtocolVersion: ConfigReader[ProtocolVersion] = ConfigReaderFromEnum.forList(
+    Vector(
+      ProtocolVersion.V3,
+      ProtocolVersion.V4,
+      ProtocolVersion.V5,
+      ProtocolVersion.DSE_V1,
+      ProtocolVersion.DSE_V2,
+    ), _.name()
+  )
 
   implicit val configReaderCassandraConfig: ConfigReader[CassandraConfig] = {
     (cursor: ConfigCursor) => {

scassandra/src/main/scala/com/evolutiongaming/scassandra/QueryConfig.scala

@@ -1,10 +1,11 @@
 package com.evolutiongaming.scassandra
 
-import com.datastax.driver.core.{ConsistencyLevel, QueryOptions}
+import com.datastax.oss.driver.api.core.ConsistencyLevel
+import com.datastax.oss.protocol.internal.request.query.QueryOptions
 import com.typesafe.config.Config
 import pureconfig.ConfigSource
 
-import scala.concurrent.duration._
+import scala.concurrent.duration.*
 
 /**
   * See [[https://docs.datastax.com/en/drivers/java/3.5/com/datastax/driver/core/QueryOptions.html]]

scassandra/src/main/scala/com/evolutiongaming/scassandra/QueryConfigImplicits.scala

@@ -1,14 +1,26 @@
 package com.evolutiongaming.scassandra
 
-import com.datastax.driver.core.ConsistencyLevel
+import com.datastax.oss.driver.api.core.ConsistencyLevel
 import com.evolutiongaming.scassandra.util.ConfigReaderFromEnum
-import com.evolutiongaming.scassandra.util.PureconfigSyntax._
+import com.evolutiongaming.scassandra.util.PureconfigSyntax.*
 import pureconfig.ConfigReader
 
-import scala.concurrent.duration._
+import scala.concurrent.duration.*
 
 trait QueryConfigImplicits {
-  implicit val configReaderConsistencyLevel: ConfigReader[ConsistencyLevel] = ConfigReaderFromEnum(ConsistencyLevel.values())
+  implicit val configReaderConsistencyLevel: ConfigReader[ConsistencyLevel] = ConfigReaderFromEnum.forList(Vector(
+    ConsistencyLevel.ANY,
+    ConsistencyLevel.ONE,
+    ConsistencyLevel.TWO,
+    ConsistencyLevel.THREE,
+    ConsistencyLevel.QUORUM,
+    ConsistencyLevel.ALL,
+    ConsistencyLevel.LOCAL_ONE,
+    ConsistencyLevel.LOCAL_QUORUM,
+    ConsistencyLevel.EACH_QUORUM,
+    ConsistencyLevel.SERIAL,
+    ConsistencyLevel.LOCAL_SERIAL,
+  ), _.name)
 
   implicit val configReaderQueryConfig: ConfigReader[QueryConfig] = ConfigReader.fromCursor[QueryConfig] { cursor =>
     val defaultConfig = QueryConfig()

scassandra/src/main/scala/com/evolutiongaming/scassandra/ReconnectionConfig.scala

@@ -1,8 +1,10 @@
 package com.evolutiongaming.scassandra
 
 import com.datastax.driver.core.policies.{ExponentialReconnectionPolicy, ReconnectionPolicy}
+import com.datastax.oss.driver.api.core.config.DefaultDriverOption
 import com.datastax.oss.driver.api.core.connection.ReconnectionPolicy
 import com.datastax.oss.driver.internal.core.connection.ExponentialReconnectionPolicy
+import com.evolutiongaming.scassandra.util.FakeConfig
 import com.typesafe.config.Config
 import pureconfig.ConfigSource
 
@@ -17,7 +19,11 @@ final case class ReconnectionConfig(
 ) {
 
   def asJava: ReconnectionPolicy = {
-    new ExponentialReconnectionPolicy(minDelay.toMillis, maxDelay.toMillis)
+    val config = FakeConfig.createFakeContext(
+      DefaultDriverOption.RECONNECTION_BASE_DELAY.getPath -> java.time.Duration.ofMillis(minDelay.toMillis),
+      DefaultDriverOption.RECONNECTION_MAX_DELAY.getPath -> java.time.Duration.ofMillis(maxDelay.toMillis),
+    )
+    new ExponentialReconnectionPolicy(config)
   }
 }
 

scassandra/src/main/scala/com/evolutiongaming/scassandra/SpeculativeExecutionConfig.scala

@@ -1,10 +1,14 @@
 package com.evolutiongaming.scassandra
 
-import com.datastax.driver.core.policies.{ConstantSpeculativeExecutionPolicy, SpeculativeExecutionPolicy}
+import com.datastax.oss.driver.api.core.config.DefaultDriverOption
+import com.datastax.oss.driver.api.core.specex.SpeculativeExecutionPolicy
+import com.datastax.oss.driver.internal.core.specex.ConstantSpeculativeExecutionPolicy
+import com.evolutiongaming.scassandra.util.FakeConfig
 import com.typesafe.config.Config
 import pureconfig.ConfigSource
 
-import scala.concurrent.duration._
+import java.time.Duration as JDuration
+import scala.concurrent.duration.*
 
 /**
   * See [[https://docs.datastax.com/en/developer/java-driver/3.5/manual/speculative_execution/]]
@@ -14,7 +18,11 @@ final case class SpeculativeExecutionConfig(
   maxExecutions: Int = 2) {
 
   def asJava: SpeculativeExecutionPolicy = {
-    new ConstantSpeculativeExecutionPolicy(delay.toMillis, maxExecutions)
+    val config = FakeConfig.createFakeContext(
+      DefaultDriverOption.SPECULATIVE_EXECUTION_MAX.getPath -> maxExecutions,
+      DefaultDriverOption.SPECULATIVE_EXECUTION_DELAY.getPath -> JDuration.ofMillis(delay.toMillis),
+    )
+    new ConstantSpeculativeExecutionPolicy(config, "")
   }
 }
 

scassandra/src/main/scala/com/evolutiongaming/scassandra/UpdateByIdx.scala

@@ -1,40 +1,35 @@
 package com.evolutiongaming.scassandra
 
-import com.datastax.driver.core.{GettableByIndexData, SettableData}
+import com.datastax.oss.driver.api.core.cql.Bindable
+import com.datastax.oss.driver.api.core.data.GettableByIndex
 
 trait UpdateByIdx[-A] {
-
-  def apply[D <: GettableByIndexData & SettableData[D]](
+  def apply[D <: GettableByIndex & Bindable[D]](
       data: D,
       idx: Int,
       value: A
   ): D
-
 }
 
 object UpdateByIdx {
-
   def apply[A: UpdateByIdx]: UpdateByIdx[A] = implicitly
 
   implicit def fromEncodeByIdx[A: EncodeByIdx]: UpdateByIdx[A] =
     new UpdateByIdx[A] {
-      def apply[D <: GettableByIndexData & SettableData[D]](
+      def apply[D <: GettableByIndex & Bindable[D]](
           data: D,
           idx: Int,
           value: A
       ): D = EncodeByIdx[A].apply(data, idx, value)
     }
 
   implicit final class Syntax[A](val self: UpdateByIdx[A]) extends AnyVal {
-
     def contramap[B](f: B => A): UpdateByIdx[B] = new UpdateByIdx[B] {
-      def apply[D <: GettableByIndexData & SettableData[D]](
+      def apply[D <: GettableByIndex & Bindable[D]](
           data: D,
           idx: Int,
           value: B
       ): D = self(data, idx, f(value))
     }
-
   }
-
 }

scassandra/src/main/scala/com/evolutiongaming/scassandra/UpdateByName.scala

@@ -1,39 +1,35 @@
 package com.evolutiongaming.scassandra
 
-import com.datastax.driver.core.{GettableByNameData, SettableData}
+import com.datastax.oss.driver.api.core.cql.Bindable
+import com.datastax.oss.driver.api.core.data.GettableByName
 
 trait UpdateByName[-A] {
-
-  def apply[D <: GettableByNameData & SettableData[D]](
+  def apply[D <: GettableByName & Bindable[D]](
       data: D,
       name: String,
       value: A
   ): D
-
 }
 
 object UpdateByName {
-
   def apply[A: UpdateByName]: UpdateByName[A] = implicitly
 
   implicit def fromEncodeByName[A: EncodeByName]: UpdateByName[A] =
     new UpdateByName[A] {
-      def apply[D <: GettableByNameData & SettableData[D]](
+      def apply[D <: GettableByName & Bindable[D]](
           data: D,
           name: String,
           value: A
-      ): D = EncodeByName[A].apply(data, name, value)
+      ): D = EncodeByName[A].bindToData(data, name, value)
     }
 
   implicit final class Syntax[A](val self: UpdateByName[A]) extends AnyVal {
-
     def contramap[B](f: B => A): UpdateByName[B] = new UpdateByName[B] {
-      def apply[D <: GettableByNameData & SettableData[D]](
+      def apply[D <: GettableByName & Bindable[D]](
           data: D,
           name: String,
           value: B
       ): D = self(data, name, f(value))
     }
-
   }
 }

scassandra/src/main/scala/com/evolutiongaming/scassandra/util/ConfigReaderFromEnum.scala

@@ -1,9 +1,10 @@
 package com.evolutiongaming.scassandra.util
 
-import cats.implicits._
+import cats.implicits.*
 import pureconfig.error.{CannotParse, ConfigReaderFailures}
 import pureconfig.{ConfigCursor, ConfigReader}
 
+import java.util.Locale
 import scala.reflect.ClassTag
 
 /** Provides [[ConfigReader]] for Java enums.
@@ -47,4 +48,17 @@ object ConfigReaderFromEnum {
       } yield r
     }
   }
+
+  def forList[A](variants: Vector[A], name: A => String)(implicit tag: ClassTag[A]): ConfigReader[A] = {
+    val map: Map[String, A] = variants.map { i => name(i).toLowerCase(Locale.ROOT) -> i }.toMap
+    (cursor: ConfigCursor) =>
+      for {
+        string <- cursor.asString
+        result <- map.get(string.toLowerCase(Locale.ROOT)).toRight {
+          val failure = CannotParse(s"Cannot parse ${tag.runtimeClass} from $string", cursor.origin)
+          ConfigReaderFailures(failure)
+        }
+      } yield result
+
+  }
 }

scassandra/src/main/scala/com/evolutiongaming/scassandra/util/FakeConfig.scala

@@ -0,0 +1,86 @@
+package com.evolutiongaming.scassandra.util
+
+import com.datastax.oss.driver.api.core.ProtocolVersion
+import com.datastax.oss.driver.api.core.`type`.codec.registry.CodecRegistry
+import com.datastax.oss.driver.api.core.addresstranslation.AddressTranslator
+import com.datastax.oss.driver.api.core.auth.AuthProvider
+import com.datastax.oss.driver.api.core.config.{DriverConfig, DriverConfigLoader, DriverExecutionProfile, DriverOption}
+import com.datastax.oss.driver.api.core.connection.ReconnectionPolicy
+import com.datastax.oss.driver.api.core.context.DriverContext
+import com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy
+import com.datastax.oss.driver.api.core.metadata.NodeStateListener
+import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener
+import com.datastax.oss.driver.api.core.retry.RetryPolicy
+import com.datastax.oss.driver.api.core.session.throttling.RequestThrottler
+import com.datastax.oss.driver.api.core.specex.SpeculativeExecutionPolicy
+import com.datastax.oss.driver.api.core.ssl.SslEngineFactory
+import com.datastax.oss.driver.api.core.time.TimestampGenerator
+import com.datastax.oss.driver.api.core.tracker.RequestTracker
+
+import java.time.Duration
+import java.{lang, util}
+
+private[scassandra] object FakeConfig {
+  def createFakeContext(contents: Map[String, Any]): DriverContext = {
+    val profile = new FakeProfile(contents)
+    val config = new FakeConfig(profile)
+    val context = new FakeContext(config)
+    context
+  }
+
+  def createFakeContext(contents: (String, Any)*): DriverContext = {
+    createFakeContext(Map(contents*))
+  }
+
+  private class FakeContext(config: FakeConfig) extends DriverContext {
+    private def unsupported[T]: T = throw new UnsupportedOperationException("Only getConfig is supported by the fake context")
+
+    override def getSessionName: String = ""
+    override def getConfig: DriverConfig = config
+    override def getConfigLoader: DriverConfigLoader = unsupported
+    override def getLoadBalancingPolicies: util.Map[String, LoadBalancingPolicy] = unsupported
+    override def getRetryPolicies: util.Map[String, RetryPolicy] = unsupported
+    override def getSpeculativeExecutionPolicies: util.Map[String, SpeculativeExecutionPolicy] = unsupported
+    override def getTimestampGenerator: TimestampGenerator = unsupported
+    override def getReconnectionPolicy: ReconnectionPolicy = unsupported
+    override def getAddressTranslator: AddressTranslator = unsupported
+    override def getAuthProvider: util.Optional[AuthProvider] = unsupported
+    override def getSslEngineFactory: util.Optional[SslEngineFactory] = unsupported
+    override def getRequestTracker: RequestTracker = unsupported
+    override def getRequestThrottler: RequestThrottler = unsupported
+    override def getNodeStateListener: NodeStateListener = unsupported
+    override def getSchemaChangeListener: SchemaChangeListener = unsupported
+    override def getProtocolVersion: ProtocolVersion = unsupported
+    override def getCodecRegistry: CodecRegistry = unsupported
+  }
+
+  private class FakeConfig(profile: FakeProfile) extends DriverConfig {
+    private def unsupported[T]: T = throw new UnsupportedOperationException("Only getProfile is supported by the fake config")
+
+    override def getProfile(profileName: String): DriverExecutionProfile = profile
+    override def getProfiles: util.Map[String, _ <: DriverExecutionProfile] = unsupported
+  }
+
+  private class FakeProfile(contents: Map[String, Any]) extends DriverExecutionProfile {
+    private def unsupported[T]: T = throw new UnsupportedOperationException("List operations not supported by the fake profile")
+
+    override def getName: String = "FakeProfile"
+    override def isDefined(option: DriverOption): Boolean = contents.isDefinedAt(option.getPath)
+    override def getBoolean(option: DriverOption): Boolean = contents(option.getPath).asInstanceOf[Boolean]
+    override def getBooleanList(option: DriverOption): util.List[lang.Boolean] = unsupported
+    override def getInt(option: DriverOption): Int = contents(option.getPath).asInstanceOf[Int]
+    override def getIntList(option: DriverOption): util.List[Integer] = unsupported
+    override def getLong(option: DriverOption): Long = contents(option.getPath).asInstanceOf[Long]
+    override def getLongList(option: DriverOption): util.List[lang.Long] = unsupported
+    override def getDouble(option: DriverOption): Double = contents(option.getPath).asInstanceOf[Double]
+    override def getDoubleList(option: DriverOption): util.List[lang.Double] = unsupported
+    override def getString(option: DriverOption): String = contents(option.getPath).asInstanceOf[String]
+    override def getStringList(option: DriverOption): util.List[String] = unsupported
+    override def getStringMap(option: DriverOption): util.Map[String, String] = unsupported
+    override def getBytes(option: DriverOption): Long = contents(option.getPath).asInstanceOf[Long]
+    override def getBytesList(option: DriverOption): util.List[lang.Long] = unsupported
+    override def getDuration(option: DriverOption): Duration = contents(option.getPath).asInstanceOf[Duration]
+    override def getDurationList(option: DriverOption): util.List[Duration] = unsupported
+    override def entrySet(): util.SortedSet[util.Map.Entry[String, AnyRef]] = unsupported
+  }
+}