Move stuff in base

src/jvmMain/kotlin/nl/astraeus/vst/base/Settings.kt

@@ -0,0 +1,44 @@
+package nl.astraeus.vst.base
+
+import java.io.File
+import java.io.FileInputStream
+import java.util.*
+
+object Settings {
+  var port = 9004
+  var connectionTimeout = 30000
+  var jdbcStatsPort = 6001
+
+  var jdbcDriver = "nl.astraeus.jdbc.Driver"
+  val jdbcConnectionUrl
+    get() = "jdbc:stat:webServerPort=$jdbcStatsPort:jdbc:sqlite:data/vst.db"
+  var jdbcUser = "sa"
+  var jdbcPassword = ""
+
+  fun getPropertiesFromFile(filename: String): Properties? {
+    val propertiesFile = File(filename)
+    return if (propertiesFile.exists()) {
+      val properties = Properties()
+      FileInputStream(propertiesFile).use {
+        properties.load(it)
+      }
+      properties
+    } else {
+      null
+    }
+  }
+
+  fun readProperties(args: Array<String>) {
+    val filename = if (args.isNotEmpty()) args[0] else "srp.properties"
+    val properties =
+      getPropertiesFromFile(filename) ?: return // return if properties couldn't be loaded
+
+    port = properties.getProperty("port", port.toString()).toInt()
+    jdbcStatsPort = properties.getProperty("jdbcStatsPort", jdbcStatsPort.toString()).toInt()
+    connectionTimeout =
+      properties.getProperty("connectionTimeout", connectionTimeout.toString()).toInt()
+    jdbcDriver = properties.getProperty("jdbcDriver", jdbcDriver)
+    jdbcUser = properties.getProperty("jdbcUser", jdbcUser)
+    jdbcPassword = properties.getProperty("jdbcPassword", jdbcPassword)
+  }
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/db/BaseDao.kt

@@ -0,0 +1,170 @@
+package nl.astraeus.vst.base.db
+
+import kotlinx.datetime.Instant
+import nl.astraeus.vst.string.logger.log
+import java.sql.PreparedStatement
+import java.sql.ResultSet
+import java.sql.Timestamp
+
+fun Instant.toSqlTimestamp() = Timestamp(this.toEpochMilliseconds())
+fun Timestamp.toDateTimeInstant() = Instant.fromEpochMilliseconds(this.time)
+
+data class SqlStatement<T : Entity>(
+  val sql: String,
+  val prepareParameters: T.(PreparedStatement) -> Unit
+)
+
+data class SqlQuery<T : Entity>(
+  val sql: String,
+  val resultMapper: (ResultSet) -> T
+)
+
+abstract class QueryProvider<T : Entity> {
+  abstract val tableName: String
+  open val idQuery: String
+    get() = "SELECT * FROM $tableName WHERE ID = ?"
+  abstract val resultSetMapper: (ResultSet) -> T
+  open val find: SqlQuery<T>
+    get() = SqlQuery(
+      idQuery,
+      resultSetMapper
+    )
+  abstract val insert: SqlStatement<T>
+  abstract val update: SqlStatement<T>
+  open val delete: SqlStatement<T>
+    get() = SqlStatement(
+      "DELETE FROM $tableName WHERE ID = ?"
+    ) { ps ->
+      ps.setLong(1, getPK()[0] as Long)
+    }
+}
+
+abstract class BaseDao<T : Entity> {
+  abstract val queryProvider: QueryProvider<T>
+  open val autogeneratedPrimaryKey: Boolean = true
+
+  open fun insert(entity: T) {
+    executeInsert(entity, "insert", queryProvider.insert)
+  }
+
+  open fun update(entity: T): Int = executeUpdate(
+    entity,
+    "update",
+    queryProvider.update,
+    true
+  )
+
+  open fun upsert(entity: T) {
+    if ((entity.getPK()[0] as Long) == 0L) {
+      insert(entity)
+    } else {
+      update(entity)
+    }
+  }
+
+  open fun delete(entity: T) {
+    executeUpdate(entity, "delete", queryProvider.delete, true)
+  }
+
+  open fun find(
+    id: Long
+  ): T? {
+    return executeQuery(
+      "find",
+      queryProvider.find
+    ) { ps ->
+      ps.setLong(1, id)
+    }.firstOrNull()
+  }
+
+  protected fun executeSQLUpdate(
+    sql: String,
+    parameterSetter: (PreparedStatement) -> Unit
+  ): Int {
+    return Database.transaction { con ->
+      con.prepareStatement(sql).use { ps ->
+        parameterSetter(ps)
+
+        ps.executeUpdate()
+      }
+    }
+  }
+
+  protected fun executeQuery(
+    label: String,
+    statement: SqlQuery<T>,
+    prepareParameters: (PreparedStatement) -> Unit,
+  ): List<T> {
+    return Database.transaction { con ->
+      log.debug { "Executing query [$label] - [${statement.sql}]" }
+      val result = mutableListOf<T>()
+
+      con.prepareStatement(statement.sql)?.use { ps ->
+        prepareParameters(ps)
+
+        val rs = ps.executeQuery()
+
+        while (rs.next()) {
+          result.add(statement.resultMapper(rs))
+        }
+      }
+
+      result
+    }
+  }
+
+  protected fun executeInsert(
+    entity: T,
+    label: String,
+    statement: SqlStatement<T>,
+    checkSingleRow: Boolean = false
+  ) {
+    Database.transaction { con ->
+      log.debug { "Executing insert [$label] - [${statement.sql}] - [$entity]" }
+      con.prepareStatement(statement.sql)?.use { ps ->
+        statement.prepareParameters(entity, ps)
+
+        val rows = if (checkSingleRow) {
+          ps.execute()
+          1
+        } else {
+          ps.executeUpdate()
+        }
+
+        if (autogeneratedPrimaryKey) {
+          val keyResult = ps.generatedKeys
+          if (keyResult.next()) {
+            entity.setPK(arrayOf(keyResult.getLong(1)))
+          }
+        }
+
+        check(rows == 1) {
+          "Statement [$label] affected more than 1 row! [${statement.sql}]"
+        }
+      }
+    }
+  }
+
+  protected fun executeUpdate(
+    entity: T,
+    label: String,
+    statement: SqlStatement<T>,
+    checkSingleRow: Boolean = false
+  ): Int = Database.transaction { con ->
+    var rows = 1
+
+    log.debug { "Executing update [$label] - [${statement.sql}] - [$entity]" }
+    con.prepareStatement(statement.sql)?.use { ps ->
+      statement.prepareParameters(entity, ps)
+
+      rows = ps.executeUpdate()
+
+      check(checkSingleRow || rows == 1) {
+        "Statement [$label] affected more than 1 row! [${statement.sql}]"
+      }
+    }
+
+    rows
+  }
+
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/db/Database.kt

@@ -0,0 +1,84 @@
+package nl.astraeus.vst.base.db
+
+import com.zaxxer.hikari.HikariConfig
+import com.zaxxer.hikari.HikariDataSource
+import nl.astraeus.vst.base.Settings
+import java.sql.Connection
+import java.util.*
+import java.util.concurrent.atomic.AtomicBoolean
+
+val DATABASE_MIGRATIONS = arrayOf<Migration>(
+  Migration.Query(
+    """
+  CREATE TABLE DATABASE_VERSION (
+    ID INTEGER PRIMARY KEY,
+    QUERY TEXT,
+    EXECUTED TIMESTAMP
+  )
+  """.trimIndent()
+  ),
+  Migration.Query(PATCH_CREATE_QUERY),
+)
+
+object Database {
+
+  private var ds: HikariDataSource? = null
+  private val currentConnection = ThreadLocal<Connection>()
+
+  fun start() {
+    Class.forName("nl.astraeus.jdbc.Driver")
+
+    val properties = Properties()
+    properties["journal_mode"] = "WAL"
+
+    val config = HikariConfig().apply {
+      driverClassName = Settings.jdbcDriver
+      jdbcUrl = Settings.jdbcConnectionUrl
+      username = Settings.jdbcUser
+      password = Settings.jdbcPassword
+      maximumPoolSize = 25
+      isAutoCommit = false
+
+      validate()
+    }
+
+    config.dataSourceProperties = properties
+    config.addDataSourceProperty("cachePrepStmts", "true")
+    config.addDataSourceProperty("prepStmtCacheSize", "250")
+    config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048")
+
+    ds = HikariDataSource(config)
+    Migrations.databaseVersionTableCreated = AtomicBoolean(false)
+    Migrations.updateDatabaseIfNeeded(DATABASE_MIGRATIONS)
+  }
+
+  private fun getConnection() = ds?.connection ?: error("Database has not been initialized!")
+
+  fun <T> transaction(
+    block: (Connection) -> T
+  ): T {
+    val hasConnection = currentConnection.get() != null
+
+    if (!hasConnection) {
+      currentConnection.set(getConnection())
+    }
+
+    val connection = currentConnection.get()
+
+    try {
+      val result = block(connection)
+
+      if (!hasConnection) {
+        connection.commit()
+      }
+
+      return result
+    } finally {
+      if (!hasConnection) {
+        connection.close()
+        currentConnection.remove()
+      }
+    }
+  }
+
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/db/Entity.kt

@@ -0,0 +1,16 @@
+package nl.astraeus.vst.base.db
+
+interface Entity {
+  fun getPK(): Array<Any>
+  fun setPK(pks: Array<Any>)
+}
+
+interface EntityId : Entity {
+  var id: Long
+
+  override fun getPK(): Array<Any> = arrayOf(id)
+
+  override fun setPK(pks: Array<Any>) {
+    id = pks[0] as Long
+  }
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/db/Migrations.kt

@@ -0,0 +1,97 @@
+package nl.astraeus.vst.base.db
+
+import nl.astraeus.vst.base.db.Database.transaction
+import java.sql.Connection
+import java.sql.SQLException
+import java.sql.Timestamp
+import java.util.concurrent.atomic.AtomicBoolean
+
+sealed class Migration {
+  class Query(
+    val query: String
+  ) : Migration() {
+    override fun toString(): String {
+      return query
+    }
+  }
+
+  class Code(
+    val code: (Connection) -> Unit
+  ) : Migration() {
+    override fun toString(): String {
+      return code.toString()
+    }
+  }
+}
+
+object Migrations {
+  var databaseVersionTableCreated = AtomicBoolean(false)
+
+  fun updateDatabaseIfNeeded(
+    migrations: Array<Migration>
+  ) {
+    try {
+      Database.transaction { con ->
+        con.prepareStatement(
+          """
+            SELECT MAX(ID) FROM DATABASE_VERSION
+          """.trimIndent()
+        ).use { ps ->
+          ps.executeQuery().use { rs ->
+            databaseVersionTableCreated.compareAndSet(false, true)
+
+            if (rs.next()) {
+              val maxId = rs.getInt(1)
+
+              for (index in maxId + 1..<migrations.size) {
+                executeMigration(index, migrations[index])
+              }
+            }
+          }
+        }
+      }
+    } catch (e: SQLException) {
+      if (databaseVersionTableCreated.compareAndSet(false, true)) {
+        executeMigration(0, migrations[0])
+        updateDatabaseIfNeeded(migrations)
+      } else {
+        throw e
+      }
+    }
+  }
+
+  private fun executeMigration(
+    index: Int,
+    migration: Migration
+  ) {
+    transaction { con ->
+/*      log.debug {
+        "Executing migration $index - [${migration}]"
+      }*/
+      val description = when (migration) {
+        is Migration.Query -> {
+          @Suppress("SqlSourceToSinkFlow")
+          con.prepareStatement(migration.query).use { ps ->
+            ps.execute()
+          }
+
+          migration.query
+        }
+
+        is Migration.Code -> {
+          migration.code(con)
+
+          migration.code.toString()
+        }
+      }
+      con.prepareStatement("INSERT INTO DATABASE_VERSION VALUES (?, ?, ?)").use { ps ->
+        ps.setInt(1, index)
+        ps.setString(2, description)
+        ps.setTimestamp(3, Timestamp(System.currentTimeMillis()))
+
+        ps.execute()
+      }
+    }
+  }
+
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/db/PatchDao.kt

@@ -0,0 +1,31 @@
+package nl.astraeus.vst.base.db
+
+object PatchDao : BaseDao<PatchEntity>() {
+
+  override val queryProvider: QueryProvider<PatchEntity>
+    get() = PatchEntityQueryProvider
+
+  fun create(
+    patchId: String,
+    patch: String
+  ): PatchEntity {
+    val result = PatchEntity(
+      0,
+      patchId,
+      patch
+    )
+
+    return result
+  }
+
+  fun findById(patchId: String): PatchEntity? = executeQuery(
+    "findById",
+    SqlQuery(
+      "SELECT * FROM ${queryProvider.tableName} WHERE PATCH_ID = ?",
+      queryProvider.resultSetMapper
+    )
+  ) { ps ->
+    ps.setString(1, patchId)
+  }.firstOrNull()
+
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/db/PatchEntity.kt

@@ -0,0 +1,12 @@
+package nl.astraeus.vst.base.db
+
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+
+data class PatchEntity(
+  override var id: Long,
+  var patchId: String,
+  var patch: String,
+  var created: Instant = Clock.System.now(),
+  var updated: Instant = Clock.System.now(),
+) : EntityId

src/jvmMain/kotlin/nl/astraeus/vst/base/db/PatchEntityQueryProvider.kt

@@ -0,0 +1,64 @@
+package nl.astraeus.vst.base.db
+
+import java.sql.ResultSet
+import java.sql.Types
+
+val PATCH_CREATE_QUERY = """
+  CREATE TABLE INSTRUMENTS (
+    ID INTEGER PRIMARY KEY AUTOINCREMENT,
+    PATCH_ID TEXT,
+    PATCH TEXT,
+    CREATED TIMESTAMP,
+    UPDATED TIMESTAMP
+  )
+  """.trimIndent()
+
+object PatchEntityQueryProvider : QueryProvider<PatchEntity>() {
+  override val tableName: String
+    get() = "INSTRUMENTS"
+  override val resultSetMapper: (ResultSet) -> PatchEntity
+    get() = { rs ->
+      PatchEntity(
+        rs.getLong(1),
+        rs.getString(2),
+        rs.getString(3),
+        rs.getTimestamp(4).toDateTimeInstant(),
+        rs.getTimestamp(5).toDateTimeInstant()
+      )
+    }
+  override val insert: SqlStatement<PatchEntity>
+    get() = SqlStatement(
+      """
+    INSERT INTO $tableName (
+      ID,
+      PATCH_ID,
+      PATCH,
+      CREATED,
+      UPDATED
+    ) VALUES (
+      ?,?,?,?,?
+    )
+  """.trimIndent()
+    ) { ps ->
+      ps.setNull(1, Types.BIGINT)
+      ps.setString(2, patchId)
+      ps.setString(3, patch)
+      ps.setTimestamp(4, created.toSqlTimestamp())
+      ps.setTimestamp(5, updated.toSqlTimestamp())
+    }
+  override val update: SqlStatement<PatchEntity>
+    get() = SqlStatement(
+      """
+    UPDATE $tableName 
+    SET  PATCH_ID = ?, 
+         PATCH = ?,
+         UPDATED = ?
+    WHERE ID = ?
+  """.trimIndent()
+    ) { ps ->
+      ps.setString(1, patchId)
+      ps.setString(2, patch)
+      ps.setTimestamp(3, updated.toSqlTimestamp())
+      ps.setLong(4, id)
+    }
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/web/GenerateId.kt

@@ -0,0 +1,16 @@
+package nl.astraeus.vst.base.web
+
+import java.security.SecureRandom
+
+val idChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+val random = SecureRandom()
+
+fun generateId(): String {
+  val id = StringBuilder()
+
+  for (i in 0 until 8) {
+    id.append(idChars[random.nextInt(idChars.length)])
+  }
+
+  return id.toString()
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/web/Index.kt

@@ -0,0 +1,46 @@
+package nl.astraeus.vst.base.web
+
+import kotlinx.html.body
+import kotlinx.html.head
+import kotlinx.html.html
+import kotlinx.html.meta
+import kotlinx.html.script
+import kotlinx.html.stream.appendHTML
+import kotlinx.html.title
+
+fun generateIndex(
+  title: String,
+  script: String,
+  patch: String?,
+): String {
+  val result = StringBuilder();
+
+  if (patch == null) {
+    result.appendHTML(true).html {
+      head {
+        title { +title }
+      }
+      body {
+        script {
+          type = "application/javascript"
+          src = script
+        }
+      }
+    }
+  } else {
+    result.appendHTML(true).html {
+      head {
+        title { +"VST Chip" }
+        meta {
+          httpEquiv = "refresh"
+          content = "0; url=/patch/$patch"
+        }
+      }
+      body {
+        +"Redirecting to patch $patch..."
+      }
+    }
+  }
+
+  return result.toString()
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/web/RequestHandler.kt

@@ -0,0 +1,134 @@
+package nl.astraeus.vst.base.web
+
+import io.undertow.Handlers.websocket
+import io.undertow.server.HttpHandler
+import io.undertow.server.HttpServerExchange
+import io.undertow.server.handlers.PathHandler
+import io.undertow.server.handlers.resource.PathResourceManager
+import io.undertow.server.handlers.resource.ResourceHandler
+import io.undertow.server.session.Session
+import io.undertow.server.session.SessionConfig
+import io.undertow.server.session.SessionManager
+import io.undertow.websockets.WebSocketConnectionCallback
+import io.undertow.websockets.core.AbstractReceiveListener
+import io.undertow.websockets.core.BufferedBinaryMessage
+import io.undertow.websockets.core.BufferedTextMessage
+import io.undertow.websockets.core.WebSocketChannel
+import io.undertow.websockets.core.WebSockets
+import io.undertow.websockets.spi.WebSocketHttpExchange
+import nl.astraeus.vst.base.db.Database
+import nl.astraeus.vst.base.db.PatchDao
+import nl.astraeus.vst.base.db.PatchEntity
+import java.nio.file.Paths
+
+class WebsocketHandler(
+  val session: Session?
+) : AbstractReceiveListener(), WebSocketConnectionCallback {
+
+  override fun onConnect(exchange: WebSocketHttpExchange, channel: WebSocketChannel) {
+    channel.receiveSetter.set(this)
+    channel.resumeReceives()
+  }
+
+  override fun onFullTextMessage(channel: WebSocketChannel, message: BufferedTextMessage) {
+    val vstSession = session?.getAttribute("html-session") as? VstSession
+
+    val data = message.data
+    val commandLength = data.indexOf('\n')
+    if (commandLength > 0) {
+      val command = data.substring(0, commandLength)
+      val value = data.substring(commandLength + 1)
+
+      when (command) {
+        "SAVE" -> {
+          val patchId = vstSession?.patchId
+          if (patchId != null) {
+            Database.transaction {
+              val patchEntity = PatchDao.findById(patchId)
+
+              if (patchEntity != null) {
+                PatchDao.update(patchEntity.copy(patch = value))
+              } else {
+                PatchDao.insert(PatchEntity(0, patchId, value))
+              }
+            }
+            WebSockets.sendText("SAVED\n$patchId", channel, null)
+          }
+        }
+
+        "LOAD" -> {
+          val patchId = vstSession?.patchId
+          if (patchId != null) {
+            Database.transaction {
+              val patchEntity = PatchDao.findById(patchId)
+
+              if (patchEntity != null) {
+                WebSockets.sendText("LOAD\n${patchEntity.patch}", channel, null)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  override fun onFullBinaryMessage(channel: WebSocketChannel?, message: BufferedBinaryMessage?) {
+    // do nothing yet
+  }
+}
+
+object WebsocketConnectHandler : HttpHandler {
+  override fun handleRequest(exchange: HttpServerExchange) {
+    val sessionManager = exchange.getAttachment(SessionManager.ATTACHMENT_KEY)
+    val sessionConfig = exchange.getAttachment(SessionConfig.ATTACHMENT_KEY)
+
+    val httpSession: Session? = sessionManager.getSession(exchange, sessionConfig)
+
+    websocket(WebsocketHandler(httpSession)).handleRequest(exchange)
+  }
+}
+
+class PatchHandler(
+  val title: String,
+  val scriptName: String,
+) : HttpHandler {
+  override fun handleRequest(exchange: HttpServerExchange) {
+    if (exchange.requestPath.startsWith("/patch/")) {
+      val patchId = exchange.requestPath.substring(7)
+      val sessionManager = exchange.getAttachment(SessionManager.ATTACHMENT_KEY)
+      val sessionConfig = exchange.getAttachment(SessionConfig.ATTACHMENT_KEY)
+      var httpSession: Session? = sessionManager.getSession(exchange, sessionConfig)
+
+      if (httpSession == null) {
+        httpSession = sessionManager.createSession(exchange, sessionConfig)
+      }
+      httpSession?.setAttribute("html-session", VstSession(patchId))
+
+      exchange.responseSender.send(generateIndex(title, scriptName, null))
+    } else {
+      val patchId = generateId()
+
+      exchange.responseSender.send(generateIndex(title, scriptName, patchId))
+    }
+  }
+}
+
+class RequestHandler(
+  title: String,
+  scriptName: String,
+) : HttpHandler {
+  val resourceHandler = ResourceHandler(PathResourceManager(Paths.get("web")))
+  val pathHandler = PathHandler(resourceHandler)
+
+  init {
+    val patchHandler = PatchHandler(title, scriptName)
+    pathHandler.addExactPath("/", patchHandler)
+    pathHandler.addExactPath("/index.html", patchHandler)
+    pathHandler.addPrefixPath("/patch", patchHandler)
+    pathHandler.addExactPath("/ws", WebsocketConnectHandler)
+  }
+
+  override fun handleRequest(exchange: HttpServerExchange) {
+    pathHandler.handleRequest(exchange)
+  }
+}

src/jvmMain/kotlin/nl/astraeus/vst/base/web/Session.kt

@@ -0,0 +1,5 @@
+package nl.astraeus.vst.base.web
+
+class VstSession(
+  val patchId: String
+)

src/jvmMain/kotlin/nl/astraeus/vst/base/web/UndertowServer.kt

@@ -0,0 +1,35 @@
+package nl.astraeus.vst.base.web
+
+import io.undertow.Undertow
+import io.undertow.UndertowOptions
+import io.undertow.server.session.InMemorySessionManager
+import io.undertow.server.session.SessionAttachmentHandler
+import io.undertow.server.session.SessionCookieConfig
+import nl.astraeus.vst.base.Settings
+
+object UndertowServer {
+  var server: Undertow? = null
+
+  fun start(
+    title: String,
+    scriptName: String,
+  ) {
+    val sessionHandler = SessionAttachmentHandler(
+      InMemorySessionManager("vst-session-manager"),
+      SessionCookieConfig()
+    )
+    sessionHandler.setNext(RequestHandler(title, scriptName))
+
+    val server = Undertow.builder()
+      .addHttpListener(Settings.port, "localhost")
+      .setIoThreads(4)
+      .setHandler(sessionHandler)
+      .setServerOption(UndertowOptions.SHUTDOWN_TIMEOUT, 1000)
+      .build()
+
+    println("Starting server at port ${Settings.port}...")
+
+    server?.start()
+  }
+
+}