281 lines
8.7 KiB
Go
281 lines
8.7 KiB
Go
package cliproxy
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/router-for-me/CLIProxyAPI/v7/internal/config"
|
|
"github.com/router-for-me/CLIProxyAPI/v7/internal/home"
|
|
"github.com/router-for-me/CLIProxyAPI/v7/internal/homeplugins"
|
|
sdkpluginstore "github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginstore"
|
|
log "github.com/sirupsen/logrus"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
const homePluginStatusReportTimeout = 10 * time.Second
|
|
|
|
type homePluginStatusWork struct {
|
|
cfg *config.Config
|
|
report homeplugins.SyncReport
|
|
}
|
|
|
|
type homePluginTaskWork struct {
|
|
cfg *config.Config
|
|
task home.PluginTask
|
|
report *homeplugins.SyncReport
|
|
}
|
|
|
|
type homePluginFinalization struct {
|
|
config *config.Config
|
|
configCommit configCommit
|
|
committed bool
|
|
statusWork []homePluginStatusWork
|
|
nextStatus int
|
|
taskWork []homePluginTaskWork
|
|
nextTask int
|
|
syncKey string
|
|
markSynced bool
|
|
}
|
|
|
|
func (s *Service) syncHomePlugins(ctx context.Context, cfg *config.Config) (homeplugins.SyncReport, string, bool, error) {
|
|
return s.syncHomePluginsWithClient(ctx, cfg, nil)
|
|
}
|
|
|
|
func (s *Service) syncHomePluginsWithClient(ctx context.Context, cfg *config.Config, client *home.Client) (homeplugins.SyncReport, string, bool, error) {
|
|
if s == nil || cfg == nil || !cfg.Home.Enabled {
|
|
return homeplugins.SyncReport{}, "", false, nil
|
|
}
|
|
syncKey := homePluginSyncKey(cfg)
|
|
if syncKey != "" {
|
|
s.homePluginSyncMu.Lock()
|
|
if s.homePluginSyncKey == syncKey {
|
|
s.homePluginSyncMu.Unlock()
|
|
return homeplugins.SyncReport{}, syncKey, false, nil
|
|
}
|
|
s.homePluginSyncMu.Unlock()
|
|
}
|
|
if !cfg.Plugins.Enabled {
|
|
return homeplugins.CompletedSyncReport(homeplugins.CurrentPlatform(), nil), syncKey, false, nil
|
|
}
|
|
installedVersions, errInstalled := homeplugins.InstalledVersions(cfg)
|
|
if errInstalled != nil {
|
|
return homeplugins.CompletedSyncReport(homeplugins.CurrentPlatform(), errInstalled), syncKey, false, errInstalled
|
|
}
|
|
platform := homeplugins.CurrentPlatform()
|
|
request := sdkpluginstore.PluginSyncRequest{
|
|
SchemaVersion: sdkpluginstore.PluginSyncSchemaVersion,
|
|
GOOS: platform.GOOS,
|
|
GOARCH: platform.GOARCH,
|
|
InstalledVersions: installedVersions,
|
|
}
|
|
defer request.Clear()
|
|
response, errFetch := s.fetchHomePluginSyncWithClient(ctx, client, request)
|
|
if errors.Is(errFetch, home.ErrPluginSyncUnsupported) {
|
|
response.Clear()
|
|
report, errSync := homeplugins.SyncWithReport(ctx, cfg, s.pluginHost)
|
|
return report, syncKey, true, errSync
|
|
}
|
|
if errFetch != nil {
|
|
return homeplugins.CompletedSyncReport(platform, errFetch), syncKey, false, errFetch
|
|
}
|
|
defer response.Clear()
|
|
report, errSync := homeplugins.SyncResolvedWithReport(ctx, cfg, response.Items, response.ExpiresAt, request.InstalledVersions, s.pluginHost)
|
|
return report, syncKey, true, errSync
|
|
}
|
|
|
|
func (s *Service) fetchHomePluginSyncWithClient(ctx context.Context, client *home.Client, request sdkpluginstore.PluginSyncRequest) (sdkpluginstore.PluginSyncResponse, error) {
|
|
if s.homePluginSyncFetch != nil {
|
|
return s.homePluginSyncFetch(ctx, request)
|
|
}
|
|
if client == nil {
|
|
s.homeMu.Lock()
|
|
client = s.homeClient
|
|
s.homeMu.Unlock()
|
|
}
|
|
if client == nil {
|
|
return sdkpluginstore.PluginSyncResponse{}, fmt.Errorf("home client is unavailable")
|
|
}
|
|
return client.GetPluginSync(ctx, request)
|
|
}
|
|
|
|
func (s *Service) markHomePluginsSynced(syncKey string) {
|
|
if s == nil || strings.TrimSpace(syncKey) == "" {
|
|
return
|
|
}
|
|
s.homePluginSyncMu.Lock()
|
|
s.homePluginSyncKey = syncKey
|
|
s.homePluginSyncMu.Unlock()
|
|
}
|
|
|
|
func (s *Service) reportHomePluginStatus(ctx context.Context, cfg *config.Config, report homeplugins.SyncReport) {
|
|
s.reportHomePluginStatusWithClient(ctx, cfg, report, nil)
|
|
}
|
|
|
|
func (s *Service) reportHomePluginStatusWithClient(ctx context.Context, cfg *config.Config, report homeplugins.SyncReport, client *home.Client) {
|
|
if errReport := s.pushHomePluginStatusWithClient(ctx, cfg, report, client); errReport != nil {
|
|
log.Warnf("failed to report home plugin status: %v", errReport)
|
|
}
|
|
}
|
|
|
|
func (s *Service) pushHomePluginStatusWithClient(ctx context.Context, cfg *config.Config, report homeplugins.SyncReport, client *home.Client) error {
|
|
if s == nil || cfg == nil {
|
|
return nil
|
|
}
|
|
if client == nil {
|
|
s.homeMu.Lock()
|
|
client = s.homeClient
|
|
s.homeMu.Unlock()
|
|
}
|
|
if client == nil {
|
|
return fmt.Errorf("home client is unavailable")
|
|
}
|
|
nodeID := strings.TrimSpace(cfg.Home.NodeID)
|
|
if nodeID == "" {
|
|
return fmt.Errorf("home node id is empty")
|
|
}
|
|
report.NodeID = nodeID
|
|
report.UpdatedAt = time.Now().UTC()
|
|
raw, errMarshal := json.Marshal(report)
|
|
if errMarshal != nil {
|
|
return fmt.Errorf("marshal home plugin status: %w", errMarshal)
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
reportCtx, cancel := context.WithTimeout(ctx, homePluginStatusReportTimeout)
|
|
defer cancel()
|
|
if errReport := client.RPushPluginStatus(reportCtx, raw); errReport != nil {
|
|
return fmt.Errorf("push home plugin status: %w", errReport)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) processHomePluginTasks(ctx context.Context, cfg *config.Config) {
|
|
s.processHomePluginTasksWithClient(ctx, cfg, nil)
|
|
}
|
|
|
|
func (s *Service) processHomePluginTasksWithClient(ctx context.Context, cfg *config.Config, client *home.Client) {
|
|
tasks, errStage := s.stageHomePluginTasksWithClient(ctx, cfg, client)
|
|
if errStage != nil {
|
|
log.Warnf("failed to fetch home plugin tasks: %v", errStage)
|
|
return
|
|
}
|
|
work := &homePluginFinalization{taskWork: tasks}
|
|
if errFinalize := s.finalizeHomePluginWork(ctx, client, work); errFinalize != nil {
|
|
log.Warnf("failed to finalize home plugin tasks: %v", errFinalize)
|
|
}
|
|
}
|
|
|
|
func (s *Service) stageHomePluginTasksWithClient(ctx context.Context, cfg *config.Config, client *home.Client) ([]homePluginTaskWork, error) {
|
|
if s == nil || cfg == nil || !cfg.Home.Enabled {
|
|
return nil, nil
|
|
}
|
|
if client == nil {
|
|
s.homeMu.Lock()
|
|
client = s.homeClient
|
|
s.homeMu.Unlock()
|
|
}
|
|
if client == nil {
|
|
return nil, fmt.Errorf("home client is unavailable")
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
tasks, errTasks := client.GetPluginTasks(ctx)
|
|
if errTasks != nil {
|
|
return nil, errTasks
|
|
}
|
|
staged := make([]homePluginTaskWork, 0, len(tasks))
|
|
for _, task := range tasks {
|
|
if !strings.EqualFold(strings.TrimSpace(task.Operation), "delete") {
|
|
continue
|
|
}
|
|
staged = append(staged, homePluginTaskWork{cfg: cfg, task: task})
|
|
}
|
|
return staged, nil
|
|
}
|
|
|
|
func (s *Service) finalizeHomePluginWork(ctx context.Context, client *home.Client, work *homePluginFinalization) error {
|
|
if work == nil {
|
|
return nil
|
|
}
|
|
if ctx != nil {
|
|
if errContext := ctx.Err(); errContext != nil {
|
|
return errContext
|
|
}
|
|
}
|
|
for work.nextStatus < len(work.statusWork) {
|
|
status := work.statusWork[work.nextStatus]
|
|
if errReport := s.pushHomePluginStatusWithClient(ctx, status.cfg, status.report, client); errReport != nil {
|
|
return errReport
|
|
}
|
|
work.nextStatus++
|
|
}
|
|
for work.nextTask < len(work.taskWork) {
|
|
taskWork := &work.taskWork[work.nextTask]
|
|
if taskWork.report == nil {
|
|
report := s.processHomePluginDeleteTask(ctx, taskWork.cfg, taskWork.task)
|
|
taskWork.report = &report
|
|
if !report.OK && strings.TrimSpace(report.Error) != "" {
|
|
log.Warnf("failed to process home plugin delete task %d for %s: %v", taskWork.task.ID, taskWork.task.PluginID, report.Error)
|
|
}
|
|
}
|
|
if errReport := s.pushHomePluginStatusWithClient(ctx, taskWork.cfg, *taskWork.report, client); errReport != nil {
|
|
return errReport
|
|
}
|
|
work.nextTask++
|
|
}
|
|
if work.markSynced {
|
|
if ctx != nil {
|
|
if errContext := ctx.Err(); errContext != nil {
|
|
return errContext
|
|
}
|
|
}
|
|
s.markHomePluginsSynced(work.syncKey)
|
|
work.markSynced = false
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) processHomePluginDeleteTask(ctx context.Context, cfg *config.Config, task home.PluginTask) homeplugins.SyncReport {
|
|
if s != nil && s.homePluginDeleteTask != nil {
|
|
return s.homePluginDeleteTask(ctx, cfg, task)
|
|
}
|
|
return homeplugins.DeleteWithReport(ctx, cfg, s.pluginHost, task.ID, task.PluginID)
|
|
}
|
|
|
|
func homePluginSyncKey(cfg *config.Config) string {
|
|
if cfg == nil || !cfg.Home.Enabled {
|
|
return ""
|
|
}
|
|
hash := sha256.New()
|
|
_, _ = fmt.Fprintf(hash, "enabled=%t\ndir=%s\nauth-revision=%d\n", cfg.Plugins.Enabled, strings.TrimSpace(cfg.Plugins.Dir), cfg.Plugins.AuthRevision)
|
|
ids := make([]string, 0, len(cfg.Plugins.Configs))
|
|
for id := range cfg.Plugins.Configs {
|
|
ids = append(ids, id)
|
|
}
|
|
sort.Strings(ids)
|
|
for _, id := range ids {
|
|
item := cfg.Plugins.Configs[id]
|
|
enabled := false
|
|
if item.Enabled != nil {
|
|
enabled = *item.Enabled
|
|
}
|
|
_, _ = fmt.Fprintf(hash, "plugin=%s\nenabled=%t\npriority=%d\n", strings.TrimSpace(id), enabled, item.Priority)
|
|
if item.Raw.Kind != 0 {
|
|
raw, errMarshal := yaml.Marshal(&item.Raw)
|
|
if errMarshal == nil {
|
|
_, _ = hash.Write(raw)
|
|
}
|
|
}
|
|
_, _ = hash.Write([]byte{'\n'})
|
|
}
|
|
return hex.EncodeToString(hash.Sum(nil))
|
|
}
|