tesaibottelegramdukun / handler.go
ibaaaaal
🚀 feat: Go image processor microservice
5ef026e
Raw History Blame Contribute Delete
2.8 kB
package main
import (
"bytes"
"encoding/base64"
"image"
"image/jpeg"
_ "image/png"
"runtime"
"sync"
"time"
"github.com/disintegration/imaging"
"github.com/gofiber/fiber/v2"
)
type CompressRequest struct {
Images []string `json:"images"` // Base64 encoded images
Quality int `json:"quality"` // JPEG quality 1-100
MaxDim int `json:"max_dim"` // Max dimension for resize
}
type CompressResponse struct {
Results []string `json:"results"` // Base64 encoded results
ProcessingMs int64 `json:"processing_ms"` // Total processing time
Count int `json:"count"` // Number of images processed
Errors []string `json:"errors"` // Any errors encountered
}
func HandleCompress(c *fiber.Ctx) error {
start := time.Now()
var req CompressRequest
if err := c.BodyParser(&req); err != nil {
return c.Status(400).JSON(fiber.Map{"error": "Invalid request: " + err.Error()})
}
// Defaults
if req.Quality == 0 {
req.Quality = 85
}
if req.MaxDim == 0 {
req.MaxDim = 2048
}
if len(req.Images) == 0 {
return c.Status(400).JSON(fiber.Map{"error": "No images provided"})
}
// Process images in parallel
results := make([]string, len(req.Images))
errors := make([]string, len(req.Images))
var wg sync.WaitGroup
sem := make(chan struct{}, runtime.NumCPU()) // Limit concurrency to CPU count
for i, imgB64 := range req.Images {
wg.Add(1)
go func(idx int, data string) {
defer wg.Done()
sem <- struct{}{} // Acquire
defer func() { <-sem }() // Release
result, err := compressImage(data, req.Quality, req.MaxDim)
if err != nil {
errors[idx] = err.Error()
results[idx] = ""
return
}
results[idx] = result
}(i, imgB64)
}
wg.Wait()
// Filter out empty errors
var nonEmptyErrors []string
for _, e := range errors {
if e != "" {
nonEmptyErrors = append(nonEmptyErrors, e)
}
}
elapsed := time.Since(start).Milliseconds()
return c.JSON(CompressResponse{
Results: results,
ProcessingMs: elapsed,
Count: len(results),
Errors: nonEmptyErrors,
})
}
func compressImage(b64 string, quality, maxDim int) (string, error) {
// Decode base64
data, err := base64.StdEncoding.DecodeString(b64)
if err != nil {
return "", err
}
// Decode image
img, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return "", err
}
// Resize if needed (maintain aspect ratio)
bounds := img.Bounds()
w, h := bounds.Dx(), bounds.Dy()
if w > maxDim || h > maxDim {
img = imaging.Fit(img, maxDim, maxDim, imaging.Lanczos)
}
// Encode to JPEG
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
}