feat(websocket): introduce authwithtoken

.github/workflows/check.yml

@@ -9,6 +9,11 @@ on:
         type: string
         required: false
         default: '.'
+    secrets:
+      GRADLE_ENCRYPTION_KEY:
+        required: true
+      CODECOV_TOKEN:
+        required: false
 
 jobs:
   gradle-check:
@@ -36,7 +41,7 @@ jobs:
         run: ./gradlew -p ${{ inputs.projectDir }} koverXmlReport
 
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         if: ${{ inputs.projectDir == '.' }}
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/java-example-check.yml

@@ -11,3 +11,4 @@ jobs:
     uses: ./.github/workflows/check.yml
     with:
       projectDir: 'examples/java'
+    secrets: inherit

.github/workflows/kotlin-example-check.yml

@@ -11,3 +11,4 @@ jobs:
     uses: ./.github/workflows/check.yml
     with:
       projectDir: 'examples/kotlin'
+    secrets: inherit

.github/workflows/loxone-client-check.yml

@@ -14,3 +14,4 @@ on:
 jobs:
   call-check:
     uses: ./.github/workflows/check.yml
+    secrets: inherit

examples/kotlin/src/main/kotlin/LoxoneClientExample.kt

@@ -6,13 +6,13 @@ import cz.smarteon.loxone.LoxoneEndpoint
 import cz.smarteon.loxone.LoxoneProfile
 import cz.smarteon.loxone.LoxoneTokenAuthenticator
 import cz.smarteon.loxone.callForMsg
-import cz.smarteon.loxone.ktor.HttpLoxoneClient
+import cz.smarteon.loxone.ktor.KtorHttpLoxoneClient
 import cz.smarteon.loxone.message.ApiInfo
 
 
 suspend fun main(args: Array<String>) {
     val endpoint = LoxoneEndpoint.fromUrl(args[0])
-    val loxoneClient: LoxoneClient = HttpLoxoneClient(
+    val loxoneClient: LoxoneClient = KtorHttpLoxoneClient(
         endpoint,
         LoxoneTokenAuthenticator(
             LoxoneProfile(

examples/kotlin/src/main/kotlin/LoxoneWebsocketClientExample.kt

@@ -6,13 +6,13 @@ import cz.smarteon.loxone.LoxoneEndpoint
 import cz.smarteon.loxone.LoxoneProfile
 import cz.smarteon.loxone.LoxoneTokenAuthenticator
 import cz.smarteon.loxone.callForMsg
-import cz.smarteon.loxone.ktor.WebsocketLoxoneClient
+import cz.smarteon.loxone.ktor.KtorWebsocketLoxoneClient
 import cz.smarteon.loxone.message.ApiInfo
 
 
 suspend fun main(args: Array<String>) {
     val endpoint = LoxoneEndpoint.fromUrl(args[0])
-    val loxoneClient: LoxoneClient = WebsocketLoxoneClient(
+    val loxoneClient: LoxoneClient = KtorWebsocketLoxoneClient(
         endpoint,
         LoxoneTokenAuthenticator(
             LoxoneProfile(

src/commonMain/kotlin/LoxoneClient.kt

@@ -13,6 +13,9 @@ interface LoxoneClient {
     suspend fun close()
 }
 
+interface HttpLoxoneClient : LoxoneClient
+interface WebsocketLoxoneClient : LoxoneClient
+
 suspend inline fun <reified VAL : LoxoneMsgVal> LoxoneClient.callForMsg(command: LoxoneMsgCommand<VAL>): VAL {
     val msg = call(command)
     return if (msg.code == command.expectedCode) {

src/commonMain/kotlin/LoxoneCommands.kt

@@ -2,6 +2,9 @@ package cz.smarteon.loxone
 
 import cz.smarteon.loxone.message.EmptyLoxoneMsgVal
 import cz.smarteon.loxone.message.LoxoneMsg
+import cz.smarteon.loxone.message.SimpleLoxoneMsgCommand
+import cz.smarteon.loxone.message.Token
+import cz.smarteon.loxone.message.TokenPermission
 import cz.smarteon.loxone.message.sysCommand
 import kotlin.jvm.JvmStatic
 
@@ -16,7 +19,7 @@ import kotlin.jvm.JvmStatic
 object LoxoneCommands {
 
     /**
-     * Keep alive command used solely in [cz.smarteon.loxone.ktor.WebsocketLoxoneClient] to ensure connection alive
+     * Keep alive command used solely in [cz.smarteon.loxone.WebsocketLoxoneClient] to ensure connection alive
      * functionality.
      */
     val KEEP_ALIVE = object : NoResponseCommand("keepalive") {}
@@ -26,6 +29,44 @@ object LoxoneCommands {
      */
     object Tokens {
 
+        /**
+         * Command to get new token.
+         * @param credentialsHash The credentials hash obtained by [LoxoneCrypto.loxoneHashing]
+         * from [LoxoneCredentials].
+         * @param user The user to get the token for.
+         * @param permission The permission of the token.
+         * @param clientId Unique identifier of this client.
+         * @param clientInfo Information about this client.
+         */
+        @JvmStatic
+        fun get(
+            credentialsHash: String,
+            user: String,
+            permission: TokenPermission,
+            clientId: String = LoxoneClientSettings.DEFAULT_CLIENT_ID,
+            clientInfo: String = LoxoneClientSettings.DEFAULT_CLIENT_INFO
+        ) = sysCommand<Token>(
+            "getjwt",
+            credentialsHash,
+            user,
+            permission.id.toString(),
+            clientId,
+            clientInfo,
+            authenticated = false
+        )
+
+        /**
+         * Command to authenticate with token.
+         * @param tokenHash The token hash to authenticate with.
+         * @param user The user to authenticate as.
+         */
+        @JvmStatic
+        fun auth(tokenHash: String, user: String) = SimpleLoxoneMsgCommand(
+            listOf("authwithtoken", tokenHash, user),
+            Token::class,
+            authenticated = false
+        )
+
         /**
          * Command to kill token.
          * @param tokenHash The token hash to kill.

src/commonMain/kotlin/LoxoneTokenAuthenticator.kt

@@ -5,7 +5,6 @@
 import cz.smarteon.loxone.message.Hashing
 import cz.smarteon.loxone.message.Hashing.Companion.commandForUser
 import cz.smarteon.loxone.message.Token
-import cz.smarteon.loxone.message.Token.Companion.commandGetToken
 import cz.smarteon.loxone.message.TokenState
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.sync.Mutex
@@ -31,49 +30,65 @@
 
     private var token: Token? by Delegates.observable(repository.getToken(profile)) { _, _, newValue ->
         if (newValue != null) {
+            logger.info {
+                "Got loxone token, valid until: ${newValue.validUntil}, " +
+                    "seconds to expire: ${newValue.secondsToExpireFromNow()}"
+            }
             repository.putToken(profile, newValue)
         } else {
             repository.removeToken(profile)
         }
     }
 
-    suspend fun ensureAuthenticated(client: LoxoneClient) = execConditionalWithMutex({ !TokenState(token).isUsable }) {
-        if (hashing == null) {
-            hashing = client.callForMsg(commandForUser(user))
-        }
+    private val authWebsockets = mutableSetOf<WebsocketLoxoneClient>()
 
-        val state = TokenState(token)
-
-        when {
-            state.isExpired -> {
-                logger.debug { "Token expired, requesting new one" }
-                token = client.callForMsg(
-                    commandGetToken(
-                        loxoneHashing(profile.credentials!!.password, checkNotNull(hashing), "getttoken", user),
-                        user,
-                        settings.tokenPermission,
-                        settings.clientId,
-                        settings.clientInfo
-                    )
-                )
-                logger.debug { "Received token: $token" }
+    suspend fun ensureAuthenticated(client: LoxoneClient) =
+        execConditionalWithMutex({ !TokenState(token).isUsable || !authWebsockets.contains(client) }) {
+            if (hashing == null) {
+                hashing = client.callForMsg(commandForUser(user))
             }
 
-            state.needsRefresh -> {
-                TODO("refresh and merge token")
-            }
+            val state = TokenState(token)
+
+            when {
+                state.isExpired -> {
+                    logger.debug { "Token expired, requesting new one" }
+                    token = client.callForMsg(
+                        Tokens.get(
+                            loxoneHashing(profile.credentials!!.password, checkNotNull(hashing), "getttoken", user),
+                            user,
+                            settings.tokenPermission,
+                            settings.clientId,
+                            settings.clientInfo
+                        )
+                    )
+                    logger.debug { "Received token: $token" }
+                    if (client is WebsocketLoxoneClient) {
+                        authWebsockets.add(client)
+                    }
+                }
+
+                state.needsRefresh -> {
+                    TODO("refresh and merge token")
+                }
 
-            else -> {
-                // TODO("send authwithtoken if websockets")
+                else -> {
+                    if (client is WebsocketLoxoneClient) {
+                        logger.debug { "Authenticating websocket with token $token" }
+                        val authResponse = client.callForMsg(Tokens.auth(tokenHash("authenticate"), user))
+                        token = token!!.merge(authResponse)
+                        authWebsockets.add(client)
+                    }
+                }
             }
         }
-    }
 
     suspend fun killToken(client: LoxoneClient) = execConditionalWithMutex({ TokenState(token).isUsable }) {
         logger.debug { "Going to kill token $token" }
         client.callForMsg(Tokens.kill(tokenHash("killtoken"), user))
         logger.info { "Token killed" }
         token = null
+        authWebsockets.remove(client)
     }
 
     suspend fun close(client: LoxoneClient) {

src/commonMain/kotlin/ktor/HttpLoxoneClient.kt → src/commonMain/kotlin/ktor/KtorHttpLoxoneClient.kt

@@ -2,7 +2,7 @@ package cz.smarteon.loxone.ktor
 
 import cz.smarteon.loxone.Codec
 import cz.smarteon.loxone.Command
-import cz.smarteon.loxone.LoxoneClient
+import cz.smarteon.loxone.HttpLoxoneClient
 import cz.smarteon.loxone.LoxoneEndpoint
 import cz.smarteon.loxone.LoxoneResponse
 import cz.smarteon.loxone.LoxoneTokenAuthenticator
@@ -17,11 +17,11 @@ import io.ktor.http.*
 import io.ktor.serialization.kotlinx.json.*
 import kotlin.jvm.JvmOverloads
 
-class HttpLoxoneClient internal constructor(
+class KtorHttpLoxoneClient internal constructor(
     private val endpoint: LoxoneEndpoint,
     private val authenticator: LoxoneTokenAuthenticator? = null,
     httpClientEngine: HttpClientEngine? = null
-) : LoxoneClient {
+) : HttpLoxoneClient {
 
     @JvmOverloads constructor(
         endpoint: LoxoneEndpoint,
@@ -40,7 +40,7 @@ class HttpLoxoneClient internal constructor(
         install(Logging) {
             logger = object : Logger {
                 override fun log(message: String) {
-                    this@HttpLoxoneClient.logger.debug { message }
+                    this@KtorHttpLoxoneClient.logger.debug { message }
                 }
             }
             level = LogLevel.ALL
@@ -72,7 +72,7 @@ class HttpLoxoneClient internal constructor(
     override suspend fun close() {
         try {
             logger.debug { "Closing authenticator" }
-            authenticator?.close(this@HttpLoxoneClient)
+            authenticator?.close(this@KtorHttpLoxoneClient)
         } catch (e: Exception) {
             logger.error(e) { "Error closing authenticator" }
         }

src/commonMain/kotlin/ktor/WebsocketLoxoneClient.kt → src/commonMain/kotlin/ktor/KtorWebsocketLoxoneClient.kt

@@ -3,11 +3,11 @@ package cz.smarteon.loxone.ktor
 import cz.smarteon.loxone.Codec
 import cz.smarteon.loxone.Codec.loxJson
 import cz.smarteon.loxone.Command
-import cz.smarteon.loxone.LoxoneClient
 import cz.smarteon.loxone.LoxoneCommands
 import cz.smarteon.loxone.LoxoneEndpoint
 import cz.smarteon.loxone.LoxoneResponse
 import cz.smarteon.loxone.LoxoneTokenAuthenticator
+import cz.smarteon.loxone.WebsocketLoxoneClient
 import cz.smarteon.loxone.message.MessageHeader
 import cz.smarteon.loxone.message.MessageKind
 import io.github.oshai.kotlinlogging.KotlinLogging
@@ -34,12 +34,12 @@ import kotlin.jvm.JvmOverloads
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
-class WebsocketLoxoneClient internal constructor(
+class KtorWebsocketLoxoneClient internal constructor(
     private val client: HttpClient,
     private val endpoint: LoxoneEndpoint? = null,
     private val authenticator: LoxoneTokenAuthenticator? = null,
     dispatcher: CoroutineDispatcher = Dispatchers.Default
-) : LoxoneClient {
+) : WebsocketLoxoneClient {
 
     @JvmOverloads constructor(
         endpoint: LoxoneEndpoint,
@@ -85,7 +85,7 @@ class WebsocketLoxoneClient internal constructor(
     override suspend fun close() {
         try {
             logger.debug { "Closing authenticator" }
-            authenticator?.close(this@WebsocketLoxoneClient)
+            authenticator?.close(this@KtorWebsocketLoxoneClient)
         } catch (e: Exception) {
             logger.error(e) { "Error closing authenticator" }
         }

src/commonMain/kotlin/message/MessageHeader.kt

@@ -6,7 +6,7 @@ package cz.smarteon.loxone.message
  * @param kind message kind
  * @param sizeEstimated whether message size is estimated or calculated, `false` if message size is exact
  * @param messageSize number of bytes in message payload
- * @see[cz.smarteon.loxone.ktor.WebsocketLoxoneClient]
+ * @see[cz.smarteon.loxone.WebsocketLoxoneClient]
  */
 internal data class MessageHeader(
     val kind: MessageKind,