fix support for external property resolution

Author: Frank Martinez

app/app.go

@@ -83,9 +83,9 @@ func ContinueOnError(a *App) error {
 	return nil
 }
 
-func ExternalProperties(providerId string, overrides string, processors ...property.PostProcessor) func(*App) error {
+func FinalizeProperties(useExternalResolvers bool, processors ...property.PostProcessor) func(*App) error {
 	return func(a *App) error {
-		return a.propManager.AddExternalProperties(providerId, overrides, processors...)
+		return a.propManager.Finalize(useExternalResolvers, processors...)
 	}
 }
 

app/propertyresolver/env.go

@@ -0,0 +1,73 @@
+package propertyresolver
+
+import (
+	"encoding/json"
+	"github.com/project-flogo/core/data/property"
+	"os"
+	"strings"
+
+	"github.com/project-flogo/core/support/log"
+)
+
+
+const EnvAppPropertyEnvConfigKey = "FLOGO_APP_PROPS_ENV"
+
+type PropertyMappings struct {
+	Mappings map[string]string `json:"mappings"`
+}
+
+var mapping PropertyMappings
+
+func init() {
+
+	logger := log.RootLogger()
+
+	property.RegisterExternalResolver("env", &EnvVariableValueResolver{})
+
+	mappings := getEnvValue()
+	if mappings != "" {
+		e := json.Unmarshal([]byte(mappings), &mapping)
+		if e != nil {
+			logger.Errorf("Can not parse value set to '%s' due to error - '%v'", EnvAppPropertyEnvConfigKey, e)
+			panic("")
+		}
+	}
+}
+
+func getEnvValue() string {
+	key := os.Getenv(EnvAppPropertyEnvConfigKey)
+	if len(key) > 0 {
+		return key
+	}
+	return ""
+}
+
+// Resolve property value from environment variable
+type EnvVariableValueResolver struct {
+}
+
+func (resolver *EnvVariableValueResolver) LookupValue(key string) (interface{}, bool) {
+	value, exists := os.LookupEnv(key) // first try with the name of the property as is
+	if exists {
+		return value, exists
+	}
+
+	// Lookup based on mapping defined
+	keyMapping, ok := mapping.Mappings[key]
+	if ok {
+		return os.LookupEnv(keyMapping)
+	}
+
+	// Replace dot with underscore e.g. a.b would be a_b
+	key = strings.Replace(key, ".", "_", -1)
+	value, exists = os.LookupEnv(key)
+	if exists {
+		return value, exists
+	}
+
+
+	// Try upper case form e.g. a.b would be A_B
+	key = strings.ToUpper(key)
+	value, exists = os.LookupEnv(key) // if not found try with the canonical form
+	return value, exists
+}

app/propertyresolver/env_test.go

@@ -0,0 +1,28 @@
+package propertyresolver
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEnvValueResolver(t *testing.T) {
+	os.Setenv("Test", "Test")
+	os.Setenv("TEST_PROP", "test.Prop")
+
+	defer func() {
+		os.Unsetenv("Test")
+		os.Unsetenv("TEST_PROP")
+	}()
+	resolver := &EnvVariableValueResolver{}
+
+	resolvedVal, found := resolver.LookupValue("Test")
+	assert.True(t, true, found)
+	assert.Equal(t, "Test", resolvedVal)
+
+	resolvedVal, found = resolver.LookupValue("test.Prop")
+	assert.True(t, true, found)
+	assert.Equal(t, "test.Prop", resolvedVal)
+
+}

app/propertyresolver/json.go

@@ -0,0 +1,66 @@
+package propertyresolver
+
+import (
+	"encoding/json"
+	"github.com/project-flogo/core/data/property"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/project-flogo/core/support/log"
+)
+
+var preload = make(map[string]interface{})
+
+//var log = logger.GetLogger("app-props-json-resolver")
+
+// Comma separated list of json files overriding default application property values
+// e.g. FLOGO_APP_PROPS_JSON=app1.json,common.json
+const EnvAppPropertyFileConfigKey = "FLOGO_APP_PROPS_JSON"
+
+func init() {
+
+	logger := log.RootLogger()
+
+	filePaths := getExternalFiles()
+	if filePaths != "" {
+		// Register value resolver
+		property.RegisterExternalResolver("json", &JSONFileValueResolver{})
+
+		// preload props from files
+		files := strings.Split(filePaths, ",")
+		if len(files) > 0 {
+			for _, filePath := range files {
+				props := make(map[string]interface{})
+
+				file, e := ioutil.ReadFile(filePath)
+				if e != nil {
+					logger.Errorf("Can not read - %s due to error - %v", filePath, e)
+					panic("")
+				}
+				e = json.Unmarshal(file, &props)
+				if e != nil {
+					logger.Errorf("Can not read - %s due to error - %v", filePath, e)
+					panic("")
+				}
+			}
+		}
+	}
+}
+
+func getExternalFiles() string {
+	key := os.Getenv(EnvAppPropertyFileConfigKey)
+	if len(key) > 0 {
+		return key
+	}
+	return ""
+}
+
+// Resolve property value from external files
+type JSONFileValueResolver struct {
+}
+
+func (resolver *JSONFileValueResolver) LookupValue(toResolve string) (interface{}, bool) {
+	val, found := preload[toResolve]
+	return val, found
+}

data/property/manager.go

@@ -1,10 +1,7 @@
 package property
 
 import (
-	"encoding/json"
 	"github.com/project-flogo/core/support/log"
-	"io/ioutil"
-	"strings"
 )
 
 func init() {
@@ -36,69 +33,27 @@ func (m *Manager) GetProperty(name string) (interface{}, bool) {
 	return val, exists
 }
 
-func (m *Manager) AddExternalProperties(providerId string, overrides string, processors ...PostProcessor) error {
+func (m *Manager) Finalize(useExternalResolvers bool, processors ...PostProcessor) error {
 
-	provider := GetProvider(providerId)
-	newProps, err := loadExternalProperties(provider, overrides)
-	if err != nil {
-		return err
-	}
-
-	for _, processor := range processors {
-		processor(newProps)
-	}
-
-	for key, value := range newProps {
-		m.properties[key] = value
-	}
-
-	return nil
-}
-
-type PostProcessor func(properties map[string]interface{}) error
+	logger := log.RootLogger()
 
-func loadExternalProperties(provider Provider, overrides string) (map[string]interface{}, error) {
+	if useExternalResolvers {
+		for name := range m.properties {
+			newVal, found := ResolveExternally(name)
 
-	props := make(map[string]interface{})
-
-	if overrides != "" {
-		if strings.HasSuffix(overrides, ".json") {
-			// Override through file
-
-			propFile := overrides
-			file, e := ioutil.ReadFile(propFile)
-			if e != nil {
-				return nil, e
-			}
-			e = json.Unmarshal(file, &props)
-
-			if e != nil {
-				return nil, e
-			}
-		} else if strings.ContainsRune(overrides, '=') {
-			// Override through P1=V1,P2=V2
-			for _, pair := range strings.Split(overrides, ",") {
-				kv := strings.Split(pair, "=")
-				if len(kv) == 2 && kv[0] != "" {
-					key := strings.TrimSpace(kv[0])
-					value := strings.TrimSpace(kv[1])
-					props[key] = value
-				} else {
-					log.RootLogger().Warnf("'%s' is not valid override value. It must be in PropName=PropValue format.", pair)
-				}
+			if !found {
+				logger.Warnf("Property '%s' could not be resolved using external resolver(s) '%s'. Using default value.", name)
+			} else {
+				m.properties[name] = newVal
 			}
 		}
 	}
 
-	//look for properties that need to go to the provider
-	if provider != nil {
-		for key, value := range props {
-			if strVal, ok := value.(string); ok && strVal[0] == '$' {
-				val := provider.GetProperty(strVal[1:])
-				props[key] = val
-			}
-		}
+	for _, processor := range processors {
+		processor(m.properties)
 	}
 
-	return props, nil
+	return nil
 }
+
+type PostProcessor func(properties map[string]interface{}) error

data/property/provider.go

@@ -0,0 +1,75 @@
+package property
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/project-flogo/core/support/log"
+)
+
+var (
+	externalResolverMap = make(map[string]ExternalResolver)
+	externalResolvers   []ExternalResolver
+)
+
+// Resolver used to resolve property value from external configuration like env, file etc
+type ExternalResolver interface {
+	// 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)
+}
+
+func RegisterExternalResolver(resolverType string, resolver ExternalResolver) error {
+
+	logger := log.RootLogger()
+
+
+	if resolverType == "" {
+		return fmt.Errorf("'resolverType' must be specified when registering external property resolver")
+	}
+
+	if resolver == nil {
+		return fmt.Errorf("cannot register 'nil' external property resolver")
+	}
+
+	if _, dup := externalResolverMap[resolverType]; dup {
+		return fmt.Errorf("external property resolver already registered: %s", resolverType)
+	}
+
+	logger.Debugf("Registering external property resolver [ %s ]", resolverType)
+
+	externalResolverMap[resolverType] = resolver
+
+	return nil
+}
+
+func GetExternalResolver(resolverType string) ExternalResolver {
+	return externalResolverMap[resolverType]
+}
+
+func EnableExternalResolvers(resolverTypes string) error {
+
+	for _, resolverType := range strings.Split(resolverTypes, ",") {
+		resolver := externalResolverMap[resolverType]
+		if resolver == nil {
+			errMag := fmt.Sprintf("Unsupported external property resolver type - %s. Resolver not registered.", resolverType)
+			return errors.New(errMag)
+		}
+		externalResolvers = append(externalResolvers, resolver)
+	}
+
+	return nil
+}
+
+func ResolveExternally(propertyName string) (interface{}, bool) {
+
+	for _, resolver := range externalResolvers {
+		// Use resolver
+		value, resolved := resolver.LookupValue(propertyName)
+		if resolved {
+			return value, true
+		}
+	}
+
+	return nil, false
+}