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
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.
*/
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.dto.LoadVersionsDto
import org.archtool.data.model.LoadBasesModel
import org.archtool.data.model.ManifestReloadTaskModel
import org.archtool.data.model.ReloadRequestModel
import org.archtool.data.model.ReloadScheduleModel
import org.archtool.data.model.ReloadTaskDataModel
import org.archtool.data.model.TaskStepStatus
import org.archtool.data.model.UpdateStatus
import org.archtool.helper.BackendServiceClient
import org.archtool.helper.UpdateServiceClient
import org.archtool.service.HistoryService
import org.archtool.service.reload.LoadVersionsCompletion
import org.archtool.service.TaskRelaunchService
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.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"
// Столько ответов /health/info подряд без версий загрузки (около минуты при периоде шага 10 с) - и
// CHECK_SEPORTAL переходит к проверке по /health, как до ERA-3627 (CAP-12, CAP-13)
const val MAX_POLLS_WITHOUT_VERSIONS = 6
fun instanceId(backend: String): String = "reload-manifest-task-instance-$backend"
}
private data class ReloadResult(
val request: ReloadRequestModel,
val message: String? = null,
val error: String? = null,
val loadVersions: LoadVersionsDto? = null
)
@Bean
fun reloadTask(
seafGasServiceClient: UpdateServiceClient,
backendServiceClient: BackendServiceClient,
serviceProperties: ServiceProperties,
historyService: HistoryService,
@Qualifier("jacksonJsonMapper") jsonMapper: JsonMapper,
taskRelaunchService: TaskRelaunchService
): Task<ManifestReloadTaskModel> {
return Tasks.custom(
TASK_NAME,
ManifestReloadTaskModel::class.java
).execute { instance, context ->
val data = instance.data
val taskDataJson = ReloadTaskDataModel.toJsonNode(data, jsonMapper)
val taskInstance = instanceId(data.backend)
val completeRun = taskRelaunchService.onComplete(context.schedulerClient, ManifestReloadRelaunch(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 = TaskStepStatus.SUCCESS,
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 = TaskStepStatus.ERROR,
errorMessage = status.errorMessage,
taskData = taskDataJson
)
log.error("Ошибка запуска обновления seaf-gas: {}", status.errorMessage)
completeRun
}
else -> {
// seaf-gas выполняет обновление, начатое до запроса, и запрос не принял: его итог
// не покрывает изменения, ради которых запущена задача. Повторяем запуск, пока
// seaf-gas не примет запрос.
historyService.saveUpdateStatus(
taskName = TASK_NAME,
taskInstance = taskInstance,
stepName = data.currentStep.name,
stepStatus = TaskStepStatus.IN_PROGRESS,
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 = TaskStepStatus.from(status.status),
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)
completeRun
}
}
}
ManifestReloadTaskModel.Step.START_SEPORTAL_RELOAD -> {
// Отказ по одному запросу не отменяет остальные: seaf-core сам склеивает запросы, пришедшие подряд.
val results = data.requests().map { sendReload(backendServiceClient, data.backend, it) }
val rejected = results.count { it.error != null }
val stepStatus = when (rejected) {
0 -> TaskStepStatus.SUCCESS
results.size -> TaskStepStatus.ERROR
else -> TaskStepStatus.PARTIAL_SUCCESS
}
historyService.saveUpdateStatus(
taskName = TASK_NAME,
taskInstance = taskInstance,
stepName = data.currentStep.name,
stepStatus = stepStatus,
errorMessage = reloadErrorMessage(results),
successMessage = reloadSuccessMessage(results),
taskData = taskDataJson
)
if (stepStatus == TaskStepStatus.ERROR) {
completeRun
} else {
data.loadBases = LoadVersionsCompletion.bases(results.filter { it.error == null }.map { it.loadVersions })
if (data.loadBases == null) {
log.info("seaf-core не вернул версии загрузки: завершение перезагрузки проверяется по /health")
}
data.currentStep = ManifestReloadTaskModel.Step.CHECK_SEPORTAL
CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
}
}
ManifestReloadTaskModel.Step.CHECK_SEPORTAL -> {
val bases = data.loadBases
val result = if (bases == null) {
checkByHealth(backendServiceClient, data.backend)
} else {
checkByLoadVersions(backendServiceClient, data, bases)
}
when (result) {
LoadVersionsCompletion.Result.InProgress -> {
historyService.saveUpdateStatus(
taskName = TASK_NAME,
taskInstance = taskInstance,
stepName = data.currentStep.name,
stepStatus = TaskStepStatus.IN_PROGRESS,
taskData = taskDataJson
)
CompletionHandler.OnCompleteReschedule(Schedules.fixedDelay(serviceProperties.reloadManifestSchedulerRate), data)
}
is LoadVersionsCompletion.Result.Finished -> {
if (result.status == TaskStepStatus.SUCCESS) {
log.info("Обновление портала SEAF успешно завершено")
} else {
log.error("Обновление портала SEAF завершено со статусом {}: {}", result.status, result.errorMessage)
}
historyService.saveUpdateStatus(
taskName = TASK_NAME,
taskInstance = taskInstance,
stepName = data.currentStep.name,
stepStatus = result.status,
errorMessage = result.errorMessage,
taskData = taskDataJson
)
completeRun
}
}
}
}
} catch (e: Exception) {
historyService.saveUpdateStatus(
taskName = TASK_NAME,
taskInstance = taskInstance,
stepName = data.currentStep.name,
stepStatus = TaskStepStatus.ERROR,
errorMessage = e.message,
taskData = taskDataJson
)
log.error("Критическая ошибка на шаге ${data.currentStep} обновления манифеста: ${e.message}", e)
completeRun
} catch (e: Throwable) {
// Error (например, NoClassDefFoundError) — не пытаемся продолжать штатную логику
// (реранить/reschedule), а фиксируем статус в истории и пробрасываем дальше, чтобы
// не остаться в промежуточном статусе навсегда и не притворяться, что всё в порядке.
historyService.saveUpdateStatus(
taskName = TASK_NAME,
taskInstance = taskInstance,
stepName = data.currentStep.name,
stepStatus = TaskStepStatus.ERROR,
errorMessage = e.message,
taskData = taskDataJson
)
log.error("Критическая ошибка JVM на шаге ${data.currentStep} обновления манифеста: ${e.message}", e)
throw e
}
}
}
// Проверка до ERA-3627 и при выкатке (CAP-13): /health не различает загрузки, ready засчитывается любой.
private fun checkByHealth(backendServiceClient: BackendServiceClient, backend: String): LoadVersionsCompletion.Result {
val status = backendServiceClient.status(backend = backend)
log.debug("Проверка статуса портала SEAF: {}", status.status)
return when (status.status) {
"ready" -> LoadVersionsCompletion.Result.Finished(TaskStepStatus.SUCCESS, null)
"error" -> LoadVersionsCompletion.Result.Finished(
TaskStepStatus.ERROR, "Портал не возвращает данные об ошибке при обновлении"
)
else -> LoadVersionsCompletion.Result.InProgress
}
}
// CAP-12: засчитываются только загрузки, начатые после запросов прогона.
private fun checkByLoadVersions(
backendServiceClient: BackendServiceClient,
data: ManifestReloadTaskModel,
bases: LoadBasesModel
): LoadVersionsCompletion.Result {
val loadVersions = backendServiceClient.healthInfo(data.backend).loadVersions
if (loadVersions == null) {
val polls = bases.pollsWithoutVersions + 1
if (polls >= MAX_POLLS_WITHOUT_VERSIONS) {
// core откатили во время прогона или он не может читать версии: без выхода прогон и очередь за ним
// ждали бы бесконечно. Дальше - как до ERA-3627
log.warn("seaf-core {} раз подряд не вернул версии загрузки в /health/info, завершение проверяется по /health", polls)
data.loadBases = null
return checkByHealth(backendServiceClient, data.backend)
}
// Одиночный ответ без версий на /health не переключает: ready от прошлой загрузки засчитался бы как успех
log.warn("seaf-core не вернул версии загрузки в /health/info ({} из {} подряд), продолжаем опрос", polls, MAX_POLLS_WITHOUT_VERSIONS)
data.loadBases = bases.copy(pollsWithoutVersions = polls)
return LoadVersionsCompletion.Result.InProgress
}
if (bases.pollsWithoutVersions > 0) {
data.loadBases = bases.copy(pollsWithoutVersions = 0)
}
log.debug("Версии загрузки портала SEAF: {}, базы прогона: {}", loadVersions, bases)
return LoadVersionsCompletion.check(bases, loadVersions)
}
private fun sendReload(
backendServiceClient: BackendServiceClient,
backend: String,
request: ReloadRequestModel
): ReloadResult =
try {
val status = backendServiceClient.reload(
backend = backend,
secret = request.secret,
reloadRoot = request.reloadRoot,
mode = request.mode,
aliases = request.aliases
)
if (status.error == null) {
log.info("Запуск обновления портала SEAF с сообщением {}", status.message)
} else {
log.error("Ошибка запуска обновления портала SEAF {}", status.error)
}
ReloadResult(request, status.message, status.error, status.loadVersions)
} catch (e: Exception) {
log.error("Запрос на перезагрузку портала SEAF отклонён: ${e.message}", e)
ReloadResult(request, error = e.message ?: e.toString())
}
// Ответ seaf-core одинаков независимо от того, шла ли уже перезагрузка; если шла, запрос выполняется
// после её завершения. Поэтому фиксируем только факт принятия запроса и сообщение портала как есть.
private fun reloadSuccessMessage(results: List<ReloadResult>): String? {
val accepted = results.filter { it.error == null }
return when {
accepted.isEmpty() -> null
results.size == 1 ->
"Портал SEAF принял запрос на перезагрузку" + (accepted.single().message?.let { ": $it" } ?: "")
else -> "Портал SEAF принял запросы на перезагрузку: ${accepted.size} из ${results.size}"
}
}
private fun reloadErrorMessage(results: List<ReloadResult>): String? =
results.filter { it.error != null }
.joinToString("; ") { "${describe(it.request)}: ${it.error}" }
.ifEmpty { null }
// Без secret: текст попадает в историю и отдаётся через API статуса.
private fun describe(request: ReloadRequestModel): String =
listOfNotNull(
request.reloadRoot?.let { "reloadRoot=$it" },
request.mode?.let { "mode=$it" },
request.aliases?.let { "alias=$it" },
request.scheduleId?.let { "scheduleId=$it" }
).joinToString(", ", "[", "]")
@Bean
fun reloadScheduleSpawnerTask(
backendServiceClient: BackendServiceClient,
serviceProperties: ServiceProperties,
taskRelaunchService: TaskRelaunchService
): 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 request = ReloadRequestModel(
secret = backendConfig.secret,
reloadRoot = dueSchedule.reloadRoot,
mode = dueSchedule.mode,
aliases = dueSchedule.alias,
scheduleId = dueSchedule.id
)
val isScheduled = taskRelaunchService.submit(schedulerClient, ManifestReloadRelaunch(backend), request)
if (isScheduled) {
log.info("Запущена перезагрузка манифеста по расписанию '{}' для бэкенда '{}'.", dueSchedule.id, backend)
} else {
log.info(
"Расписание '{}' для бэкенда '{}' поставлено в очередь: перезагрузка манифеста для этого бэкенда уже выполняется.",
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)
}
}