Fixed a lot

Author: Robert Winkler

kotlin-wot-binding-http/src/main/kotlin/http/HttpProtocolClient.kt

@@ -1,12 +1,11 @@
 package ai.ancf.lmos.wot.binding.http
 
-import ai.ancf.lmos.wot.Servient
+import ai.ancf.lmos.wot.content.Content
 import ai.ancf.lmos.wot.security.BasicSecurityScheme
 import ai.ancf.lmos.wot.security.BearerSecurityScheme
 import ai.ancf.lmos.wot.security.NoSecurityScheme
 import ai.ancf.lmos.wot.security.SecurityScheme
 import ai.ancf.lmos.wot.thing.form.Form
-import ai.anfc.lmos.wot.binding.Content
 import ai.anfc.lmos.wot.binding.ProtocolClient
 import ai.anfc.lmos.wot.binding.ProtocolClientException
 import io.ktor.client.*
@@ -58,15 +57,6 @@ class HttpProtocolClient(
         }
     }.flowOn(Dispatchers.IO) // Run the flow on IO thread, as it involves network operations
 
-    override fun supports(scheme: String) = scheme == "http" || scheme == "https"
-
-    override suspend fun start(servient: Servient) {
-    }
-
-    override suspend fun stop() {
-        client.close()
-    }
-
     override fun setSecurity(metadata: List<SecurityScheme>, credentials: Map<String, String>): Boolean {
         if (metadata.isEmpty()) {
             log.warn("HttpClient without security")

kotlin-wot-binding-http/src/main/kotlin/http/HttpProtocolClientFactory.kt

@@ -0,0 +1,24 @@
+package ai.ancf.lmos.wot.binding.http
+
+import ai.anfc.lmos.wot.binding.ProtocolClientFactory
+
+/**
+ * Creates new [HttpProtocolClient] instances.
+ */
+open class HttpProtocolClientFactory : ProtocolClientFactory {
+    override fun toString(): String {
+        return "HttpClient"
+    }
+    override val scheme: String
+        get() = "http"
+    override val client: HttpProtocolClient
+        get() = HttpProtocolClient()
+
+    override suspend fun init() {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun destroy() {
+        TODO("Not yet implemented")
+    }
+}

kotlin-wot-binding-http/src/main/kotlin/http/HttpProtocolServer.kt

@@ -1,13 +1,13 @@
 package ai.ancf.lmos.wot.binding.http
 
 import ai.ancf.lmos.wot.Servient
-import ai.ancf.lmos.wot.thing.ContentManager
+import ai.ancf.lmos.wot.content.Content
+import ai.ancf.lmos.wot.content.ContentCodecException
+import ai.ancf.lmos.wot.content.ContentManager
 import ai.ancf.lmos.wot.thing.ExposedThing
-import ai.ancf.lmos.wot.thing.action.ExposedThingAction
 import ai.ancf.lmos.wot.thing.form.Form
 import ai.ancf.lmos.wot.thing.form.Operation
 import ai.ancf.lmos.wot.thing.schema.InteractionAffordance
-import ai.anfc.lmos.wot.binding.Content
 import ai.anfc.lmos.wot.binding.ProtocolServer
 import ai.anfc.lmos.wot.binding.ProtocolServerException
 import com.fasterxml.jackson.databind.DeserializationFeature
@@ -22,12 +22,13 @@ import io.ktor.server.request.*
 import io.ktor.server.routing.*
 import io.ktor.util.reflect.*
 import org.slf4j.LoggerFactory
+import java.util.concurrent.ExecutionException
 import kotlin.collections.set
 
 /**
  * Allows exposing Things via HTTP.
  */
-class HttpProtocolServer(
+open class HttpProtocolServer(
     private val wait: Boolean = false,
     private val bindHost: String = "0.0.0.0",
     private val bindPort: Int = 8080,
@@ -36,7 +37,7 @@ class HttpProtocolServer(
     val things: MutableMap<String, ExposedThing> = mutableMapOf()
     var started = false
     private var server: EmbeddedServer<*, *>? = null
-    private val actualAddresses: List<String> = listOf()
+    private var actualAddresses: List<String> = listOf("http://$bindHost:$bindPort")
 
     companion object {
         private val log = LoggerFactory.getLogger(HttpProtocolServer::class.java)
@@ -57,16 +58,16 @@ class HttpProtocolServer(
     }
 
     // Expose a thing
-    override suspend fun expose(thing: ExposedThing) {
+    override fun expose(thing: ExposedThing) {
         if (!started) throw ProtocolServerException("Server has not started yet")
 
         log.info("Exposing thing '{}'", thing.id)
         things[thing.id] = thing
 
         for (address in actualAddresses) {
-            for (contentType in ContentManager.getOfferedMediaTypes()) {
+            for (contentType in ContentManager.offeredMediaTypes) {
                 // make reporting of all properties optional?
-                val href = (address + "/" + thing.id).toString() + "/all/properties"
+                val href = "$address/${thing.id}/all/properties"
                 val form = Form(href = href, contentType = contentType, op =  listOf( Operation.READ_ALL_PROPERTIES,
                     Operation.READ_MULTIPLE_PROPERTIES))
 
@@ -80,10 +81,8 @@ class HttpProtocolServer(
         }
     }
 
-    fun exposeProperties(thing: ExposedThing, address: String, contentType: String) {
-        val properties = thing.exposedProperties
-
-        properties.forEach { (name, property) ->
+    internal fun exposeProperties(thing: ExposedThing, address: String, contentType: String) {
+        thing.properties.forEach { (name, property) ->
 
             val href = getHrefWithVariablePattern(address, thing, "properties", name, property)
 
@@ -96,7 +95,7 @@ class HttpProtocolServer(
 
             // Create the main form and add it to the property
             val form = Form(href = href, contentType = contentType, op = operations)
-            property.forms?.plusAssign(form)
+            property.forms += form
             log.debug("Assign '{}' to Property '{}'", href, name)
 
             // If the property is observable, add an additional form with an observable href
@@ -108,15 +107,14 @@ class HttpProtocolServer(
                     op = listOf(Operation.OBSERVE_PROPERTY),
                     subprotocol = "longpoll"
                 )
-                property.forms?.plusAssign(observableForm)
+                property.forms += observableForm
                 log.debug("Assign '{}' to observe Property '{}'", observableHref, name)
             }
         }
     }
 
-    fun exposeActions(thing: ExposedThing, address: String, contentType: String) {
-        val actions: Map<String, ExposedThingAction<*, *>> = thing.exposedActions
-        actions.forEach { (name, action) ->
+    internal fun exposeActions(thing: ExposedThing, address: String, contentType: String) {
+        thing.actions.forEach { (name, action) ->
             val href: String = getHrefWithVariablePattern(address, thing, "actions", name, action)
             // Initialize the form using named parameters
             val form = Form(
@@ -126,14 +124,13 @@ class HttpProtocolServer(
             )
 
             // Add the form to the action
-            action.forms?.plusAssign(form)
+            action.forms += form
             log.debug("Assign '{}' to Action '{}'", href, name)
         }
     }
 
-    fun exposeEvents(thing: ExposedThing, address: String, contentType: String) {
-        val events = thing.exposedEvents
-        events.forEach { (name, event) ->
+    internal fun exposeEvents(thing: ExposedThing, address: String, contentType: String) {
+        thing.events.forEach { (name, event) ->
             val href = getHrefWithVariablePattern(address, thing, "events", name, event)
 
             // Create the form using named parameters directly
@@ -145,7 +142,7 @@ class HttpProtocolServer(
             )
 
             // Add the form to the event
-            event.forms?.plusAssign(form)
+            event.forms += form
             log.debug("Assign '{}' to Event '{}'", href, name)
         }
     }
@@ -159,7 +156,7 @@ class HttpProtocolServer(
     ): String {
         var variables = ""
         val uriVariables = interaction.uriVariables?.keys
-        if (uriVariables != null) {
+        if (!uriVariables.isNullOrEmpty()) {
             variables = "{?" + java.lang.String.join(",", uriVariables) + "}"
         }
         return "$address/${thing.id}/$type/$interactionName$variables"
@@ -208,9 +205,23 @@ fun Application.setupRouting(servient: Servient) {
                     val id = call.parameters["id"] ?: return@get call.response.status(HttpStatusCode.BadRequest)
                     val propertyName = call.parameters["name"]
                     val thing = servient.things[id] ?: return@get call.response.status(HttpStatusCode.NotFound)
-                    val property = thing.exposedProperties[propertyName]
+                    val property = thing.properties[propertyName]
                     if (property != null) {
-                       // call.respond(property.read())
+                        if (!property.writeOnly) {
+                             try {
+                                val value = property.read()
+                                //contentType = getOrDefaultRequestContentType(call.request)
+                                //val content = ContentManager.valueToContent(value, contentType.toString())
+                                call.respond(value, typeInfo<Any>())
+                            }
+                             catch (e: ContentCodecException) {
+                                 call.response.status(HttpStatusCode.InternalServerError)
+                            } catch (e: ExecutionException) {
+                                call.response.status(HttpStatusCode.InternalServerError)
+                            }
+                        } else {
+                            call.response.status(HttpStatusCode.BadRequest)
+                        }
                     } else {
                         call.response.status(HttpStatusCode.NotFound)
                     }
@@ -219,15 +230,13 @@ fun Application.setupRouting(servient: Servient) {
                     val id = call.parameters["id"] ?: return@put call.response.status(HttpStatusCode.BadRequest)
                     val propertyName = call.parameters["name"]
                     val thing = servient.things[id] ?: return@put call.response.status(HttpStatusCode.NotFound)
-                    val property = thing.exposedProperties[propertyName]
+                    val property = thing.properties[propertyName]
                     if (property != null) {
                         if (!property.readOnly) {
-                            val contentType = getOrDefaultRequestContentType(call.request)
-                            val content = Content(contentType.toString(), call.receiveText())
-                            val input = ContentManager.contentToValue(content, property)
-
-                            //val newValue = property.write(input)
-                            //call.respond(newValue)
+                            //val contentType = getOrDefaultRequestContentType(call.request)
+                            //val content = Content(contentType.toString(), call.receiveChannel().toByteArray())
+                            //val newValue = property.write(call.receive())
+                            //call.respond(newValue, typeInfo<Any>())
                         } else {
                             call.response.status(HttpStatusCode.BadRequest)
                         }
@@ -240,10 +249,26 @@ fun Application.setupRouting(servient: Servient) {
                 val id = call.parameters["id"] ?: return@post call.response.status(HttpStatusCode.BadRequest)
                 val actionName = call.parameters["name"]
                 val thing = servient.things[id] ?: return@post call.response.status(HttpStatusCode.NotFound)
-                val action = thing.exposedActions[actionName]
+                val action = thing.actions[actionName]
                 if (action != null) {
-                    val input = call.receive<Any>()
-                    call.respond("TODO Return action response", typeInfo<String>())
+                    val requestContentType = getOrDefaultRequestContentType(call.request).toString()
+                    val content = Content(requestContentType, call.receive())
+
+                    if(action.input != null){
+                        val input = ContentManager.contentToValue(content, action.input!!)
+                        val newValue = action.invokeAction(null, null)
+                        call.respond(newValue, typeInfo<Any>())
+                    }else{
+                        val newValue = action.invokeAction(null, null)
+                        call.respond(newValue, typeInfo<Any>())
+                    }
+
+
+                    /*
+                    val options = mapOf<String, Map<String, Any>>(
+                        "uriVariables" to parseUrlParameters(request.queryMap().toMap(), action.uriVariables)
+                    )
+                    */
                 } else {
                     call.response.status(HttpStatusCode.NotFound)
                 }
@@ -272,4 +297,25 @@ private fun getOrDefaultRequestContentType(request: RoutingRequest): ContentType
     } else {
         contentType
     }
-}
+}
+
+/*
+private fun parseUrlParameters(
+    urlParams: Map<String, Array<String>>,
+    uriVariables: MutableMap<String, DataSchema<Any>>?
+): Map<String, Any> {
+    return urlParams.mapNotNull { (name, urlValue) ->
+        val uriVariable = uriVariables?.get(name)
+        val type = uriVariable["type"]
+
+        val value: Any = when (type) {
+            "integer", "number" -> urlValue.firstOrNull()?.toIntOrNull()
+            "string" -> urlValue.firstOrNull()
+            else -> {
+                null
+            }
+        }
+        name to value
+    }.toMap()
+}
+*/

kotlin-wot-binding-http/src/main/kotlin/http/HttpsProtocolClientFactory.kt

@@ -0,0 +1,14 @@
+package ai.ancf.lmos.wot.binding.http
+
+/**
+ * Creates new [HttpProtocolClient] instances that allow consuming Things via HTTPS.
+ */
+class HttpsProtocolClientFactory() : HttpProtocolClientFactory() {
+
+    override fun toString(): String {
+        return "HttpsClient"
+    }
+
+    override val scheme: String
+        get() = "https"
+}

kotlin-wot-binding-http/src/main/kotlin/http/routes/AbstractInteractionRoute.kt

@@ -0,0 +1,47 @@
+package ai.ancf.lmos.wot.binding.http.routes
+
+import ai.ancf.lmos.wot.Servient
+import ai.ancf.lmos.wot.thing.ExposedThing
+import io.ktor.http.*
+import io.ktor.server.request.*
+import io.ktor.server.routing.*
+import io.ktor.util.*
+
+internal abstract class AbstractInteractionRoute(private val servient: Servient, private val securityScheme: String, private val  things: Map<String, ExposedThing>
+) : AbstractRoute() {
+
+    private fun checkCredentials(securityScheme: String?, id: String, request: RoutingRequest): Boolean {
+        if (securityScheme == null) {
+            // No security configured -> always authorized
+            return true
+        }
+
+        log.debug("HttpServer checking credentials for '{}'", id)
+        val credentials = servient.getCredentials(id) as? Map<*, *> ?: return false
+
+        val header = request.header(HttpHeaders.Authorization)?.takeIf { it.isNotBlank() }
+        return when (securityScheme) {
+            "Basic" -> {
+                header?.removePrefix("Basic ")?.decodeBase64Bytes()?.toString(Charsets.UTF_8)?.let { decodedHeader ->
+                    val (givenUsername, givenPassword) = decodedHeader.split(":", limit = 2)
+                    val requiredUsername = credentials["username"] as? String
+                    val requiredPassword = credentials["password"] as? String
+                    givenUsername == requiredUsername && givenPassword == requiredPassword
+                } ?: run {
+                    log.warn("Unable to decode username and password from authorization header")
+                    false
+                }
+            }
+
+            "Bearer" -> {
+                val requiredToken = credentials["token"] as? String
+                header?.removePrefix("Bearer ") == requiredToken
+            }
+
+            else -> {
+                log.warn("Unknown security scheme provided. Decline access.")
+                false
+            }
+        }
+    }
+}