kubelatte-ce

1
package initmanager
2

3
import (
4
	"context"
5
	"errors"
6
	"gitverse.ru/synapse/kubelatte/pkg/observability/logger"
7
	"gitverse.ru/synapse/kubelatte/pkg/operator/utils"
8
	"gitverse.ru/synapse/kubelatte/pkg/util/env"
9
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
10
	"time"
11
)
12

13
type InitManager struct {
14
	ticker         *time.Ticker
15
	triggersExist  bool
16
	templatesExist bool
17
	scopesExist    bool
18
	act            InitManagerI
19
}
20

21
type InitManagerI interface {
22
	Start(ctx context.Context)
23
	Stop(ctx context.Context)
24
	CheckResources(ctx context.Context) error
25
	DoesTriggersExist() bool
26
	DoesTemplatesExist() bool
27
	DoesScopesExist() bool
28
}
29

30
var (
31
	ErrCheckTriggers  = errors.New("failed list triggers")
32
	ErrCheckTemplates = errors.New("failed list templates")
33
	ErrCheckScopes    = errors.New("failed list scopes")
34
)
35

36
func NewInitManager(act InitManagerI) InitManagerI {
37
	mgr := &InitManager{
38
		triggersExist:  !utils.IsControllerNeeded("trigger"),
39
		templatesExist: !utils.IsControllerNeeded("template"),
40
		scopesExist:    !utils.IsControllerNeeded("scope"),
41
	}
42
	if act == nil {
43
		act = mgr
44
	}
45
	mgr.act = act
46
	return mgr
47
}
48

49
func (m *InitManager) Start(ctx context.Context) {
50
	m.ticker = time.NewTicker(3 * time.Second)
51
	for {
52
		select {
53
		case <-m.ticker.C:
54
			_ = m.act.CheckResources(ctx)
55
		case <-ctx.Done():
56
			m.act.Stop(ctx)
57
			return
58
		}
59

60
		if m.triggersExist && m.templatesExist && m.scopesExist {
61
			m.act.Stop(ctx)
62
			return
63
		}
64
	}
65
}
66

67
func (m *InitManager) Stop(ctx context.Context) {
68
	if m.ticker != nil {
69
		m.ticker.Stop()
70
	}
71
	ctx.Done()
72
}
73

74
func (m *InitManager) CheckResources(ctx context.Context) error {
75
	var errs error
76
	var err error
77

78
	if !m.triggersExist && utils.IsControllerNeeded("trigger") {
79
		m.triggersExist, err = checkTriggers(ctx)
80
		errs = errors.Join(errs, err)
81
	}
82
	if !m.templatesExist && utils.IsControllerNeeded("template") {
83
		m.templatesExist, err = checkTemplates(ctx)
84
		errs = errors.Join(errs, err)
85
	}
86
	if !m.scopesExist && utils.IsControllerNeeded("scope") {
87
		m.scopesExist, err = checkScopes(ctx)
88
		errs = errors.Join(errs, err)
89
	}
90
	return errs
91
}
92

93
func (m *InitManager) DoesTriggersExist() bool {
94
	return m.triggersExist
95
}
96

97
func (m *InitManager) DoesTemplatesExist() bool {
98
	return m.templatesExist
99
}
100

101
func (m *InitManager) DoesScopesExist() bool {
102
	return m.scopesExist
103
}
104

105
func checkTriggers(ctx context.Context) (bool, error) {
106
	log := logger.FromContext(ctx)
107
	triggers, err := utils.Cl.Trigger(env.OperatorNamespace).List(ctx, metav1.ListOptions{})
108
	if err != nil {
109
		log.Errorf("[InitManager] Failed List triggers %s", err)
110
		return false, ErrCheckTriggers
111
	}
112
	return len(triggers.Items) != 0, nil
113
}
114

115
func checkTemplates(ctx context.Context) (bool, error) {
116
	log := logger.FromContext(ctx)
117
	templates, err := utils.Cl.Template(env.OperatorNamespace).List(ctx, metav1.ListOptions{})
118
	if err != nil {
119
		log.Errorf("[InitManager] Failed List templates %s", err)
120
		return false, ErrCheckTemplates
121
	}
122

123
	return len(templates.Items) != 0, nil
124
}
125

126
func checkScopes(ctx context.Context) (bool, error) {
127
	log := logger.FromContext(ctx)
128
	scopes, err := utils.Cl.Scope(env.OperatorNamespace).List(ctx, metav1.ListOptions{})
129
	if err != nil {
130
		log.Errorf("[InitManager] Failed List scopes %s", err)
131
		return false, ErrCheckScopes
132
	}
133

134
	return len(scopes.Items) != 0, nil
135
}
136