OpenFlare/internal/apps/openflare/async_tasks.go

// Copyright 2026 Arctel.net
// SPDX-License-Identifier: Apache-2.0

// Package openflare implements openflare configuration, service orchestration, and background tasks.
package openflare

import (
	"context"
	"fmt"
	"sync"
	"time"

	"github.com/Rain-kl/Wavelet/internal/apps/openflare/tasks"
	"github.com/Rain-kl/Wavelet/internal/apps/openflare/uptimekuma"
	"github.com/Rain-kl/Wavelet/internal/apps/openflare/waf"
	"github.com/Rain-kl/Wavelet/internal/infra/task"
	"github.com/Rain-kl/Wavelet/internal/model"
	"github.com/Rain-kl/Wavelet/internal/repository"
)

const (
	// SSLRenewTask renews due ACME TLS certificates.
	SSLRenewTask = "openflare:ssl_renew"
	// TaskTypeSSLRenew is the admin task type for SSL renewal.
	TaskTypeSSLRenew = "of_ssl_renew"

	// WAFIPGroupSyncTask syncs due automatic/subscription WAF IP groups.
	WAFIPGroupSyncTask = "openflare:waf_ip_group_sync"
	// TaskTypeWAFIPGroupSync is the admin task type for WAF IP group sync.
	TaskTypeWAFIPGroupSync = "of_waf_ip_group_sync"

	// UptimeKumaSyncTask synchronizes proxy routes to Uptime Kuma monitors.
	UptimeKumaSyncTask = "openflare:uptime_kuma_sync"
	// TaskTypeUptimeKumaSync is the admin task type for Uptime Kuma sync.
	TaskTypeUptimeKumaSync = "of_uptime_kuma_sync"

	// LogDBSwitchTask 切换日志数据库任务标识。
	LogDBSwitchTask = "openflare:log_db_switch"
	// TaskTypeLogDBSwitch is the admin task type for log database switch.
	TaskTypeLogDBSwitch = "of_log_db_switch"
)

var (
	lastUptimeKumaSyncTime time.Time
	uptimeKumaSyncMutex    sync.Mutex
)

// SSLRenewMeta describes the SSL renewal task.
var SSLRenewMeta = task.TaskMeta{
	Type:         TaskTypeSSLRenew,
	AsynqTask:    SSLRenewTask,
	Name:         "OpenFlare automatic SSL renewal",
	Description:  "Scan ACME certificates nearing expiration and renew them automatically",
	SupportsTime: false,
	MaxRetry:     task.DefaultMaxRetry,
	Queue:        task.QueueDefault,
	Retryable:    true,
}

// WAFIPGroupSyncMeta describes the WAF IP group sync task.
var WAFIPGroupSyncMeta = task.TaskMeta{
	Type:         TaskTypeWAFIPGroupSync,
	AsynqTask:    WAFIPGroupSyncTask,
	Name:         "OpenFlare WAF IP group synchronization",
	Description:  "Synchronize automatic and subscription WAF IP groups that are due for an update",
	SupportsTime: false,
	MaxRetry:     task.DefaultMaxRetry,
	Queue:        task.QueueDefault,
	Retryable:    true,
}

// UptimeKumaSyncMeta describes the Uptime Kuma sync task.
var UptimeKumaSyncMeta = task.TaskMeta{
	Type:         TaskTypeUptimeKumaSync,
	AsynqTask:    UptimeKumaSyncTask,
	Name:         "OpenFlare Uptime Kuma synchronization",
	Description:  "Synchronize enabled proxy routes with Uptime Kuma monitors",
	SupportsTime: false,
	MaxRetry:     task.DefaultMaxRetry,
	Queue:        task.QueueDefault,
	Retryable:    true,
}

// LogDBSwitchMeta 描述切换日志数据库任务。
var LogDBSwitchMeta = task.TaskMeta{
	Type:         TaskTypeLogDBSwitch,
	AsynqTask:    LogDBSwitchTask,
	Name:         "Switch log database",
	Description:  "Copy log data and switch the log database on success; log writes are paused during migration",
	SupportsTime: false,
	MaxRetry:     task.DefaultMaxRetry,
	Queue:        task.QueueDefault,
	Retryable:    true,
	Params: []task.TaskParam{
		{Name: "target", Label: "Target log database", Type: "string", Required: true,
			Placeholder: "postgres|sqlite|clickhouse", Description: "Migration target: postgres for a PostgreSQL primary, sqlite for a SQLite primary, or clickhouse"},
	},
}

// SSLRenewHandler renews due TLS certificates.
type SSLRenewHandler struct{}

// Execute runs SSL certificate renewal for all due certificates.
func (h *SSLRenewHandler) Execute(ctx context.Context, _ []byte) (*task.TaskResult, error) {
	task.AppendLog(ctx, "Scanning certificates due for renewal")
	if err := tasks.RunSSLRenewJob(ctx); err != nil {
		task.AppendLog(ctx, "Automatic SSL renewal failed: %v", err)
		return nil, err
	}
	msg := "Automatic SSL renewal task completed"
	task.AppendLog(ctx, "%s", msg)
	return &task.TaskResult{Message: msg}, nil
}

// WAFIPGroupSyncHandler syncs due WAF IP groups to agents.
type WAFIPGroupSyncHandler struct{}

// Execute syncs all due automatic/subscription WAF IP groups.
func (h *WAFIPGroupSyncHandler) Execute(ctx context.Context, _ []byte) (*task.TaskResult, error) {
	task.AppendLog(ctx, "Synchronizing WAF IP groups due for an update")
	if err := waf.SyncDueWAFIPGroups(ctx); err != nil {
		task.AppendLog(ctx, "WAF IP group synchronization failed: %v", err)
		return nil, err
	}
	msg := "WAF IP group synchronization completed"
	task.AppendLog(ctx, "%s", msg)
	return &task.TaskResult{Message: msg}, nil
}

// UptimeKumaSyncHandler synchronizes proxy routes to Uptime Kuma.
type UptimeKumaSyncHandler struct{}

// Execute runs Uptime Kuma sync when integration is enabled and the interval has elapsed.
func (h *UptimeKumaSyncHandler) Execute(ctx context.Context, _ []byte) (*task.TaskResult, error) {
	// 从 SystemConfig 读取 UptimeKuma 配置
	enabled, _ := repository.GetBoolByKey(ctx, model.ConfigKeyUptimeKumaEnabled)
	if !enabled {
		msg := "Uptime Kuma integration is disabled; skipping execution"
		task.AppendLog(ctx, "%s", msg)
		return &task.TaskResult{Message: msg}, nil
	}

	interval, _ := repository.GetIntByKey(ctx, model.ConfigKeyUptimeKumaSyncInterval)
	if interval <= 0 {
		interval = 5
	}
	if time.Since(lastUptimeKumaSyncTime) < time.Duration(interval)*time.Minute {
		msg := fmt.Sprintf("Less than %d minutes since the last synchronization; skipping execution", interval)
		task.AppendLog(ctx, "%s", msg)
		return &task.TaskResult{Message: msg}, nil
	}

	if !uptimeKumaSyncMutex.TryLock() {
		msg := "Uptime Kuma synchronization is already running; skipping this schedule"
		task.AppendLog(ctx, "%s", msg)
		return &task.TaskResult{Message: msg}, nil
	}
	defer uptimeKumaSyncMutex.Unlock()

	task.AppendLog(ctx, "Synchronizing proxy routes with Uptime Kuma")
	if err := uptimekuma.SyncToUptimeKuma(ctx); err != nil {
		task.AppendLog(ctx, "Uptime Kuma synchronization failed: %v", err)
		return nil, err
	}

	lastUptimeKumaSyncTime = time.Now()
	msg := "Uptime Kuma synchronization completed"
	task.AppendLog(ctx, "%s", msg)
	return &task.TaskResult{Message: msg}, nil
}