Allowing a pre-established set of compiler flags

Author: dominv

server/src/main/resources/application.conf

@@ -12,4 +12,28 @@ eval.auth {
 
 # Loader IO Configuration
 loaderio.verificationToken=loaderio-changeme
-loaderio.verificationToken=${?LOADERIO_VERIFICATION_TOKEN}
+loaderio.verificationToken=${?LOADERIO_VERIFICATION_TOKEN}
+
+allowed.compiler{
+  flags = ["-deprecation",
+    "-encoding", "UTF-8",
+    "-feature",
+    "-language:existentials",
+    "-language:experimental.macros",
+    "-language:higherKinds",
+    "-language:implicitConversions",
+    "-language:reflectiveCalls",
+    "-unchecked",
+    "-Xfatal-warnings",
+    "-Xfuture",
+    "-Xlint",
+    "-Xplugin-require:macroparadise",
+    "-Yinline-warnings",
+    "-Yliteral-types",
+    "-Yno-adapted-args",
+    "-Ywarn-dead-code",
+    "-Ywarn-numeric-widen",
+    "-Ywarn-value-discard",
+    "-Ypartial-unification"]
+  flags = ${?ALLOWED_COMPILER_FLAGS}
+}

server/src/main/scala/org/scalaexercises/evaluator/services.scala

@@ -5,13 +5,15 @@
 
 package org.scalaexercises.evaluator
 
+import com.typesafe.config.ConfigFactory
 import io.circe.Decoder
 import monix.execution.Scheduler
 import org.http4s._
 import org.http4s.dsl._
 import org.http4s.server.blaze._
 import org.log4s.getLogger
 
+import scala.collection.JavaConversions._
 import scala.concurrent.duration._
 import scala.language.postfixOps
 
@@ -23,6 +25,17 @@ object services {
 
   private val logger = getLogger
 
+  val config = ConfigFactory.load()
+
+  val AllowedCompilerFlags = "allowed.compiler.flags"
+
+  val allowedCompilerFlags = if (config.hasPath(AllowedCompilerFlags)) {
+    config.getStringList(AllowedCompilerFlags).toList
+  } else {
+    throw new IllegalStateException(
+      "Missing -D allowed.compiler.flags=[YOUR_KEY_HERE] or env var [ALLOWED_COMPILER_FLAGS]")
+  }
+
   implicit val scheduler: Scheduler = Scheduler.io("scala-evaluator")
 
   val evaluator = new Evaluator(20 seconds)
@@ -68,45 +81,52 @@ object services {
         req
           .decodeWith[EvalRequest](decoder, strict = false) {
             evalRequest =>
-              evaluator.eval[Any](
-                code = evalRequest.code,
-                remotes = evalRequest.resolvers,
-                dependencies = evalRequest.dependencies,
-                compilerFlags = evalRequest.compilerFlags
-              ) flatMap {
-                (result: EvalResult[_]) =>
-                  val response = result match {
-                    case EvalSuccess(cis, res, out) =>
-                      EvalResponse(
-                        `ok`,
-                        Option(res.toString),
-                        Option(res.asInstanceOf[AnyRef].getClass.getName),
-                        cis)
-                    case Timeout(_) =>
-                      EvalResponse(`Timeout Exceded`, None, None, Map.empty)
-                    case UnresolvedDependency(msg) =>
-                      EvalResponse(
-                        `Unresolved Dependency` + " : " + msg,
-                        None,
-                        None,
-                        Map.empty)
-                    case EvalRuntimeError(cis, runtimeError) =>
-                      EvalResponse(
-                        `Runtime Error`,
-                        runtimeError map (_.error.getMessage),
-                        runtimeError map (_.error.getClass.getName),
-                        cis)
-                    case CompilationError(cis) =>
-                      EvalResponse(`Compilation Error`, None, None, cis)
-                    case GeneralError(err) =>
-                      EvalResponse(
-                        `Unforeseen Exception`,
-                        None,
-                        None,
-                        Map.empty)
-                  }
-                  Ok(response.asJson)
-              }
+              val (validCompilerFlags, invalidCompilerFlags) =
+                evalRequest.compilerFlags.partition(
+                  allowedCompilerFlags.contains(_))
+              if (invalidCompilerFlags.isEmpty) {
+                evaluator.eval[Any](
+                  code = evalRequest.code,
+                  remotes = evalRequest.resolvers,
+                  dependencies = evalRequest.dependencies,
+                  compilerFlags = validCompilerFlags
+                ) flatMap {
+                  (result: EvalResult[_]) =>
+                    val response = result match {
+                      case EvalSuccess(cis, res, out) =>
+                        EvalResponse(
+                          `ok`,
+                          Option(res.toString),
+                          Option(res.asInstanceOf[AnyRef].getClass.getName),
+                          cis)
+                      case Timeout(_) =>
+                        EvalResponse(`Timeout Exceded`, None, None, Map.empty)
+                      case UnresolvedDependency(msg) =>
+                        EvalResponse(
+                          `Unresolved Dependency` + " : " + msg,
+                          None,
+                          None,
+                          Map.empty)
+                      case EvalRuntimeError(cis, runtimeError) =>
+                        EvalResponse(
+                          `Runtime Error`,
+                          runtimeError map (_.error.getMessage),
+                          runtimeError map (_.error.getClass.getName),
+                          cis)
+                      case CompilationError(cis) =>
+                        EvalResponse(`Compilation Error`, None, None, cis)
+                      case GeneralError(err) =>
+                        EvalResponse(
+                          `Unforeseen Exception`,
+                          None,
+                          None,
+                          Map.empty)
+                    }
+                    Ok(response.asJson)
+                }
+              } else
+                BadRequest(
+                  s"Invalid compiler flags: ${invalidCompilerFlags.mkString(",")}")
           }
           .map((r: Response) => r.putHeaders(corsHeaders: _*))
     })