Postrelease dxapi 0.13.15 and revert it (#145)

* Release dxApi 0.13.15

* Postrelease and revert of 0.13.15 changes

Author: windok

api/RELEASE_NOTES.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+* Revert preferring v3 instance types over v2, until v3 are more widely available.
+
+## 0.13.15 (2025-11-14)
+
 * Prefer v3 instance types over v2
 
 ## 0.13.14 (2025-10-03)

api/src/main/resources/application.conf

@@ -1,5 +1,5 @@
 dxApi {
-  version = "0.13.15-SNAPSHOT"
+  version = "0.13.16-SNAPSHOT"
 }
 
 #

api/src/main/scala/dx/api/DxInstanceType.scala

@@ -27,7 +27,7 @@ price       comparative price
 package dx.api
 
 import dx.api
-import dx.util.{Enum, JsUtils, Logger}
+import dx.util.{Enum, JsUtils, LinkedList, LinkedListInterface, LinkedNil, Logger}
 import dx.util.Enum.enumFormat
 import spray.json.{RootJsonFormat, _}
 
@@ -70,7 +70,7 @@ case class InstanceTypeRequest(dxInstanceType: Option[String] = None,
                                os: Option[ExecutionEnvironment] = None,
                                optional: Boolean = false) {
   override def toString: String = {
-    s"""memory=(${minMemoryMB},${maxMemoryMB}) disk=(${minDiskGB},${maxDiskGB}) diskType=${diskType}
+    s"""memory=(${minMemoryMB},${maxMemoryMB}) disk=(${minDiskGB},${maxDiskGB}) diskType=${diskType} 
        |cores=(${minCpu},${maxCpu}) gpu=${gpu} os=${os} instancetype=${dxInstanceType}
        |optional=${optional}""".stripMargin.replaceAll("\n", " ")
   }
@@ -118,8 +118,6 @@ case class DxInstanceType(name: String,
                           priceRank: Option[Int] = None)
     extends Ordered[DxInstanceType] {
 
-  @transient private lazy val version: Int = DxInstanceType.typeVersion(name)
-
   /**
     * Returns true if this instance type satisfies the requirements of `query`,
     * which happens if 1) this instance type has the same name as specified in
@@ -220,11 +218,12 @@ case class DxInstanceType(name: String,
   }
 
   /**
-    * Compare instances based on version (v1 vs v2 vs v3 vs ...).
-    * Higher version number is always better.
+    * Compare instances based on version (v1 vs v2) -
+    * v2 instances are always better than v1 instances.
     */
   def compareByType(that: DxInstanceType): Int = {
-    this.version.compareTo(that.version)
+    def typeVersion(name: String): Int = if (name contains DxInstanceType.Version2Suffix) 2 else 1
+    typeVersion(this.name).compareTo(typeVersion(that.name))
   }
 
   override def compare(that: DxInstanceType): Int = {
@@ -238,7 +237,7 @@ case class DxInstanceType(name: String,
       if (resCmp != 0) {
         resCmp
       } else {
-        // all else being equal, choose newer versions (higher version number is better)
+        // all else being equal, choose v2 instances over v1
         -compareByType(that)
       }
     }
@@ -254,33 +253,12 @@ object DxInstanceType extends DefaultJsonProtocol {
   implicit val dxInstanceTypeFormat: RootJsonFormat[DxInstanceType] = jsonFormat8(
       DxInstanceType.apply
   )
-
-  // Use a regex to dynamically find any version suffix like '_vN'
-  val VersionRegex = "_v(\\d+)_".r
+  val Version2Suffix = "_v2"
+  val NewestVersion = "v2"
   val CpuSuffixStart = "x"
   val InstanceNameSeparator = "_"
   private val MemoryNormFactor: Double = 1024.0
   private val DiskNormFactor: Double = 16.0
-
-  /**
-    * Extracts the numeric version from the instance type name.
-    * Examples:
-    * "mem1_ssd1_x4" -> 1 (default)
-    * "mem1_ssd1_v2_x4" -> 2
-    * "mem1_ssd1_v3_x4" -> 3
-    */
-  def typeVersion(name: String): Int = {
-    // Iterate over matches to find the last (most relevant) version suffix
-    VersionRegex.findFirstMatchIn(name) match {
-      case Some(m) =>
-        try {
-          m.group(1).toInt
-        } catch {
-          case _: NumberFormatException => 1
-        }
-      case _ => 1
-    }
-  }
 }
 
 case class InstanceTypeDB(instanceTypes: Map[String, DxInstanceType]) {
@@ -292,63 +270,30 @@ case class InstanceTypeDB(instanceTypes: Map[String, DxInstanceType]) {
     instanceTypes.toVector.sortWith(_ < _).headOption
   }
 
-  /**
-    * Generates the name of the next highest version of the current instance name.
-    * If the current version is vN, it returns the string for v(N+1).
-    * E.g., "mem1_ssd1_x4" (v1) -> "mem1_ssd1_v2_x4"
-    * E.g., "mem1_ssd1_v2_x4" -> "mem1_ssd1_v3_x4"
-    *
-    * @param instance The DxInstanceType to upgrade.
-    * @return The potential name of the next version instance.
-    */
-  private def getNextVersionName(instance: DxInstanceType): String = {
-    val currentName = instance.name
-    val currentVersion = DxInstanceType.typeVersion(currentName)
-    val nextVersion = currentVersion + 1
-    val nextVersionSuffix = s"_v${nextVersion}"
-
-    // Explicitly match the type for the regex result to access start/end
-    DxInstanceType.VersionRegex.findFirstMatchIn(currentName) match {
-      case Some(m: scala.util.matching.Regex.Match) =>
-        // Replace the existing version suffix with the next version suffix
-        currentName.substring(0, m.start) + nextVersionSuffix + currentName.substring(m.end)
-      case None =>
-        // Append the version suffix before the CPU part
-        val parts = currentName.split(DxInstanceType.InstanceNameSeparator).toVector
-        val (prefix, suffix) = parts.partition(!_.startsWith(DxInstanceType.CpuSuffixStart))
-
-        (prefix :+ nextVersionSuffix.stripPrefix("_") :+ suffix.head)
-          .mkString(DxInstanceType.InstanceNameSeparator)
-    }
-  }
-
   private def newerVersionAvailable(instance: DxInstanceType): Boolean = {
-    val nextVersionName = getNextVersionName(instance)
-    instanceTypes.contains(nextVersionName)
+    if (instance.name contains DxInstanceType.Version2Suffix) true
+    else {
+      instanceTypes.contains(upgradeToLatestVersion(instance))
+    }
   }
 
   private def upgradeToLatestVersion(instance: DxInstanceType): String = {
+    val instanceNameElements = instance.name.split(DxInstanceType.InstanceNameSeparator).toVector
+    val linkedElements = LinkedList.create(instanceNameElements)
     @tailrec
-    def findLatest(currentName: String): String = {
-      instanceTypes.get(currentName) match {
-        case None =>
-          currentName
-        case Some(tempInstance) =>
-          val nextVersionName = getNextVersionName(tempInstance)
-          if (nextVersionName != currentName && instanceTypes.contains(nextVersionName)) {
-            findLatest(nextVersionName)
-          } else {
-            currentName
-          }
+    def insertVersion(linkedList: LinkedListInterface[String],
+                      accu: Vector[String] = Vector.empty): Vector[String] = {
+      linkedList match {
+        case LinkedNil                                    => accu
+        case l: LinkedList[String] if l.next == LinkedNil => l.value +: accu
+        case l: LinkedList[String]
+            if l.value.startsWith(DxInstanceType.CpuSuffixStart)
+              && l.next.value != DxInstanceType.NewestVersion =>
+          insertVersion(l.next, DxInstanceType.NewestVersion +: l.value +: accu)
+        case l: LinkedList[(String)] => insertVersion(l.next, l.value +: accu)
       }
     }
-
-    val nextVersionName = getNextVersionName(instance)
-    if (instanceTypes.contains(nextVersionName)) {
-      findLatest(nextVersionName)
-    } else {
-      instance.name
-    }
+    insertVersion(linkedElements).mkString("_")
   }
 
   /**
@@ -367,21 +312,12 @@ case class InstanceTypeDB(instanceTypes: Map[String, DxInstanceType]) {
     val preferredInstances = eligibleInstances.filterNot { instance =>
       instance.gpu || instance.name.contains("fpga")
     }
+    val (v2Instances, v1Instances) =
+      preferredInstances.partition(_.name.contains(DxInstanceType.Version2Suffix))
 
-    val instancesToConsider =
-      if (preferredInstances.nonEmpty) preferredInstances else eligibleInstances
-
-    // Sort by version first (descending), then by price/resources (ascending)
-    instancesToConsider.toVector
-      .sortWith { (a, b) =>
-        val versionCmp = -a.compareByType(b)
-        if (versionCmp != 0) {
-          versionCmp < 0
-        } else {
-          a.compare(b) < 0
-        }
-      }
-      .headOption
+    selectMinimalInstanceType(v2Instances) // Try preferred v2 non-GPU/FPGA
+      .orElse(selectMinimalInstanceType(v1Instances)) // Then try v1 non-GPU/FPGA
+      .orElse(selectMinimalInstanceType(eligibleInstances)) // As a last resort, consider all instances (including GPU/FPGA)
       .getOrElse(
           throw new Exception(
               s"""no instance types meet the minimal requirements memory >= ${InstanceTypeDB.MinMemory}
@@ -430,7 +366,8 @@ case class InstanceTypeDB(instanceTypes: Map[String, DxInstanceType]) {
       val instance = instanceTypes.get(name)
       instance match {
         case None => return instance
-        case Some(x) if newerVersionAvailable(x) =>
+        case Some(x)
+            if newerVersionAvailable(x) && !(x.name contains DxInstanceType.Version2Suffix) =>
           Logger.get.warning(
               s"""
                  |WARNING: an older version of the instance ${x.name} is specified.

api/src/test/scala/dx/api/InstanceTypeDBTest.scala

@@ -153,27 +153,6 @@ class InstanceTypeDBTest extends AnyFlatSpec with Matchers {
     )
   }
 
-  it should "defaultInstanceType. prefer v3 instance over v2" in {
-    val db = createInstanceTypeDB(
-        createTestInstance("mem1_ssd1_x4", 3072, 80),
-        createTestInstance("mem1_ssd1_v2_x4", 3072, 80),
-        createTestInstance("mem1_ssd1_v3_x4", 3072, 80),
-        createTestInstance("mem1_ssd1_gpu1_x4", 3072, 80)
-    )
-
-    db.defaultInstanceType.name shouldBe "mem1_ssd1_v3_x4"
-  }
-
-  it should "defaultInstanceType. prefer gpu v3 instance if non-gpu v3, v2, or v1 exists" in {
-    // All preferred (non-GPU/FPGA) instances are filtered out. Only GPU/FPGA remain.
-    val db = createInstanceTypeDB(
-        createTestInstance("mem1_ssd1_gpu1_v3_x4", 3072, 80),
-        createTestInstance("mem1_ssd1_gpu1_v2_x4", 3072, 80)
-    )
-
-    db.defaultInstanceType.name shouldBe "mem1_ssd1_gpu1_v3_x4"
-  }
-
   it should "selectOptimal. work on large instances (JIRA-1258)" in {
     val db = createInstanceTypeDB(
         createTestInstance("mem3_ssd1_x32", 245751, 597),
@@ -231,48 +210,12 @@ class InstanceTypeDBTest extends AnyFlatSpec with Matchers {
     db.selectOptimal(InstanceTypeRequest(minCpu = Some(8), gpu = Some(false))) shouldBe None
   }
 
-  it should "selectOptimal. prefer v3 over v2 over v1 when resources are equal" taggedAs EdgeTest in {
-    val db = createInstanceTypeDB(
-        createTestInstance("mem1_ssd1_x4", 8000, 80),
-        createTestInstance("mem1_ssd1_v2_x4", 8000, 80),
-        createTestInstance("mem1_ssd1_v3_x4", 8000, 80)
-    )
-
-    db.selectOptimal(InstanceTypeRequest(minCpu = Some(4))) should matchPattern {
-      case Some(instanceType: DxInstanceType) if instanceType.name == "mem1_ssd1_v3_x4" =>
-    }
-  }
-
-  it should "selectOptimal. GPU request prefers v3 GPU over v2 GPU" taggedAs EdgeTest in {
-    val db = createInstanceTypeDB(
-        createTestInstance("mem3_ssd1_gpu_v2_x8", 30000, 100),
-        createTestInstance("mem3_ssd1_gpu_v3_x8", 30000, 100),
-        createTestInstance("mem1_ssd1_v3_x4", 8000, 80)
-    )
-
-    db.selectOptimal(InstanceTypeRequest(minCpu = Some(8), gpu = Some(true))) should matchPattern {
-      case Some(instanceType: DxInstanceType) if instanceType.name == "mem3_ssd1_gpu_v3_x8" =>
-    }
-  }
-
   it should "selectByName. issue a warning if requested a v1 instance by ID but v2 is available" in {
     testDb.selectByName("mem1_ssd1_x16") should matchPattern {
       case Some(instanceType: DxInstanceType) if instanceType.name == "mem1_ssd1_x16" =>
     }
   }
 
-  it should "selectByName. issue a warning if requested a v1 instance by ID but v3 is available" in {
-    val db = createInstanceTypeDB(
-        createTestInstance("mem1_ssd1_x16", 8000, 100),
-        createTestInstance("mem1_ssd1_v2_x16", 8000, 100),
-        createTestInstance("mem1_ssd1_v3_x16", 8000, 100)
-    )
-
-    db.selectByName("mem1_ssd1_x16") should matchPattern {
-      case Some(instanceType: DxInstanceType) if instanceType.name == "mem1_ssd1_x16" =>
-    }
-  }
-
   it should "AWS region. Query returns correct pricing models for org and user" taggedAs ApiTest in {
     def instanceTypeFilter(instanceType: DxInstanceType): Boolean = {
       instanceType.os.exists(_.release == "24.04")
@@ -281,7 +224,7 @@ class InstanceTypeDBTest extends AnyFlatSpec with Matchers {
     val db = InstanceTypeDB.create(userBilltoProject, instanceTypeFilter)
 
     db.instanceTypes.size shouldBe 133
-    db.defaultInstanceType.name shouldBe "mem1_ssd2_v3_x2"
+    db.defaultInstanceType.name shouldBe "mem1_ssd1_v2_x2"
   }
 
   it should "OCI region. Query returns correct pricing models for org and user" taggedAs ApiTest in {

build.sbt

@@ -112,7 +112,7 @@ val yaml = project
 lazy val dependencies =
   new {
     val dxCommonVersion = "0.11.5"
-    val dxApiVersion = "0.13.14"
+    val dxApiVersion = "0.13.15"
     val typesafeVersion = "1.4.1"
     val sprayVersion = "1.3.6"
     val snakeyamlVersion = "2.3"