fun start()

in src/main/kotlin/org/opensearch/indexmanagement/indexstatemanagement/transport/action/explain/TransportExplainAction.kt [97:207]
52 lines of code
4 McCabe index (conditional complexity)

        fun start() {
            log.debug(
                "User and roles string from thread context: ${client.threadPool().threadContext.getTransient<String>(
                    ConfigConstants.OPENSEARCH_SECURITY_USER_INFO_THREAD_CONTEXT
                )}"
            )
            val params = request.searchParams

            val sortBuilder = SortBuilders
                .fieldSort(params.sortField)
                .order(SortOrder.fromString(params.sortOrder))

            val queryBuilder = QueryBuilders.boolQuery()
                .must(
                    QueryBuilders
                        .queryStringQuery(params.queryString)
                        .defaultField("managed_index.name")
                        .defaultOperator(Operator.AND)
                )

            var searchSourceBuilder = SearchSourceBuilder()
                .from(params.from)
                .fetchSource(FETCH_SOURCE)
                .seqNoAndPrimaryTerm(true)
                .version(true)
                .sort(sortBuilder)

            if (!explainAll) {
                searchSourceBuilder = searchSourceBuilder.size(MAX_HITS)
                if (wildcard) { // explain/index*
                    indices.forEach {
                        if (it.contains("*")) {
                            queryBuilder.should(QueryBuilders.wildcardQuery("managed_index.index", it))
                        } else {
                            queryBuilder.should(QueryBuilders.termsQuery("managed_index.index", it))
                        }
                    }
                } else { // explain/{index}
                    queryBuilder.filter(QueryBuilders.termsQuery("managed_index.index", indices))
                }
            } else { // explain all
                searchSourceBuilder = searchSourceBuilder.size(params.size)
                queryBuilder.filter(QueryBuilders.existsQuery("managed_index"))
            }

            searchSourceBuilder = searchSourceBuilder.query(queryBuilder)

            val searchRequest = SearchRequest()
                .indices(INDEX_MANAGEMENT_INDEX)
                .source(searchSourceBuilder)

            client.threadPool().threadContext.stashContext().use { threadContext ->
                client.search(
                    searchRequest,
                    object : ActionListener<SearchResponse> {
                        override fun onResponse(response: SearchResponse) {
                            val totalHits = response.hits.totalHits
                            if (totalHits != null) {
                                totalManagedIndices = totalHits.value.toInt()
                            }

                            response.hits.hits.map {
                                val hitMap = it.sourceAsMap["managed_index"] as Map<String, Any>
                                val managedIndex = hitMap["index"] as String
                                managedIndices.add(managedIndex)
                                enabledState[managedIndex] = hitMap["enabled"] as Boolean
                                managedIndicesMetaDataMap[managedIndex] = mapOf(
                                    "index" to hitMap["index"] as String?,
                                    "index_uuid" to hitMap["index_uuid"] as String?,
                                    "policy_id" to hitMap["policy_id"] as String?,
                                    "enabled" to hitMap["enabled"]?.toString()
                                )
                            }

                            // explain all only return managed indices
                            if (explainAll) {
                                if (managedIndices.size == 0) {
                                    // edge case: if specify query param pagination size to be 0
                                    // we still show total managed indices
                                    sendResponse()
                                    return
                                } else {
                                    indexNames.addAll(managedIndices)
                                    getMetadata(managedIndices, threadContext)
                                    return
                                }
                            }

                            // explain/{index} return results for all indices
                            indexNames.addAll(indices)
                            getMetadata(indices, threadContext)
                        }

                        override fun onFailure(t: Exception) {
                            if (t is IndexNotFoundException) {
                                // config index hasn't been initialized
                                // show all requested indices not managed
                                if (indices.isNotEmpty()) {
                                    indexNames.addAll(indices)
                                    getMetadata(indices, threadContext)
                                    return
                                }
                                sendResponse()
                                return
                            }
                            actionListener.onFailure(ExceptionsHelper.unwrapCause(t) as Exception)
                        }
                    }
                )
            }
        }