fix(misc): Add space checkers in scalastyle (spark-jobserver#879)

noorul · web-flow · commit 362dfff17d12 · 2017-07-03T14:07:12.000+05:30
There several small checks that we can add to scalastyle to improve readability
and to make the code base consistent. One of them is space checks before and
after tokens.
diff --git a/akka-app/src/main/scala/spark/jobserver/common/akka/web/CommonRoutes.scala b/akka-app/src/main/scala/spark/jobserver/common/akka/web/CommonRoutes.scala
@@ -81,8 +81,8 @@ object MetricsSerializer {
 
   private def process(metric: Metric): Map[String, Any] = {
     metric match {
-      case c: Counter =>   Map("type" -> "counter", "count" -> c.count())
-      case m: Meter =>     Map("type" -> "meter") ++ meterToMap(m)
+      case c: Counter => Map("type" -> "counter", "count" -> c.count())
+      case m: Meter => Map("type" -> "meter") ++ meterToMap(m)
       case g: Gauge[_] => Map("type" -> "gauge", "value" -> g.value())
       // For Timers, ignore the min/max/mean values, as they are for all time.  We're just interested
       // in the recent (biased) histogram values.
@@ -97,17 +97,17 @@ object MetricsSerializer {
   private def meterToMap(m: Metered) =
     Map("units" -> m.rateUnit.toString.toLowerCase,
         "count" -> m.count,
-        "mean"  -> m.meanRate,
-        "m1"    -> m.oneMinuteRate,
-        "m5"    -> m.fiveMinuteRate,
-        "m15"   -> m.fifteenMinuteRate)
+        "mean" -> m.meanRate,
+        "m1" -> m.oneMinuteRate,
+        "m5" -> m.fiveMinuteRate,
+        "m15" -> m.fifteenMinuteRate)
 
   /** Extracts the histogram (Median, 75%, 95%, 98%, 99% 99.9%) values to a map */
   private def histogramToMap(h: Sampling) =
     Map("median" -> h.getSnapshot().getMedian(),
-        "p75"    -> h.getSnapshot().get75thPercentile(),
-        "p95"    -> h.getSnapshot().get95thPercentile(),
-        "p98"    -> h.getSnapshot().get98thPercentile(),
-        "p99"    -> h.getSnapshot().get99thPercentile(),
-        "p999"   -> h.getSnapshot().get999thPercentile())
+        "p75" -> h.getSnapshot().get75thPercentile(),
+        "p95" -> h.getSnapshot().get95thPercentile(),
+        "p98" -> h.getSnapshot().get98thPercentile(),
+        "p99" -> h.getSnapshot().get99thPercentile(),
+        "p999" -> h.getSnapshot().get999thPercentile())
 }
diff --git a/akka-app/src/main/scala/spark/jobserver/common/akka/web/JsonUtils.scala b/akka-app/src/main/scala/spark/jobserver/common/akka/web/JsonUtils.scala
@@ -35,13 +35,13 @@ object JsonUtils {
           JsObject(pairs)
       }
       case a: Array[_] => seqFormat[Any].write(a.toSeq)
-      case true        => JsTrue
-      case false       => JsFalse
-      case p: Product  => seqFormat[Any].write(p.productIterator.toSeq)
-      case null        => JsNull
+      case true => JsTrue
+      case false => JsFalse
+      case p: Product => seqFormat[Any].write(p.productIterator.toSeq)
+      case null => JsNull
       case m: java.util.Map[_, _] => AnyJsonFormat.write(m.asScala.toMap)
       case l: java.util.List[_] => seqFormat[Any].write(l.asScala)
-      case x           => JsString(x.toString)
+      case x => JsString(x.toString)
     }
     def read(value: JsValue): Any = value match {
       case JsNumber(n) => n.intValue()
diff --git a/job-server-api/src/main/scala/spark/jobserver/NamedRddSupport.scala b/job-server-api/src/main/scala/spark/jobserver/NamedRddSupport.scala
@@ -22,7 +22,7 @@ class RDDPersister[T] extends NamedObjectPersister[NamedRDD[T]] {
         rdd.setName(name)
         rdd.getStorageLevel match {
           case StorageLevel.NONE => rdd.persist(storageLevel)
-          case currentLevel      => rdd.persist(currentLevel)
+          case currentLevel => rdd.persist(currentLevel)
         }
         // perform some action to force computation of the RDD
         if (forceComputation) rdd.count()
@@ -174,7 +174,7 @@ trait NamedRddSupport extends NamedObjectSupport { self: SparkJob =>
       val namedObj: Option[NamedRDD[T]] = namedObjects.get(name)(timeout)
       namedObj match {
         case Some(NamedRDD(namedRdd: RDD[T], _, _)) => Some(namedRdd)
-        case _                                      => None
+        case _ => None
       }
     }
 
diff --git a/job-server-api/src/main/scala/spark/jobserver/SparkJob.scala b/job-server-api/src/main/scala/spark/jobserver/SparkJob.scala
@@ -33,7 +33,7 @@ trait SparkJobBase extends NewSparkJob {
   def validate(sc: C, runtime: JobEnvironment, config: Config): JobData Or Every[ValidationProblem] = {
     namedObjects = runtime.namedObjects
     validate(sc, config) match {
-      case SparkJobValid      => Good(config)
+      case SparkJobValid => Good(config)
       case i: SparkJobInvalid => Bad(One(i))
     }
   }
diff --git a/job-server-api/src/main/scala/spark/jobserver/context/SparkContextFactory.scala b/job-server-api/src/main/scala/spark/jobserver/context/SparkContextFactory.scala
@@ -50,7 +50,7 @@ trait SparkContextFactory {
    * @param contextName the name of the context to start
    * @return the newly created context.
    */
-  def makeContext(sparkConf: SparkConf, config: Config,  contextName: String): C
+  def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C
 
   /**
    * Creates a SparkContext or derived context.
@@ -90,7 +90,7 @@ trait ScalaContextFactory extends SparkContextFactory {
       if (isValidJob(job)) Good(ScalaJobContainer(job)) else Bad(JobWrongType)
     } catch {
       case _: ClassNotFoundException => Bad(JobClassNotFound)
-      case err: Exception            => Bad(JobLoadError(err))
+      case err: Exception => Bad(JobLoadError(err))
     }
   }
 
@@ -122,7 +122,7 @@ trait JavaContextFactory extends SparkContextFactory {
       if (isValidJob(job)) Good(ScalaJobContainer(JavaJob(job))) else Bad(JobWrongType)
     } catch {
       case _: ClassNotFoundException => Bad(JobClassNotFound)
-      case err: Exception            => Bad(JobLoadError(err))
+      case err: Exception => Bad(JobLoadError(err))
     }
   }
 
@@ -140,7 +140,7 @@ class DefaultSparkContextFactory extends ScalaContextFactory {
 
   type C = SparkContext with ContextLike
 
-  def makeContext(sparkConf: SparkConf, config: Config,  contextName: String): C = {
+  def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {
     val sc = new SparkContext(sparkConf) with ContextLike {
       def sparkContext: SparkContext = this
     }
diff --git a/job-server-api/src/main/scala/spark/jobserver/util/SparkJobUtils.scala b/job-server-api/src/main/scala/spark/jobserver/util/SparkJobUtils.scala
@@ -72,7 +72,7 @@ object SparkJobUtils {
     // This is useful for setting configurations for hadoop connectors such as
     // elasticsearch, cassandra, etc.
     for (e <- Try(contextConfig.getConfig("passthrough"))) {
-         e.entrySet().asScala.map { s=>
+         e.entrySet().asScala.map { s =>
             conf.set(s.getKey, s.getValue.unwrapped.toString)
          }
     }
@@ -104,7 +104,7 @@ object SparkJobUtils {
       case "yarn-client" =>
         Try(config.getDuration(yarn,
               TimeUnit.MILLISECONDS).toInt / 1000).getOrElse(40)
-      case _               =>
+      case _ =>
         Try(config.getDuration(standalone,
               TimeUnit.MILLISECONDS).toInt / 1000).getOrElse(15)
     }
diff --git a/job-server-extras/src/main/scala/spark/jobserver/NamedObjectsTestJob.scala b/job-server-extras/src/main/scala/spark/jobserver/NamedObjectsTestJob.scala
@@ -35,8 +35,8 @@ class NamedObjectsTestJob extends SparkJob with NamedObjectSupport {
       namedObjects.update("rdd1", NamedRDD(rows(sc), true, StorageLevel.MEMORY_ONLY))
     }
 
-    if (config.hasPath(CREATE_BROADCAST)){
-      val broadcast = sc.broadcast(Set(1,2,3,4,5))
+    if (config.hasPath(CREATE_BROADCAST)) {
+      val broadcast = sc.broadcast(Set(1, 2, 3, 4, 5))
       namedObjects.update("broadcast1", NamedBroadcast(broadcast))
     }
 
diff --git a/job-server-extras/src/main/scala/spark/jobserver/context/HiveContextFactory.scala b/job-server-extras/src/main/scala/spark/jobserver/context/HiveContextFactory.scala
@@ -10,7 +10,7 @@ class HiveContextFactory extends ScalaContextFactory {
 
   def isValidJob(job: api.SparkJobBase): Boolean = job.isInstanceOf[SparkHiveJob]
 
-  def makeContext(sparkConf: SparkConf, config: Config,  contextName: String): C = {
+  def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {
     contextFactory(sparkConf)
   }
 
diff --git a/job-server-extras/src/main/scala/spark/jobserver/context/SQLContextFactory.scala b/job-server-extras/src/main/scala/spark/jobserver/context/SQLContextFactory.scala
@@ -11,9 +11,9 @@ class SQLContextFactory extends ScalaContextFactory {
 
   def isValidJob(job: api.SparkJobBase): Boolean = job.isInstanceOf[SparkSqlJob]
 
-  def makeContext(sparkConf: SparkConf, config: Config,  contextName: String): C = {
+  def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {
     new SQLContext(new SparkContext(sparkConf)) with ContextLike {
       def stop() { this.sparkContext.stop() }
     }
   }
-}
+}
diff --git a/job-server-extras/src/main/scala/spark/jobserver/context/StreamingContextFactory.scala b/job-server-extras/src/main/scala/spark/jobserver/context/StreamingContextFactory.scala
@@ -11,7 +11,7 @@ class StreamingContextFactory extends ScalaContextFactory {
 
   def isValidJob(job: api.SparkJobBase): Boolean = job.isInstanceOf[SparkStreamingJob]
 
-  def makeContext(sparkConf: SparkConf, config: Config,  contextName: String): C = {
+  def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {
     val interval = config.getInt("streaming.batch_interval")
     val stopGracefully = config.getBoolean("streaming.stopGracefully")
     val stopSparkContext = config.getBoolean("streaming.stopSparkContext")
diff --git a/job-server-extras/src/main/scala/spark/jobserver/python/PythonContextFactory.scala b/job-server-extras/src/main/scala/spark/jobserver/python/PythonContextFactory.scala
@@ -69,7 +69,7 @@ trait PythonContextFactory extends SparkContextFactory {
     }
   }
 
-  def buildJob(eggPath: String, modulePath:String): PythonJob[C] =
+  def buildJob(eggPath: String, modulePath: String): PythonJob[C] =
     PythonJob[C](eggPath, modulePath, py4JImports)
 
   /**
diff --git a/job-server-extras/src/main/scala/spark/jobserver/python/PythonJob.scala b/job-server-extras/src/main/scala/spark/jobserver/python/PythonJob.scala
@@ -10,15 +10,15 @@ import scala.sys.process.{ProcessLogger, Process}
 import scala.util.{Failure, Success, Try}
 
 case class PythonJob[X <: PythonContextLike](eggPath: String,
-                                             modulePath:String,
+                                             modulePath: String,
                                              py4JImports: Seq[String]) extends SparkJobBase {
   override type JobData = Config
   override type JobOutput = Any
   override type C = X
 
   val logger = LoggerFactory.getLogger(getClass)
 
-  private def endpoint(context: C, contextConfig:Config, jobId: String, jobConfig:Config) = {
+  private def endpoint(context: C, contextConfig: Config, jobId: String, jobConfig: Config) = {
     val sparkConf = context.sparkContext.getConf
     JobEndpoint(context, sparkConf, contextConfig, jobId, jobConfig, modulePath, py4JImports)
   }
@@ -54,7 +54,7 @@ case class PythonJob[X <: PythonContextLike](eggPath: String,
     logger.info(s"Running $modulePath from $eggPath")
     val ep = endpoint(sc, runtime.contextConfig, runtime.jobId, data)
     val server = new GatewayServer(ep, 0)
-    val pythonPathDelimiter : String = if(System.getProperty("os.name").indexOf("Win") >= 0) ";" else ":"
+    val pythonPathDelimiter : String = if (System.getProperty("os.name").indexOf("Win") >= 0) ";" else ":"
     val pythonPath = (eggPath +: sc.pythonPath).mkString(pythonPathDelimiter)
     logger.info(s"Using Python path of ${pythonPath}")
     val subProcessOutcome = Try {
diff --git a/job-server/src/main/scala/spark/jobserver/AkkaClusterSupervisorActor.scala b/job-server/src/main/scala/spark/jobserver/AkkaClusterSupervisorActor.scala
@@ -185,7 +185,7 @@ class AkkaClusterSupervisorActor(daoActor: ActorRef) extends InstrumentedActor {
     val resultActor = if (isAdHoc) globalResultActor else context.actorOf(Props(classOf[JobResultActor]))
     (ref ? JobManagerActor.Initialize(
       Some(resultActor)))(Timeout(timeoutSecs.second)).onComplete {
-      case Failure(e:Exception) =>
+      case Failure(e: Exception) =>
         logger.info("Failed to send initialize message to context " + ref, e)
         cluster.down(ref.path.address)
         ref ! PoisonPill
diff --git a/job-server/src/main/scala/spark/jobserver/BinaryManager.scala b/job-server/src/main/scala/spark/jobserver/BinaryManager.scala
@@ -69,7 +69,7 @@ class BinaryManager(jobDao: ActorRef) extends InstrumentedActor {
       val successF =
         localBinaries.foldLeft(Future.successful[Boolean](true)) { (succ, pair) =>
          succ.flatMap{s =>
-           if(!s) {
+           if (!s) {
              Future.successful(false)
            } else {
              val (appName, (binaryType, binPath)) = pair
diff --git a/job-server/src/main/scala/spark/jobserver/CorsSupport.scala b/job-server/src/main/scala/spark/jobserver/CorsSupport.scala
@@ -28,7 +28,7 @@ trait CORSSupport {
           x.collect { case rejection: MethodRejection => rejection.supported }
         ctx.complete {
           HttpResponse().withHeaders(
-            `Access-Control-Allow-Methods`(HttpMethods.OPTIONS, allowedMethods :_*) ::
+            `Access-Control-Allow-Methods`(HttpMethods.OPTIONS, allowedMethods: _*) ::
               allowOriginHeader :: optionsCorsHeaders
           )
         }
@@ -37,4 +37,4 @@ trait CORSSupport {
       allowOriginHeader :: headers
     }
   }
-}
+}
diff --git a/job-server/src/main/scala/spark/jobserver/JobInfoActor.scala b/job-server/src/main/scala/spark/jobserver/JobInfoActor.scala
@@ -39,7 +39,7 @@ class JobInfoActor(jobDao: JobDAO, contextSupervisor: ActorRef) extends Instrume
 
       jobDao.getJobInfo(jobId).collect {
         case Some(jobInfo) => originator ! jobInfo
-        case None          => originator ! NoSuchJobId
+        case None => originator ! NoSuchJobId
       }
 
     case GetJobResult(jobId) =>
diff --git a/job-server/src/main/scala/spark/jobserver/JobManagerActor.scala b/job-server/src/main/scala/spark/jobserver/JobManagerActor.scala
@@ -244,9 +244,9 @@ class JobManagerActor(contextConfig: Config, daoActor: ActorRef)
     val jobId = java.util.UUID.randomUUID().toString()
     val jobContainer = factory.loadAndValidateJob(appName, lastUploadTime,
                                                   classPath, jobCache) match {
-      case Good(container)       => container
+      case Good(container) => container
       case Bad(JobClassNotFound) => return failed(NoSuchClass)
-      case Bad(JobWrongType)     => return failed(WrongJobType)
+      case Bad(JobWrongType) => return failed(WrongJobType)
       case Bad(JobLoadError(ex)) => return failed(JobLoadingError(ex))
     }
 
@@ -355,7 +355,7 @@ class JobManagerActor(contextConfig: Config, daoActor: ActorRef)
   protected def wrapInRuntimeException(t: Throwable): RuntimeException = {
     val cause : Throwable = getRootCause(t)
     val e : RuntimeException = new RuntimeException("%s: %s"
-      .format(cause.getClass().getName() ,cause.getMessage))
+      .format(cause.getClass().getName(), cause.getMessage))
     e.setStackTrace(cause.getStackTrace())
     return e
   }
diff --git a/job-server/src/main/scala/spark/jobserver/JobServer.scala b/job-server/src/main/scala/spark/jobserver/JobServer.scala
@@ -72,9 +72,13 @@ object JobServer {
           new DataFileDAO(config)), "data-manager")
       val binManager = system.actorOf(Props(classOf[BinaryManager], daoActor), "binary-manager")
       val supervisor =
-        system.actorOf(Props(if (contextPerJvm) { classOf[AkkaClusterSupervisorActor] }
-                             else               { classOf[LocalContextSupervisorActor] }, daoActor),
-                       "context-supervisor")
+        system.actorOf(Props(
+          if (contextPerJvm) {
+            classOf[AkkaClusterSupervisorActor]
+          } else {
+            classOf[LocalContextSupervisorActor]
+          },
+          daoActor), "context-supervisor")
       val jobInfo = system.actorOf(Props(classOf[JobInfoActor], jobDAO, supervisor), "job-info")
 
       // Add initial job JARs, if specified in configuration.
diff --git a/job-server/src/main/scala/spark/jobserver/JobServerNamedObjects.scala b/job-server/src/main/scala/spark/jobserver/JobServerNamedObjects.scala
@@ -68,7 +68,7 @@ class JobServerNamedObjects(system: ActorSystem) extends NamedObjects {
                                         (implicit timeout : FiniteDuration = defaultTimeout,
                                             persister: NamedObjectPersister[O]): O = {
     get(name) match {
-      case None    => {}
+      case None => {}
       case Some(_) => forget(name)
     }
     //this does not work when the old object is not of the same type as the new one
diff --git a/job-server/src/main/scala/spark/jobserver/JobServerSprayProtocol.scala b/job-server/src/main/scala/spark/jobserver/JobServerSprayProtocol.scala
@@ -7,7 +7,7 @@ import spray.json._
   * Created by alexsilva on 8/20/16.
   */
 case class JobServerResponse(status: String, result: String) {
-  def isSuccess:Boolean = status == "SUCCESS"
+  def isSuccess: Boolean = status == "SUCCESS"
 }
 
 object JobServerSprayProtocol extends DefaultJsonProtocol {
diff --git a/job-server/src/main/scala/spark/jobserver/WebApi.scala b/job-server/src/main/scala/spark/jobserver/WebApi.scala
@@ -54,16 +54,16 @@ object WebApi {
   def errMap(t: Throwable, status: String) : Map[String, Any] =
     Map(StatusKey -> status, ResultKey -> formatException(t))
 
-  def successMap(msg:String):Map[String,String] = Map(StatusKey -> "SUCCESS", ResultKey -> msg)
+  def successMap(msg: String): Map[String, String] = Map(StatusKey -> "SUCCESS", ResultKey -> msg)
 
   def getJobDurationString(info: JobInfo): String =
     info.jobLengthMillis.map { ms => ms / 1000.0 + " secs" }.getOrElse("Job not done yet")
 
   def resultToMap(result: Any): Map[String, Any] = result match {
     case m: Map[_, _] => m.map { case (k, v) => (k.toString, v) }.toMap
-    case s: Seq[_]    => s.zipWithIndex.map { case (item, idx) => (idx.toString, item) }.toMap
-    case a: Array[_]  => a.toSeq.zipWithIndex.map { case (item, idx) => (idx.toString, item) }.toMap
-    case item         => Map(ResultKey -> item)
+    case s: Seq[_] => s.zipWithIndex.map { case (item, idx) => (idx.toString, item) }.toMap
+    case a: Array[_] => a.toSeq.zipWithIndex.map { case (item, idx) => (idx.toString, item) }.toMap
+    case item => Map(ResultKey -> item)
   }
 
   def resultToTable(result: Any): Map[String, Any] = {
@@ -74,7 +74,7 @@ object WebApi {
     ResultKeyStartBytes.toIterator ++
       (jobReport.map(t => Seq(AnyJsonFormat.write(t._1).toString(),
                 AnyJsonFormat.write(t._2).toString()).mkString(":") ).mkString(",") ++
-        (if(jobReport.nonEmpty) "," else "")).getBytes().toIterator ++
+        (if (jobReport.nonEmpty) "," else "")).getBytes().toIterator ++
       ResultKeyBytes.toIterator ++ result ++ ResultKeyEndBytes.toIterator
   }
 
@@ -303,7 +303,7 @@ class WebApi(system: ActorSystem,
               val future = binaryManager ? StoreBinary(appName, BinaryType.Jar, jarBytes)
               respondWithMediaType(MediaTypes.`application/json`) { ctx =>
                 future.map {
-                  case BinaryStored  => ctx.complete(StatusCodes.OK, successMap("Jar uploaded"))
+                  case BinaryStored => ctx.complete(StatusCodes.OK, successMap("Jar uploaded"))
                   case InvalidBinary => badRequest(ctx, "Jar is not of the right format")
                   case BinaryStorageFailure(ex) => ctx.complete(500, errMap(ex, "Storage Failure"))
                 }.recover {
@@ -374,10 +374,10 @@ class WebApi(system: ActorSystem,
                 val future = (supervisor ? AddContext(cName, config))(contextTimeout.seconds)
                 respondWithMediaType(MediaTypes.`application/json`) { ctx =>
                   future.map {
-                    case ContextInitialized   => ctx.complete(StatusCodes.OK,
+                    case ContextInitialized => ctx.complete(StatusCodes.OK,
                       successMap("Context initialized"))
                     case ContextAlreadyExists => badRequest(ctx, "context " + contextName + " exists")
-                    case ContextInitError(e)  => ctx.complete(500, errMap(e, "CONTEXT INIT ERROR"))
+                    case ContextInitError(e) => ctx.complete(500, errMap(e, "CONTEXT INIT ERROR"))
                   }
                 }
               }
@@ -395,7 +395,7 @@ class WebApi(system: ActorSystem,
             respondWithMediaType(MediaTypes.`application/json`) { ctx =>
               future.map {
                 case ContextStopped => ctx.complete(StatusCodes.OK, successMap("Context stopped"))
-                case NoSuchContext  => notFound(ctx, "context " + contextName + " not found")
+                case NoSuchContext => notFound(ctx, "context " + contextName + " not found")
                 case ContextStopError(e) => ctx.complete(500, errMap(e, "CONTEXT DELETE ERROR"))
               }
             }
@@ -626,7 +626,7 @@ class WebApi(system: ActorSystem,
                         case JobValidationFailed(_, _, ex) =>
                           ctx.complete(400, errMap(ex, "VALIDATION FAILED"))
                         case NoSuchApplication => notFound(ctx, "appName " + appName + " not found")
-                        case NoSuchClass       => notFound(ctx, "classPath " + classPath + " not found")
+                        case NoSuchClass => notFound(ctx, "classPath " + classPath + " not found")
                         case WrongJobType =>
                           ctx.complete(400, errMap("Invalid job type for this context"))
                         case JobLoadingError(err) =>
@@ -715,8 +715,8 @@ class WebApi(system: ActorSystem,
     val future = (supervisor ? msg)(contextTimeout.seconds)
     Await.result(future, contextTimeout.seconds) match {
       case (manager: ActorRef, resultActor: ActorRef) => Some(manager)
-      case NoSuchContext                              => None
-      case ContextInitError(err)                      => throw new RuntimeException(err)
+      case NoSuchContext => None
+      case ContextInitError(err) => throw new RuntimeException(err)
     }
   }
 
diff --git a/job-server/src/main/scala/spark/jobserver/auth/SJSAuthenticator.scala b/job-server/src/main/scala/spark/jobserver/auth/SJSAuthenticator.scala
diff --git a/job-server/src/main/scala/spark/jobserver/io/JobDAO.scala b/job-server/src/main/scala/spark/jobserver/io/JobDAO.scala
diff --git a/job-server/src/main/scala/spark/jobserver/io/JobDAOActor.scala b/job-server/src/main/scala/spark/jobserver/io/JobDAOActor.scala
diff --git a/job-server/src/main/scala/spark/jobserver/io/JobFileDAO.scala b/job-server/src/main/scala/spark/jobserver/io/JobFileDAO.scala
diff --git a/job-server/src/main/scala/spark/jobserver/io/JobSqlDAO.scala b/job-server/src/main/scala/spark/jobserver/io/JobSqlDAO.scala
diff --git a/job-server/src/main/scala/spark/jobserver/util/LRUCache.scala b/job-server/src/main/scala/spark/jobserver/util/LRUCache.scala
diff --git a/scalastyle-config.xml b/scalastyle-config.xml

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ class RDDPersister[T] extends NamedObjectPersister[NamedRDD[T]] {`
`22`	`22`	`rdd.setName(name)`
`23`	`23`	`rdd.getStorageLevel match {`
`24`	`24`	`case StorageLevel.NONE => rdd.persist(storageLevel)`
`25`		`- case currentLevel => rdd.persist(currentLevel)`
	`25`	`+ case currentLevel => rdd.persist(currentLevel)`
`26`	`26`	`}`
`27`	`27`	`// perform some action to force computation of the RDD`
`28`	`28`	`if (forceComputation) rdd.count()`
`@@ -174,7 +174,7 @@ trait NamedRddSupport extends NamedObjectSupport { self: SparkJob =>`
`174`	`174`	`val namedObj: Option[NamedRDD[T]] = namedObjects.get(name)(timeout)`
`175`	`175`	`namedObj match {`
`176`	`176`	`case Some(NamedRDD(namedRdd: RDD[T], _, _)) => Some(namedRdd)`
`177`		`- case _ => None`
	`177`	`+ case _ => None`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ trait SparkJobBase extends NewSparkJob {`
`33`	`33`	`def validate(sc: C, runtime: JobEnvironment, config: Config): JobData Or Every[ValidationProblem] = {`
`34`	`34`	`namedObjects = runtime.namedObjects`
`35`	`35`	`validate(sc, config) match {`
`36`		`- case SparkJobValid => Good(config)`
	`36`	`+ case SparkJobValid => Good(config)`
`37`	`37`	`case i: SparkJobInvalid => Bad(One(i))`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ trait SparkContextFactory {`
`50`	`50`	`* @param contextName the name of the context to start`
`51`	`51`	`* @return the newly created context.`
`52`	`52`	`*/`
`53`		`- def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C`
	`53`	`+ def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C`
`54`	`54`
`55`	`55`	`/**`
`56`	`56`	`* Creates a SparkContext or derived context.`
`@@ -90,7 +90,7 @@ trait ScalaContextFactory extends SparkContextFactory {`
`90`	`90`	`if (isValidJob(job)) Good(ScalaJobContainer(job)) else Bad(JobWrongType)`
`91`	`91`	`} catch {`
`92`	`92`	`case _: ClassNotFoundException => Bad(JobClassNotFound)`
`93`		`- case err: Exception => Bad(JobLoadError(err))`
	`93`	`+ case err: Exception => Bad(JobLoadError(err))`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`@@ -122,7 +122,7 @@ trait JavaContextFactory extends SparkContextFactory {`
`122`	`122`	`if (isValidJob(job)) Good(ScalaJobContainer(JavaJob(job))) else Bad(JobWrongType)`
`123`	`123`	`} catch {`
`124`	`124`	`case _: ClassNotFoundException => Bad(JobClassNotFound)`
`125`		`- case err: Exception => Bad(JobLoadError(err))`
	`125`	`+ case err: Exception => Bad(JobLoadError(err))`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`@@ -140,7 +140,7 @@ class DefaultSparkContextFactory extends ScalaContextFactory {`
`140`	`140`
`141`	`141`	`type C = SparkContext with ContextLike`
`142`	`142`
`143`		`- def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {`
	`143`	`+ def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {`
`144`	`144`	`val sc = new SparkContext(sparkConf) with ContextLike {`
`145`	`145`	`def sparkContext: SparkContext = this`
`146`	`146`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ object SparkJobUtils {`
`72`	`72`	`// This is useful for setting configurations for hadoop connectors such as`
`73`	`73`	`// elasticsearch, cassandra, etc.`
`74`	`74`	`for (e <- Try(contextConfig.getConfig("passthrough"))) {`
`75`		`- e.entrySet().asScala.map { s=>`
	`75`	`+ e.entrySet().asScala.map { s =>`
`76`	`76`	`conf.set(s.getKey, s.getValue.unwrapped.toString)`
`77`	`77`	`}`
`78`	`78`	`}`
`@@ -104,7 +104,7 @@ object SparkJobUtils {`
`104`	`104`	`case "yarn-client" =>`
`105`	`105`	`Try(config.getDuration(yarn,`
`106`	`106`	`TimeUnit.MILLISECONDS).toInt / 1000).getOrElse(40)`
`107`		`- case _ =>`
	`107`	`+ case _ =>`
`108`	`108`	`Try(config.getDuration(standalone,`
`109`	`109`	`TimeUnit.MILLISECONDS).toInt / 1000).getOrElse(15)`
`110`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,8 @@ class NamedObjectsTestJob extends SparkJob with NamedObjectSupport {`
`35`	`35`	`namedObjects.update("rdd1", NamedRDD(rows(sc), true, StorageLevel.MEMORY_ONLY))`
`36`	`36`	`}`
`37`	`37`
`38`		`- if (config.hasPath(CREATE_BROADCAST)){`
`39`		`- val broadcast = sc.broadcast(Set(1,2,3,4,5))`
	`38`	`+ if (config.hasPath(CREATE_BROADCAST)) {`
	`39`	`+ val broadcast = sc.broadcast(Set(1, 2, 3, 4, 5))`
`40`	`40`	`namedObjects.update("broadcast1", NamedBroadcast(broadcast))`
`41`	`41`	`}`
`42`	`42`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ class HiveContextFactory extends ScalaContextFactory {`
`10`	`10`
`11`	`11`	`def isValidJob(job: api.SparkJobBase): Boolean = job.isInstanceOf[SparkHiveJob]`
`12`	`12`
`13`		`- def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {`
	`13`	`+ def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {`
`14`	`14`	`contextFactory(sparkConf)`
`15`	`15`	`}`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,9 @@ class SQLContextFactory extends ScalaContextFactory {`
`11`	`11`
`12`	`12`	`def isValidJob(job: api.SparkJobBase): Boolean = job.isInstanceOf[SparkSqlJob]`
`13`	`13`
`14`		`- def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {`
	`14`	`+ def makeContext(sparkConf: SparkConf, config: Config, contextName: String): C = {`
`15`	`15`	`new SQLContext(new SparkContext(sparkConf)) with ContextLike {`
`16`	`16`	`def stop() { this.sparkContext.stop() }`
`17`	`17`	`}`
`18`	`18`	`}`
`19`		`-}`
	`19`	`+}`