ZipValidator.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:
      Sergeev Viktor <sergeevviktor017@gmail.com>, Sber - 2025

  Contributors:
      Sergeev Viktor <sergeevviktor017@gmail.com>, Sber - 2025
*/

package org.archtool.archloader.service.zip.income

import java.util.zip.ZipEntry
import java.util.zip.ZipInputStream
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Component
import org.springframework.web.multipart.MultipartFile
import org.archtool.archloader.configuration.properties.ZipProperties
import org.archtool.archloader.exception.UserDataException
import org.archtool.archloader.service.dto.ArchZipMeta
import org.archtool.archloader.service.zip.FileConst
import tools.jackson.databind.json.JsonMapper
import tools.jackson.module.kotlin.readValue

@Component
class ZipValidator(
    private val jsonMapper: JsonMapper,
    zipProperties: ZipProperties,
) {

    private val log = LoggerFactory.getLogger(javaClass)
    private val maxPayloadUnzipSizeBytes = zipProperties.maxPayloadUnzipSize.toBytes()
    private val maxMetaUnzipSizeBytes = zipProperties.maxMetaUnzipSize.toBytes()

    fun validateAndExtractMeta(file: MultipartFile): ArchZipMeta {

        var payloadEntry: ZipEntry? = null
        var meta: ArchZipMeta? = null

        try {
            ZipInputStream(file.inputStream).use { zipStream ->
                generateSequence {
                    //для валидации нам нужны только payloadEntry и meta
                    // если обоих нашли (оба не null), идти дальше по архиву не нужно (возвращаем null для выхода)
                    if (payloadEntry != null && meta != null) {
                        null
                    } else {
                        zipStream.nextEntry
                    }
                }.forEach { entry ->
                    when (entry.name) {
                        FileConst.PAYLOAD_JSON_FILE_NAME -> payloadEntry = entry
                        FileConst.META_JSON_FILE_NAME -> meta = readMeta(zipStream, entry)
                    }
                }
            }
        } catch (e: Exception) {
            log.error("Ошибка при чтении файла в запросе", e)
            throw e
        }

        log.debug("{} из zip {}", FileConst.META_JSON_FILE_NAME, meta)
        log.debug(
            "{} в zip существует? ({}) и имеет размер {} байт",
            FileConst.PAYLOAD_JSON_FILE_NAME,
            payloadEntry != null,
            payloadEntry?.size
        )
        if (meta == null) {
            throw UserDataException(
                "Обязательный файл ${FileConst.META_JSON_FILE_NAME} не найден / пустой / содержит сломанный json, " +
                        "Должен быть такой структуры ${ArchZipMeta.DESCRIBE_DTO_HINT}"
            )
        }
        if (payloadEntry == null) {
            throw UserDataException("Обязательный файл: ${FileConst.PAYLOAD_JSON_FILE_NAME} не найден")
        }
        if (payloadEntry.size > maxPayloadUnzipSizeBytes) {
            throw UserDataException("Размер распакованного файла ${FileConst.PAYLOAD_JSON_FILE_NAME} (${payloadEntry.size} байт) превышает лимит: $maxPayloadUnzipSizeBytes байт")
        }
        return meta
    }

    private fun readMeta(inputStream: ZipInputStream, entry: ZipEntry): ArchZipMeta? {
        if (entry.size > maxMetaUnzipSizeBytes) {
            log.error(
                "Размер {} в архиве ({}) байт превышает лимит в {} байт, лимит для этого файла - защитый механизм," +
                        " его должно быть достаточно, т.к. данных не должно быть много. Необходимо проверить, что приходит" +
                        " в файле и при необходимости скорректировать лимит настройкой seaf.zip.max-meta-unzip-size",
                FileConst.META_JSON_FILE_NAME, entry.size, maxMetaUnzipSizeBytes
            )
            throw UserDataException(
                "Размер распакованного файла ${FileConst.META_JSON_FILE_NAME} " +
                        "(${entry.size} байт) превышает лимит: $maxMetaUnzipSizeBytes байт"
            )
        }
        val content = inputStream.bufferedReader()
            .readText()
        if (content.isBlank()) {
            log.warn(
                "файл {} пустой, так быть не должно, пользователю вернется ошибка bad request, " +
                        "это сообщение маркер, что каким-то образом пришел пустой файл",
                FileConst.META_JSON_FILE_NAME
            )
            return null
        }
        return try {
            jsonMapper.readValue<ArchZipMeta?>(content)
        } catch (e: Exception) {
            log.trace("содержимое файла {}: {}", FileConst.META_JSON_FILE_NAME, content)
            log.error(
                "Ошибка при парсинге {}, чтобы посмотреть видимый контент файла, необходимо включить " +
                        "логирование уровня trace и он появится в случае ошибки", FileConst.META_JSON_FILE_NAME, e
            )
            return null
        }
    }
}