Merge pull request #21 from scala-exercises/jp-evaluator-client-enabling-timeout-options

JP - Allows to specify Conn and Read Timeouts

Author: juanpedromoreno

client/src/main/scala/org/scalaexercises/evaluator/EvaluatorAPI.scala

@@ -5,13 +5,28 @@
 
 package org.scalaexercises.evaluator
 
+import cats.free.Free
+import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
 import org.scalaexercises.evaluator.free.algebra.{EvaluatorOp, EvaluatorOps}
 
-class EvaluatorAPI(url: String, authKey: String)(
-  implicit O: EvaluatorOps[EvaluatorOp]) {
+import scala.concurrent.duration.Duration
 
-  def evaluates(resolvers: List[String] = Nil,
-                dependencies: List[Dependency] = Nil,
-                code: String) =
-    O.evaluates(url, authKey, resolvers, dependencies, code)
+class EvaluatorAPI(
+  url: String,
+  authKey: String,
+  connTimeout: Duration,
+  readTimeout: Duration)(implicit O: EvaluatorOps[EvaluatorOp]) {
+
+  def evaluates(
+    resolvers: List[String] = Nil,
+    dependencies: List[Dependency] = Nil,
+    code: String): Free[EvaluatorOp, EvaluationResponse[EvalResponse]] =
+    O.evaluates(
+      url,
+      authKey,
+      connTimeout,
+      readTimeout,
+      resolvers,
+      dependencies,
+      code)
 }

client/src/main/scala/org/scalaexercises/evaluator/EvaluatorClient.scala

@@ -7,12 +7,18 @@ package org.scalaexercises.evaluator
 
 import cats.data.XorT
 import cats.{MonadError, ~>}
-import org.scalaexercises.evaluator.EvaluatorResponses.{EvaluationException, EvaluationResponse, EvaluationResult, EvalIO}
+import org.scalaexercises.evaluator.EvaluatorResponses.{EvalIO, EvaluationException, EvaluationResponse, EvaluationResult}
 import org.scalaexercises.evaluator.free.algebra.EvaluatorOp
 
-class EvaluatorClient(url: String, authKey: String) {
+import scala.concurrent.duration._
+import scala.concurrent.duration.Duration
 
-  lazy val api = new EvaluatorAPI(url, authKey)
+class EvaluatorClient(url: String,
+                      authKey: String,
+                      connTimeout: Duration = 1.second,
+                      readTimeout: Duration = 10.seconds) {
+
+  lazy val api = new EvaluatorAPI(url, authKey, connTimeout, readTimeout)
 
 }
 

client/src/main/scala/org/scalaexercises/evaluator/api/Evaluator.scala

@@ -11,6 +11,8 @@ import org.scalaexercises.evaluator.http.HttpClient
 import io.circe.generic.auto._
 import io.circe.syntax._
 
+import scala.concurrent.duration.Duration
+
 class Evaluator {
 
   import Decoders._
@@ -19,6 +21,8 @@ class Evaluator {
 
   def eval(url: String,
            authKey: String,
+           connTimeout: Duration,
+           readTimeout: Duration,
            resolvers: List[String] = Nil,
            dependencies: List[Dependency] = Nil,
            code: String): EvaluationResponse[EvalResponse] =

client/src/main/scala/org/scalaexercises/evaluator/free/algebra/EvaluatorOps.scala

@@ -9,9 +9,14 @@ import cats.free.{Free, Inject}
 import org.scalaexercises.evaluator.{Dependency, EvalResponse}
 import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
 
+import scala.concurrent.duration._
+import scala.concurrent.duration.Duration
+
 sealed trait EvaluatorOp[A]
 final case class Evaluates(url: String,
                            authKey: String,
+                           connTimeout: Duration = 1.second,
+                           readTimeout: Duration = 10.seconds,
                            resolvers: List[String] = Nil,
                            dependencies: List[Dependency] = Nil,
                            code: String)
@@ -22,12 +27,21 @@ class EvaluatorOps[F[_]](implicit I: Inject[EvaluatorOp, F]) {
   def evaluates(
     url: String,
     authKey: String,
+    connTimeout: Duration = 1.second,
+    readTimeout: Duration = 10.seconds,
     resolvers: List[String] = Nil,
     dependencies: List[Dependency] = Nil,
     code: String
   ): Free[F, EvaluationResponse[EvalResponse]] =
     Free.inject[EvaluatorOp, F](
-      Evaluates(url, authKey, resolvers, dependencies, code))
+      Evaluates(
+        url,
+        authKey,
+        connTimeout,
+        readTimeout,
+        resolvers,
+        dependencies,
+        code))
 
 }
 

client/src/main/scala/org/scalaexercises/evaluator/free/interpreters/Interpreter.scala

@@ -27,10 +27,24 @@ trait Interpreter {
       val evaluator = new Evaluator()
 
       def apply[A](fa: EvaluatorOp[A]): M[A] = fa match {
-        case Evaluates(url, authKey, resolvers, dependencies, code) ⇒
+        case Evaluates(
+            url,
+            authKey,
+            connTimeout,
+            readTimeout,
+            resolvers,
+            dependencies,
+            code) ⇒
           A.pureEval(
             Eval.later(
-              evaluator.eval(url, authKey, resolvers, dependencies, code)))
+              evaluator.eval(
+                url,
+                authKey,
+                connTimeout,
+                readTimeout,
+                resolvers,
+                dependencies,
+                code)))
       }
 
     }

client/src/main/scala/org/scalaexercises/evaluator/http/HttpClient.scala

@@ -9,6 +9,9 @@ import io.circe.Decoder
 import org.scalaexercises.evaluator.EvaluatorResponses
 import org.scalaexercises.evaluator.EvaluatorResponses.EvaluationResponse
 
+import scala.concurrent.duration._
+import scala.concurrent.duration.Duration
+
 object HttpClient {
 
   val authHeaderName = "x-scala-eval-api-token"
@@ -23,11 +26,17 @@ class HttpClient {
     url: String,
     secretKey: String,
     method: String = "post",
+    connTimeout: Duration = 1.second,
+    readTimeout: Duration = 10.seconds,
     headers: Headers = Map.empty,
     data: String
   )(implicit D: Decoder[A]): EvaluationResponse[A] =
     EvaluatorResponses.toEntity(
-      HttpRequestBuilder(url = url, httpVerb = method)
+      HttpRequestBuilder(
+        url = url,
+        httpVerb = method,
+        connTimeout = connTimeout,
+        readTimeout = readTimeout)
         .withHeaders(headers + (authHeaderName -> secretKey))
         .withBody(data)
         .run)

client/src/main/scala/org/scalaexercises/evaluator/http/HttpRequestBuilder.scala

@@ -7,11 +7,15 @@ package org.scalaexercises.evaluator.http
 
 import org.scalaexercises.evaluator.http.HttpClient._
 
-import scalaj.http.Http
+import scala.concurrent.duration.Duration
+import scalaj.http.{Http, HttpOptions}
 
 case class HttpRequestBuilder(
   url: String,
   httpVerb: String,
+  connTimeout: Duration,
+  readTimeout: Duration,
+  followRedirects: Boolean = true,
   headers: Headers = Map.empty[String, String],
   body: Option[String] = None
 ) {
@@ -25,7 +29,11 @@ case class HttpRequestBuilder(
 
     body
       .fold(request)(
-        request.postData(_).header("content-type", "application/json"))
+        request
+          .postData(_)
+          .option(HttpOptions.connTimeout(connTimeout.toMillis.toInt))
+          .option(HttpOptions.readTimeout(readTimeout.toMillis.toInt))
+          .header("content-type", "application/json"))
       .asString
   }
 }

client/src/main/scala/org/scalaexercises/evaluator/implicits.scala

@@ -10,10 +10,7 @@ import cats.std.future._
 import cats.{Eval, MonadError}
 import org.scalaexercises.evaluator.free.interpreters.Interpreter
 
-object implicits
-    extends Interpreter
-    with EvalInstances
-    with FutureInstances
+object implicits extends Interpreter with EvalInstances with FutureInstances
 
 trait EvalInstances {
 

project/EvaluatorBuild.scala

@@ -37,7 +37,7 @@ object EvaluatorBuild extends AutoPlugin {
 
 
   private[this] def baseSettings = Seq(
-    version := "0.0.1-SNAPSHOT",
+    version := "0.0.2-SNAPSHOT",
     organization := "org.scala-exercises",
     scalaVersion := "2.11.8",
     scalafmtConfig in ThisBuild := Some(file(".scalafmt")),