forked from project-flogo/core
-
Notifications
You must be signed in to change notification settings - Fork 0
/
external.go
122 lines (95 loc) · 3.18 KB
/
external.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
package property
import (
"errors"
"fmt"
"strings"
"github.com/JCorpse96/core/data"
"github.com/JCorpse96/core/data/coerce"
"github.com/JCorpse96/core/support/log"
)
var (
RegisteredResolvers = make(map[string]ExternalResolver)
EnabledResolvers []ExternalResolver
)
// Resolver used to resolve property value from external configuration like env, file etc
type ExternalResolver interface {
// Name of the resolver (e.g., consul)
Name() string
// Should return value and true if the given key exists in the external configuration otherwise should return nil and false.
LookupValue(key string) (interface{}, bool)
}
//DEPRECATED
func RegisterPropertyResolver(resolver ExternalResolver) error {
return RegisterExternalResolver(resolver)
}
func RegisterExternalResolver(resolver ExternalResolver) error {
logger := log.RootLogger()
resolverName := resolver.Name()
if resolverName == "" {
return fmt.Errorf("an external property resolver must have a non-empty name")
}
if resolver == nil {
return fmt.Errorf("cannot register a 'nil' external property resolver")
}
if _, dup := RegisteredResolvers[resolverName]; dup {
return fmt.Errorf("external property resolver already registered: %s", resolverName)
}
logger.Debugf("Registering external property resolver [ %s ]", resolverName)
RegisteredResolvers[resolverName] = resolver
return nil
}
func GetExternalPropertyResolver(resolverType string) ExternalResolver {
return RegisteredResolvers[resolverType]
}
func EnableExternalPropertyResolvers(resolverTypes string) error {
for _, resolverType := range strings.Split(resolverTypes, ",") {
resolver := RegisteredResolvers[resolverType]
if resolver == nil {
errMag := fmt.Sprintf("Unsupported property resolver type - %s. Resolver not registered.", resolverType)
return errors.New(errMag)
}
EnabledResolvers = append(EnabledResolvers, resolver)
}
return nil
}
func ResolvePropertyExternally(propertyName string) (interface{}, bool) {
for _, resolver := range EnabledResolvers {
// Use resolver
value, resolved := resolver.LookupValue(propertyName)
if resolved {
return value, true
}
}
return nil, false
}
func ExternalResolverProcessor(properties map[string]interface{}) error {
logger := log.RootLogger()
var enabledResolvers []string
var resolver ExternalResolver
for _, resolver = range EnabledResolvers {
enabledResolvers = append(enabledResolvers, resolver.Name())
}
if len(enabledResolvers) == 1 {
logger.Infof("Properties will be resolved with the '%s' resolver", EnabledResolvers[0].Name())
} else {
logger.Infof("Properties will be resolved with these resolvers (in decreasing order of priority): %v", enabledResolvers)
}
for name := range properties {
newVal, found := ResolvePropertyExternally(name)
if !found {
logger.Warnf("Property '%s' could not be resolved using property resolver(s). Using default value from flogo.json.", name)
} else {
// Get datatype of old value
dType, _ := data.GetType(properties[name])
if dType != data.TypeUnknown {
coercedVal, err := coerce.ToType(newVal, dType)
if err == nil {
properties[name] = coercedVal
continue
}
}
properties[name] = newVal
}
}
return nil
}