propagating max connections when using DataSourceJdbcDataSource

slick/src/main/scala/slick/jdbc/JdbcBackend.scala

@@ -85,7 +85,7 @@ trait JdbcBackend extends RelationalBackend {
     /** Create a Database based on a DataSource.
       *
       * @param ds The DataSource to use.
-      * @param maxConnection The maximum number of connections that the DataSource can provide. This is necessary to
+      * @param maxConnections The maximum number of connections that the DataSource can provide. This is necessary to
       *                      prevent deadlocks when scheduling database actions. Use `None` if there is no hard limit.
       * @param executor The AsyncExecutor for scheduling database actions.
       * @param keepAliveConnection If this is set to true, one extra connection will be opened as soon as the database
@@ -97,18 +97,25 @@ trait JdbcBackend extends RelationalBackend {
 
     /** Create a Database based on the JNDI name of a DataSource.
       *
-      * @param ds The name of the DataSource to use.
-      * @param maxConnection The maximum number of connections that the DataSource can provide. This is necessary to
+      * @param name The name of the DataSource to use.
+      * @param maxConnections The maximum number of connections that the DataSource can provide. This is necessary to
       *                      prevent deadlocks when scheduling database actions. Use `None` if there is no hard limit.
       * @param executor The AsyncExecutor for scheduling database actions.
       */
-    def forName(name: String, maxConnections: Option[Int], executor: AsyncExecutor = null) = new InitialContext().lookup(name) match {
-      case ds: DataSource => forDataSource(ds, maxConnections, executor match {
-        case null => AsyncExecutor.default(name)
-        case e => e
-      })
-      case x => throw new SlickException("Expected a DataSource for JNDI name "+name+", but got "+x)
-    }
+    def forName(name: String, maxConnections: Option[Int], executor: AsyncExecutor = null) =
+      new InitialContext().lookup(name) match {
+
+        case ds: DataSource =>
+          val configuredExecutor =
+            (executor, maxConnections) match {
+              case (null, Some(maxConnec)) => AsyncExecutor.default(name, maxConnec)
+              case (null, None) => AsyncExecutor.default(name)
+              case (e, _) => e
+            }
+          forDataSource(ds, maxConnections, configuredExecutor)
+
+        case x => throw new SlickException("Expected a DataSource for JNDI name "+name+", but got "+x)
+      }
 
     /** Create a Database that uses the DriverManager to open new connections. */
     def forURL(url: String, user: String = null, password: String = null, prop: Properties = null, driver: String = null,
@@ -287,7 +294,7 @@ trait JdbcBackend extends RelationalBackend {
       val source = JdbcDataSource.forConfig(usedConfig, driver, path, classLoader)
       val poolName = usedConfig.getStringOr("poolName", path)
       val numThreads = usedConfig.getIntOr("numThreads", 20)
-      val maxConnections = source.maxConnections.fold(numThreads)(identity)
+      val maxConnections = source.maxConnections.getOrElse(numThreads)
       val registerMbeans = usedConfig.getBooleanOr("registerMbeans", false)
       val executor = AsyncExecutor(poolName, numThreads, numThreads, usedConfig.getIntOr("queueSize", 1000),
         maxConnections, registerMbeans = registerMbeans)

slick/src/main/scala/slick/jdbc/JdbcDataSource.scala

@@ -84,22 +84,26 @@ class DataSourceJdbcDataSource(val ds: DataSource, val keepAliveConnection: Bool
 
 object DataSourceJdbcDataSource extends JdbcDataSourceFactory {
   def forConfig(c: Config, driver: Driver, name: String, classLoader: ClassLoader): DataSourceJdbcDataSource = {
-    val ds = c.getStringOpt("dataSourceClass") match {
-      case Some(dsClass) =>
-        val propsO = c.getPropertiesOpt("properties")
-        try {
-          val ds = Class.forName(dsClass).newInstance.asInstanceOf[DataSource]
-          propsO.foreach(BeanConfigurator.configure(ds, _))
-          ds
-        } catch { case ex: Exception => throw new SlickException("Error configuring DataSource "+dsClass, ex) }
-      case None =>
-        val ds = new DriverDataSource
-        ds.classLoader = classLoader
-        ds.driverObject = driver
-        BeanConfigurator.configure(ds, c.toProperties, Set("url", "user", "password", "properties", "driver", "driverClassName"))
-        ds
-    }
-    new DataSourceJdbcDataSource(ds, c.getBooleanOr("keepAliveConnection"), None, new ConnectionPreparer(c))
+    val (ds, maxConnections) =
+      c.getStringOpt("dataSourceClass") match {
+
+        case Some(dsClass) =>
+          val propsO = c.getPropertiesOpt("properties")
+          try {
+            val ds = Class.forName(dsClass).newInstance.asInstanceOf[DataSource]
+            propsO.foreach(BeanConfigurator.configure(ds, _))
+            val maxConnections = c.getIntOpt("maxConnections")
+            (ds, maxConnections)
+          } catch { case ex: Exception => throw new SlickException("Error configuring DataSource " + dsClass, ex) }
+
+        case None =>
+          val ds = new DriverDataSource
+          ds.classLoader = classLoader
+          ds.driverObject = driver
+          BeanConfigurator.configure(ds, c.toProperties, Set("url", "user", "password", "properties", "driver", "driverClassName"))
+          (ds, None)
+      }
+    new DataSourceJdbcDataSource(ds, c.getBooleanOr("keepAliveConnection"), maxConnections, new ConnectionPreparer(c))
   }
 }
 

slick/src/main/scala/slick/util/AsyncExecutor.scala

@@ -49,6 +49,7 @@ object AsyncExecutor extends Logging {
     *        queue and thread pool workload. */
   def apply(name: String, minThreads: Int, maxThreads: Int, queueSize: Int, maxConnections: Int = Integer.MAX_VALUE, keepAliveTime: Duration = 1.minute,
             registerMbeans: Boolean = false): AsyncExecutor = new AsyncExecutor {
+
     @volatile private[this] lazy val mbeanName = new ObjectName(s"slick:type=AsyncExecutor,name=$name");
 
     // Before init: 0, during init: 1, after init: 2, during/after shutdown: 3
@@ -184,6 +185,15 @@ object AsyncExecutor extends Logging {
     }
   }
 
+  def default(name: String, maxConnections: Int): AsyncExecutor =
+    apply(
+      name,
+      minThreads = 20,
+      maxThreads = 20,
+      queueSize = 1000,
+      maxConnections = maxConnections
+    )
+
   def default(name: String = "AsyncExecutor.default"): AsyncExecutor =
     apply(name, 20, 1000)