-
Notifications
You must be signed in to change notification settings - Fork 29
/
api.go
246 lines (196 loc) · 5.98 KB
/
api.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
package openfeature
import (
"errors"
"fmt"
"sync"
"github.com/go-logr/logr"
"github.com/open-feature/go-sdk/openfeature/internal"
"golang.org/x/exp/maps"
)
// evaluationAPI wraps OpenFeature evaluation API functionalities
type evaluationAPI struct {
defaultProvider FeatureProvider
namedProviders map[string]FeatureProvider
hks []Hook
apiCtx EvaluationContext
logger logr.Logger
mu sync.RWMutex
eventExecutor *eventExecutor
}
// newEvaluationAPI is a helper to generate an API. Used internally
func newEvaluationAPI() evaluationAPI {
logger := logr.New(internal.Logger{})
return evaluationAPI{
defaultProvider: NoopProvider{},
namedProviders: map[string]FeatureProvider{},
hks: []Hook{},
apiCtx: EvaluationContext{},
logger: logger,
mu: sync.RWMutex{},
eventExecutor: newEventExecutor(logger),
}
}
// setProvider sets the default FeatureProvider of the evaluationAPI.
// Returns an error if provider registration cause an error
func (api *evaluationAPI) setProvider(provider FeatureProvider, async bool) error {
api.mu.Lock()
defer api.mu.Unlock()
if provider == nil {
return errors.New("default provider cannot be set to nil")
}
oldProvider := api.defaultProvider
api.defaultProvider = provider
err := api.initNewAndShutdownOld(provider, oldProvider, async)
if err != nil {
return err
}
err = api.eventExecutor.registerDefaultProvider(provider)
if err != nil {
return err
}
return nil
}
// getProvider returns the default FeatureProvider
func (api *evaluationAPI) getProvider() FeatureProvider {
api.mu.RLock()
defer api.mu.RUnlock()
return api.defaultProvider
}
// setProvider sets a provider with client name. Returns an error if FeatureProvider is nil
func (api *evaluationAPI) setNamedProvider(clientName string, provider FeatureProvider, async bool) error {
api.mu.Lock()
defer api.mu.Unlock()
if provider == nil {
return errors.New("provider cannot be set to nil")
}
// Initialize new named provider and shutdown the old one
// Provider update must be non-blocking, hence initialization & shutdown happens concurrently
oldProvider := api.namedProviders[clientName]
api.namedProviders[clientName] = provider
err := api.initNewAndShutdownOld(provider, oldProvider, async)
if err != nil {
return err
}
err = api.eventExecutor.registerNamedEventingProvider(clientName, provider)
if err != nil {
return err
}
return nil
}
// getNamedProviders returns named providers map.
func (api *evaluationAPI) getNamedProviders() map[string]FeatureProvider {
api.mu.RLock()
defer api.mu.RUnlock()
return api.namedProviders
}
func (api *evaluationAPI) setEvaluationContext(apiCtx EvaluationContext) {
api.mu.Lock()
defer api.mu.Unlock()
api.apiCtx = apiCtx
}
func (api *evaluationAPI) setLogger(l logr.Logger) {
api.mu.Lock()
defer api.mu.Unlock()
api.logger = l
api.eventExecutor.updateLogger(l)
}
func (api *evaluationAPI) getLogger() logr.Logger {
api.mu.RLock()
defer api.mu.RUnlock()
return api.logger
}
func (api *evaluationAPI) addHooks(hooks ...Hook) {
api.mu.Lock()
defer api.mu.Unlock()
api.hks = append(api.hks, hooks...)
}
func (api *evaluationAPI) shutdown() {
api.mu.Lock()
defer api.mu.Unlock()
v, ok := api.defaultProvider.(StateHandler)
if ok {
v.Shutdown()
}
for _, provider := range api.namedProviders {
v, ok = provider.(StateHandler)
if ok {
v.Shutdown()
}
}
}
func (api *evaluationAPI) getHooks() []Hook {
api.mu.RLock()
defer api.mu.RUnlock()
return api.hks
}
// forTransaction is a helper to retrieve transaction(flag evaluation) scoped operators.
// Returns the default FeatureProvider if no provider mapping exist for the given client name.
func (api *evaluationAPI) forTransaction(clientName string) (FeatureProvider, []Hook, EvaluationContext) {
api.mu.RLock()
defer api.mu.RUnlock()
var provider FeatureProvider
provider = api.namedProviders[clientName]
if provider == nil {
provider = api.defaultProvider
}
return provider, api.hks, api.apiCtx
}
// initNewAndShutdownOld is a helper to initialise new FeatureProvider and shutdown the old FeatureProvider.
func (api *evaluationAPI) initNewAndShutdownOld(newProvider FeatureProvider, oldProvider FeatureProvider, async bool) error {
if async {
go func(executor *eventExecutor, ctx EvaluationContext) {
// for async initialization, error is conveyed as an event
event, _ := initializer(newProvider, ctx)
executor.triggerEvent(event, newProvider)
}(api.eventExecutor, api.apiCtx)
} else {
event, err := initializer(newProvider, api.apiCtx)
api.eventExecutor.triggerEvent(event, newProvider)
if err != nil {
return err
}
}
v, ok := oldProvider.(StateHandler)
// oldProvider can be nil or without state handling capability
if oldProvider == nil || !ok {
return nil
}
// check for multiple bindings
if oldProvider == api.defaultProvider || contains(oldProvider, maps.Values(api.namedProviders)) {
return nil
}
go func(forShutdown StateHandler) {
forShutdown.Shutdown()
}(v)
return nil
}
// initializer is a helper to execute provider initialization and generate appropriate event for the initialization
// It also returns an error if the initialization resulted in an error
func initializer(provider FeatureProvider, apiCtx EvaluationContext) (Event, error) {
var event = Event{
ProviderName: provider.Metadata().Name,
EventType: ProviderReady,
ProviderEventDetails: ProviderEventDetails{
Message: "Provider initialization successful",
},
}
handler, ok := provider.(StateHandler)
if !ok {
// Note - a provider without state handling capability can be assumed to be ready immediately.
return event, nil
}
err := handler.Init(apiCtx)
if err != nil {
event.EventType = ProviderError
event.Message = fmt.Sprintf("Provider initialization error, %v", err)
}
return event, err
}
func contains(provider FeatureProvider, in []FeatureProvider) bool {
for _, p := range in {
if provider == p {
return true
}
}
return false
}