fix style

Author: lsm1

externals/kyuubi-spark-sql-engine/src/main/scala/org/apache/kyuubi/engine/spark/SparkSQLEngine.scala

@@ -25,6 +25,7 @@ import java.util.concurrent.atomic.AtomicBoolean
 import scala.concurrent.duration.Duration
 import scala.util.control.NonFatal
 
+import com.fasterxml.jackson.databind.ObjectMapper
 import com.google.common.annotations.VisibleForTesting
 import org.apache.hadoop.fs.Path
 import org.apache.spark.{ui, SparkConf}
@@ -57,7 +58,7 @@ case class SparkSQLEngine(spark: SparkSession) extends Serverable("SparkSQLEngin
 
   private val shutdown = new AtomicBoolean(false)
   private val gracefulStopDeregistered = new AtomicBoolean(false)
-
+  private val objectMapper = new ObjectMapper
   @volatile private var lifetimeTerminatingChecker: Option[ScheduledExecutorService] = None
   @volatile private var stopEngineExec: Option[ThreadPoolExecutor] = None
   @volatile private var engineSavePath: Option[String] = None
@@ -185,18 +186,17 @@ case class SparkSQLEngine(spark: SparkSession) extends Serverable("SparkSQLEngin
           .flatMap { stage =>
             statusTracker.getStageInfo(stage).map(_.numActiveTasks)
           }.sum
-        val engineMetrics = Map(
-          "openSessionCount" -> openSessionCount,
-          "activeTask" -> activeTask,
-          "poolId" -> engineSpace.split("-").last)
-        info(s"Spark engine has $openSessionCount open sessions and $activeTask active tasks.")
+        val engineMetrics = objectMapper.createObjectNode()
+          .put("openSessionCount", openSessionCount)
+          .put("activeTask", activeTask)
+          .put("poolID", engineSpace.split("-").last.toInt).toString
         DiscoveryClientProvider.withDiscoveryClient(conf) { client =>
           if (client.pathNonExists(metricsSpace)) {
             client.create(metricsSpace, "PERSISTENT")
           }
           client.setData(
             s"/metrics$engineSpace",
-            engineMetrics.map { case (k, v) => s"$k=$v" }.mkString(";").getBytes)
+            engineMetrics.getBytes)
         }
       }
     }

kyuubi-server/src/main/scala/org/apache/kyuubi/engine/EngineRef.scala

@@ -23,6 +23,8 @@ import scala.collection.JavaConverters._
 import scala.util.Random
 
 import com.codahale.metrics.MetricRegistry
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.scala.DefaultScalaModule
 import com.google.common.annotations.VisibleForTesting
 
 import org.apache.kyuubi.{KYUUBI_VERSION, KyuubiSQLException, Logging, Utils}
@@ -65,6 +67,8 @@ private[kyuubi] class EngineRef(
 
   private val timeout: Long = conf.get(ENGINE_INIT_TIMEOUT)
 
+  private val objectMapper = new ObjectMapper().registerModule(DefaultScalaModule)
+
   // Share level of the engine
   private val shareLevel: ShareLevel = ShareLevel.withName(conf.get(ENGINE_SHARE_LEVEL))
 
@@ -324,10 +328,10 @@ private[kyuubi] class EngineRef(
     }
   }
 
-  def getAdaptivePoolId(poolSize: Int): Int = {
+  private def getAdaptivePoolId(poolSize: Int): Int = {
     val sessionThreshold = conf.get(ENGINE_POOL_ADAPTIVE_SESSION_THRESHOLD)
     val metricsSpace =
-      s"/metrics/${serverSpace}_${KYUUBI_VERSION}_${shareLevel}_${engineType}/$user"
+      s"/metrics/${serverSpace}_${KYUUBI_VERSION}_${shareLevel}_$engineType/$user"
     DiscoveryClientProvider.withDiscoveryClient(conf) { client =>
       tryWithLock(client) {
         if (client.pathNonExists(metricsSpace)) {
@@ -340,25 +344,23 @@ private[kyuubi] class EngineRef(
       } else {
         engineType match {
           case SPARK_SQL =>
-            val engineMetricsMap = metrics.map(p =>
-              new String(client.getData(s"$metricsSpace/$p"))
-                .split(";")
-                .map(_.split("=", 2))
-                .filter(_.length == 2)
-                .map(kv => (kv.head, kv.last.toInt))
-                .toMap)
+            val engineMetricsMap = metrics.map { p =>
+              objectMapper.readValue(
+                new String(client.getData(s"$metricsSpace/$p")),
+                classOf[Map[String, Int]])
+            }
             if (engineMetricsMap.isEmpty) {
               return Random.nextInt(poolSize)
             } else {
-              val sortedEngineMetrics = engineMetricsMap.sortBy { map =>
-                (
-                  map.getOrElse("openSessionCount", sessionThreshold),
-                  map.getOrElse("activeTask", 0))
-              }
-              val candidate = sortedEngineMetrics.head
-              if (candidate.contains("poolId") && (candidate(
-                  "openSessionCount") < sessionThreshold || metrics.size == poolSize)) {
-                candidate("poolId")
+              val candidate = engineMetricsMap.filter(_.contains("poolID"))
+                .minBy { map =>
+                  (
+                    map.getOrElse("openSessionCount", sessionThreshold),
+                    map.getOrElse("activeTask", 0))
+                }
+              if ((candidate.nonEmpty && candidate("openSessionCount") < sessionThreshold) ||
+                metrics.size == poolSize) {
+                candidate("poolID")
               } else {
                 Random.nextInt(poolSize)
               }