142 lines
4.7 KiB
Go
142 lines
4.7 KiB
Go
package imagevariant
|
|
|
|
import (
|
|
"RenewCMS/api/pkg/apperr"
|
|
validator "RenewCMS/api/pkg/validator"
|
|
"RenewCMS/internal/domain/image"
|
|
"RenewCMS/internal/infrastructure/useCases"
|
|
"encoding/json"
|
|
"errors"
|
|
"math"
|
|
"net/http"
|
|
|
|
validatorlib "github.com/go-playground/validator/v10"
|
|
)
|
|
|
|
type cacheUnusedResponse struct {
|
|
Files int `json:"files"`
|
|
Bytes int64 `json:"bytes"`
|
|
Days int `json:"days"`
|
|
}
|
|
|
|
type cacheVariantResponse struct {
|
|
Name string `json:"name"`
|
|
Enabled bool `json:"enabled"`
|
|
Files int `json:"files"`
|
|
Bytes int64 `json:"bytes"`
|
|
}
|
|
|
|
type cacheImageResponse struct {
|
|
ID uint32 `json:"id"`
|
|
Filename string `json:"filename"`
|
|
URL string `json:"url"`
|
|
Files int `json:"files"`
|
|
Bytes int64 `json:"bytes"`
|
|
}
|
|
|
|
type cacheResponse struct {
|
|
GeneratedFiles int `json:"generated_files"`
|
|
DiskUsed int64 `json:"disk_used"`
|
|
VariantsDefined int `json:"variants_defined"`
|
|
VariantsEnabled int `json:"variants_enabled"`
|
|
VariantsDisabled int `json:"variants_disabled"`
|
|
RejectedRequests int `json:"rejected_requests"`
|
|
RejectedWindowDays int `json:"rejected_window_days"`
|
|
Unused cacheUnusedResponse `json:"unused"`
|
|
ByVariant []cacheVariantResponse `json:"by_variant"`
|
|
TopImages []cacheImageResponse `json:"top_images"`
|
|
}
|
|
|
|
type cachePurgeRequest struct {
|
|
Scope string `json:"scope" validate:"required,oneof=all unused variant image"`
|
|
Variant string `json:"variant" validate:"required_if=Scope variant"`
|
|
ImageID int64 `json:"image_id" validate:"required_if=Scope image,omitempty,gt=0,lte=4294967295"`
|
|
}
|
|
|
|
type cachePurgeResponse struct {
|
|
Scope string `json:"scope"`
|
|
PurgedFiles int `json:"purged_files"`
|
|
PurgedBytes int64 `json:"purged_bytes"`
|
|
FailedFiles int `json:"failed_files"`
|
|
}
|
|
|
|
func (r *cachePurgeRequest) ignoreUnusedTargets() {
|
|
if r.Scope != string(image.CacheScopeVariant) {
|
|
r.Variant = ""
|
|
}
|
|
if r.Scope != string(image.CacheScopeImage) {
|
|
r.ImageID = 0
|
|
}
|
|
}
|
|
|
|
func cacheResponseOf(stats useCases.VariantCacheStats) cacheResponse {
|
|
response := cacheResponse{
|
|
GeneratedFiles: stats.GeneratedFiles,
|
|
DiskUsed: stats.DiskUsed,
|
|
VariantsDefined: stats.VariantsDefined,
|
|
VariantsEnabled: stats.VariantsEnabled,
|
|
VariantsDisabled: stats.VariantsDisabled,
|
|
RejectedRequests: stats.RejectedRequests,
|
|
RejectedWindowDays: stats.RejectedWindowDays,
|
|
Unused: cacheUnusedResponse{Files: stats.Unused.Files, Bytes: stats.Unused.Bytes, Days: stats.UnusedDays},
|
|
ByVariant: make([]cacheVariantResponse, 0, len(stats.ByVariant)),
|
|
TopImages: make([]cacheImageResponse, 0, len(stats.TopImages)),
|
|
}
|
|
for _, entry := range stats.ByVariant {
|
|
response.ByVariant = append(response.ByVariant, cacheVariantResponse{Name: entry.Name, Enabled: entry.Enabled, Files: entry.Files, Bytes: entry.Bytes})
|
|
}
|
|
for _, top := range stats.TopImages {
|
|
response.TopImages = append(response.TopImages, cacheImageResponse{ID: top.ID, Filename: top.Filename, URL: top.URL, Files: top.Files, Bytes: top.Bytes})
|
|
}
|
|
return response
|
|
}
|
|
|
|
func (h *Handler) CacheStats(w http.ResponseWriter, _ *http.Request) {
|
|
stats, err := h.cacheStats.Get()
|
|
if err != nil {
|
|
h.writeError(w, "", err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, cacheResponseOf(stats))
|
|
}
|
|
|
|
func (h *Handler) PurgeCache(w http.ResponseWriter, r *http.Request) {
|
|
var request cachePurgeRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
|
http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
request.ignoreUnusedTargets()
|
|
if err := validator.Validate.Struct(request); err != nil {
|
|
http.Error(w, cachePurgeValidationMessage(err), http.StatusUnprocessableEntity)
|
|
return
|
|
}
|
|
|
|
result, err := h.purgeCache.Purge(r.Context(), useCases.PurgeVariantCacheCommand{
|
|
Scope: image.CachePurgeScope(request.Scope),
|
|
Variant: request.Variant,
|
|
ImageID: uint32(min(request.ImageID, math.MaxUint32)),
|
|
})
|
|
if err != nil {
|
|
h.writePurgeCacheError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, cachePurgeResponse{Scope: string(result.Scope), PurgedFiles: result.Files, PurgedBytes: result.Bytes, FailedFiles: result.Failed})
|
|
}
|
|
|
|
func cachePurgeValidationMessage(err error) string {
|
|
var failures validatorlib.ValidationErrors
|
|
if errors.As(err, &failures) && len(failures) > 0 && failures[0].StructField() != "Scope" {
|
|
return apperr.CachePurgeTargetErrorMessage
|
|
}
|
|
return apperr.CachePurgeScopeErrorMessage
|
|
}
|
|
|
|
func (h *Handler) writePurgeCacheError(w http.ResponseWriter, err error) {
|
|
if errors.Is(err, image.ErrImageNotFound) {
|
|
http.Error(w, apperr.ImageNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
h.writeError(w, "", err)
|
|
}
|