Suggest enabling edit resources (#3149)

* Add ability to suggest experiments including handling notifications

* Adding event emitting on experiment state change

* Suggest enabling the edit experiment on dynamic resources

* Fixing PR feedback

* Removing nasty -1 (replacing with slightly less nasty Long.MAX_VALUE)

* Removing unnecessary blank line

* Adding MutableMap.replace equivalent (and tests)

* Fixing serialization bug

Author: kiiadi

core/src/software/aws/toolkits/core/utils/CollectionUtils.kt

@@ -7,6 +7,14 @@ package software.aws.toolkits.core.utils
  * Removes all items in this collection and replaces them with the items in the [other] collection
  */
 fun <T> MutableCollection<T>.replace(other: Collection<T>) {
-    this.clear()
-    this.addAll(other)
+    clear()
+    addAll(other)
+}
+
+/**
+ * Removes all items in this map and replaces them with the items in the [other] map
+ */
+fun <K, V> MutableMap<K, V>.replace(other: Map<K, V>) {
+    clear()
+    putAll(other)
 }

core/tst/software/aws/toolkits/core/utils/CollectionUtilsTest.kt

@@ -0,0 +1,27 @@
+// Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.core.utils
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class CollectionUtilsTest {
+
+    @Test
+    fun `collection items are replaced`() {
+        val source = mutableListOf("hello")
+
+        source.replace(listOf("world"))
+
+        assertThat(source).containsOnly("world")
+    }
+
+    @Test
+    fun `map entries are replaced`() {
+        val source = mutableMapOf("foo" to "bar")
+        source.replace(mapOf("hello" to "world"))
+
+        assertThat(source).containsOnlyKeys("hello")
+    }
+}

jetbrains-core/resources/META-INF/plugin.xml

@@ -96,7 +96,10 @@ with what features/services are supported.
                   topic="software.aws.toolkits.jetbrains.core.credentials.ConnectionSettingsStateChangeNotifier"/>
         <listener class="software.aws.toolkits.jetbrains.services.dynamic.DynamicResourceStateChangedNotificationHandler"
                   topic="software.aws.toolkits.jetbrains.services.dynamic.DynamicResourceStateMutationHandler"/>
-
+        <listener class="software.aws.toolkits.jetbrains.services.dynamic.SuggestEditExperimentListener"
+                  topic="com.intellij.openapi.fileEditor.FileEditorManagerListener"/>
+        <listener class="software.aws.toolkits.jetbrains.services.dynamic.UpdateOnExperimentState"
+                  topic="software.aws.toolkits.jetbrains.core.experiments.ToolkitExperimentStateChangedListener"/>
     </projectListeners>
     <extensionPoints>
         <extensionPoint name="credentialProviderFactory" interface="software.aws.toolkits.core.credentials.CredentialProviderFactory" dynamic="true"/>

jetbrains-core/src/software/aws/toolkits/jetbrains/core/experiments/ToolkitExperiment.kt

@@ -3,17 +3,27 @@
 
 package software.aws.toolkits.jetbrains.core.experiments
 
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.BaseState
 import com.intellij.openapi.components.PersistentStateComponent
 import com.intellij.openapi.components.State
 import com.intellij.openapi.components.Storage
 import com.intellij.openapi.components.service
 import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.project.DumbAwareAction
+import com.intellij.util.messages.Topic
 import com.intellij.util.xmlb.annotations.Property
+import software.aws.toolkits.core.utils.replace
 import software.aws.toolkits.jetbrains.AwsToolkit
+import software.aws.toolkits.jetbrains.utils.createNotificationExpiringAction
+import software.aws.toolkits.jetbrains.utils.notifyInfo
+import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.AwsTelemetry
 import software.aws.toolkits.telemetry.ExperimentState.Activated
 import software.aws.toolkits.telemetry.ExperimentState.Deactivated
+import java.time.Duration
+import java.time.Instant
 
 /**
  * Used to control the state of an experimental feature.
@@ -22,6 +32,7 @@ import software.aws.toolkits.telemetry.ExperimentState.Deactivated
  *
  * @param hidden determines whether this experiment should surface in the settings/menus; hidden experiments can only be enabled by system property or manually modifying config in aws.xml
  * @param default determines the default state of an experiment
+ * @param suggestionSnooze how long to wait between prompting a suggestion to enable the experiment (when using the experiment suggestion system ([ToolkitExperiment.suggest]))
  *
  * `ToolkitExperiment` implementations should be an `object` for example:
  *
@@ -42,7 +53,8 @@ abstract class ToolkitExperiment(
     internal val title: () -> String,
     internal val description: () -> String,
     internal val hidden: Boolean = false,
-    internal val default: Boolean = false
+    internal val default: Boolean = false,
+    internal val suggestionSnooze: Duration = Duration.ofDays(7)
 ) {
     override fun equals(other: Any?) = (other as? ToolkitExperiment)?.id?.equals(id) == true
     override fun hashCode() = id.hashCode()
@@ -51,13 +63,48 @@ abstract class ToolkitExperiment(
 fun ToolkitExperiment.isEnabled(): Boolean = ToolkitExperimentManager.getInstance().isEnabled(this)
 internal fun ToolkitExperiment.setState(enabled: Boolean) = ToolkitExperimentManager.getInstance().setState(this, enabled)
 
+/**
+ * Surface a notification suggesting that the given experiment be enabled.
+ */
+fun ToolkitExperiment.suggest() {
+    if (ToolkitExperimentManager.getInstance().shouldPrompt(this)) {
+        notifyInfo(
+            title = message("aws.toolkit.experimental.suggestion.title"),
+            content = message("aws.toolkit.experimental.suggestion.description", title(), description()),
+            notificationActions = listOf(
+                createNotificationExpiringAction(EnableExperiment(this)),
+                createNotificationExpiringAction(NeverShowAgain(this))
+            ),
+            stripHtml = false
+        )
+    }
+}
+
+private class EnableExperiment(private val experiment: ToolkitExperiment) :
+    DumbAwareAction(message("aws.toolkit.experimental.enable")) {
+    override fun actionPerformed(e: AnActionEvent) {
+        experiment.setState(true)
+    }
+}
+
+private class NeverShowAgain(private val experiment: ToolkitExperiment) : DumbAwareAction(message("settings.never_show_again")) {
+    override fun actionPerformed(e: AnActionEvent) {
+        ToolkitExperimentManager.getInstance().neverPrompt(experiment)
+    }
+}
+
 @State(name = "experiments", storages = [Storage("aws.xml")])
 internal class ToolkitExperimentManager : PersistentStateComponent<ExperimentState> {
-    private val enabledState = mutableMapOf<String, Boolean>()
+    private val state = ExperimentState()
+    private val enabledState get() = state.value
+
     fun isEnabled(experiment: ToolkitExperiment): Boolean =
         EP_NAME.extensionList.contains(experiment) && enabledState.getOrDefault(experiment.id, getDefault(experiment))
 
     fun setState(experiment: ToolkitExperiment, enabled: Boolean) {
+        if (enabled != isEnabled(experiment)) {
+            ApplicationManager.getApplication().messageBus.syncPublisher(EXPERIMENT_CHANGED).enableSettingsStateChanged(experiment)
+        }
         if (enabled == getDefault(experiment)) {
             enabledState.remove(experiment.id)
         } else {
@@ -73,11 +120,11 @@ internal class ToolkitExperimentManager : PersistentStateComponent<ExperimentSta
         )
     }
 
-    override fun getState(): ExperimentState = ExperimentState().apply { value.putAll(enabledState) }
+    override fun getState(): ExperimentState = state
 
-    override fun loadState(state: ExperimentState) {
-        enabledState.clear()
-        enabledState.putAll(state.value)
+    override fun loadState(loadedState: ExperimentState) {
+        state.value.replace(loadedState.value)
+        state.nextSuggestion.replace(loadedState.nextSuggestion)
     }
 
     private fun getDefault(experiment: ToolkitExperiment): Boolean {
@@ -89,14 +136,40 @@ internal class ToolkitExperimentManager : PersistentStateComponent<ExperimentSta
         }
     }
 
+    internal fun shouldPrompt(experiment: ToolkitExperiment, now: Instant = Instant.now()): Boolean {
+        if (experiment.isEnabled()) {
+            return false
+        }
+        val should = state.nextSuggestion[experiment.id]?.let { now.isAfter(Instant.ofEpochMilli(it)) } ?: true
+        if (should) {
+            state.nextSuggestion[experiment.id] = now.plus(experiment.suggestionSnooze).toEpochMilli()
+        }
+        return should
+    }
+
+    internal fun neverPrompt(experiment: ToolkitExperiment) {
+        state.nextSuggestion[experiment.id] = Long.MAX_VALUE // This is ~240 years in the future, effectively "never".
+    }
+
     companion object {
         internal val EP_NAME = ExtensionPointName.create<ToolkitExperiment>("aws.toolkit.experiment")
+        internal val EXPERIMENT_CHANGED = Topic.create("experiment service enable state changed", ToolkitExperimentStateChangedListener::class.java)
         internal fun getInstance(): ToolkitExperimentManager = service()
         internal fun visibleExperiments(): List<ToolkitExperiment> = EP_NAME.extensionList.filterNot { it.hidden }
     }
 }
 
 internal class ExperimentState : BaseState() {
+    // This represents whether an experiment is enabled or not, don't want to rename it as that will
+    // cause problems with any experiments already out there in the wild who've been persisted
+    // as 'value'
     @get:Property
     val value by map<String, Boolean>()
+
+    @get:Property
+    val nextSuggestion by map<String, Long>()
+}
+
+interface ToolkitExperimentStateChangedListener {
+    fun enableSettingsStateChanged(toolkitExperiment: ToolkitExperiment)
 }

jetbrains-core/src/software/aws/toolkits/jetbrains/services/dynamic/JsonResourceModificationExperiment.kt

@@ -3,11 +3,36 @@
 
 package software.aws.toolkits.jetbrains.services.dynamic
 
+import com.intellij.openapi.fileEditor.FileEditorManager
+import com.intellij.openapi.fileEditor.FileEditorManagerListener
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.ui.EditorNotifications
 import software.aws.toolkits.jetbrains.core.experiments.ToolkitExperiment
+import software.aws.toolkits.jetbrains.core.experiments.ToolkitExperimentStateChangedListener
+import software.aws.toolkits.jetbrains.core.experiments.suggest
 import software.aws.toolkits.resources.message
 
 object JsonResourceModificationExperiment : ToolkitExperiment(
     "jsonResourceModification",
     { message("dynamic_resources.experiment.title") },
     { message("dynamic_resources.experiment.description") }
 )
+
+class SuggestEditExperimentListener : FileEditorManagerListener {
+    override fun fileOpened(source: FileEditorManager, file: VirtualFile) {
+        if (file is DynamicResourceVirtualFile) {
+            JsonResourceModificationExperiment.suggest()
+        }
+    }
+}
+
+class UpdateOnExperimentState(private val project: Project) : ToolkitExperimentStateChangedListener {
+    override fun enableSettingsStateChanged(toolkitExperiment: ToolkitExperiment) {
+        if (toolkitExperiment is JsonResourceModificationExperiment) {
+            with(EditorNotifications.getInstance(project)) {
+                FileEditorManager.getInstance(project).openFiles.filterIsInstance<DynamicResourceVirtualFile>().forEach { updateNotifications(it) }
+            }
+        }
+    }
+}