GasSenderScheduler.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.archloader.service.scheduler

import java.util.concurrent.Executors
import java.util.concurrent.RejectedExecutionException
import kotlin.io.path.exists
import kotlin.io.path.inputStream
import org.slf4j.LoggerFactory
import org.springframework.core.io.FileSystemResource
import org.springframework.scheduling.annotation.Scheduled
import org.springframework.stereotype.Component
import org.archtool.archloader.configuration.properties.SchedulersProperties
import org.archtool.archloader.exception.UserDataException
import org.archtool.archloader.service.TaskStoreService
import org.archtool.archloader.service.dto.UploadTask
import org.archtool.archloader.service.integraion.gas.GasApiClient
import org.archtool.archloader.service.integraion.gas.dto.GasSendRequest
import org.archtool.archloader.utils.ChecksumUtils
import org.archtool.archloader.utils.DateTimeComponent
import org.archtool.archloader.utils.TraceIdWrapper

@Component
class GasSenderScheduler(
    private val taskStoreService: TaskStoreService,
    private val gasApiClient: GasApiClient,
    private val dateTimeComponent: DateTimeComponent,
    private val checksumUtils: ChecksumUtils,
    private val traceIdWrapper: TraceIdWrapper,
    schedulersProperties: SchedulersProperties,
) {

    private val properties = schedulersProperties.gas
    private val executor = Executors.newFixedThreadPool(properties.workerThreadCount)
    private val log = LoggerFactory.getLogger(javaClass)

    init {
        log.info(
            "Шедулер запущен с {} потоками воркерами и частотой запуска {}",
            properties.workerThreadCount,
            properties.rate.toString(),
        )
    }

    @Scheduled(fixedRateString = "\${seaf.schedulers.gas.rate}")
    fun scheduleTask() {
        generateSequence {
            taskStoreService.moveTaskToStatus(
                currentStatus = UploadTask.Status.GIT_SEND_NEW,
                nextStatus = UploadTask.Status.GIT_SEND_IN_PROGRESS
            )
        }.forEach { nextTask ->
            val presStatusDesc = nextTask.statusDesc
            try {
                nextTask.statusDesc = "Процесс отправки в git"
                executor.submit {
                    traceIdWrapper(nextTask.traceHeaders) {
                        try {
                            exec(task = nextTask)
                        } catch (e: UserDataException) {
                            log.error("Ошибка в пользовательских данных при отправке запроса в git", e)
                            nextTask.status = UploadTask.Status.ERROR
                            nextTask.statusDesc = e.message
                        } catch (e: Exception) {
                            log.error("Непойманная Exception при отправке запроса в git", e)
                            nextTask.status = UploadTask.Status.ERROR
                            nextTask.statusDesc = UNEXPECTED_TASK_ERROR_DESC
                        } catch (e: Throwable) {
                            log.error("Непойманная Throwable при отправке запроса в git", e)
                            nextTask.status = UploadTask.Status.ERROR
                            nextTask.statusDesc = THROWABLE_DESC
                            throw e
                        }
                    }
                }
                log.debug("Задача передана на отправку в git")
            } catch (e: RejectedExecutionException) {
                // откатываем статус задачи на NEW, чтобы взять в следующий раз, если не получилось обработать
                nextTask.status = UploadTask.Status.GIT_SEND_NEW
                nextTask.statusDesc = presStatusDesc
                log.warn(
                    "Пул не принял задачу {} на выполнение, возвращаем в статус {}, эту итерацию шедулера пропускаем, " +
                            "ждем пока очередь разберется, если ошибка повторяется часто, надо проверять количество запросов и время обработки",
                    nextTask.id, nextTask.status, e
                )
                return@forEach // выходим из цикла т.к. очередь заполнена
            } catch (e: Exception) {
                nextTask.status = UploadTask.Status.ERROR
                nextTask.statusDesc = UNEXPECTED_TASK_ERROR_DESC
                log.error(
                    "Ошибка при попытке запустить задачу {} в работу, переводим в статус {}",
                    nextTask.id,
                    nextTask.status,
                    e
                )
            }
        }
    }

    private fun exec(task: UploadTask) {
        log.debug("Начали обработку задачи {}, должны отправить файл {} в git", task.id, task.gitZipFile?.path)
        log.trace("Данные по задаче {}", task)

        val zipFile = task.gitZipFile
        if (zipFile == null) {
            log.error(
                "По непонятной причине данные для отправки в git не заполнены, но задача переведена в статус " +
                        "GIT_SEND_NEW, такого не должно случатся, если повторяется, следует включить логи (дебаг/трейс) и повторить запрос"
            )
            throw RuntimeException("В задаче не был создан архив для отправки в git, указано null")
        }
        if (!zipFile.path.exists()) {
            log.error(
                "Файл для отправки в git не найден: {} на диске, стоит проверить лог, вдруг у задачи истек ttl, " +
                        "она должна быть удалена не раньше ({})", zipFile, task.timing.deleteTaskAfter
            )
            throw RuntimeException("При обработке задачи не найден файл")
        }
        zipFile.path.inputStream().use { fileInputStream ->
            checksumUtils.validateChecksum(
                inputStream = fileInputStream,
                expectedChecksum = zipFile.checksum,
                context = "Проверка checksum сгенерированного файла для git перед отправкой"
            )
        }
        val resource = FileSystemResource(zipFile.path)
        val repoUrl = task.repoInfo.url
        val request = GasSendRequest(
            processId = task.metaData.type,
            repoUrl = repoUrl,
            file = resource,
            fileChecksum = zipFile.checksum,
            sub = task.userData.sub,
            name = task.userData.name,
            surname = task.userData.surname,
            email = task.userData.email
        )

        try {
            val response = gasApiClient.sendArchitecture(request)
            if (response.status == GAS_SUCCESS_STATUS) {
                log.debug("Архитектура успешно передана в git адаптер и получен статус {}", GAS_SUCCESS_STATUS)
                task.status = UploadTask.Status.FINISH
                task.statusDesc = response.message
                task.timing.gasSendTime = dateTimeComponent.now()
            } else {
                log.error(
                    "Ошибка при отправке задачи в GAS: в ответ на запрос вернулся статус {}, а мы ожидаем {}," +
                            " для просмотра ответа от gas можно включить debug лог у {}",
                    response.status,
                    GAS_SUCCESS_STATUS,
                    gasApiClient.javaClass.name
                )
                task.status = UploadTask.Status.ERROR
                task.statusDesc = response.message
            }
        } catch (e: Exception) {
            task.status = UploadTask.Status.ERROR
            task.statusDesc = "${UNEXPECTED_TASK_ERROR_DESC}: сохранение прошло не успешно"
            log.error("Ошибка при отправке задачи в GAS", e)
        }
    }

    companion object {
        private const val UNEXPECTED_TASK_ERROR_DESC = "Ошибка при отправке файла в git"
        private const val THROWABLE_DESC =
            "Системная ошибка, обратитесь в поддержку указав traceId и taskId"
        private const val GAS_SUCCESS_STATUS = "success"
    }

}