ReloadTaskConfig.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.ManifestReloadTaskModel
import org.archtool.data.model.ReloadScheduleModel
import org.archtool.data.model.ReloadTaskDataModel
import org.archtool.data.model.UpdateStatus
import org.archtool.helper.BackendServiceClient
import org.archtool.helper.UpdateServiceClient
import org.archtool.service.HistoryService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.scheduling.support.CronExpression
import tools.jackson.databind.json.JsonMapper
import java.time.Duration
import java.time.Instant
import java.time.LocalDateTime

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

    companion object {
        const val TASK_NAME = "reload-manifest-task"
        const val TASK_SPAWNER_NAME = "reload-manifest-schedule-spawner-task"

        fun instanceId(backend: String): String = "reload-manifest-task-instance-$backend"
    }

    @Bean
    fun reloadTask(
        seafGasServiceClient: UpdateServiceClient,
        backendServiceClient: BackendServiceClient,
        serviceProperties: ServiceProperties,
        historyService: HistoryService,
        @Qualifier("jacksonJsonMapper") jsonMapper: JsonMapper
    ): Task<ManifestReloadTaskModel> {
        return Tasks.custom(
            TASK_NAME,
            ManifestReloadTaskModel::class.java
        ).execute { instance, _ ->
            val data = instance.data
            val taskDataJson = ReloadTaskDataModel.toJsonNode(data, jsonMapper)
            val taskInstance = instanceId(data.backend)
            try {
                when (data.currentStep) {
                    ManifestReloadTaskModel.Step.START_GAS_UPDATE -> {
                        // Первый шаг нового запуска: история должна содержать только шаги текущего запуска.
                        // Повтор шага (seaf-gas занят) тоже очищает историю — в ней только этот шаг.
                        historyService.clearTaskHistory(TASK_NAME, taskInstance)
                        val status = seafGasServiceClient.update()
                        when (status.status) {
                            UpdateStatus.SCHEDULED -> {
                                // seaf-gas принял запрос: обновление начнётся после него. Шаг запуска завершён,
                                // ход обновления отслеживает CHECK_GAS.
                                val launchDescription = "Запущено новое обновление seaf-gas"
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = taskInstance,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.SUCCESS.name,
                                    successMessage = launchDescription,
                                    taskData = taskDataJson
                                )
                                log.info("Запуск обновления seaf-gas: {}", launchDescription)
                                data.currentStep = ManifestReloadTaskModel.Step.CHECK_GAS
                                CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                            }
                            UpdateStatus.ERROR -> {
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = taskInstance,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.ERROR.name,
                                    errorMessage = status.errorMessage,
                                    taskData = taskDataJson
                                )
                                log.error("Ошибка запуска обновления seaf-gas: {}", status.errorMessage)
                                CompletionHandler.OnCompleteRemove()
                            }
                            else -> {
                                // seaf-gas выполняет обновление, начатое до запроса, и запрос не принял: его итог
                                // не покрывает изменения, ради которых запущена задача. Повторяем запуск, пока
                                // seaf-gas не примет запрос.
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = taskInstance,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.IN_PROGRESS.name,
                                    taskData = taskDataJson
                                )
                                log.debug("seaf-gas уже выполняет обновление (статус {}), повторяем запуск", status.status)
                                CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                            }
                        }
                    }
                    ManifestReloadTaskModel.Step.CHECK_GAS -> {
                        val status = seafGasServiceClient.status()
                        historyService.saveUpdateStatus(
                            taskName = TASK_NAME,
                            taskInstance = taskInstance,
                            stepName = data.currentStep.name,
                            stepStatus = status.status.name,
                            errorMessage = status.errorMessage,
                            taskData = taskDataJson
                        )
                        log.debug("Проверка статуса seaf-gas: {}", status)
                        when (status.status) {
                            UpdateStatus.SUCCESS -> {
                                log.info("Seaf-gas успешно обновлен. Переход к порталу SEAF.")
                                data.currentStep = ManifestReloadTaskModel.Step.START_SEPORTAL_RELOAD
                                CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                            }
                            UpdateStatus.SCHEDULED -> {
                                log.trace("Обновление seaf-gas еще не начато, продолжаем наблюдение")
                                CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                            }
                            UpdateStatus.IN_PROGRESS -> {
                                log.trace("Обновление seaf-gas выполняется, продолжаем наблюдение")
                                CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                            }
                            UpdateStatus.ERROR -> {
                                log.error("Обновление seaf-gas завершилось с ошибкой: {}", status.errorMessage)
                                CompletionHandler.OnCompleteRemove()
                            }
                        }
                    }
                    ManifestReloadTaskModel.Step.START_SEPORTAL_RELOAD -> {
                        val status = backendServiceClient.reload(
                            backend = data.backend,
                            secret = data.secret,
                            reloadRoot = data.reloadRoot,
                            mode = data.mode,
                            aliases = data.aliases
                        )
                        if(status.error == null) {
                            log.info("Запуск обновления портала SEAF с сообщением {}", status.message)
                            // Ответ seaf-core одинаков независимо от того, шла ли уже перезагрузка; если шла,
                            // запрос выполняется после её завершения. Поэтому фиксируем только факт принятия
                            // запроса и сообщение портала как есть.
                            historyService.saveUpdateStatus(
                                taskName = TASK_NAME,
                                taskInstance = taskInstance,
                                stepName = data.currentStep.name,
                                stepStatus = UpdateStatus.SUCCESS.name,
                                successMessage = "Портал SEAF принял запрос на перезагрузку" + (status.message?.let { ": $it" } ?: ""),
                                taskData = taskDataJson
                            )
                            data.currentStep = ManifestReloadTaskModel.Step.CHECK_SEPORTAL
                            CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                        } else {
                            log.error("Ошибка запуска обновления портала SEAF {}", status.error)
                            historyService.saveUpdateStatus(
                                taskName = TASK_NAME,
                                taskInstance = taskInstance,
                                stepName = data.currentStep.name,
                                stepStatus = UpdateStatus.ERROR.name,
                                errorMessage = status.error,
                                taskData = taskDataJson
                            )
                            CompletionHandler.OnCompleteRemove()
                        }
                    }
                    ManifestReloadTaskModel.Step.CHECK_SEPORTAL -> {
                        val status = backendServiceClient.status(
                            backend = data.backend,
                        )
                        log.debug("Проверка статуса портала SEAF...")
                        when (status.status) {
                            "ready" -> {
                                log.info("Обновление портала SEAF успешно завершено")
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = taskInstance,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.SUCCESS.name,
                                    taskData = taskDataJson
                                )
                                CompletionHandler.OnCompleteRemove()
                            }
                            "error" -> {
                                log.error("Обновление портала SEAF завершено с ошибкой, посмотрите лог портала SEAF")
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = taskInstance,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.ERROR.name,
                                    errorMessage = "Портал не возвращает данные об ошибке при обновлении",
                                    taskData = taskDataJson
                                )
                                CompletionHandler.OnCompleteRemove()
                            }
                            else -> {
                                log.trace("Обновление портала SEAF выполняется, продолжаем наблюдение: {}", status.status)
                                historyService.saveUpdateStatus(
                                    taskName = TASK_NAME,
                                    taskInstance = taskInstance,
                                    stepName = data.currentStep.name,
                                    stepStatus = UpdateStatus.IN_PROGRESS.name,
                                    taskData = taskDataJson
                                )
                                CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
                            }
                        }
                    }
                }
            } catch (e: Exception) {
                historyService.saveUpdateStatus(
                    taskName = TASK_NAME,
                    taskInstance = taskInstance,
                    stepName = data.currentStep.name,
                    stepStatus = UpdateStatus.ERROR.name,
                    errorMessage = e.message,
                    taskData = taskDataJson
                )
                log.error("Критическая ошибка на шаге ${data.currentStep} обновления манифеста: ${e.message}", e)
                CompletionHandler.OnCompleteRemove()
            } catch (e: Throwable) {
                // Error (например, NoClassDefFoundError) — не пытаемся продолжать штатную логику
                // (реранить/reschedule), а фиксируем статус в истории и пробрасываем дальше, чтобы
                // не остаться в промежуточном статусе навсегда и не притворяться, что всё в порядке.
                historyService.saveUpdateStatus(
                    taskName = TASK_NAME,
                    taskInstance = taskInstance,
                    stepName = data.currentStep.name,
                    stepStatus = UpdateStatus.ERROR.name,
                    errorMessage = e.message,
                    taskData = taskDataJson
                )
                log.error("Критическая ошибка JVM на шаге ${data.currentStep} обновления манифеста: ${e.message}", e)
                throw e
            }
        }
    }

    @Bean
    fun reloadScheduleSpawnerTask(
        reloadTask: Task<ManifestReloadTaskModel>,
        backendServiceClient: BackendServiceClient,
        serviceProperties: ServiceProperties
    ): Task<Void> {
        return Tasks.recurring(
            TASK_SPAWNER_NAME,
            Schedules.fixedDelay(serviceProperties.reloadScheduleSpawnerRate)
        ).execute { _, context ->
            val schedulerClient = context.schedulerClient
            val now = LocalDateTime.now()
            for ((backend, backendConfig) in backendServiceClient.backends()) {
                val dueSchedule = selectDueSchedule(
                    backendConfig.reloadSchedules,
                    now,
                    serviceProperties.reloadScheduleSpawnerRate
                )
                if (dueSchedule == null) {
                    log.trace("Пропускаем бэкенд {}", backend)
                    continue
                } else {
                    log.trace("Начинаем обновление бэкенда {}", backend)
                }
                try {
                    val initialData = ManifestReloadTaskModel(
                        backend = backend,
                        secret = backendConfig.secret,
                        reloadRoot = dueSchedule.reloadRoot,
                        mode = dueSchedule.mode,
                        aliases = dueSchedule.alias,
                        scheduleId = dueSchedule.id
                    )
                    val taskInstance = reloadTask.instance(instanceId(backend), initialData)
                    val isScheduled = schedulerClient.scheduleIfNotExists(taskInstance, Instant.now())
                    if (isScheduled) {
                        log.info("Запущена перезагрузка манифеста по расписанию '{}' для бэкенда '{}'.", dueSchedule.id, backend)
                    } else {
                        log.warn(
                            "Расписание '{}' для бэкенда '{}' пропущено: перезагрузка манифеста для этого бэкенда уже выполняется.",
                            dueSchedule.id, backend
                        )
                    }
                } catch (e: Exception) {
                    log.error(
                        "Непредвиденная ошибка при старте задачи перезагрузки манифеста по расписанию '{}' для бэкенда '{}': {}",
                        dueSchedule.id, backend, e.message, e
                    )
                } catch (e: Throwable) {
                    // Error пробрасываем дальше вместо продолжения цикла по остальным бэкендам —
                    // это оборвёт обработку оставшихся due-бэкендов в этом тике (они будут подхвачены
                    // на следующем тике), но не даст притвориться, что всё в порядке.
                    log.error(
                        "Критическая ошибка JVM при старте задачи перезагрузки манифеста по расписанию '{}' для бэкенда '{}': {}",
                        dueSchedule.id, backend, e.message, e
                    )
                    throw e
                }
            }
        }
    }

    internal fun selectDueSchedule(
        schedules: List<ReloadScheduleModel>,
        now: LocalDateTime,
        tickInterval: Duration
    ): ReloadScheduleModel? =
        schedules.firstOrNull { schedule ->
            val due = isDue(schedule.cronExpression, now, tickInterval)
            log.trace("Правило {}: enabled = {}, isDue = {}", schedule.id, schedule.enabled, due)
            schedule.enabled && due
        }

    internal fun isDue(cronExpression: CronExpression, now: LocalDateTime, tickInterval: Duration): Boolean {
        val windowStart = now.minus(tickInterval)
        val next = cronExpression.next(windowStart)
        return next != null && !next.isAfter(now)
    }
}