Enabling alias action on managed indices only

Author: goyamegh

src/main/kotlin/org/opensearch/indexmanagement/indexstatemanagement/action/AliasAction.kt

@@ -21,6 +21,8 @@ class AliasAction(
 
     init {
         require(actions.isNotEmpty()) { "At least one alias action needs to be specified." }
+        require(!actions.any { it.actionType() == IndicesAliasesRequest.AliasActions.Type.REMOVE_INDEX }) { "Remove_index is not allowed here." }
+        require(actions.all { it.indices().isNullOrEmpty() }) { "Alias actions are only allowed on managed indices." }
     }
 
     private val attemptAliasStep = AttemptAliasStep(this)

src/main/kotlin/org/opensearch/indexmanagement/indexstatemanagement/step/alias/AttemptAliasStep.kt

@@ -8,17 +8,11 @@ package org.opensearch.indexmanagement.indexstatemanagement.step.alias
 import org.apache.logging.log4j.LogManager
 import org.opensearch.action.admin.indices.alias.IndicesAliasesRequest
 import org.opensearch.action.support.master.AcknowledgedResponse
-import org.opensearch.common.Strings
 import org.opensearch.indexmanagement.indexstatemanagement.action.AliasAction
-import org.opensearch.indexmanagement.opensearchapi.convertToMap
 import org.opensearch.indexmanagement.opensearchapi.suspendUntil
 import org.opensearch.indexmanagement.spi.indexstatemanagement.Step
 import org.opensearch.indexmanagement.spi.indexstatemanagement.model.ManagedIndexMetaData
 import org.opensearch.indexmanagement.spi.indexstatemanagement.model.StepMetaData
-import org.opensearch.script.Script
-import org.opensearch.script.ScriptService
-import org.opensearch.script.ScriptType
-import org.opensearch.script.TemplateScript
 
 class AttemptAliasStep(private val action: AliasAction) : Step(name) {
 
@@ -32,15 +26,8 @@ class AttemptAliasStep(private val action: AliasAction) : Step(name) {
         try {
             val request = IndicesAliasesRequest()
             action.actions.forEach {
-                // Take the indices that were set to be updated on the alias action and join them into a single string
-                // So we don't have to pass each one individually into the script service to be compiled
-                val indices = it.indices().joinToString(",")
-                // Compile them so the user can use the current dynamic index name in the name such as "{{ctx.index}}" in the static policy
-                val indicesScript = Script(ScriptType.INLINE, Script.DEFAULT_TEMPLATE_LANG, indices, mapOf())
-                val compiledIndices = compileTemplate(indicesScript, context.metadata, indices, context.scriptService)
-                // Split them back into individual index names and set back on the AliasActions request
-                val splitIndices = Strings.splitStringByCommaToArray(compiledIndices)
-                it.indices(*splitIndices)
+                // Applying the actions on the managed index.
+                it.indices(indexName)
                 request.addAliasAction(it)
             }
             val response: AcknowledgedResponse = context.client.admin().indices().suspendUntil { aliases(request, it) }
@@ -79,19 +66,6 @@ class AttemptAliasStep(private val action: AliasAction) : Step(name) {
         )
     }
 
-    private fun compileTemplate(
-        template: Script,
-        managedIndexMetaData: ManagedIndexMetaData,
-        defaultValue: String,
-        scriptService: ScriptService
-    ): String {
-        val contextMap = managedIndexMetaData.convertToMap().filterKeys { key -> key in validTopContextFields }
-        val compiledValue = scriptService.compile(template, TemplateScript.CONTEXT)
-            .newInstance(template.params + mapOf("ctx" to contextMap))
-            .execute()
-        return compiledValue.ifBlank { defaultValue }
-    }
-
     override fun isIdempotent() = true
 
     companion object {

src/test/kotlin/org/opensearch/indexmanagement/indexstatemanagement/TestHelpers.kt

@@ -208,16 +208,22 @@ fun randomOpenActionConfig(): OpenAction {
     return OpenAction(index = 0)
 }
 
-fun randomAliasAction(): AliasAction {
-    val actions = List(OpenSearchRestTestCase.randomIntBetween(1, 10)) { randomAliasActions() }
+fun randomAliasAction(includeIndices: Boolean = false): AliasAction {
+    val actions = List(OpenSearchRestTestCase.randomIntBetween(1, 10)) { if (includeIndices) randomAliasActionWithIndices() else randomAliasActions() }
     return AliasAction(actions = actions, index = 0)
 }
 
 fun randomAliasActions(): IndicesAliasesRequest.AliasActions {
     val types = listOf(IndicesAliasesRequest.AliasActions.Type.ADD, IndicesAliasesRequest.AliasActions.Type.REMOVE)
     return IndicesAliasesRequest.AliasActions(OpenSearchRestTestCase.randomSubsetOf(1, types).first())
         .alias(OpenSearchRestTestCase.randomAlphaOfLength(10))
-        .index(OpenSearchRestTestCase.randomAlphaOfLength(10))
+}
+
+fun randomAliasActionWithIndices(): IndicesAliasesRequest.AliasActions {
+    val types = listOf(IndicesAliasesRequest.AliasActions.Type.ADD, IndicesAliasesRequest.AliasActions.Type.REMOVE)
+    return IndicesAliasesRequest.AliasActions(OpenSearchRestTestCase.randomSubsetOf(1, types).first())
+        .alias(OpenSearchRestTestCase.randomAlphaOfLength(10))
+        .indices(OpenSearchRestTestCase.randomAlphaOfLength(10))
 }
 
 fun randomDestination(type: DestinationType = randomDestinationType()): Destination {

src/test/kotlin/org/opensearch/indexmanagement/indexstatemanagement/action/AliasActionIT.kt

@@ -17,13 +17,13 @@ import java.time.temporal.ChronoUnit
 import java.util.Locale
 
 class AliasActionIT : IndexStateManagementRestTestCase() {
-    private val testIndexName = javaClass.simpleName.toLowerCase(Locale.ROOT)
+    private val testIndexName = javaClass.simpleName.lowercase(Locale.ROOT)
 
     fun `test adding alias to index`() {
         val indexName = "${testIndexName}_index_1"
         val policyID = "${testIndexName}_testPolicyName_1"
         val aliasName = "some_alias_to_add"
-        val actions = listOf(IndicesAliasesRequest.AliasActions.add().alias(aliasName).index(indexName))
+        val actions = listOf(IndicesAliasesRequest.AliasActions.add().alias(aliasName))
         val actionConfig = AliasAction(actions = actions, index = 0)
         val states = listOf(State("alias", listOf(actionConfig), listOf()))
 
@@ -66,7 +66,7 @@ class AliasActionIT : IndexStateManagementRestTestCase() {
         val indexName = "${testIndexName}_index_2"
         val policyID = "${testIndexName}_testPolicyName_2"
         val aliasName = "some_alias_to_add"
-        val actions = listOf(IndicesAliasesRequest.AliasActions.add().alias(aliasName).index("{{ctx.index}}"))
+        val actions = listOf(IndicesAliasesRequest.AliasActions.add().alias(aliasName))
         val actionConfig = AliasAction(actions = actions, index = 0)
         val states = listOf(State("alias", listOf(actionConfig), listOf()))
 
@@ -109,7 +109,7 @@ class AliasActionIT : IndexStateManagementRestTestCase() {
         val indexName = "${testIndexName}_index_3"
         val policyID = "${testIndexName}_testPolicyName_3"
         val aliasName = "some_alias_to_remove"
-        val actions = listOf(IndicesAliasesRequest.AliasActions.remove().alias(aliasName).index(indexName))
+        val actions = listOf(IndicesAliasesRequest.AliasActions.remove().alias(aliasName))
         val actionConfig = AliasAction(actions = actions, index = 0)
         val states = listOf(State("alias", listOf(actionConfig), listOf()))
 

src/test/kotlin/org/opensearch/indexmanagement/indexstatemanagement/model/XContentTests.kt

@@ -40,6 +40,7 @@ import org.opensearch.indexmanagement.opensearchapi.convertToMap
 import org.opensearch.indexmanagement.opensearchapi.parseWithType
 import org.opensearch.indexmanagement.spi.indexstatemanagement.model.ManagedIndexMetaData
 import org.opensearch.test.OpenSearchTestCase
+import kotlin.test.assertFailsWith
 
 class XContentTests : OpenSearchTestCase() {
 
@@ -274,13 +275,23 @@ class XContentTests : OpenSearchTestCase() {
     }
 
     fun `test alias action parsing`() {
-        val aliasAction = randomAliasAction()
-
+        val aliasAction = randomAliasAction(false)
         val aliasActionString = aliasAction.toJsonString()
         val parsedAliasAction = ISMActionsParser.instance.parse(parser(aliasActionString), 0)
         assertEquals("Round tripping AliasAction doesn't work", aliasAction.convertToMap(), parsedAliasAction.convertToMap())
     }
 
+    fun `test alias action parsing with index`() {
+        assertFailsWith<IllegalArgumentException>(
+            message = "Alias actions are only allowed on managed indices.",
+            block = {
+                val aliasAction = randomAliasAction(true)
+                val aliasActionString = aliasAction.toJsonString()
+                ISMActionsParser.instance.parse(parser(aliasActionString), 0)
+            }
+        )
+    }
+
     private fun parser(xc: String): XContentParser {
         val parser = XContentType.JSON.xContent().createParser(xContentRegistry(), LoggingDeprecationHandler.INSTANCE, xc)
         parser.nextToken()