kubelatte-ce

1
package plugins
2

3
import (
4
	"context"
5
	"fmt"
6
	"github.com/traefik/yaegi/interp"
7
	"github.com/traefik/yaegi/stdlib"
8
	"gitverse.ru/synapse/kubelatte/pkg/observability/logger"
9
	"gitverse.ru/synapse/kubelatte/pkg/util/env"
10
	"gopkg.in/yaml.v2"
11
	"os"
12
)
13

14
const DirCommon = "./config/plugins"
15

16
var DirExtra = "./config/plugins/extra"
17

18
var PluginsController = Manager{}
19

20
type Manager struct {
21
	plugins []Plugin
22
}
23

24
type Plugin struct {
25
	PluginName string `yaml:"name"`
26
	Data       string `yaml:"data"`
27
	Cached     func(interface{}) interface{}
28
}
29

30
func (m *Manager) Start() {
31
	log := logger.FromContext(context.Background())
32
	log.Debug("[PluginManager] Plugin manager started")
33
	if env.DirPlugin != "" {
34
		DirExtra = env.DirPlugin
35
	}
36

37
	m.Load()
38
}
39

40
func (m *Manager) Load() {
41
	m.LoadPluginsFromDir(DirCommon)
42
	m.LoadPluginsFromDir(DirExtra)
43
}
44

45
func (m *Manager) LoadPluginsFromDir(path string) {
46
	log := logger.FromContext(context.Background())
47
	log.Debugf("[PluginManager] Load plugins from dir %s", path)
48
	entries, err := os.ReadDir(path)
49
	if err != nil {
50
		log.Errorf("[PluginManager] Load plugins error %s", err.Error())
51
	}
52
	for _, e := range entries {
53
		if e.IsDir() {
54
			continue
55
		}
56

57
		file, err := os.ReadFile(fmt.Sprintf("%s/%s", path, e.Name()))
58
		if err != nil {
59
			log.Errorf("[PluginManager] Load plugin %s error: %s", e.Name(), err.Error())
60
			continue
61
		}
62
		var plugin Plugin
63
		err = yaml.Unmarshal(file, &plugin)
64
		if err != nil {
65
			log.Errorf("[PluginManager] Parse plugin %s error: %s", e.Name(), err.Error())
66
			continue
67
		}
68
		plugin.Cached, err = m.Precompile(plugin.PluginName, plugin.Data)
69
		if err != nil {
70
			log.Errorf("[PluginManager] Precompile plugin %s error: %s", e.Name(), err.Error())
71
			continue
72
		}
73
		m.plugins = append(m.plugins, plugin)
74
	}
75
}
76

77
func (m *Manager) Precompile(name, data string) (func(interface{}) interface{}, error) {
78
	log := logger.FromContext(context.Background())
79
	i := interp.New(interp.Options{})
80

81
	err := i.Use(stdlib.Symbols)
82
	if err != nil {
83
		log.Errorf("[PluginManager] Compile plugin %s error: %s", name, err.Error())
84
		return nil, err
85
	}
86

87
	_, err = i.Eval(data)
88
	if err != nil {
89
		log.Errorf("[PluginManager] Compile plugin %s error: %s", name, err.Error())
90
		return nil, err
91
	}
92

93
	v, err := i.Eval("plugin.Logic")
94
	if err != nil {
95
		log.Errorf("[PluginManager] Logic plugin %s error: %s", name, err.Error())
96
		return nil, err
97
	}
98

99
	return v.Interface().(func(interface{}) interface{}), nil
100
}
101

102
func (m *Manager) Process(pluginName string, object interface{}) (interface{}, error) {
103
	log := logger.FromContext(context.Background())
104
	log.Debugf("[PluginManager] Process logic plugin %s", pluginName)
105
	for _, plugin := range m.plugins {
106
		if plugin.PluginName == pluginName {
107
			r := plugin.Cached(object)
108
			return r, nil
109
		}
110
	}
111
	return nil, fmt.Errorf("plugin not found")
112
}
113