init push

2026-07-16 22:16:45 +07:00
commit 8b068bdb10
1021 changed files with 332816 additions and 0 deletions
--- a/internal/app/worker/file_processing_runner.go
+++ b/internal/app/worker/file_processing_runner.go
@@ -0,0 +1,193 @@
+package worker
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"wucher/internal/config"
+	"wucher/internal/shared/pkg/metrics"
+	"wucher/internal/queue"
+)
+
+type FileProcessingRunner struct {
+	worker            *queue.FileProcessingWorker
+	consumer          queue.QueueConsumer
+	dispatcher        *FileProcessingOutboxDispatcher
+	logger            *slog.Logger
+	monitorAddr       string
+	depthPollInterval time.Duration
+	shutdownTimeout   time.Duration
+	backend           string
+	monitorServer     *http.Server
+}
+
+func NewFileProcessingRunner(
+	cfg config.FileQueueConfig,
+	consumer queue.QueueConsumer,
+	serializer queue.FileProcessingMessageSerializer,
+	handler queue.FileProcessingJobHandler,
+	idempotency queue.IdempotencyStore,
+	dispatcher *FileProcessingOutboxDispatcher,
+	logger *slog.Logger,
+) *FileProcessingRunner {
+	if logger == nil {
+		logger = slog.Default()
+	}
+	metrics := queue.NewMetrics()
+	health := queue.NewHealthReporter(cfg.WorkerHealthErrorThreshold)
+	worker := queue.NewFileProcessingWorker(queue.WorkerConfig{
+		Concurrency:      cfg.WorkerConcurrency,
+		MaxBatchSize:     cfg.WorkerMaxBatchSize,
+		ProcessTimeout:   cfg.WorkerProcessTimeout,
+		ProcessingTTL:    cfg.ProcessingTTL,
+		IdempotencyTTL:   cfg.IdempotencyTTL,
+		PollErrorDelay:   cfg.WorkerBackoffMin,
+		MetricsComponent: "file_worker",
+	}, consumer, serializer, handler, queue.NewExponentialBackoffPolicy(cfg.WorkerBackoffMin, cfg.WorkerBackoffMax, cfg.WorkerPermanentFailureDelay), idempotency, metrics, health, logger)
+
+	backend := ""
+	if consumer != nil {
+		backend = consumer.Backend()
+	}
+	return &FileProcessingRunner{
+		worker:            worker,
+		consumer:          consumer,
+		dispatcher:        dispatcher,
+		logger:            logger,
+		monitorAddr:       cfg.WorkerMonitorAddr,
+		depthPollInterval: cfg.WorkerDepthPollInterval,
+		shutdownTimeout:   cfg.WorkerShutdownTimeout,
+		backend:           backend,
+	}
+}
+
+func (r *FileProcessingRunner) Start(ctx context.Context) error {
+	if r.worker == nil {
+		return errors.New("worker is required")
+	}
+	runCtx, cancelRun := context.WithCancel(ctx)
+	defer cancelRun()
+	if err := r.startMonitor(); err != nil {
+		return err
+	}
+	pollerDone := make(chan struct{})
+	go func() {
+		defer close(pollerDone)
+		r.runDepthPoller(runCtx)
+	}()
+
+	workerErrCh := make(chan error, 1)
+	go func() {
+		workerErrCh <- r.worker.Run(runCtx)
+	}()
+
+	var dispatcherErrCh chan error
+	if r.dispatcher != nil {
+		dispatcherErrCh = make(chan error, 1)
+		go func() {
+			dispatcherErrCh <- r.dispatcher.Run(runCtx)
+		}()
+	}
+
+	var err error
+	select {
+	case err = <-workerErrCh:
+		cancelRun()
+		if dispatcherErrCh != nil {
+			if dispatcherErr := <-dispatcherErrCh; err == nil {
+				err = dispatcherErr
+			}
+		}
+	case err = <-dispatcherErrCh:
+		cancelRun()
+		if workerErr := <-workerErrCh; err == nil {
+			err = workerErr
+		}
+	}
+
+	cancelRun()
+	shutdownCtx, cancel := context.WithTimeout(context.Background(), r.shutdownTimeout)
+	defer cancel()
+	if r.monitorServer != nil {
+		_ = r.monitorServer.Shutdown(shutdownCtx)
+	}
+	if r.consumer != nil {
+		_ = r.consumer.Close()
+	}
+	<-pollerDone
+	return err
+}
+
+func (r *FileProcessingRunner) startMonitor() error {
+	if r.monitorAddr == "" {
+		return nil
+	}
+	mux := http.NewServeMux()
+	mux.HandleFunc("/health", r.handleHealth)
+	mux.Handle("/metrics", metrics.PromHTTPHandler())
+	r.monitorServer = &http.Server{
+		Addr:              r.monitorAddr,
+		Handler:           mux,
+		ReadHeaderTimeout: 5 * time.Second,
+	}
+	go func() {
+		r.logger.Info("file worker monitor listening",
+			slog.String("addr", r.monitorAddr),
+			slog.String("backend", r.backend),
+		)
+		if err := r.monitorServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			r.logger.Error("file worker monitor failed", slog.Any("error", err))
+		}
+	}()
+	return nil
+}
+
+func (r *FileProcessingRunner) runDepthPoller(ctx context.Context) {
+	if r.depthPollInterval <= 0 {
+		return
+	}
+	ticker := time.NewTicker(r.depthPollInterval)
+	defer ticker.Stop()
+	for {
+		refreshCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		_ = r.worker.RefreshQueueDepth(refreshCtx)
+		cancel()
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+		}
+	}
+}
+
+func (r *FileProcessingRunner) handleHealth(w http.ResponseWriter, _ *http.Request) {
+	snapshot := struct {
+		Backend string                 `json:"backend"`
+		Health  queue.HealthSnapshot   `json:"health"`
+		Metrics queue.MetricsSnapshot  `json:"metrics"`
+		Outbox  *OutboxMetricsSnapshot `json:"outbox,omitempty"`
+	}{
+		Backend: r.backend,
+		Health:  r.worker.Health().Snapshot(),
+		Metrics: r.worker.Metrics().Snapshot(),
+	}
+	if r.dispatcher != nil {
+		snapshot.Outbox = ptr(r.dispatcher.Metrics())
+	}
+	statusCode := http.StatusOK
+	if snapshot.Health.Status == "degraded" {
+		statusCode = http.StatusServiceUnavailable
+	}
+	writeFileWorkerJSON(w, statusCode, snapshot)
+}
+
+func writeFileWorkerJSON(w http.ResponseWriter, statusCode int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
+	_ = json.NewEncoder(w).Encode(payload)
+}