Added a lot of files and dependencies to create the skeleton application. Will branch from this to have it saved and usable for the others.

Author: nikolovivan

README.md

@@ -2,3 +2,54 @@ scala-api
 =========
 
 A simple api written in Scala using the Spray Framework.
+
+Features
+--------
+
+The API includes the following libraries:
+
+1.  Spray.IO: This is the core of the API that allows users to generate API services.
+    The main components of spray.io are the **spray-servlet**, **spray-routing** and all the **Akka**-related dependencies.
+    Additionally we have added support for caching and json marshalling and unmarshalling using the **spray-caching** and **spray-json** dependencies.
+2.  Jetty: This is the application container.
+3.  Typesafe config: The application and the underlying **Akka** classes use the typesafe config system for configuration.
+4.  Slick: This is a library for database query and access that supports various underlying DBMSs. The user is free to use whatever they want and add the required connector later.
+5.  Testing tools: **Scalatest** is the preferred testing tool, together with **Mockito**.
+6.  **sbt-assembly**: For creating a fat jar with embedded Jetty for distribution.
+7.  **sbt-release**: For defining custom release steps.
+
+Starting the Server
+-------------------
+
+Starting the server is relatively easy. There are two ways of doing this:
+
+1.  Without building the fat jar.
+2.  Building the fat jar and running it.
+
+### Running the Application Through SBT
+
+To run the application through SBT, run the following command:
+
+> sbt container:start shell
+
+It might take some time to compile if you haven't done this yet and then you will see a shell. Then your service will become available and you will be able to query it through the browser.
+
+To stop the server, run:
+
+> container:stop
+
+### Running the Server Through a Fat JAR
+
+For this operation you will need to create the fat jar first and then simply start it as normal Java application.
+
+1.  Building the fat jar:
+    > sbt assembly
+2.  Running the application:
+    > java -jar jar-name.jar
+
+Then to stop the application, just press Ctrl+C.
+
+Conclusion
+----------
+
+This is the skeleton application you can use to quickly start your development. From then on, it is up to you to add the dependencies you need and make the API do whatever you want.

assembly.sbt

@@ -0,0 +1,15 @@
+import sbtassembly.Plugin.AssemblyKeys._
+
+assemblySettings
+
+// Could add a merge strategy if something doesn't work when building the fat jar.
+
+mainClass in assembly := Some("com.ivan.nikolov.JettyStart")
+
+jarName in assembly := { s"${name.value}_${scalaVersion.value}-${version.value}-assembly.jar" }
+
+artifact in (Compile, assembly) ~= {art =>
+  art.copy(`classifier` = Some("assembly"))
+}
+
+addArtifact(artifact in (Compile, assembly), assembly)

build.sbt

@@ -0,0 +1,49 @@
+organization := "com.ivan.nikolov"
+
+name := "scala-api"
+
+scalaVersion := "2.10.3"
+
+scalacOptions := Seq("-unchecked", "-deprecation", "-encoding", "utf8")
+
+javaOptions ++= Seq("-target", "1.7", "-source", "1.7")
+
+resolvers ++= Seq(
+  "spray repo" at "http://repo.spray.io"
+)
+
+publishMavenStyle := true
+
+libraryDependencies ++= {
+  val akkaVersion = "2.3.0"
+  val sprayVersion = "1.3.1"
+  val sprayJsonVersion = "1.2.6"
+  val typesafeVersion = "1.2.0"
+  val slickVersion = "2.0.1"
+  Seq(
+    "org.scalatest" % "scalatest_2.10" % "2.1.3" % "test",
+    "io.spray" % "spray-servlet" % sprayVersion,
+    "io.spray" % "spray-routing" % sprayVersion,
+    "io.spray" % "spray-caching" % sprayVersion,
+    "io.spray" %%  "spray-json" % sprayJsonVersion,
+    "io.spray" % "spray-testkit" % sprayVersion % "test",
+    "org.eclipse.jetty" % "jetty-webapp" % "9.1.0.v20131115" % "container",
+    "org.eclipse.jetty" % "jetty-plus" % "9.1.0.v20131115" % "container",
+    "org.eclipse.jetty.orbit" % "javax.servlet" % "3.0.0.v201112011016" % "container" artifacts Artifact("javax.servlet", "jar", "jar"),
+    "org.eclipse.jetty" % "jetty-server" % "9.1.3.v20140225",
+    "org.eclipse.jetty" % "jetty-servlet" % "9.1.3.v20140225",
+    "com.typesafe.akka" %% "akka-actor" % akkaVersion,
+    "com.typesafe.akka" %% "akka-testkit" % akkaVersion % "test",
+    "com.typesafe" % "config" % typesafeVersion, // configuration.
+    "com.typesafe.slick" %% "slick" % slickVersion, // for database connectivity.
+    "org.scala-tools.testing" % "specs_2.9.1" % "1.6.9" % "test", // for the mockito sugar
+    "org.mockito" % "mockito-all" % "1.9.5" % "test" // mockito for tests
+  )
+}
+
+// Import the web settings.
+seq(webSettings: _*)
+
+port in container.Configuration := 8888
+
+//ssl in container.Configuration := Some("192.168.1.4", 8443, "keystore_path", "keystore_password", "key_password")

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.1

src/main/resources/application.conf

@@ -0,0 +1,16 @@
+akka {
+    loglevel = INFO
+}
+
+spray.servlet {
+    boot-class = "com.ivan.nikolov.Boot"
+    request-timeout = 30s
+}
+
+
+# The api configurations.
+scala-api {
+    application {
+        port = 8888
+    }
+}

src/main/scala/com/ivan/nikolov/Boot.scala

@@ -0,0 +1,15 @@
+package com.ivan.nikolov
+
+import spray.servlet.WebBoot
+import akka.actor.{Props, ActorSystem}
+import com.ivan.nikolov.actor.ScalaApiActor
+
+/**
+ * The boot class the initialized the actor system and assigns the
+ * service actor. It is instantiated by the servlet initializer.
+ */
+class Boot extends WebBoot {
+  val system = ActorSystem("scala-api")
+
+  val serviceActor = system.actorOf(Props[ScalaApiActor])
+}

src/main/scala/com/ivan/nikolov/JettyStart.scala

@@ -0,0 +1,38 @@
+package com.ivan.nikolov
+
+import org.eclipse.jetty.server.Server
+import org.eclipse.jetty.servlet.ServletContextHandler
+import spray.servlet.{Servlet30ConnectorServlet, Initializer}
+import com.ivan.nikolov.app.ComponentRegistry._
+
+/**
+ * Starts the embedded Jetty server that runs the given application.
+ */
+object JettyStart {
+
+  def main(args: Array[String]) {
+    start()
+  }
+
+  /**
+   * Starts the embedded Jetty instance. This is similar to the
+   * web.xml contents here.
+   */
+  def start() {
+    try {
+      val server = new Server(settings.Application.port)
+
+      val contextHandler = new ServletContextHandler(ServletContextHandler.NO_SESSIONS)
+      contextHandler.setContextPath("/")
+      server.setHandler(contextHandler)
+      contextHandler.addEventListener(new Initializer)
+
+      contextHandler.addServlet(classOf[Servlet30ConnectorServlet].getName, "/*")
+
+      server.start()
+      server.join()
+    } catch {
+      case e: Throwable => e.printStackTrace()
+    }
+  }
+}

src/main/scala/com/ivan/nikolov/actor/ScalaApiActor.scala

@@ -0,0 +1,17 @@
+package com.ivan.nikolov.actor
+
+import akka.actor.Actor
+import com.ivan.nikolov.routes.PingRoute
+import com.ivan.nikolov.app.ComponentRegistry._
+
+/**
+ * The Scala API actor.
+ */
+class ScalaApiActor extends Actor with PingRoute {
+
+  val settingsDep = settings
+
+  implicit def actorRefFactory = context
+
+  def receive = runRoute(pingRoute)
+}

src/main/scala/com/ivan/nikolov/app/ComponentRegistry.scala

@@ -0,0 +1,10 @@
+package com.ivan.nikolov.app
+
+import com.ivan.nikolov.config.SettingsComponent
+
+/**
+ * The component registry that leverages the cake design pattern.
+ */
+object ComponentRegistry extends SettingsComponent {
+  val settings = Settings.createSettings("/etc/ivan/nikolov/scala-api/config.properties")
+}

src/main/scala/com/ivan/nikolov/config/SettingsComponent.scala

@@ -0,0 +1,41 @@
+package com.ivan.nikolov.config
+
+import com.typesafe.config.{ConfigSyntax, ConfigParseOptions, ConfigFactory, Config}
+import java.io.File
+
+/**
+ * Created by volcom on 13/04/14.
+ */
+trait SettingsComponent {
+
+  val settings: Settings
+
+  class Settings(config: Config) {
+    config.checkValid(ConfigFactory.defaultReference(), "scala-api")
+
+    object Application {
+      val port = config.getInt("scala-api.application.port")
+    }
+  }
+
+  object Settings {
+    /**
+     * Creates settings that can exist in different environments.
+     * @param configPath The path to the config file.
+     * @param configName The name of the config file. The default is application.conf, as
+     *                   the typesafe config recommendations are.
+     * @return
+     */
+    def createSettings(configPath: String, configName: Option[String] = None): Settings = {
+      val file = new File(configPath)
+      if (file.exists()) {
+        val fileConfig = ConfigFactory.parseFile(file, ConfigParseOptions.defaults().setSyntax(ConfigSyntax.CONF))
+        new Settings(ConfigFactory.load(fileConfig))
+      } else if (configName.isDefined) {
+        new Settings(ConfigFactory.load(configName.get))
+      } else {
+        new Settings(ConfigFactory.load())
+      }
+    }
+  }
+}