Remove unnecessary feature

Author: ningyougang

common/scala/src/main/scala/org/apache/openwhisk/common/TransactionId.scala

@@ -191,8 +191,6 @@ case class TransactionId private (meta: TransactionMetadata) extends AnyVal {
       case Some(parent) => findRoot(parent)
       case _            => meta
     }
-
-  def serialize = TransactionId.serdes.write(this).compactPrint
 }
 
 /**

common/scala/src/main/scala/org/apache/openwhisk/core/containerpool/Container.scala

@@ -135,13 +135,6 @@ trait Container {
           transid.failed(this, start, s"initializiation failed with $t")
       }
       .flatMap { result =>
-        // if runtime container is shutting down, reschedule the activation message
-        result.response.right.map { res =>
-          if (res.shuttingDown) {
-            throw ContainerHealthError(transid, containerId.asString)
-          }
-        }
-
         if (result.ok) {
           Future.successful(result.interval)
         } else if (result.interval.duration >= timeout) {
@@ -187,13 +180,6 @@ trait Container {
           transid.failed(this, start, s"run failed with $t")
       }
       .map { result =>
-        // if runtime container is shutting down, reschedule the activation message
-        result.response.right.map { res =>
-          if (res.shuttingDown) {
-            throw ContainerHealthError(transid, containerId.asString)
-          }
-        }
-
         val response = if (result.interval.duration >= timeout) {
           ActivationResponse.developerError(Messages.timedoutActivation(timeout, false))
         } else {

common/scala/src/main/scala/org/apache/openwhisk/core/containerpool/ContainerFactory.scala

@@ -114,8 +114,16 @@ trait ContainerFactory {
     userProvidedImage: Boolean,
     memory: ByteSize,
     cpuShares: Int,
-    action: Option[ExecutableWhiskAction],
-    resourceTags: Option[List[String]] = None)(implicit config: WhiskConfig, logging: Logging): Future[Container]
+    action: Option[ExecutableWhiskAction])(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
+    createContainer(tid, name, actionImage, userProvidedImage, memory, cpuShares)
+  }
+
+  def createContainer(tid: TransactionId,
+                      name: String,
+                      actionImage: ExecManifest.ImageName,
+                      userProvidedImage: Boolean,
+                      memory: ByteSize,
+                      cpuShares: Int)(implicit config: WhiskConfig, logging: Logging): Future[Container]
 
   /** perform any initialization */
   def init(): Unit

common/scala/src/main/scala/org/apache/openwhisk/core/entity/ActivationResult.scala

@@ -18,10 +18,13 @@
 package org.apache.openwhisk.core.entity
 
 import scala.util.Try
-import akka.http.scaladsl.model.StatusCodes.{OK, ServiceUnavailable}
+
+import akka.http.scaladsl.model.StatusCodes.OK
+
 import spray.json._
 import spray.json.DefaultJsonProtocol
-import org.apache.openwhisk.common.{Logging, TransactionId}
+
+import org.apache.openwhisk.common.Logging
 import org.apache.openwhisk.http.Messages._
 
 protected[core] case class ActivationResponse private (statusCode: Int,
@@ -136,10 +139,6 @@ protected[core] object ActivationResponse extends DefaultJsonProtocol {
     /** true iff status code is OK (HTTP 200 status code), anything else is considered an error. **/
     val okStatus = statusCode == OK.intValue
     val ok = okStatus && truncated.isEmpty
-
-    /** true iff status code is ServiceUnavailable (HTTP 503 status code) */
-    val shuttingDown = statusCode == ServiceUnavailable.intValue
-
     override def toString = {
       val base = if (okStatus) "ok" else "not ok"
       val rest = truncated.map(e => s", truncated ${e.toString}").getOrElse("")
@@ -196,9 +195,8 @@ protected[core] object ActivationResponse extends DefaultJsonProtocol {
    * @param response an Option (HTTP Status Code, HTTP response bytes as String)
    * @return appropriate ActivationResponse representing run result
    */
-  protected[core] def processRunResponseContent(
-    response: Either[ContainerConnectionError, ContainerResponse],
-    logger: Logging)(implicit id: TransactionId = TransactionId.unknown): ActivationResponse = {
+  protected[core] def processRunResponseContent(response: Either[ContainerConnectionError, ContainerResponse],
+                                                logger: Logging): ActivationResponse = {
     response match {
       case Right(res @ ContainerResponse(_, str, truncated)) =>
         truncated match {
@@ -242,7 +240,6 @@ protected[core] object ActivationResponse extends DefaultJsonProtocol {
 
       case Left(e) =>
         // This indicates a terminal failure in the container (it exited prematurely).
-        logger.error(this, abnormalRun)
         developerError(abnormalRun)
     }
   }

common/scala/src/main/scala/org/apache/openwhisk/core/mesos/MesosContainerFactory.scala

@@ -45,7 +45,10 @@ import org.apache.openwhisk.common.TransactionId
 import org.apache.openwhisk.core.ConfigKeys
 import org.apache.openwhisk.core.WhiskConfig
 import org.apache.openwhisk.core.containerpool._
-import org.apache.openwhisk.core.entity.{ByteSize, ExecManifest, ExecutableWhiskAction, InvokerInstanceId, UUID}
+import org.apache.openwhisk.core.entity.ByteSize
+import org.apache.openwhisk.core.entity.ExecManifest
+import org.apache.openwhisk.core.entity.InvokerInstanceId
+import org.apache.openwhisk.core.entity.UUID
 
 /**
  * Configuration for mesos timeouts
@@ -122,15 +125,12 @@ class MesosContainerFactory(config: WhiskConfig,
       }
   }
 
-  override def createContainer(
-    tid: TransactionId,
-    name: String,
-    actionImage: ExecManifest.ImageName,
-    userProvidedImage: Boolean,
-    memory: ByteSize,
-    cpuShares: Int,
-    action: Option[ExecutableWhiskAction] = None,
-    resourceTags: Option[List[String]] = None)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
+  override def createContainer(tid: TransactionId,
+                               name: String,
+                               actionImage: ExecManifest.ImageName,
+                               userProvidedImage: Boolean,
+                               memory: ByteSize,
+                               cpuShares: Int)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
     implicit val transid = tid
     val image = actionImage.resolveImageName(Some(
       ContainerFactory.resolveRegistryConfig(userProvidedImage, runtimesRegistryConfig, userImagesRegistryConfig).url))

common/scala/src/main/scala/org/apache/openwhisk/core/yarn/YARNContainerFactory.scala

@@ -24,7 +24,7 @@ import akka.util.Timeout
 import org.apache.openwhisk.common.{Logging, TransactionId}
 import org.apache.openwhisk.core.containerpool._
 import org.apache.openwhisk.core.entity.ExecManifest.ImageName
-import org.apache.openwhisk.core.entity.{ByteSize, ExecManifest, ExecutableWhiskAction, InvokerInstanceId}
+import org.apache.openwhisk.core.entity.{ByteSize, ExecManifest, InvokerInstanceId}
 import org.apache.openwhisk.core.yarn.YARNComponentActor.CreateContainerAsync
 import org.apache.openwhisk.core.{ConfigKeys, WhiskConfig}
 import pureconfig._
@@ -125,9 +125,7 @@ class YARNContainerFactory(actorSystem: ActorSystem,
     actionImage: ExecManifest.ImageName,
     unuseduserProvidedImage: Boolean,
     unusedmemory: ByteSize,
-    unusedcpuShares: Int,
-    action: Option[ExecutableWhiskAction] = None,
-    resourceTags: Option[List[String]] = None)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
+    unusedcpuShares: Int)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
     implicit val timeout: Timeout = Timeout(containerStartTimeoutMS.milliseconds)
 
     //First send the create command to YARN, then with a different actor, wait for the container to be ready

core/invoker/src/main/resources/application.conf

@@ -155,8 +155,6 @@ whisk {
       #aka 'How long should a container sit idle until we kill it?'
       idle-container = 10 minutes
       pause-grace = 50 milliseconds
-      lease-grace = 5 seconds
-      keeping-duration = 60 minutes
     }
     action-health-check {
       enabled = false # if true, prewarm containers will be pinged periodically and warm containers will be pinged once after resumed
@@ -180,6 +178,4 @@ whisk {
     protocol: http
   }
   runtime.delete.timeout = "30 seconds"
-
-  runtime.resource.role = "openwhisk-runtime-resource-role"
 }

core/invoker/src/main/scala/org/apache/openwhisk/core/containerpool/ContainerProxy.scala

@@ -251,8 +251,7 @@ class ContainerProxy(factory: (TransactionId,
                                Boolean,
                                ByteSize,
                                Int,
-                               Option[ExecutableWhiskAction],
-                               Option[List[String]]) => Future[Container],
+                               Option[ExecutableWhiskAction]) => Future[Container],
                      sendActiveAck: ActiveAck,
                      storeActivation: (TransactionId, WhiskActivation, Boolean, UserContext) => Future[Any],
                      collectLogs: LogsCollector,
@@ -291,7 +290,6 @@ class ContainerProxy(factory: (TransactionId,
         job.exec.pull,
         job.memoryLimit,
         poolConfig.cpuShare(job.memoryLimit),
-        None,
         None)
         .map(container =>
           PreWarmCompleted(PreWarmedData(container, job.exec.kind, job.memoryLimit, expires = job.ttl.map(_.fromNow))))
@@ -311,8 +309,7 @@ class ContainerProxy(factory: (TransactionId,
         job.action.exec.pull,
         job.action.limits.memory.megabytes.MB,
         poolConfig.cpuShare(job.action.limits.memory.megabytes.MB),
-        Some(job.action),
-        job.action.annotations.get(Annotations.InvokerResourcesAnnotationName).map(_.convertTo[List[String]]))
+        Some(job.action))
 
       // container factory will either yield a new container ready to execute the action, or
       // starting up the container failed; for the latter, it's either an internal error starting
@@ -966,9 +963,7 @@ class ContainerProxy(factory: (TransactionId,
   }
 }
 
-final case class ContainerProxyTimeoutConfig(idleContainer: FiniteDuration,
-                                             pauseGrace: FiniteDuration,
-                                             keepingDuration: FiniteDuration)
+final case class ContainerProxyTimeoutConfig(idleContainer: FiniteDuration, pauseGrace: FiniteDuration)
 final case class ContainerProxyHealthCheckConfig(enabled: Boolean, checkPeriod: FiniteDuration, maxFails: Int)
 final case class ContainerProxyActivationErrorLogConfig(applicationErrors: Boolean,
                                                         developerErrors: Boolean,
@@ -981,8 +976,7 @@ object ContainerProxy {
                       Boolean,
                       ByteSize,
                       Int,
-                      Option[ExecutableWhiskAction],
-                      Option[List[String]]) => Future[Container],
+                      Option[ExecutableWhiskAction]) => Future[Container],
             ack: ActiveAck,
             store: (TransactionId, WhiskActivation, Boolean, UserContext) => Future[Any],
             collectLogs: LogsCollector,

core/invoker/src/main/scala/org/apache/openwhisk/core/containerpool/docker/DockerContainerFactory.scala

@@ -26,7 +26,9 @@ import org.apache.openwhisk.common.Logging
 import org.apache.openwhisk.common.TransactionId
 import org.apache.openwhisk.core.WhiskConfig
 import org.apache.openwhisk.core.containerpool._
-import org.apache.openwhisk.core.entity.{ByteSize, ExecManifest, ExecutableWhiskAction, InvokerInstanceId}
+import org.apache.openwhisk.core.entity.ByteSize
+import org.apache.openwhisk.core.entity.ExecManifest
+import org.apache.openwhisk.core.entity.InvokerInstanceId
 
 import scala.concurrent.duration._
 import java.util.concurrent.TimeoutException
@@ -55,15 +57,12 @@ class DockerContainerFactory(instance: InvokerInstanceId,
     extends ContainerFactory {
 
   /** Create a container using docker cli */
-  override def createContainer(
-    tid: TransactionId,
-    name: String,
-    actionImage: ExecManifest.ImageName,
-    userProvidedImage: Boolean,
-    memory: ByteSize,
-    cpuShares: Int,
-    action: Option[ExecutableWhiskAction] = None,
-    resourceTags: Option[List[String]] = None)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
+  override def createContainer(tid: TransactionId,
+                               name: String,
+                               actionImage: ExecManifest.ImageName,
+                               userProvidedImage: Boolean,
+                               memory: ByteSize,
+                               cpuShares: Int)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
     val registryConfig =
       ContainerFactory.resolveRegistryConfig(userProvidedImage, runtimesRegistryConfig, userImagesRegistryConfig)
     val image = if (userProvidedImage) Left(actionImage) else Right(actionImage)

core/invoker/src/main/scala/org/apache/openwhisk/core/containerpool/docker/StandaloneDockerContainerFactory.scala

@@ -22,7 +22,7 @@ import org.apache.commons.lang3.SystemUtils
 import org.apache.openwhisk.common.{Logging, TransactionId}
 import org.apache.openwhisk.core.{ConfigKeys, WhiskConfig}
 import org.apache.openwhisk.core.containerpool.{Container, ContainerFactory, ContainerFactoryProvider}
-import org.apache.openwhisk.core.entity.{ByteSize, ExecManifest, ExecutableWhiskAction, InvokerInstanceId}
+import org.apache.openwhisk.core.entity.{ByteSize, ExecManifest, InvokerInstanceId}
 import pureconfig._
 import pureconfig.generic.auto._
 
@@ -61,15 +61,12 @@ class StandaloneDockerContainerFactory(instance: InvokerInstanceId, parameters:
   private val pulledImages = new TrieMap[String, Boolean]()
   private val factoryConfig = loadConfigOrThrow[StandaloneDockerConfig](ConfigKeys.standaloneDockerContainerFactory)
 
-  override def createContainer(
-    tid: TransactionId,
-    name: String,
-    actionImage: ExecManifest.ImageName,
-    userProvidedImage: Boolean,
-    memory: ByteSize,
-    cpuShares: Int,
-    action: Option[ExecutableWhiskAction] = None,
-    resourceTags: Option[List[String]] = None)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
+  override def createContainer(tid: TransactionId,
+                               name: String,
+                               actionImage: ExecManifest.ImageName,
+                               userProvidedImage: Boolean,
+                               memory: ByteSize,
+                               cpuShares: Int)(implicit config: WhiskConfig, logging: Logging): Future[Container] = {
 
     //For standalone server usage we would also want to pull the OpenWhisk provided image so as to ensure if
     //local setup does not have the image then it pulls it down