AccessUpdateTaskConfig.kt

/*

  Copyright (C) 2026 Sber

  Licensed 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

  In any derivative products, you must retain the information of
  owner of the original code and provide clear attribution to the project

  https://dochub.info

  The use of this product or its derivatives for any purpose cannot be a secret.


  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.

  Maintainers:
      Alexander Romashin <romashin.a.va@sberbank.ru>, Sber - 2026

  Contributors:
      Alexander Romashin <romashin.a.va@sberbank.ru>, Sber - 2026

*/

package org.archtool.configuration.tasks

import com.github.kagkarlsson.scheduler.task.CompletionHandler
import com.github.kagkarlsson.scheduler.task.Task
import com.github.kagkarlsson.scheduler.task.helper.Tasks
import com.github.kagkarlsson.scheduler.task.schedule.Schedules
import org.archtool.configuration.ServiceProperties
import org.archtool.data.model.AccessUpdateTaskModel
import org.archtool.data.model.UpdateStatus
import org.archtool.helper.UpdateServiceClient
import org.archtool.service.HistoryService
import org.slf4j.LoggerFactory
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.time.Instant

@Configuration
class AccessUpdateTaskConfig {
    private val log = LoggerFactory.getLogger(javaClass)

    companion object {
        const val TASK_NAME = "ams-access-task"
        const val TASK_SPAWNER_NAME = "ams-access-spawner-task"
        const val GLOBAL_INSTANCE_ID = "ams-access-task-instance"
    }

    @Bean
    fun accessUpdateTask(
        seafAmsServiceClient: UpdateServiceClient,
        serviceProperties: ServiceProperties,
        historyService: HistoryService
    ): Task<AccessUpdateTaskModel> {
        return Tasks.custom(
            TASK_NAME,
            AccessUpdateTaskModel::class.java
        ).execute { instance, context ->
            val data = instance.data ?: AccessUpdateTaskModel()
            try {
                when (data.currentStep) {
                    AccessUpdateTaskModel.Step.START_AMS_UPDATE -> {
                        // Первый шаг нового запуска: история должна содержать только шаги текущего запуска.
                        // Повтор шага (seaf-ams занят) тоже очищает историю — в ней только этот шаг.
                        historyService.clearTaskHistory(TASK_NAME, GLOBAL_INSTANCE_ID)
                        val status = seafAmsServiceClient.update()
                        when (status.status) {
                            UpdateStatus.SCHEDULED -> {
                                // seaf-ams принял запрос: обновление начнётся после него. Шаг запуска завершён,
                                // ход обновления отслеживает CHECK_AMS.
                                val launchDescription = "Запущено новое обновление seaf-ams"
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = GLOBAL_INSTANCE_ID,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.SUCCESS.name,
                                    successMessage = launchDescription
                                )
                                log.info("Запуск обновления seaf-ams: {}", launchDescription)
                                data.currentStep = AccessUpdateTaskModel.Step.CHECK_AMS
                                CompletionHandler.OnCompleteReschedule(
                                    Schedules.fixedDelay(serviceProperties.amsAccessSchedulerRate),
                                    data
                                )
                            }
                            UpdateStatus.ERROR -> {
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = GLOBAL_INSTANCE_ID,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.ERROR.name,
                                    errorMessage = status.errorMessage
                                )
                                log.error("Ошибка запуска обновления seaf-ams: {}", status.errorMessage)
                                CompletionHandler.OnCompleteRemove()
                            }
                            else -> {
                                // seaf-ams выполняет обновление, начатое до запроса, и запрос не принял: его итог
                                // не покрывает изменения, ради которых запущена задача. Повторяем запуск, пока
                                // seaf-ams не примет запрос.
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = GLOBAL_INSTANCE_ID,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.IN_PROGRESS.name
                                )
                                log.debug("seaf-ams уже выполняет обновление (статус {}), повторяем запуск", status.status)
                                CompletionHandler.OnCompleteReschedule(
                                    Schedules.fixedDelay(serviceProperties.amsAccessSchedulerRate),
                                    data
                                )
                            }
                        }
                    }
                    AccessUpdateTaskModel.Step.CHECK_AMS -> {
                        val status = seafAmsServiceClient.status()
                        historyService.saveUpdateStatus(
                            taskName = TASK_NAME,
                            taskInstance = GLOBAL_INSTANCE_ID,
                            stepName = data.currentStep.name,
                            stepStatus = status.status.name,
                            errorMessage = status.errorMessage
                        )
                        log.debug("Проверка статуса seaf-ams: {}", status)
                        when (status.status) {
                            UpdateStatus.SUCCESS -> {
                                log.info("Seaf-ams успешно обновлен. Задача завершена.")
                                CompletionHandler.OnCompleteRemove()
                            }
                            UpdateStatus.SCHEDULED -> {
                                log.trace("Обновление seaf-ams еще не начато, продолжаем наблюдение")
                                CompletionHandler.OnCompleteReschedule(
                                    Schedules.fixedDelay(serviceProperties.amsAccessSchedulerRate),
                                    data
                                )
                            }
                            UpdateStatus.IN_PROGRESS -> {
                                log.trace("Обновление seaf-ams выполняется, продолжаем наблюдение")
                                CompletionHandler.OnCompleteReschedule(
                                    Schedules.fixedDelay(serviceProperties.amsAccessSchedulerRate),
                                    data
                                )
                            }
                            UpdateStatus.ERROR -> {
                                log.error("Обновление seaf-ams завершилось с ошибкой: {}", status.errorMessage)
                                CompletionHandler.OnCompleteRemove()
                            }
                        }
                    }
                }
            } catch (e: Exception) {
                historyService.saveUpdateStatus(
                    taskName = TASK_NAME,
                    taskInstance = GLOBAL_INSTANCE_ID,
                    stepName = data.currentStep.name,
                    stepStatus = UpdateStatus.ERROR.name,
                    errorMessage = e.message
                )
                log.error("Критическая ошибка на шаге ${data.currentStep}: ${e.message}", e)
                CompletionHandler.OnCompleteRemove()
            } catch (e: Throwable) {
                // Error — фиксируем статус в истории и пробрасываем дальше, не пытаясь продолжить
                // штатную логику планирования.
                historyService.saveUpdateStatus(
                    taskName = TASK_NAME,
                    taskInstance = GLOBAL_INSTANCE_ID,
                    stepName = data.currentStep.name,
                    stepStatus = UpdateStatus.ERROR.name,
                    errorMessage = e.message
                )
                log.error("Критическая ошибка JVM на шаге ${data.currentStep}: ${e.message}", e)
                throw e
            }
        }
    }

    @Bean
    fun accessUpdateTaskSpawner(
        accessUpdateTask: Task<AccessUpdateTaskModel>,
        serviceProperties: ServiceProperties
    ) : Task<Void> {
        return Tasks.recurring(
            TASK_SPAWNER_NAME,
            Schedules.fixedDelay(serviceProperties.amsAccessSchedule)
        ).execute { instance, context ->
            val schedulerClient = context.schedulerClient
            val initialData = AccessUpdateTaskModel()
            try {
                val taskInstance = accessUpdateTask.instance(GLOBAL_INSTANCE_ID, initialData)
                val isScheduled = schedulerClient.scheduleIfNotExists(taskInstance, Instant.now())
                if (isScheduled) {
                    log.info("Процесс обновления seaf-ams успешно запущен.")
                } else {
                    log.warn("Попытка дублирующего запуска обновления seaf-ams. Процесс уже выполняется.")
                }
            } catch (e: Exception) {
                log.error("Непредвиденная ошибка при старте задачи обновления seaf-ams: ${e.message}", e)
            } catch (e: Throwable) {
                log.error("Критическая ошибка JVM при старте задачи обновления seaf-ams: ${e.message}", e)
                throw e
            }
        }
    }
}