apache · chetanmeh · Aug 15, 2019 · Jul 25, 2019 · Jul 25, 2019 · Jul 25, 2019
diff --git a/core/standalone/README.md b/core/standalone/README.md
@@ -75,8 +75,11 @@ $ java -jar openwhisk-standalone.jar -h
  \   \  /  \/    \___/| .__/ \___|_| |_|__/\__|_| |_|_|___/_|\_\
   \___\/ tm           |_|
 
+      --api-gw                  Enable API Gateway support
+      --api-gw-port  <arg>      Api Gateway Port
   -c, --config-file  <arg>      application.conf which overrides the default
                                 standalone.conf
+  -d, --data-dir  <arg>         Directory used for storage
       --disable-color-logging   Disables colored logging
   -m, --manifest  <arg>         Manifest json defining the supported runtimes
   -p, --port  <arg>             Server port
@@ -85,6 +88,7 @@ $ java -jar openwhisk-standalone.jar -h
       --version                 Show version of this program
 
 OpenWhisk standalone server
+
 ```
 
 Sections below would illustrate some of the supported options
@@ -189,5 +193,13 @@ whisk {
 
 Then pass this config file via `-c` option.
 
-[1]: https://github.com/apache/openwhisk/blob/master/docs/cli.md
-[2]: https://github.com/apache/openwhisk/blob/master/docs/samples.md
+#### Using Api Gateway
+
+Api Gateway mode can be enabled via `--api-gw` flag. In this mode upon launch a separate container for [OpenWhisk Api gateway][3]
+would be launched on port `3234` (can be changed with `--api-gw-port`). In this mode you can make use of the
+[api gateway][4] support.
+
+[1]: https://github.com/apache/incubator-openwhisk/blob/master/docs/cli.md
+[2]: https://github.com/apache/incubator-openwhisk/blob/master/docs/samples.md
+[3]: https://github.com/apache/incubator-openwhisk-apigateway
+[4]: https://github.com/apache/incubator-openwhisk/blob/master/docs/apigateway.md
diff --git a/core/standalone/build.gradle b/core/standalone/build.gradle
@@ -46,7 +46,42 @@ task copySwagger(type: Copy) {
     project.ext.swaggerUiDir = file("$buildDir/tmp/swagger/swagger-ui/swagger-ui-${version}/dist")
 }
 
+def apiGwActions = ['createApi', "deleteApi", "getApi"]
+
+task copyGWActions() {
+    doLast {
+        def routeMgmtDir = new File(project.projectDir.getParentFile(), "routemgmt")
+        def commonDir = new File(routeMgmtDir, "common")
+        def routeBuildDir = mkdir("$buildDir/tmp/routemgmt")
+        apiGwActions.each { actionName ->
+            def zipFileName = actionName + ".zip"
+            def actionDir = new File(routeMgmtDir, actionName)
+            def zipFile = new File(routeBuildDir, zipFileName)
+            if (!zipFile.exists()) {
+                ant.exec(dir:actionDir, executable:"npm", failonerror:true){
+                    arg(line:"install")
+                }
+                ant.zip(destfile:zipFile){
+                    fileset(dir:actionDir){
+                        exclude(name:zipFileName)
+                        //Somehow if in zip we add same file twice it causes issues
+                        //Its possible that installRouteMgmt.sh has been invoked which would
+                        //have copied the common files to each action dir.
+                        //Exclude such files to zipped twice
+                        commonDir.listFiles().each {f ->
+                            exclude(name:f.name)
+                        }
+                    }
+                    fileset(dir:commonDir)
+                }
+                logger.info("Create action zip $zipFileName")
+            }
+        }
+    }
+}
+
 processResources.dependsOn copySwagger
+processResources.dependsOn copyGWActions
 
 processResources {
     from(new File(project.rootProject.projectDir, "ansible/files/runtimes.json")) {
@@ -64,6 +99,11 @@ processResources {
         exclude "index.html"
         into("swagger-ui")
     }
+    apiGwActions.each { action ->
+        from(file("$buildDir/tmp/routemgmt/${action}.zip")){
+            into(".")
+        }
+    }
 }
 
 task copyBootJarToBin(type:Copy){
@@ -86,5 +126,17 @@ dependencies {
     compile project(':core:controller')
     compile project(':tools:admin')
     compile 'org.rogach:scallop_2.12:3.3.1'
+
+    testCompile 'junit:junit:4.11'
+    testCompile 'org.scalatest:scalatest_2.12:3.0.5'
 }
 
+gradle.projectsEvaluated {
+    tasks.withType(Test) {
+        testLogging {
+            events "passed", "skipped", "failed"
+            showStandardStreams = true
+            exceptionFormat = 'full'
+        }
+    }
+}
diff --git a/core/standalone/src/main/resources/standalone.conf b/core/standalone/src/main/resources/standalone.conf
@@ -81,4 +81,14 @@ whisk {
     file-system : false
     dir-path : "BOOT-INF/classes/swagger-ui"
   }
+
+  standalone {
+    redis {
+      image: "redis:4.0"
+    }
+
+    api-gateway {
+      image: "openwhisk/apigateway:nightly"
+    }
+  }
 }
diff --git a/core/standalone/src/main/scala/org/apache/openwhisk/standalone/ApiGwLauncher.scala b/core/standalone/src/main/scala/org/apache/openwhisk/standalone/ApiGwLauncher.scala
@@ -0,0 +1,139 @@
+/*
+ * 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.openwhisk.standalone
+
+import akka.actor.{ActorSystem, Scheduler}
+import akka.http.scaladsl.model.Uri
+import akka.pattern.RetrySupport
+import org.apache.openwhisk.common.{Logging, TransactionId}
+import org.apache.openwhisk.core.containerpool.docker.BrokenDockerContainer
+import org.apache.openwhisk.standalone.StandaloneDockerSupport.{containerName, createRunCmd}
+import pureconfig.loadConfigOrThrow
+
+import scala.concurrent.duration._
+import scala.concurrent.{ExecutionContext, Future}
+
+class ApiGwLauncher(docker: StandaloneDockerClient, apiGwApiPort: Int, apiGwMgmtPort: Int, serverPort: Int)(
+  implicit logging: Logging,
+  ec: ExecutionContext,
+  actorSystem: ActorSystem,
+  tid: TransactionId)
+    extends RetrySupport {
+  private implicit val scd: Scheduler = actorSystem.scheduler
+  case class RedisConfig(image: String)
+  case class ApiGwConfig(image: String)
+  private val redisConfig = loadConfigOrThrow[RedisConfig](StandaloneConfigKeys.redisConfigKey)
+  private val apiGwConfig = loadConfigOrThrow[ApiGwConfig](StandaloneConfigKeys.apiGwConfigKey)
+
+  def run(): Future[Seq[ServiceContainer]] = {
+    for {
+      (redis, redisSvcs) <- runRedis()
+      _ <- waitForRedis(redis)
+      (_, apiGwSvcs) <- runApiGateway(redis)
+      _ <- waitForApiGw()
+    } yield Seq(redisSvcs, apiGwSvcs).flatten
+  }
+
+  def runRedis(): Future[(StandaloneDockerContainer, Seq[ServiceContainer])] = {
+    val defaultRedisPort = 6379
+    val redisPort = StandaloneDockerSupport.checkOrAllocatePort(defaultRedisPort)
+    logging.info(this, s"Starting Redis at $redisPort")
+
+    val params = Map("-p" -> Set(s"$redisPort:6379"))
+    val name = containerName("redis")
+    val args = createRunCmd(name, dockerRunParameters = params)
+    val f = runDetached(redisConfig.image, args, pull = true)
+    val sc = ServiceContainer(redisPort, "Redis", name)
+    f.map(c => (c, Seq(sc)))
+  }
+
+  def waitForRedis(c: StandaloneDockerContainer): Future[Unit] = {
+    retry(() => isRedisUp(c), 12, 5.seconds)
+  }
+
+  private def isRedisUp(c: StandaloneDockerContainer) = {
+    val args = Seq(
+      "run",
+      "--rm",
+      "--name",
+      containerName("redis-test"),
+      redisConfig.image,
+      "redis-cli",
+      "-h",
+      c.addr.host,
+      "-p",
+      "6379",
+      "ping")
+    docker.runCmd(args, docker.clientConfig.timeouts.run).map(out => require(out.toLowerCase == "pong"))
+  }
+
+  def runApiGateway(redis: StandaloneDockerContainer): Future[(StandaloneDockerContainer, Seq[ServiceContainer])] = {
+    val hostIp = StandaloneDockerSupport.getLocalHostIp()
+    val env = Map(
+      "BACKEND_HOST" -> s"http://$hostIp:$serverPort",
+      "REDIS_HOST" -> redis.addr.host,
+      "REDIS_PORT" -> "6379",
+      //This is the name used to render the final url. So should be localhost
+      //as that would be used by end user outside of docker
+      "PUBLIC_MANAGEDURL_HOST" -> StandaloneDockerSupport.getLocalHostName(),
+      "PUBLIC_MANAGEDURL_PORT" -> apiGwMgmtPort.toString)
+
+    logging.info(this, s"Starting Api Gateway at api port: $apiGwApiPort, management port: $apiGwMgmtPort")
+    val name = containerName("apigw")
+    val params = Map("-p" -> Set(s"$apiGwApiPort:9000", s"$apiGwMgmtPort:8080"))
+    val args = createRunCmd(name, env, params)
+
+    //TODO ExecManifest is scoped to core. Ideally we would like to do
+    // ExecManifest.ImageName(apiGwConfig.image).prefix.contains("openwhisk")
+    val pull = apiGwConfig.image.startsWith("openwhisk")
+    val f = runDetached(apiGwConfig.image, args, pull)
+    val sc = Seq(
+      ServiceContainer(apiGwApiPort, "Api Gateway - Api Service", name),
+      ServiceContainer(apiGwMgmtPort, "Api Gateway - Management Service", name))
+    f.map(c => (c, sc))
+  }
+
+  def waitForApiGw(): Future[Unit] = {
+    new ServerStartupCheck(
+      Uri(s"http://${StandaloneDockerSupport.getLocalHostName()}:$apiGwApiPort/v1/apis"),
+      "ApiGateway")
+      .waitForServerToStart()
+    Future.successful(())
+  }
+
+  private def runDetached(image: String, args: Seq[String], pull: Boolean): Future[StandaloneDockerContainer] = {
+    for {
+      _ <- if (pull) docker.pull(image) else Future.successful(())
+      id <- docker.run(image, args).recoverWith {
+        case t @ BrokenDockerContainer(brokenId, _) =>
+          // Remove the broken container - but don't wait or check for the result.
+          // If the removal fails, there is nothing we could do to recover from the recovery.
+          docker.rm(brokenId)
+          Future.failed(t)
+        case t => Future.failed(t)
+      }
+      ip <- docker.inspectIPAddress(id, StandaloneDockerSupport.network).recoverWith {
+        // remove the container immediately if inspect failed as
+        // we cannot recover that case automatically
+        case e =>
+          docker.rm(id)
+          Future.failed(e)
+      }
+    } yield StandaloneDockerContainer(id, ip)
+  }
+}
diff --git a/core/standalone/src/main/scala/org/apache/openwhisk/standalone/DockerVersion.scala b/core/standalone/src/main/scala/org/apache/openwhisk/standalone/DockerVersion.scala
@@ -0,0 +1,50 @@
+/*
+ * 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.openwhisk.standalone
+
+import scala.util.control.NonFatal
+
+case class DockerVersion(major: Int, minor: Int, patch: Int) extends Ordered[DockerVersion] {
+  import scala.math.Ordered.orderingToOrdered
+  def compare(that: DockerVersion): Int =
+    (this.major, this.minor, this.patch) compare (that.major, that.minor, that.patch)
+
+  override def toString = s"$major.$minor.$patch"
+}
+
+object DockerVersion {
+  implicit val ord: Ordering[DockerVersion] = Ordering.by(unapply)
+  private val pattern = ".*Docker version ([\\d.]+).*".r
+
+  def apply(str: String): DockerVersion = {
+    try {
+      val parts = if (str != null && str.nonEmpty) str.split('.') else Array[String]()
+      val major = if (parts.length >= 1) parts(0).toInt else 0
+      val minor = if (parts.length >= 2) parts(1).toInt else 0
+      val patch = if (parts.length >= 3) parts(2).toInt else 0
+      DockerVersion(major, minor, patch)
+    } catch {
+      case NonFatal(_) => throw new IllegalArgumentException(s"bad docker version $str")
+    }
+  }
+
+  def fromVersionCommand(str: String): DockerVersion = {
+    val pattern(version) = str
+    apply(version)
+  }
+}