You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@linkis.apache.org by ca...@apache.org on 2022/08/11 14:05:04 UTC
[incubator-linkis] branch dev-1.2.1 updated: Add specific resource info in resource insufficient message (#2710)
This is an automated email from the ASF dual-hosted git repository.
casion pushed a commit to branch dev-1.2.1
in repository https://gitbox.apache.org/repos/asf/incubator-linkis.git
The following commit(s) were added to refs/heads/dev-1.2.1 by this push:
new 8f9e5cc4d Add specific resource info in resource insufficient message (#2710)
8f9e5cc4d is described below
commit 8f9e5cc4d9346397443c6473c7ba0897b0bd27f2
Author: Alexyang <xu...@qq.com>
AuthorDate: Thu Aug 11 22:04:58 2022 +0800
Add specific resource info in resource insufficient message (#2710)
* #2429
linkis-application-manager - Add specific resource info in resource insufficient message
---
.../rm/service/RequestResourceService.scala | 72 +++++++++++++++-------
.../impl/DriverAndYarnReqResourceService.scala | 18 ++++--
.../apache/linkis/manager/rm/utils/RMUtils.scala | 28 ++++++++-
.../linkis/manager/common/constant/RMConstant.java | 33 ++++++++++
4 files changed, 123 insertions(+), 28 deletions(-)
diff --git a/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/RequestResourceService.scala b/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/RequestResourceService.scala
index 5b61ff789..349708a87 100644
--- a/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/RequestResourceService.scala
+++ b/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/RequestResourceService.scala
@@ -18,6 +18,7 @@
package org.apache.linkis.manager.rm.service
import org.apache.linkis.common.utils.Logging
+import org.apache.linkis.manager.common.constant.RMConstant
import org.apache.linkis.manager.common.entity.resource._
import org.apache.linkis.manager.common.exception.RMWarnException
import org.apache.linkis.manager.label.entity.em.EMInstanceLabel
@@ -62,10 +63,11 @@ abstract class RequestResourceService(labelResourceService: LabelResourceService
logger.debug(s"Label [${labelContainer.getCurrentLabel}] has resource + [${labelResource }]")
if (labelResource != null) {
val labelAvailableResource = labelResource.getLeftResource
+ val labelMaxResource = labelResource.getMaxResource
if(labelAvailableResource < requestResource && enableRequest) {
logger.info(s"Failed check: ${labelContainer.getUserCreatorLabel.getUser} want to use label [${labelContainer.getCurrentLabel}] resource[${requestResource}] > label available resource[${labelAvailableResource}]")
// TODO sendAlert(moduleInstance, user, creator, requestResource, moduleAvailableResource.resource, moduleLeftResource)
- val notEnoughMessage = generateNotEnoughMessage(requestResource, labelAvailableResource)
+ val notEnoughMessage = generateNotEnoughMessage(requestResource, labelAvailableResource, labelMaxResource)
throw new RMWarnException(notEnoughMessage._1, notEnoughMessage._2)
}
logger.debug(s"Passed check: ${labelContainer.getUserCreatorLabel.getUser} want to use label [${labelContainer.getCurrentLabel}] resource[${requestResource}] <= label available resource[${labelAvailableResource}]")
@@ -85,7 +87,7 @@ abstract class RequestResourceService(labelResourceService: LabelResourceService
if(labelAvailableResource < requestResource && enableRequest) {
logger.info(s"user want to use resource[${requestResource}] > em ${emInstanceLabel.getInstance()} available resource[${labelAvailableResource}]")
// TODO sendAlert(moduleInstance, user, creator, requestResource, moduleAvailableResource.resource, moduleLeftResource)
- val notEnoughMessage = generateECMNotEnoughMessage(requestResource, labelAvailableResource)
+ val notEnoughMessage = generateECMNotEnoughMessage(requestResource, labelAvailableResource, labelResource.getMaxResource)
throw new RMWarnException(notEnoughMessage._1, notEnoughMessage._2)
}
logger.debug(s"Passed check: resource[${requestResource}] want to use em ${emInstanceLabel.getInstance()} available resource[${labelAvailableResource}]")
@@ -96,7 +98,7 @@ abstract class RequestResourceService(labelResourceService: LabelResourceService
}
}
- def generateECMNotEnoughMessage(requestResource: Resource, availableResource: Resource) : (Int, String) = {
+ def generateECMNotEnoughMessage(requestResource: Resource, availableResource: Resource, maxResource: Resource) : (Int, String) = {
val loadRequestResource = requestResource match {
case li: LoadInstanceResource => li
case driverAndYarnResource: DriverAndYarnResource => driverAndYarnResource.loadInstanceResource
@@ -105,61 +107,89 @@ abstract class RequestResourceService(labelResourceService: LabelResourceService
loadRequestResource match {
case li: LoadInstanceResource =>
val loadInstanceAvailable = availableResource.asInstanceOf[LoadInstanceResource]
+ val loadInstanceMax = maxResource.asInstanceOf[LoadInstanceResource]
if(li.cores > loadInstanceAvailable.cores) {
- (RMErrorCode.ECM_CPU_INSUFFICIENT.getCode, RMErrorCode.ECM_CPU_INSUFFICIENT.getMessage)
+ (RMErrorCode.ECM_CPU_INSUFFICIENT.getCode, RMErrorCode.ECM_CPU_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.CPU, RMConstant.CPU_UNIT, li.cores, loadInstanceAvailable.cores, loadInstanceMax.cores))
} else if (li.memory > loadInstanceAvailable.memory) {
- (RMErrorCode.ECM_MEMORY_INSUFFICIENT.getCode, RMErrorCode.ECM_MEMORY_INSUFFICIENT.getMessage)
+ (RMErrorCode.ECM_MEMORY_INSUFFICIENT.getCode, RMErrorCode.ECM_MEMORY_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.MEMORY, RMConstant.MEMORY_UNIT_BYTE, li.memory, loadInstanceAvailable.memory, loadInstanceMax.memory))
} else {
- (RMErrorCode.ECM_INSTANCES_INSUFFICIENT.getCode, RMErrorCode.ECM_INSTANCES_INSUFFICIENT.getMessage)
+ (RMErrorCode.ECM_INSTANCES_INSUFFICIENT.getCode, RMErrorCode.ECM_INSTANCES_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.APP_INSTANCE, RMConstant.INSTANCE_UNIT, li.instances, loadInstanceAvailable.instances, loadInstanceMax.instances))
}
case _ =>
- (RMErrorCode.ECM_RESOURCE_INSUFFICIENT.getCode, RMErrorCode.ECM_RESOURCE_INSUFFICIENT.getMessage)
+ (RMErrorCode.ECM_RESOURCE_INSUFFICIENT.getCode, RMErrorCode.ECM_RESOURCE_INSUFFICIENT.getMessage + " Unusual insufficient queue memory.")
}
}
- def generateNotEnoughMessage(requestResource: Resource, availableResource: Resource) : (Int, String) = {
+ def generateNotEnoughMessage(requestResource: Resource, availableResource: Resource, maxResource: Resource) : (Int, String) = {
requestResource match {
case m: MemoryResource =>
- (RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getCode, RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getMessage)
+ val avail = availableResource.asInstanceOf[MemoryResource]
+ val max = maxResource.asInstanceOf[MemoryResource]
+ (RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getCode, RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.MEMORY, RMConstant.MEMORY_UNIT_BYTE, m.memory, avail.memory, max.memory))
case i: InstanceResource =>
- (RMErrorCode.INSTANCES_INSUFFICIENT.getCode, RMErrorCode.INSTANCES_INSUFFICIENT.getMessage)
+ val avail = availableResource.asInstanceOf[InstanceResource]
+ val max = maxResource.asInstanceOf[InstanceResource]
+ (RMErrorCode.INSTANCES_INSUFFICIENT.getCode, RMErrorCode.INSTANCES_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.APP_INSTANCE, RMConstant.INSTANCE_UNIT, i.instances, avail.instances, max.instances))
case c: CPUResource =>
- (RMErrorCode.DRIVER_CPU_INSUFFICIENT.getCode, RMErrorCode.DRIVER_CPU_INSUFFICIENT.getMessage)
+ val avail = availableResource.asInstanceOf[CPUResource]
+ val max = maxResource.asInstanceOf[CPUResource]
+ (RMErrorCode.DRIVER_CPU_INSUFFICIENT.getCode, RMErrorCode.DRIVER_CPU_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.CPU, RMConstant.CPU_UNIT, c.cores, avail.cores, max.cores))
case l: LoadResource =>
val loadAvailable = availableResource.asInstanceOf[LoadResource]
+ val avail = availableResource.asInstanceOf[LoadResource]
+ val max = maxResource.asInstanceOf[LoadResource]
if(l.cores > loadAvailable.cores) {
- (RMErrorCode.DRIVER_CPU_INSUFFICIENT.getCode, RMErrorCode.DRIVER_CPU_INSUFFICIENT.getMessage)
+ (RMErrorCode.DRIVER_CPU_INSUFFICIENT.getCode, RMErrorCode.DRIVER_CPU_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.CPU, RMConstant.CPU_UNIT, l.cores, avail.cores, max.cores))
} else {
- (RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getCode, RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getMessage)
+ (RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getCode, RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.MEMORY, RMConstant.MEMORY_UNIT_BYTE, l.memory, avail.memory, max.memory))
}
case li: LoadInstanceResource =>
val loadInstanceAvailable = availableResource.asInstanceOf[LoadInstanceResource]
+ val avail = availableResource.asInstanceOf[LoadInstanceResource]
+ val max = maxResource.asInstanceOf[LoadInstanceResource]
if(li.cores > loadInstanceAvailable.cores) {
- (RMErrorCode.DRIVER_CPU_INSUFFICIENT.getCode, RMErrorCode.DRIVER_CPU_INSUFFICIENT.getMessage)
+ (RMErrorCode.DRIVER_CPU_INSUFFICIENT.getCode, RMErrorCode.DRIVER_CPU_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.CPU, RMConstant.CPU_UNIT, li.cores, avail.cores, max.cores))
} else if (li.memory > loadInstanceAvailable.memory) {
- (RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getCode, RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getMessage)
+ (RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getCode, RMErrorCode.DRIVER_MEMORY_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.MEMORY, RMConstant.MEMORY_UNIT_BYTE, li.memory, avail.memory, max.memory))
} else {
- (RMErrorCode.INSTANCES_INSUFFICIENT.getCode, RMErrorCode.INSTANCES_INSUFFICIENT.getMessage)
+ (RMErrorCode.INSTANCES_INSUFFICIENT.getCode, RMErrorCode.INSTANCES_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.APP_INSTANCE, RMConstant.INSTANCE_UNIT, li.instances, avail.instances, max.instances))
}
case yarn: YarnResource =>
val yarnAvailable = availableResource.asInstanceOf[YarnResource]
+ val avail = availableResource.asInstanceOf[YarnResource]
+ val max = maxResource.asInstanceOf[YarnResource]
if(yarn.queueCores > yarnAvailable.queueCores) {
- (RMErrorCode.QUEUE_CPU_INSUFFICIENT.getCode, RMErrorCode.QUEUE_CPU_INSUFFICIENT.getMessage)
+ (RMErrorCode.QUEUE_CPU_INSUFFICIENT.getCode, RMErrorCode.QUEUE_CPU_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.CPU, RMConstant.CPU_UNIT, yarn.queueCores, avail.queueCores, max.queueCores))
} else if (yarn.queueMemory > yarnAvailable.queueMemory) {
- (RMErrorCode.QUEUE_MEMORY_INSUFFICIENT.getCode, RMErrorCode.QUEUE_MEMORY_INSUFFICIENT.getMessage)
+ (RMErrorCode.QUEUE_MEMORY_INSUFFICIENT.getCode, RMErrorCode.QUEUE_MEMORY_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.MEMORY, RMConstant.MEMORY_UNIT_BYTE, yarn.queueMemory, avail.queueMemory, max.queueMemory))
} else {
- (RMErrorCode.QUEUE_INSTANCES_INSUFFICIENT.getCode, RMErrorCode.QUEUE_INSTANCES_INSUFFICIENT.getMessage)
+ (RMErrorCode.QUEUE_INSTANCES_INSUFFICIENT.getCode, RMErrorCode.QUEUE_INSTANCES_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.APP_INSTANCE, RMConstant.INSTANCE_UNIT, yarn.queueInstances, avail.queueInstances, max.queueInstances))
}
case dy: DriverAndYarnResource =>
val dyAvailable = availableResource.asInstanceOf[DriverAndYarnResource]
+ val dyMax = maxResource.asInstanceOf[DriverAndYarnResource]
if(dy.loadInstanceResource.memory > dyAvailable.loadInstanceResource.memory ||
dy.loadInstanceResource.cores > dyAvailable.loadInstanceResource.cores ||
dy.loadInstanceResource.instances > dyAvailable.loadInstanceResource.instances) {
- val detail = generateNotEnoughMessage(dy.loadInstanceResource, dyAvailable.loadInstanceResource)
+ val detail = generateNotEnoughMessage(dy.loadInstanceResource, dyAvailable.loadInstanceResource, dyMax.loadInstanceResource)
(detail._1, {detail._2})
} else {
- val detail = generateNotEnoughMessage(dy.yarnResource, dyAvailable.yarnResource)
+ val detail = generateNotEnoughMessage(dy.yarnResource, dyAvailable.yarnResource, dyMax.yarnResource)
(detail._1, {detail._2})
}
case s: SpecialResource => throw new RMWarnException(11003, " not supported resource type " + s.getClass)
diff --git a/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/impl/DriverAndYarnReqResourceService.scala b/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/impl/DriverAndYarnReqResourceService.scala
index f934c6110..7d30961e5 100644
--- a/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/impl/DriverAndYarnReqResourceService.scala
+++ b/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/service/impl/DriverAndYarnReqResourceService.scala
@@ -17,6 +17,7 @@
package org.apache.linkis.manager.rm.service.impl
+import org.apache.linkis.manager.common.constant.RMConstant
import org.apache.linkis.manager.common.entity.resource.ResourceType.DriverAndYarn
import org.apache.linkis.manager.common.entity.resource._
import org.apache.linkis.manager.common.exception.RMWarnException
@@ -25,6 +26,7 @@ import org.apache.linkis.manager.rm.exception.RMErrorCode
import org.apache.linkis.manager.rm.external.service.ExternalResourceService
import org.apache.linkis.manager.rm.external.yarn.YarnResourceIdentifier
import org.apache.linkis.manager.rm.service.{LabelResourceService, RequestResourceService}
+import org.apache.linkis.manager.rm.utils.RMUtils
import org.json4s.DefaultFormats
class DriverAndYarnReqResourceService(labelResourceService: LabelResourceService, externalResourceService: ExternalResourceService) extends RequestResourceService(labelResourceService) {
@@ -47,24 +49,28 @@ class DriverAndYarnReqResourceService(labelResourceService: LabelResourceService
logger.info(s"queue: ${requestedYarnResource.queueName} left $queueLeftResource, this request requires: $requestedYarnResource")
if (queueLeftResource < requestedYarnResource) {
logger.info(s"user: ${labelContainer.getUserCreatorLabel.getUser} request queue resource $requestedYarnResource > left resource $queueLeftResource")
- val notEnoughMessage = generateQueueNotEnoughMessage(requestedYarnResource, queueLeftResource)
+ val notEnoughMessage = generateQueueNotEnoughMessage(requestedYarnResource, queueLeftResource, maxCapacity)
throw new RMWarnException(notEnoughMessage._1, notEnoughMessage._2)
} else true
}
- def generateQueueNotEnoughMessage(requestResource: Resource, availableResource: Resource) : (Int, String) = {
+ def generateQueueNotEnoughMessage(requestResource: Resource, availableResource: Resource, maxResource: Resource) : (Int, String) = {
requestResource match {
case yarn: YarnResource =>
val yarnAvailable = availableResource.asInstanceOf[YarnResource]
+ val maxYarn = maxResource.asInstanceOf[YarnResource]
if(yarn.queueCores > yarnAvailable.queueCores) {
- (RMErrorCode.CLUSTER_QUEUE_CPU_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_CPU_INSUFFICIENT.getMessage)
+ (RMErrorCode.CLUSTER_QUEUE_CPU_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_CPU_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.CPU, RMConstant.CPU_UNIT, yarn.queueCores, yarnAvailable.queueCores, maxYarn.queueCores))
} else if (yarn.queueMemory > yarnAvailable.queueMemory) {
- (RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getMessage)
+ (RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.MEMORY, RMConstant.MEMORY_UNIT_BYTE, yarn.queueMemory, yarnAvailable.queueMemory, maxYarn.queueMemory))
} else {
- (RMErrorCode.CLUSTER_QUEUE_INSTANCES_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_INSTANCES_INSUFFICIENT.getMessage)
+ (RMErrorCode.CLUSTER_QUEUE_INSTANCES_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_INSTANCES_INSUFFICIENT.getMessage +
+ RMUtils.getResourceInfoMsg(RMConstant.APP_INSTANCE, RMConstant.INSTANCE_UNIT, yarn.queueInstances, yarnAvailable.queueInstances, maxYarn.queueInstances))
}
case _ =>
- (RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getMessage)
+ (RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getCode, RMErrorCode.CLUSTER_QUEUE_MEMORY_INSUFFICIENT.getMessage + " Unusual insufficient queue memory.")
}
}
diff --git a/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/utils/RMUtils.scala b/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/utils/RMUtils.scala
index 25ea08ca6..63e8fbfa1 100644
--- a/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/utils/RMUtils.scala
+++ b/linkis-computation-governance/linkis-manager/linkis-application-manager/src/main/scala/org/apache/linkis/manager/rm/utils/RMUtils.scala
@@ -18,7 +18,8 @@
package org.apache.linkis.manager.rm.utils
import org.apache.linkis.common.conf.{CommonVars, Configuration, TimeType}
-import org.apache.linkis.common.utils.Logging
+import org.apache.linkis.common.utils.{ByteTimeUtils, Logging, Utils}
+import org.apache.linkis.manager.common.constant.RMConstant
import org.apache.linkis.manager.common.entity.persistence.PersistenceResource
import org.apache.linkis.manager.common.entity.resource._
import org.apache.linkis.manager.common.serializer.NodeResourceSerializer
@@ -143,4 +144,29 @@ object RMUtils extends Logging {
}
}
+ def getResourceInfoMsg(resourceType: String, unitType: String, requestResource: Any, availableResource: Any, maxResource: Any): String = {
+
+ def dealMemory(resourceType: String, unitType: String, resource: Any): String = {
+ if (RMConstant.MEMORY.equals(resourceType) && RMConstant.MEMORY_UNIT_BYTE.equals(unitType)) {
+ Utils.tryCatch {
+ if (logger.isDebugEnabled()) {
+ logger.debug(s"Will change ${resource.toString} from ${unitType} to GB")
+ }
+ ByteTimeUtils.byteStringAsGb(resource.toString + "b").toString + "GB"
+ } {
+ case e: Exception =>
+ logger.error(s"Cannot convert ${resource} to Gb, " + e.getMessage)
+ resource.toString + unitType
+ }
+ } else {
+ resource.toString + unitType
+ }
+ }
+
+ val reqMsg = if (null == requestResource) "null" + unitType else dealMemory(resourceType, unitType, requestResource)
+ val availMsg = if (null == availableResource) "null" + unitType else dealMemory(resourceType, unitType, availableResource.toString)
+ val maxMsg = if (null == maxResource) "null" + unitType else dealMemory(resourceType, unitType, maxResource.toString)
+ s" user ${resourceType}, requestResource : ${reqMsg} > availableResource : ${availMsg}, maxResource : ${maxMsg}."
+ }
+
}
diff --git a/linkis-computation-governance/linkis-manager/linkis-manager-common/src/main/java/org/apache/linkis/manager/common/constant/RMConstant.java b/linkis-computation-governance/linkis-manager/linkis-manager-common/src/main/java/org/apache/linkis/manager/common/constant/RMConstant.java
new file mode 100644
index 000000000..63dc1eec1
--- /dev/null
+++ b/linkis-computation-governance/linkis-manager/linkis-manager-common/src/main/java/org/apache/linkis/manager/common/constant/RMConstant.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.linkis.manager.common.constant;
+
+public class RMConstant {
+
+ public static final String CPU = "CPU";
+
+ public static final String MEMORY = "Memory";
+
+ public static final String APP_INSTANCE = "Instance";
+
+ public static final String CPU_UNIT = "cores";
+
+ public static final String MEMORY_UNIT_BYTE = "bytes";
+
+ public static final String INSTANCE_UNIT = "";
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@linkis.apache.org
For additional commands, e-mail: commits-help@linkis.apache.org