Added no_alias condition check for ISM

Signed-off-by: Tarun-kishore <[email protected]>

Author: Tarun Kishore

src/main/kotlin/org/opensearch/indexmanagement/indexstatemanagement/model/Transition.kt

@@ -80,10 +80,11 @@ data class Conditions(
     val size: ByteSizeValue? = null,
     val cron: CronSchedule? = null,
     val rolloverAge: TimeValue? = null,
+    val noAlias: Boolean? = null,
 ) : ToXContentObject,
     Writeable {
     init {
-        val conditionsList = listOf(indexAge, docCount, size, cron, rolloverAge)
+        val conditionsList = listOf(indexAge, docCount, size, cron, rolloverAge, noAlias)
         require(conditionsList.filterNotNull().size == 1) { "Cannot provide more than one Transition condition" }
 
         // Validate doc count condition
@@ -100,6 +101,7 @@ data class Conditions(
         if (size != null) builder.field(MIN_SIZE_FIELD, size.stringRep)
         if (cron != null) builder.field(CRON_FIELD, cron)
         if (rolloverAge != null) builder.field(MIN_ROLLOVER_AGE_FIELD, rolloverAge.stringRep)
+        if (noAlias != null) builder.field(NO_ALIAS_FIELD, noAlias)
         return builder.endObject()
     }
 
@@ -110,6 +112,7 @@ data class Conditions(
         size = sin.readOptionalWriteable(::ByteSizeValue),
         cron = sin.readOptionalWriteable(::CronSchedule),
         rolloverAge = sin.readOptionalTimeValue(),
+        noAlias = sin.readOptionalBoolean(),
     )
 
     @Throws(IOException::class)
@@ -119,6 +122,7 @@ data class Conditions(
         out.writeOptionalWriteable(size)
         out.writeOptionalWriteable(cron)
         out.writeOptionalTimeValue(rolloverAge)
+        out.writeOptionalBoolean(noAlias)
     }
 
     companion object {
@@ -127,6 +131,7 @@ data class Conditions(
         const val MIN_SIZE_FIELD = "min_size"
         const val CRON_FIELD = "cron"
         const val MIN_ROLLOVER_AGE_FIELD = "min_rollover_age"
+        const val NO_ALIAS_FIELD = "no_alias"
 
         @JvmStatic
         @Throws(IOException::class)
@@ -136,6 +141,7 @@ data class Conditions(
             var size: ByteSizeValue? = null
             var cron: CronSchedule? = null
             var rolloverAge: TimeValue? = null
+            var noAlias: Boolean? = null
 
             ensureExpectedToken(Token.START_OBJECT, xcp.currentToken(), xcp)
             while (xcp.nextToken() != Token.END_OBJECT) {
@@ -148,11 +154,12 @@ data class Conditions(
                     MIN_SIZE_FIELD -> size = ByteSizeValue.parseBytesSizeValue(xcp.text(), MIN_SIZE_FIELD)
                     CRON_FIELD -> cron = ScheduleParser.parse(xcp) as? CronSchedule
                     MIN_ROLLOVER_AGE_FIELD -> rolloverAge = TimeValue.parseTimeValue(xcp.text(), MIN_ROLLOVER_AGE_FIELD)
+                    NO_ALIAS_FIELD -> noAlias = xcp.booleanValue()
                     else -> throw IllegalArgumentException("Invalid field: [$fieldName] found in Conditions.")
                 }
             }
 
-            return Conditions(indexAge, docCount, size, cron, rolloverAge)
+            return Conditions(indexAge, docCount, size, cron, rolloverAge, noAlias)
         }
     }
 }

src/main/kotlin/org/opensearch/indexmanagement/indexstatemanagement/step/transition/AttemptTransitionStep.kt

@@ -100,9 +100,10 @@ class AttemptTransitionStep(private val action: TransitionsAction) : Step(name)
             }
 
             // Find the first transition that evaluates to true and get the state to transition to, otherwise return null if none are true
+            val indexAliasesCount = indexMetadata?.aliases?.size ?: 0
             stateName =
                 transitions.find {
-                    it.evaluateConditions(indexCreationDateInstant, numDocs, indexSize, stepStartTime, rolloverDate)
+                    it.evaluateConditions(indexCreationDateInstant, numDocs, indexSize, stepStartTime, rolloverDate, indexAliasesCount)
                 }?.stateName
             val message: String
             val stateName = stateName // shadowed on purpose to prevent var from changing

src/main/kotlin/org/opensearch/indexmanagement/indexstatemanagement/util/ManagedIndexUtils.kt

@@ -189,6 +189,7 @@ fun Transition.evaluateConditions(
     indexSize: ByteSizeValue?,
     transitionStartTime: Instant,
     rolloverDate: Instant?,
+    indexAliasesCount: Int? = null,
 ): Boolean {
     // If there are no conditions, treat as always true
     if (this.conditions == null) return true
@@ -219,6 +220,11 @@ fun Transition.evaluateConditions(
         return this.conditions.rolloverAge.millis <= elapsedTime
     }
 
+    if (this.conditions.noAlias != null && indexAliasesCount != null) {
+        return (this.conditions.noAlias && indexAliasesCount == 0) ||
+            (!this.conditions.noAlias && indexAliasesCount > 0)
+    }
+
     // We should never reach this
     return false
 }

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

@@ -147,4 +147,87 @@ class TransitionActionIT : IndexStateManagementRestTestCase() {
         // Should have evaluated to true
         waitFor { assertEquals(AttemptTransitionStep.getSuccessMessage(indexName, secondStateName), getExplainManagedIndexMetaData(indexName).info?.get("message")) }
     }
+
+    fun `test noAlias transition condition`() {
+        val indexName = "${testIndexName}_no_alias"
+        val policyID = "${testIndexName}_no_alias_policy"
+        val secondStateName = "second"
+        val states =
+            listOf(
+                State("first", listOf(), listOf(Transition(secondStateName, Conditions(noAlias = true)))),
+                State(secondStateName, listOf(), listOf()),
+            )
+
+        val policy =
+            Policy(
+                id = policyID,
+                description = "$testIndexName description",
+                schemaVersion = 1L,
+                lastUpdatedTime = Instant.now().truncatedTo(ChronoUnit.MILLIS),
+                errorNotification = randomErrorNotification(),
+                defaultState = states[0].name,
+                states = states,
+            )
+
+        createPolicy(policy, policyID)
+        createIndex(indexName, policyID)
+
+        val managedIndexConfig = getExistingManagedIndexConfig(indexName)
+
+        // Initializing the policy/metadata
+        updateManagedIndexConfigStartTime(managedIndexConfig)
+
+        waitFor { assertEquals(policyID, getExplainManagedIndexMetaData(indexName).policyID) }
+
+        // Evaluating transition conditions for first time (should succeed, no alias)
+        updateManagedIndexConfigStartTime(managedIndexConfig)
+        waitFor { assertEquals(AttemptTransitionStep.getSuccessMessage(indexName, secondStateName), getExplainManagedIndexMetaData(indexName).info?.get("message")) }
+
+        // Create a new index and add an alias, then attach the policy with noAlias=true (should NOT transition)
+        val indexWithAlias = "${testIndexName}_with_alias"
+        createIndex(indexWithAlias, policyID, "foo-alias")
+        addPolicyToIndex(indexWithAlias, policyID)
+        val managedIndexConfigWithAlias = getExistingManagedIndexConfig(indexWithAlias)
+        updateManagedIndexConfigStartTime(managedIndexConfigWithAlias)
+        waitFor { assertEquals(policyID, getExplainManagedIndexMetaData(indexWithAlias).policyID) }
+        updateManagedIndexConfigStartTime(managedIndexConfigWithAlias)
+        // Should not transition because alias exists and noAlias=true
+        waitFor { assertEquals(AttemptTransitionStep.getEvaluatingMessage(indexWithAlias), getExplainManagedIndexMetaData(indexWithAlias).info?.get("message")) }
+
+        // Now test noAlias=false: should transition if alias exists
+        val indexWithAlias2 = "${indexWithAlias}_2"
+        val policyIDWithNoAliasFalse = "${testIndexName}_no_alias_false_policy"
+        val statesWithNoAliasFalse =
+            listOf(
+                State("first", listOf(), listOf(Transition(secondStateName, Conditions(noAlias = false)))),
+                State(secondStateName, listOf(), listOf()),
+            )
+        val policyWithAlias =
+            Policy(
+                id = policyIDWithNoAliasFalse,
+                description = "$testIndexName description",
+                schemaVersion = 1L,
+                lastUpdatedTime = Instant.now().truncatedTo(ChronoUnit.MILLIS),
+                errorNotification = randomErrorNotification(),
+                defaultState = statesWithNoAliasFalse[0].name,
+                states = statesWithNoAliasFalse,
+            )
+        createPolicy(policyWithAlias, policyIDWithNoAliasFalse)
+        waitFor { assertNotNull(getPolicy(policyIDWithNoAliasFalse)) }
+        createIndex(indexWithAlias2, policyIDWithNoAliasFalse, "foo-alias-2")
+        addPolicyToIndex(indexWithAlias2, policyIDWithNoAliasFalse)
+        val managedIndexConfigWithAlias2 = getExistingManagedIndexConfig(indexWithAlias2)
+        updateManagedIndexConfigStartTime(managedIndexConfigWithAlias2)
+        waitFor { assertEquals(policyIDWithNoAliasFalse, getExplainManagedIndexMetaData(indexWithAlias2).policyID) }
+        updateManagedIndexConfigStartTime(managedIndexConfigWithAlias2)
+        // Should transition because alias exists and noAlias=false
+        waitFor {
+            assertEquals(
+                AttemptTransitionStep.getSuccessMessage(indexWithAlias2, secondStateName),
+                getExplainManagedIndexMetaData(
+                    indexWithAlias2,
+                ).info?.get("message"),
+            )
+        }
+    }
 }