Add project config

Author: EdwarDDay

.github/scripts/test.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/bash
+#!/bin/bash
 
 set -eu
 set -o pipefail

.github/workflows/develop.yml

@@ -25,7 +25,7 @@ jobs:
           java-version: 17
 
       - name: Build
-        run: ./gradlew build
+        run: ./gradlew build installDist
 
       - name: Start nginx
         uses: nyurik/[email protected]
@@ -54,10 +54,13 @@ jobs:
               }
             }
 
+      - name: Create test config
+        run: echo "socket.address=$RUNNER_TEMP/kss.sock" >> kss.properties
+
       - name: Run tests on nginx
         uses: BerniWittmann/[email protected]
         with:
-          start: ./gradlew scripting-host:run --args="$RUNNER_TEMP/kss.sock"
+          start: ./scripting-host/build/install/scripting-host/bin/scripting-host
           wait-on: sleep 5
           command: ./.github/scripts/test.sh "${{ steps.start_ngingx.outputs.html-dir }}"
 

.gitignore

@@ -31,3 +31,6 @@ bin/
 
 ### Mac OS ###
 .DS_Store
+
+### Project ###
+/kss.properties

scripting-host/build.gradle.kts

@@ -26,5 +26,5 @@ kotlin {
 }
 
 application {
-    mainClass.set("net.edwardday.serverscript.scripthost.ScriptingHostKt")
+    mainClass.set("net.edwardday.serverscript.scripthost.MainKt")
 }

scripting-host/src/main/kotlin/Main.kt

@@ -0,0 +1,48 @@
+package net.edwardday.serverscript.scripthost
+
+import java.io.File
+import java.io.IOException
+import java.io.InputStream
+import java.util.*
+
+private const val CONFIG_FILE_NAME = "kss.properties"
+
+suspend fun main() {
+    // load default config
+    val defaultConfig = try {
+        Thread.currentThread()
+            .getContextClassLoader()
+            .getResourceAsStream(CONFIG_FILE_NAME)
+            ?.use<InputStream?, Properties> { stream ->
+                Properties().apply {
+                    load(stream)
+                }
+            }
+            ?: error("Could not load default configuration")
+    } catch (e: IOException) {
+        error("Could not read default configuration because of ${e.localizedMessage}")
+    }
+
+    // load config file from working directory
+    val workingDirectoryConfig = Properties(defaultConfig)
+    try {
+        File(CONFIG_FILE_NAME).takeIf(File::exists)?.bufferedReader()?.use(workingDirectoryConfig::load)
+    } catch (e: IOException) {
+        // Ignore for now, maybe log?
+    }
+
+    // load config from system properties
+    val commandLineConfig = Properties(workingDirectoryConfig)
+    workingDirectoryConfig.keys.forEach { key ->
+        val keyAsString = key.toString()
+        System.getProperty(keyAsString)?.also { value -> commandLineConfig[keyAsString] = value }
+    }
+
+    val socket = commandLineConfig.getProperty("socket.address") ?: "unix:/var/run/kss/kss.sock"
+    val maxConnections = commandLineConfig.getProperty("connections.max")?.toIntOrNull() ?: 4
+
+    readFromSocket(
+        socket = socket,
+        maxConnections = maxConnections,
+    )
+}

scripting-host/src/main/kotlin/ScriptingHost.kt

@@ -26,31 +26,15 @@ import java.nio.file.Files
 import java.nio.file.attribute.PosixFilePermission
 import kotlin.io.path.absolutePathString
 import kotlin.io.path.setPosixFilePermissions
-import kotlin.system.exitProcess
-
-private const val DEFAULT_MAX_CONNECTIONS = 4
 
 private val logger = KotlinLogging.logger {}
 
-suspend fun main(vararg args: String) {
-    if (args.size !in 1..2) {
-        logger.error { "usage: <app> <fast cgi socket> [max connections=$DEFAULT_MAX_CONNECTIONS]" }
-        exitProcess(status = 1)
-    } else {
-        val input = args[0]
-        try {
-            readFromSocket(input, args.getOrNull(1)?.toInt() ?: DEFAULT_MAX_CONNECTIONS)
-        } finally {
-            logger.info { "stop kss process" }
-        }
-    }
-}
-
 suspend fun readFromSocket(socket: String, maxConnections: Int) {
     logger.info { "start kss process" }
     logger.debug { "reading from $socket with $maxConnections max connections" }
     val socketAddress = UnixDomainSocketAddress.of(socket)
     runInterruptible { Files.deleteIfExists(socketAddress.path) }
+    val socketPath = socketAddress.path.absolutePathString()
 
     val globalState = GlobalState(maxConnections)
     try {
@@ -64,7 +48,12 @@ suspend fun readFromSocket(socket: String, maxConnections: Int) {
                     PosixFilePermission.GROUP_READ, PosixFilePermission.GROUP_WRITE,
                 ),
             )
-            listenToConnections(maxConnections, serverChannel, socketAddress, globalState)
+            listenToConnections(
+                maxConnections = maxConnections,
+                serverChannel = serverChannel,
+                socketDescription = socketPath,
+                globalState = globalState,
+            )
         }
     } finally {
         runInterruptible {
@@ -76,17 +65,17 @@ suspend fun readFromSocket(socket: String, maxConnections: Int) {
 private suspend fun listenToConnections(
     maxConnections: Int,
     serverChannel: ServerSocketChannel,
-    socketAddress: UnixDomainSocketAddress,
+    socketDescription: String,
     globalState: GlobalState,
 ) {
     coroutineScope {
         List(maxConnections) { index ->
             withLoggingContext("Connection Index" to index.toString()) {
                 launch(MDCContext()) {
                     handleRequests(
-                        serverChannel,
-                        socketAddress,
-                        globalState.connectionStates[index]
+                        serverChannel = serverChannel,
+                        socketDescription = socketDescription,
+                        connectionState = globalState.connectionStates[index]
                     )
                 }
             }
@@ -96,21 +85,23 @@ private suspend fun listenToConnections(
 
 private suspend fun handleRequests(
     serverChannel: ServerSocketChannel,
-    socketAddress: UnixDomainSocketAddress,
+    socketDescription: String,
     connectionState: GlobalState.ConnectionState,
 ): Nothing {
     while (true) {
+        logger.debug { "listen for connection" }
         val socketChannel = try {
             runInterruptible(Dispatchers.IO, block = serverChannel::accept)
         } catch (e: Exception) {
-            throw IllegalStateException("cannot accept socket of ${socketAddress.path.absolutePathString()}", e)
+            throw IllegalStateException("cannot accept socket of $socketDescription", e)
         }
         logger.debug { "open connection" }
         val source = socketChannel.source().buffer()
         val sink = socketChannel.sink().buffer()
         while (true) {
             try {
-                val message = runInterruptible { FCGIRequestMessage.read(source) }
+                logger.trace { "read message" }
+                val message = runInterruptible(Dispatchers.IO) { FCGIRequestMessage.read(source) }
                 val result = connectionState.handleMessage(message)
                 val close = result.fold(false) { close, responseMessage ->
                     when (responseMessage) {

scripting-host/src/main/resources/kss.properties

@@ -0,0 +1,2 @@
+connections.max=4
+socket.address=/var/run/kss/kss.sock

scripting-host/src/test/kotlin/ServerScriptingHostCacheTest.kt

@@ -0,0 +1,27 @@
+package net.edwardday.serverscript.scripthost
+
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ServerScriptingHostCacheTest {
+
+    @Test
+    fun testCacheWithUds() = runTest {
+        val (url, response) = readResource("cache_data")
+
+        val urls = List(5) { url }
+        val actualResponses = executeWithUds {
+            executeScripts(it, urls)
+        }
+
+        repeat(5) { index ->
+            val counter = index + 1
+            val expected = response.map { it.replace("{counter}", "$counter") }
+
+            val actual = actualResponses[index]
+
+            assertEquals(expected, actual)
+        }
+    }
+}

scripting-host/src/test/kotlin/ServerScriptingHostScriptsTest.kt

@@ -0,0 +1,31 @@
+package net.edwardday.serverscript.scripthost
+
+import kotlinx.coroutines.test.runTest
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+@RunWith(Parameterized::class)
+class ServerScriptingHostScriptsTest(private val testCaseName: String) {
+
+    @Test
+    fun testScript() = runTest {
+        val (url, expected) = readResource(testCaseName)
+
+        val actual = executeWithUds { executeScript(it, url) }
+
+        assertEquals(expected, actual)
+    }
+
+
+    companion object {
+
+        @JvmStatic
+        @Parameterized.Parameters(name = "script:{0}")
+        fun data() = listOf(
+            "simple_script", "custom_headers", "known_status", "unknown_status",
+            "big_output", "dependency", "multiple_output",
+        )
+    }
+}