def generateNotEnoughMessage()

in linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/RequestResourceService.scala [336:529]
194 lines of code
18 McCabe index (conditional complexity)

  def generateNotEnoughMessage(
      requestResource: Resource,
      availableResource: Resource,
      maxResource: Resource
  ): (Int, String) = {
    requestResource match {
      case m: MemoryResource =>
        val avail = availableResource.asInstanceOf[MemoryResource]
        val max = maxResource.asInstanceOf[MemoryResource]
        (
          RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getErrorCode,
          RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getErrorDesc +
            RMUtils.getResourceInfoMsg(
              RMConstant.MEMORY,
              RMConstant.MEMORY_UNIT_BYTE,
              m.getMemory,
              avail.getMemory,
              max.getMemory
            )
        )
      case i: InstanceResource =>
        val avail = availableResource.asInstanceOf[InstanceResource]
        val max = maxResource.asInstanceOf[InstanceResource]
        (
          RMErrorCode.INSTANCES_INSUFFICIENT.getErrorCode,
          RMErrorCode.INSTANCES_INSUFFICIENT.getErrorDesc +
            RMUtils.getResourceInfoMsg(
              RMConstant.APP_INSTANCE,
              RMConstant.INSTANCE_UNIT,
              i.getInstances,
              avail.getInstances,
              max.getInstances
            )
        )
      case c: CPUResource =>
        val avail = availableResource.asInstanceOf[CPUResource]
        val max = maxResource.asInstanceOf[CPUResource]
        (
          RMErrorCode.DRIVER_CPU_INSUFFICIENT.getErrorCode,
          RMErrorCode.DRIVER_CPU_INSUFFICIENT.getErrorDesc +
            RMUtils.getResourceInfoMsg(
              RMConstant.CPU,
              RMConstant.CPU_UNIT,
              c.getCores,
              avail.getCores,
              max.getCores
            )
        )
      case l: LoadResource =>
        val loadAvailable = availableResource.asInstanceOf[LoadResource]
        val avail = availableResource.asInstanceOf[LoadResource]
        val max = maxResource.asInstanceOf[LoadResource]
        if (l.getCores > loadAvailable.getCores) {
          (
            RMErrorCode.DRIVER_CPU_INSUFFICIENT.getErrorCode,
            RMErrorCode.DRIVER_CPU_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.CPU,
                RMConstant.CPU_UNIT,
                l.getCores,
                avail.getCores,
                max.getCores
              )
          )
        } else {
          (
            RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getErrorCode,
            RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.MEMORY,
                RMConstant.MEMORY_UNIT_BYTE,
                l.getMemory,
                avail.getMemory,
                max.getMemory
              )
          )
        }
      case li: LoadInstanceResource =>
        val loadInstanceAvailable = availableResource.asInstanceOf[LoadInstanceResource]
        val avail = availableResource.asInstanceOf[LoadInstanceResource]
        val max = maxResource.asInstanceOf[LoadInstanceResource]
        if (li.getCores > loadInstanceAvailable.getCores) {
          (
            RMErrorCode.DRIVER_CPU_INSUFFICIENT.getErrorCode,
            RMErrorCode.DRIVER_CPU_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.CPU,
                RMConstant.CPU_UNIT,
                li.getCores,
                avail.getCores,
                max.getCores
              )
          )
        } else if (li.getMemory > loadInstanceAvailable.getMemory) {
          (
            RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getErrorCode,
            RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.MEMORY,
                RMConstant.MEMORY_UNIT_BYTE,
                li.getMemory,
                avail.getMemory,
                max.getMemory
              )
          )
        } else {
          (
            RMErrorCode.INSTANCES_INSUFFICIENT.getErrorCode,
            RMErrorCode.INSTANCES_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.APP_INSTANCE,
                RMConstant.INSTANCE_UNIT,
                li.getInstances,
                avail.getInstances,
                max.getInstances
              )
          )
        }
      case yarn: YarnResource =>
        val yarnAvailable = availableResource.asInstanceOf[YarnResource]
        val avail = availableResource.asInstanceOf[YarnResource]
        val max = maxResource.asInstanceOf[YarnResource]
        if (yarn.getQueueCores > yarnAvailable.getQueueCores) {
          (
            RMErrorCode.QUEUE_CPU_INSUFFICIENT.getErrorCode,
            RMErrorCode.QUEUE_CPU_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.CPU,
                RMConstant.CPU_UNIT,
                yarn.getQueueCores,
                avail.getQueueCores,
                max.getQueueCores
              )
          )
        } else if (yarn.getQueueMemory > yarnAvailable.getQueueMemory) {
          (
            RMErrorCode.QUEUE_MEMORY_INSUFFICIENT.getErrorCode,
            RMErrorCode.QUEUE_MEMORY_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.MEMORY,
                RMConstant.MEMORY_UNIT_BYTE,
                yarn.getQueueMemory,
                avail.getQueueMemory,
                max.getQueueMemory
              )
          )
        } else {
          (
            RMErrorCode.QUEUE_INSTANCES_INSUFFICIENT.getErrorCode,
            RMErrorCode.QUEUE_INSTANCES_INSUFFICIENT.getErrorDesc +
              RMUtils.getResourceInfoMsg(
                RMConstant.APP_INSTANCE,
                RMConstant.INSTANCE_UNIT,
                yarn.getQueueInstances,
                avail.getQueueInstances,
                max.getQueueInstances
              )
          )
        }
      case dy: DriverAndYarnResource =>
        val dyAvailable = availableResource.asInstanceOf[DriverAndYarnResource]
        val dyMax = maxResource.asInstanceOf[DriverAndYarnResource]
        if (
            dy.getLoadInstanceResource.getMemory > dyAvailable.getLoadInstanceResource.getMemory ||
            dy.getLoadInstanceResource.getCores > dyAvailable.getLoadInstanceResource.getCores ||
            dy.getLoadInstanceResource.getInstances > dyAvailable.getLoadInstanceResource.getInstances
        ) {
          val detail = generateNotEnoughMessage(
            dy.getLoadInstanceResource,
            dyAvailable.getLoadInstanceResource,
            dyMax.getLoadInstanceResource
          )
          (detail._1, { detail._2 })
        } else {
          val detail =
            generateNotEnoughMessage(
              dy.getYarnResource,
              dyAvailable.getYarnResource,
              dyMax.getYarnResource
            )
          (detail._1, { detail._2 })
        }
      case s: SpecialResource =>
        throw new RMWarnException(
          NOT_RESOURCE_TYPE.getErrorCode,
          MessageFormat.format(NOT_RESOURCE_TYPE.getErrorDesc, s.getClass)
        )
      case r: Resource =>
        throw new RMWarnException(
          NOT_RESOURCE_TYPE.getErrorCode,
          MessageFormat.format(NOT_RESOURCE_TYPE.getErrorDesc, r.getClass)
        )
    }
  }