Refactored retrieve command to sttp

Author: Hariharan Ramanathan

src/main/scala/de/upb/cs/swt/delphi/cli/DelphiCLI.scala

@@ -16,13 +16,47 @@
 
 package de.upb.cs.swt.delphi.cli
 
-import de.upb.cs.swt.delphi.cli.commands.TestCommand
+import com.softwaremill.sttp.{HttpURLConnectionBackend, Id, SttpBackend}
+import de.upb.cs.swt.delphi.cli.commands._
 
 /**
   * The application class for the Delphi command line interface
   */
 object DelphiCLI {
 
+
+  def main(args: Array[String]): Unit = {
+
+    def getEnvOrElse(envVar: String, defaultPath: String) = sys.env.getOrElse(envVar, defaultPath)
+
+    val javaLibPath = getEnvOrElse("JAVA_LIB_PATH", "/usr/lib/jvm/default-java/lib/")
+
+    val trustStorePath = getEnvOrElse("JAVA_TRUSTSTORE", "/usr/lib/jvm/default-java/lib/security/cacerts")
+
+    System.setProperty("java.library.path", javaLibPath)
+    System.setProperty("javax.net.ssl.trustStore", trustStorePath)
+
+    cliParser.parse(args, Config()) match {
+      case Some(c) =>
+
+        implicit val config: Config = c
+        implicit val backend: SttpBackend[Id, Nothing] = HttpURLConnectionBackend()
+
+        if (!config.silent) cliParser.showHeader()
+
+        config.mode match {
+          case "test" => TestCommand.execute
+          case "retrieve" => RetrieveCommand.execute
+          //        case "search" => SearchCommand.execute(config)
+          case x => config.consoleOutput.outputError(s"Unknown command: $x")
+        }
+
+
+      case None =>
+    }
+
+  }
+
   private def cliParser = {
     val parser = {
       new scopt.OptionParser[Config]("delphi-cli") {
@@ -64,23 +98,4 @@ object DelphiCLI {
     }
     parser
   }
-
-  def main(args: Array[String]): Unit = {
-
-    System.setProperty("java.library.path", javaLibPath.get)
-    System.setProperty("javax.net.ssl.trustStore", trustStorePath.get)
-    System.setProperty("picocli.ansi", "true")
-    cliParser.parse(args, config) match {
-      case Some(config) =>
-        if (!config.silent) cliParser.showHeader()
-        config.mode match {
-          case "test" => TestCommand.execute
-          //          case "retrieve" => RetrieveCommand.execute(config)
-          //        case "search" => SearchCommand.execute(config)
-          case x => config.consoleOutput.outputError(s"Unknown command: $x")
-        }
-      case None =>
-    }
-
-  }
 }

src/main/scala/de/upb/cs/swt/delphi/cli/commands/Command.scala

@@ -16,19 +16,9 @@
 
 package de.upb.cs.swt.delphi.cli.commands
 
-import akka.actor.ActorSystem
-import akka.http.scaladsl.Http
-import akka.http.scaladsl.model.Uri.Query
-import akka.http.scaladsl.model.{HttpRequest, HttpResponse, StatusCodes, Uri}
-import akka.stream.ActorMaterializer
-import akka.util.ByteString
 import com.softwaremill.sttp._
 import de.upb.cs.swt.delphi.cli.Config
 
-import scala.concurrent.duration._
-import scala.concurrent.{Await, Future}
-import scala.util.Failure
-
 /**
   * Represents the implementation of a command of the CLI
   */
@@ -39,54 +29,18 @@ trait Command {
     *
     * @param config The current configuration for the command
     */
-  def execute(implicit config: Config): Unit = {}
-
-  /**
-    * Implements a common request type using currying to avoid code duplication
-    *
-    * @param target The endpoint to perform a Get request on
-    * @param config The current configuration for the command
-    */
-  protected def executeGet(target: String, parameters: Map[String, String] = Map())(config: Config, system: ActorSystem): Option[String] = {
-    implicit val sys: ActorSystem = system
-    implicit val materializer = ActorMaterializer()
-    implicit val executionContext = sys.dispatcher
-
-    val uri = Uri(config.server)
-    config.consoleOutput.outputInformation(s"Contacting server ${uri}...")
+  def execute(implicit config: Config, backend: SttpBackend[Id, Nothing]): Unit = {}
 
-    val responseFuture = Http().singleRequest(HttpRequest(uri = uri.withPath(uri.path + target).withQuery(Query(parameters))))
-
-    responseFuture.onComplete {
-      case Failure(_) => error(config)(s"Could not reach server ${config.server}.")
-      case _ =>
-    }
-
-    val result = Await.result(responseFuture, 30 seconds)
-    val resultString = result match {
-      case HttpResponse(StatusCodes.OK, headers, entity, _) =>
-        entity.dataBytes.runFold(ByteString(""))(_ ++ _).map { body =>
-          Some(body.utf8String)
-        }
-      case resp@HttpResponse(code, _, _, _) => {
-        error(config)("Artifact not found.")
-        resp.discardEntityBytes()
-        Future(None)
-      }
-    }
-
-    Await.result(resultString, Duration.Inf)
-  }
 
   /**
     * Generic http GET request
     *
-    * @param target Sub url in delphi server
+    * @param target     Sub url in delphi server
     * @param parameters Query params
     * @return GET response
     */
-  protected def executeGet1(target: String, parameters: Map[String, String] = Map())
-                           (implicit config: Config, backend: SttpBackend[Id, Nothing]): Option[String] = {
+  protected def executeGet(target: String, parameters: Map[String, String] = Map())
+                          (implicit config: Config, backend: SttpBackend[Id, Nothing]): Option[String] = {
 
     val request = sttp.get(uri"${config.server}/$target?$parameters")
     config.consoleOutput.outputInformation(s"Sending request ${request.uri}")

src/main/scala/de/upb/cs/swt/delphi/cli/commands/RetrieveCommand.scala

@@ -16,31 +16,21 @@
 
 package de.upb.cs.swt.delphi.cli.commands
 
-import akka.actor.ActorSystem
-import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
-import akka.http.scaladsl.unmarshalling.Unmarshal
-import akka.stream.ActorMaterializer
-import de.upb.cs.swt.delphi.cli.Config
+import com.softwaremill.sttp.{Id, SttpBackend}
+import de.upb.cs.swt.delphi.cli._
 import de.upb.cs.swt.delphi.cli.artifacts.RetrieveResult
-import de.upb.cs.swt.delphi.cli.artifacts.SearchResultJson._
-import de.upb.cs.swt.delphi.cli.commands.SearchCommand.information
-import spray.json.DefaultJsonProtocol
+import spray.json._
 
-import scala.concurrent.Await
-import scala.concurrent.duration.Duration
 import scala.io.Source
-import scala.util.{Failure, Success}
 
 /**
   * The implementation of the retrieve command.
   * Retrieves the contents of the file at the endpoint specified by the config file, and prints them to stdout
   */
-object RetrieveCommand extends Command with SprayJsonSupport with DefaultJsonProtocol {
+object RetrieveCommand extends Command with DefaultJsonProtocol {
 
 
-   def execute(config: Config)(implicit system: ActorSystem): Unit = {
-    implicit val ec = system.dispatcher
-    implicit val materializer = ActorMaterializer()
+  override def execute(implicit config: Config, backend: SttpBackend[Id, Nothing]): Unit = {
 
     //Checks whether the ID should be loaded from a file or not, and either returns the first line
     //  of the given file if it is, or the specified ID otherwise
@@ -56,37 +46,54 @@ object RetrieveCommand extends Command with SprayJsonSupport with DefaultJsonPro
     }
 
     val result = executeGet(
-      s"/retrieve/$checkTarget",
+      s"retrieve/$checkTarget",
       Map("pretty" -> "")
-    )(config, system)
+    )
 
-    result.map(s => {
+    result.foreach(s => {
       if (config.raw) {
-        reportResult(config)(s)
+        reportResult.apply(s)
       }
-
       if (!config.raw || !config.csv.equals("")) {
-        val unmarshalledFuture = Unmarshal(s).to[List[RetrieveResult]]
+        import artifacts.SearchResultJson._
 
-        unmarshalledFuture.transform {
-          case Success(unmarshalled) => {
-            val unmarshalled = Await.result(unmarshalledFuture, Duration.Inf)
-            success(config)(s"Found ${unmarshalled.size} item(s).")
-            reportResult(config)(unmarshalled)
+        //TODO:  convertTo[List[RetrieveResult]] not working ???
 
-            if(!config.csv.equals("")) {
-              exportResult(config)(unmarshalled)
-              information(config)("Results written to file '" + config.csv + "'")
-            }
+        val jsonArr = s.parseJson.asInstanceOf[JsArray].elements
+        val retrieveResults = jsonArr.map(r => r.convertTo[RetrieveResult])
 
-            Success(unmarshalled)
-          }
-          case Failure(e) => {
-            error(config)(s)
-            Failure(e)
-          }
+        success.apply(s"Found ${retrieveResults.size} item(s).")
+        reportResult.apply(retrieveResults)
+        if (!config.csv.equals("")) {
+          exportResult.apply(retrieveResults)
+          information.apply("Results written to file '" + config.csv + "'")
         }
       }
+
+
     })
   }
 }
+
+/* if (!config.raw || !config.csv.equals("")) {
+      val unmarshalledFuture = Unmarshal(s).to[List[RetrieveResult]]
+
+      unmarshalledFuture.transform {
+        case Success(unmarshalled) => {
+          val unmarshalled = Await.result(unmarshalledFuture, Duration.Inf)
+          success.apply(s"Found ${unmarshalled.size} item(s).")
+          reportResult.apply(unmarshalled)
+
+          if (!config.csv.equals("")) {
+            exportResult.apply(unmarshalled)
+            information.apply("Results written to file '" + config.csv + "'")
+          }
+
+          Success(unmarshalled)
+        }
+        case Failure(e) => {
+          error.apply(s)
+          Failure(e)
+        }
+      }
+    }*/

src/main/scala/de/upb/cs/swt/delphi/cli/commands/TestCommand.scala

@@ -16,18 +16,19 @@
 
 package de.upb.cs.swt.delphi.cli.commands
 
+import com.softwaremill.sttp.{Id, SttpBackend}
 import de.upb.cs.swt.delphi.cli.Config
-import de.upb.cs.swt.delphi.cli._
 
 /**
   * The implementation of the test command.
   * Tries to connect to the Delphi server and reports on the results of the version call.
   */
 object TestCommand extends Command {
-  override def execute(implicit config: Config): Unit = executeGet1(
-    "version"
-  ).map(s => {
-    success(config)("Successfully contacted Delphi server. ")
-    information(config)("Server version: " + s)
-  })
+  override def execute(implicit config: Config,backend: SttpBackend[Id, Nothing]): Unit = {
+    executeGet("version")
+      .foreach(s => {
+        success.apply("Successfully contacted Delphi server. ")
+        information.apply("Server version: " + s)
+      })
+  }
 }