SOLR-17659: Add basic auth support in new UI (#3435)

* Add basic auth support

* Rename "unauthenticated" component resources

Rename "unauthenticated" component resources to "authentication"

* Fix tab navigation and improve user feedback and context

* Add tests and implement missing logic

* Add logout functionality and merge main component instantiation functions

Author: malliaridis

gradle/libs.versions.toml

@@ -150,7 +150,7 @@ kotlinx-browser = "0.3"
 kotlinx-coroutines = "1.10.1"
 kotlinx-datetime = "0.6.2"
 kotlinx-serialization = "1.8.0"
-ktor = "3.1.0"
+ktor = "3.2.2"
 langchain4j = "0.35.0"
 # @keep Link checker version used in ref-guide
 link-checker = "1.4.2"
@@ -438,6 +438,7 @@ kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serializa
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
 ktor-client-contentNegotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
+ktor-client-auth = { module = "io.ktor:ktor-client-auth", version.ref = "ktor" }
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-mock = { module = "io.ktor:ktor-client-mock", version.ref = "ktor" }
 ktor-client-serialization-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }

solr/ui/build.gradle.kts

@@ -91,6 +91,7 @@ kotlin {
                 implementation(libs.mvikotlin.main)
                 implementation(libs.mvikotlin.logging)
 
+                implementation(libs.ktor.client.auth)
                 implementation(libs.ktor.client.core)
                 implementation(libs.ktor.client.cio)
                 implementation(libs.ktor.client.contentNegotiation)

solr/ui/gradle.lockfile

@@ -19,18 +19,24 @@
 <resources>
   <!-- Actions (action) -->
   <string name="action_connect">Connect</string>
+  <string name="action_go_back">Go Back</string>
   <string name="action_logout">Logout</string>
+  <string name="action_sign_in_with_credentials">Sign In with Credentials</string>
 
   <!-- Content Descriptions (cd) -->
+  <string name="cd_back_navigation">Back Navigation</string>
   <string name="cd_solr_logo">Solr Logo</string>
 
   <!-- Descriptions (desc) -->
   <string name="desc_to_get_started">To get started, please provide a Solr host URL:</string>
+  <string name="desc_solr_instance_with_auth">The Solr instance %1$s has enabled authentication.</string>
+  <string name="desc_sign_in_with_credentials_to_realm">To authenticate you may use your credentials for the realm %1$s.</string>
 
   <!-- Errors (error) -->
   <string name="error_invalid_url">The provided URL is invalid.</string>
   <string name="error_solr_host_not_found">Solr host could not be found.</string>
   <string name="error_unknown">An unknown error occurred.</string>
+  <string name="error_invalid_credentials">Invalid credentials. Please try again.</string>
 
   <!-- Navigation (nav) -->
   <string name="nav_cluster">Cluster</string>
@@ -49,8 +55,10 @@
 
   <!-- Titles (title) -->
   <string name="title_welcome_to_solr">Welcome to Solr Admin UI</string>
+  <string name="title_sign_in_to_solr">Sign In to Solr</string>
 
   <!-- General Text -->
+  <string name="authenticating">Authenticating...</string>
   <string name="community">Community</string>
   <string name="documentation">Documentation</string>
   <string name="irc">IRC</string>
@@ -60,5 +68,9 @@
   <string name="support">Support</string>
   <string name="connecting">Connecting...</string>
 
+  <!-- Input Labels -->
+  <string name="label_username">Username</string>
+  <string name="label_password">Password</string>
+
   <!-- Uncategorized -->
 </resources>

solr/ui/src/commonMain/composeResources/values/strings.xml

@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.solr.ui.components.auth
+
+import com.arkivanov.decompose.router.slot.ChildSlot
+import com.arkivanov.decompose.value.Value
+import io.ktor.http.Url
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.serialization.Serializable
+import org.apache.solr.ui.domain.AuthMethod
+import org.apache.solr.ui.domain.AuthOption
+import org.jetbrains.compose.resources.StringResource
+
+/**
+ * The authentication component takes care of the authentication processes. This typically includes
+ * user authentication with credentials, tokens or certificates.
+ */
+interface AuthenticationComponent {
+
+    /**
+     * Component state flow.
+     */
+    val model: StateFlow<Model>
+
+    /**
+     * A child slot that holds the [BasicAuthComponent] for user authentication with credentials
+     * (basic auth) if it is supported.
+     */
+    val basicAuthSlot: Value<ChildSlot<BasicAuthConfiguration, BasicAuthComponent>>
+
+    @Serializable
+    data class BasicAuthConfiguration(val method: AuthMethod.BasicAuthMethod = AuthMethod.BasicAuthMethod())
+
+    /**
+     * Aborts the authentication attempt.
+     */
+    fun onAbort()
+
+    /**
+     * Model data class that represents the component state.
+     *
+     * @property url URL of the Solr instance the user is trying to connect.
+     * @property methods List of authentication methods to render.
+     * @property isAuthenticating Whether a connection is currently established.
+     * @property error The error that may have occurred.
+     */
+    data class Model(
+        val url: String = "",
+        val methods: List<AuthMethod> = emptyList(),
+        val isAuthenticating: Boolean = false,
+        val error: StringResource? = null,
+    )
+
+    sealed interface Output {
+
+        /**
+         * Emitted when the user successfully authenticated against the Solr instance.
+         *
+         * @property option The final authentication option that succeeded.
+         */
+        data class OnAuthenticated(val option: AuthOption) : Output
+
+        /**
+         * Emitted when the user aborts the authentication flow.
+         */
+        data object OnAbort : Output
+    }
+}

solr/ui/src/commonMain/kotlin/org/apache/solr/ui/components/auth/AuthenticationComponent.kt

@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.solr.ui.components.auth
+
+import kotlinx.coroutines.flow.StateFlow
+import org.apache.solr.ui.domain.AuthMethod
+
+/**
+ * Component interface that is handling basic authentication with username and password.
+ */
+interface BasicAuthComponent {
+
+    val model: StateFlow<Model>
+
+    /**
+     * Function that handles username changes.
+     */
+    fun onChangeUsername(username: String)
+
+    /**
+     * Function that handles password changes.
+     */
+    fun onChangePassword(password: String)
+
+    /**
+     * Tries to authenticate the user with the given username and password.
+     */
+    fun onAuthenticate()
+
+    /**
+     * Data class model that represents the [BasicAuthComponent] state.
+     *
+     * @property realm The basic auth realm the user is supposed to provide the credentials for.
+     * @property username The username that is currently typed in.
+     * @property password The password that is currently typed in.
+     * @property hasError Whether the current input has an error. This is a simplified variant that
+     * does not distinguish input fields.
+     */
+    data class Model(
+        val realm: String = "",
+        val username: String = "",
+        val password: String = "",
+        val hasError: Boolean = false,
+    )
+
+    sealed interface Output {
+
+        /**
+         * Output that is emitted when a connection process is started.
+         */
+        data object Authenticating : Output
+
+        /**
+         * Output that is emitted when the user successfully connected to the server
+         * with the credentials.
+         *
+         * The username and password are passed to the parent to configure a client
+         * with basic auth and pass it to other instances for further use.
+         *
+         * @property method The method that was used for authentication.
+         * @property username The username that was used for authentication.
+         * @property password The password that was used for authentication.
+         */
+        data class Authenticated(
+            val method: AuthMethod.BasicAuthMethod,
+            val username: String,
+            val password: String,
+        ) : Output
+
+        /**
+         * Output that is emitted when an authentication error occurs, for example, in case
+         * of invalid credentials.
+         *
+         * @property error The error that was thrown during a connection establishment.
+         */
+        data class AuthenticationFailed(val error: Throwable) : Output
+
+        /**
+         * Output that allows resetting any error reported via [AuthenticationFailed].
+         */
+        data object ErrorReset : Output
+    }
+}

solr/ui/src/commonMain/kotlin/org/apache/solr/ui/components/auth/BasicAuthComponent.kt

@@ -0,0 +1,139 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.solr.ui.components.auth.integration
+
+import com.arkivanov.decompose.router.slot.ChildSlot
+import com.arkivanov.decompose.router.slot.SlotNavigation
+import com.arkivanov.decompose.router.slot.activate
+import com.arkivanov.decompose.router.slot.childSlot
+import com.arkivanov.decompose.value.Value
+import com.arkivanov.essenty.lifecycle.doOnCreate
+import com.arkivanov.mvikotlin.core.instancekeeper.getStore
+import com.arkivanov.mvikotlin.core.store.StoreFactory
+import com.arkivanov.mvikotlin.extensions.coroutines.stateFlow
+import io.ktor.client.HttpClient
+import io.ktor.http.Url
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.SupervisorJob
+import org.apache.solr.ui.components.auth.AuthenticationComponent
+import org.apache.solr.ui.components.auth.AuthenticationComponent.BasicAuthConfiguration
+import org.apache.solr.ui.components.auth.AuthenticationComponent.Output
+import org.apache.solr.ui.components.auth.AuthenticationComponent.Output.OnAuthenticated
+import org.apache.solr.ui.components.auth.BasicAuthComponent
+import org.apache.solr.ui.components.auth.store.AuthenticationStore.Intent
+import org.apache.solr.ui.components.auth.store.AuthenticationStore.Intent.FailAuthentication
+import org.apache.solr.ui.components.auth.store.AuthenticationStore.Intent.ResetError
+import org.apache.solr.ui.components.auth.store.AuthenticationStoreProvider
+import org.apache.solr.ui.domain.AuthMethod
+import org.apache.solr.ui.domain.AuthOption
+import org.apache.solr.ui.utils.AppComponentContext
+import org.apache.solr.ui.utils.coroutineScope
+import org.apache.solr.ui.utils.map
+
+/**
+ * Default implementation of the [AuthenticationComponent].
+ *
+ * @param componentContext Application component context.
+ * @param storeFactory Store factory to pass to the store provider.
+ * @param httpClient HTTP client to use for API interactions. The client has to be pre-configured
+ * with a base URL pointing to a Solr instance.
+ * @param methods A list of authentication methods that are supported by the Solr instance the
+ * [httpClient] is pointing to.
+ * @property output Output handler that is used to send outputs from this component.
+ */
+class DefaultAuthenticationComponent(
+    componentContext: AppComponentContext,
+    storeFactory: StoreFactory,
+    httpClient: HttpClient,
+    private val url: Url,
+    methods: List<AuthMethod>,
+    private val output: (Output) -> Unit,
+) : AuthenticationComponent,
+    AppComponentContext by componentContext {
+
+    private val mainScope = coroutineScope(SupervisorJob() + mainContext)
+    private val ioScope = coroutineScope(SupervisorJob() + ioContext)
+
+    private val store = instanceKeeper.getStore {
+        AuthenticationStoreProvider(
+            storeFactory = storeFactory,
+            mainContext = mainScope.coroutineContext,
+            ioContext = ioScope.coroutineContext,
+            url = url,
+            methods = methods,
+        ).provide()
+    }
+
+    private val basicAuthNavigation = SlotNavigation<BasicAuthConfiguration>()
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val model = store.stateFlow.map(mainScope, authStateToModel)
+
+    override val basicAuthSlot: Value<ChildSlot<BasicAuthConfiguration, BasicAuthComponent>> =
+        childSlot(
+            source = basicAuthNavigation,
+            serializer = BasicAuthConfiguration.serializer(),
+            handleBackButton = true,
+        ) { config, childComponentContext ->
+            DefaultBasicAuthComponent(
+                componentContext = childComponentContext,
+                storeFactory = storeFactory,
+                httpClient = httpClient,
+                method = config.method,
+                output = ::basicAuthOutput,
+            )
+        }
+
+    init {
+        lifecycle.doOnCreate {
+            methods.forEach { method ->
+                when (method) {
+                    is AuthMethod.BasicAuthMethod ->
+                        basicAuthNavigation.activate(configuration = BasicAuthConfiguration(method))
+                }
+            }
+        }
+    }
+
+    /**
+     * Output handler function that handles the outputs from [BasicAuthComponent]s.
+     *
+     * @param output The output of the component to handle
+     */
+    private fun basicAuthOutput(output: BasicAuthComponent.Output): Unit = when (output) {
+        is BasicAuthComponent.Output.Authenticated -> output(
+            OnAuthenticated(
+                option = AuthOption.BasicAuthOption(
+                    url = url,
+                    method = output.method,
+                    username = output.username,
+                    password = output.password,
+                ),
+            ),
+        )
+
+        is BasicAuthComponent.Output.Authenticating -> store.accept(Intent.StartAuthenticating)
+        is BasicAuthComponent.Output.AuthenticationFailed ->
+            store.accept(FailAuthentication(output.error))
+
+        BasicAuthComponent.Output.ErrorReset ->
+            store.accept(ResetError)
+    }
+
+    override fun onAbort() = output(Output.OnAbort)
+}