KTOR-3419 DB Connection created on the top and passed in routing as argument; postgres keys moved to separate file for using both in application and docker-compose; added specific exception for database call

Author: VGoncharova

postgres/README.md

@@ -6,6 +6,10 @@ An application for creating, editing and deleting articles that uses Postgres da
 
 1. Execute gradle task `databaseInstance` and wait until Docker Compose builds image and starts container
 
-2. Run the sample to create database table
+2. Execute this command to run the sample:
+
+```bash
+./gradlew run
+```
 
 Then, you can open [http://localhost:8080/](http://localhost:8080/) in a browser to create, edit, and delete articles.

postgres/build.gradle.kts

@@ -34,7 +34,7 @@ dependencies {
 
 tasks.register("databaseInstance") {
     doLast {
-        val command = arrayOf("docker-compose","up")
+        val command = arrayOf("docker-compose", "up")
         Runtime.getRuntime().exec(command)
     }
 }

postgres/docker-compose.yaml

@@ -1,10 +1,9 @@
 version: '3'
 services:
-  postgres:
+  db:
     image: postgres:13.2-alpine
-    environment:
-      POSTGRES_USER: "user"
-      POSTGRES_PASSWORD: "password"
-      POSTGRES_DB: "articles"
     ports:
-      - 5432:5432
+      - 5432:5432
+    extends:
+      file: postgres.yaml
+      service: postgres

postgres/postgres.yaml

@@ -0,0 +1,7 @@
+version: '3'
+services:
+  postgres:
+    environment:
+      POSTGRES_USER: "user"
+      POSTGRES_PASSWORD: "password"
+      POSTGRES_DB: "articles"

postgres/settings.gradle.kts

@@ -1 +1 @@
-rootProject.name = "postgres"
+rootProject.name = "ktor-postgres"

postgres/src/main/kotlin/com/example/Application.kt

@@ -9,5 +9,5 @@ fun main(args: Array<String>): Unit =
 @Suppress("unused") // application.conf references the main function. This annotation prevents the IDE from marking it as unused.
 fun Application.module() {
     configureSerialization()
-    configureRouting()
+    configureRouting(dbConnection = connectToPostgres(embedded = false))
 }

postgres/src/main/kotlin/com/example/exceptions/DbElementNotFoundException.kt

@@ -0,0 +1,3 @@
+package com.example.exceptions
+
+class DbElementNotFoundException(message: String? = null, throwable: Throwable? = null) : Throwable(message, throwable)

postgres/src/main/kotlin/com/example/plugins/Routing.kt

@@ -1,17 +1,17 @@
 package com.example.plugins
 
+import com.example.exceptions.DbElementNotFoundException
 import com.example.models.Article
 import com.example.service.ArticleService
 import io.ktor.http.*
 import io.ktor.server.application.*
+import io.ktor.server.config.yaml.*
 import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
-import kotlinx.coroutines.*
 import java.sql.*
 
-fun Application.configureRouting() {
-    val dbConnection: Connection = connectToPostgres(embedded = false)
+fun Application.configureRouting(dbConnection: Connection) {
     val articleService = ArticleService(dbConnection)
     routing {
         // Create new Article
@@ -22,60 +22,48 @@ fun Application.configureRouting() {
         }
         // Read an Article
         get("/articles/{id}") {
-            val id = call.parameters["id"]?.toInt() ?: throw IllegalArgumentException("Invalid ID")
+            val id = call.parameters["id"]?.toInt() ?: throw DbElementNotFoundException("Invalid article ID")
             try {
                 val article = articleService.read(id)
                 call.respond(HttpStatusCode.OK, article)
-            } catch (e: Exception) {
+            } catch (cause: DbElementNotFoundException) {
                 call.respond(HttpStatusCode.NotFound)
             }
         }
         // Update an Article
         put("/articles/{id}") {
-            val id = call.parameters["id"]?.toInt() ?: throw IllegalArgumentException("Invalid ID")
-            val article = call.receive<Article>()
-            articleService.update(id, article)
-            call.respond(HttpStatusCode.OK)
+            val id = call.parameters["id"]?.toInt() ?: throw DbElementNotFoundException("Invalid article ID")
+            try {
+                val article = call.receive<Article>()
+                articleService.update(id, article)
+                call.respond(HttpStatusCode.OK)
+            } catch (cause: DbElementNotFoundException) {
+                call.respond(HttpStatusCode.NotFound)
+            }
         }
         // Delete an Article
         delete("/articles/{id}") {
-            val id = call.parameters["id"]?.toInt() ?: throw IllegalArgumentException("Invalid ID")
-            articleService.delete(id)
-            call.respond(HttpStatusCode.OK)
+            val id = call.parameters["id"]?.toInt() ?: throw DbElementNotFoundException("Invalid article ID")
+            try {
+                articleService.delete(id)
+                call.respond(HttpStatusCode.OK)
+            } catch (cause: DbElementNotFoundException) {
+                call.respond(HttpStatusCode.NotFound)
+            }
         }
     }
 }
 
-/**
- * Makes a connection to a Postgres database.
- *
- * In order to connect to your running Postgres process,
- * please specify the following parameters in your configuration file:
- * - postgres.url -- Url of your running database process.
- * - postgres.user -- Username for database connection
- * - postgres.password -- Password for database connection
- *
- * If you don't have a database process running yet, you may need to [download]((https://www.postgresql.org/download/))
- * and install Postgres and follow the instructions [here](https://postgresapp.com/).
- * Then, you would be edit your url,  which is usually "jdbc:postgresql://host:port/database", as well as
- * user and password values.
- *
- *
- * @param embedded -- if [true] defaults to an embedded database for tests that runs locally in the same process.
- * In this case you don't have to provide any parameters in configuration file, and you don't have to run a process.
- *
- * @return [Connection] that represent connection to the database. Please, don't forget to close this connection when
- * your application shuts down by calling [Connection.close]
- * */
 fun Application.connectToPostgres(embedded: Boolean): Connection {
     Class.forName("org.postgresql.Driver")
     if (embedded) {
         return DriverManager.getConnection("jdbc:postgresql://localhost/test;DB_CLOSE_DELAY=-1", "root", "")
     } else {
-        val url = environment.config.property("postgres.url").getString()
-        val user = environment.config.property("postgres.user").getString()
-        val password = environment.config.property("postgres.password").getString()
-
+        val configs = YamlConfig("postgres.yaml")
+        val url = "jdbc:postgresql://localhost:5432/" +
+                configs?.property("services.postgres.environment.POSTGRES_DB")?.getString()
+        val user = configs?.property("services.postgres.environment.POSTGRES_USER")?.getString()
+        val password = configs?.property("services.postgres.environment.POSTGRES_PASSWORD")?.getString()
         return DriverManager.getConnection(url, user, password)
     }
 }

postgres/src/main/kotlin/com/example/plugins/Serialization.kt

@@ -2,17 +2,10 @@ package com.example.plugins
 
 import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.plugins.contentnegotiation.*
-import io.ktor.server.response.*
 import io.ktor.server.application.*
-import io.ktor.server.routing.*
 
 fun Application.configureSerialization() {
     install(ContentNegotiation) {
         json()
     }
-    routing {
-        get("/json/kotlinx-serialization") {
-            call.respond(mapOf("hello" to "world"))
-        }
-    }
 }

postgres/src/main/resources/application.yaml

@@ -4,7 +4,3 @@ ktor:
       - com.example.ApplicationKt.module
   deployment:
     port: 8080
-postgres:
-  url: "jdbc:postgresql://localhost:5432/articles"
-  user: "user"
-  password: "password"