Join + ProvideFromRaw (#1030)

Signed-off-by: Angelo De Caro <[email protected]>

Author: adecaro

platform/view/services/config/join.go

@@ -0,0 +1,25 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package config
+
+import (
+	"strings"
+)
+
+// Join joins multiple string components with a dot (.).
+// It also trims leading/trailing dots from each component to ensure clean joining.
+func Join(components ...string) string {
+	var validComponents []string
+	for _, comp := range components {
+		// Trim leading/trailing dots and spaces from each component
+		trimmedComp := strings.Trim(comp, " .") // Trim both dots and spaces
+		if trimmedComp != "" {
+			validComponents = append(validComponents, trimmedComp)
+		}
+	}
+	return strings.Join(validComponents, ".")
+}

platform/view/services/config/join_test.go

@@ -0,0 +1,75 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestJoin tests the Join function
+func TestJoin(t *testing.T) {
+	tests := []struct {
+		name       string
+		components []string
+		expected   string
+	}{
+		{
+			name:       "Multiple components",
+			components: []string{"server", "ports", "http"},
+			expected:   "server.ports.http",
+		},
+		{
+			name:       "Single component",
+			components: []string{"version"},
+			expected:   "version",
+		},
+		{
+			name:       "No components",
+			components: []string{},
+			expected:   "",
+		},
+		{
+			name:       "Components with leading/trailing dots",
+			components: []string{".app", "settings."},
+			expected:   "app.settings",
+		},
+		{
+			name:       "Components with internal dots (should not be split)",
+			components: []string{"my.service", "config"},
+			expected:   "my.service.config",
+		},
+		{
+			name:       "Mixed case with empty strings",
+			components: []string{"parent", "", "child", "grandchild"},
+			expected:   "parent.child.grandchild",
+		},
+		{
+			name:       "All empty strings",
+			components: []string{"", "", ""},
+			expected:   "",
+		},
+		{
+			name:       "Components with spaces and dots",
+			components: []string{" user name ", ".api.v1.", "endpoint "},
+			expected:   "user name.api.v1.endpoint",
+		},
+		{
+			name:       "Complex case with various trims",
+			components: []string{" .key1 ", " key2. ", " key3 ", ".key4."},
+			expected:   "key1.key2.key3.key4",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := Join(tt.components...)
+			assert.Equal(t, tt.expected, got, "Join(%v) = %q; want %q", tt.components, got, tt.expected)
+		})
+	}
+}

platform/view/services/config/provider.go

@@ -18,6 +18,7 @@ import (
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/services/logging"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/hash"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services"
 	viperutil "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/config/viper"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/events"
@@ -45,7 +46,6 @@ type OnMergeConfigEventHandler interface {
 type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
 
 type Provider struct {
-	confPath    string
 	Backend     *viper.Viper
 	eventSystem events.EventSystem
 
@@ -54,10 +54,9 @@ type Provider struct {
 
 func NewProvider(confPath string) (*Provider, error) {
 	p := &Provider{
-		confPath:    confPath,
 		eventSystem: simple.NewEventBus(),
 	}
-	if err := p.load(); err != nil {
+	if err := p.loadFromPath(confPath); err != nil {
 		return nil, err
 	}
 
@@ -151,15 +150,31 @@ func (p *Provider) OnMergeConfig(handler OnMergeConfigEventHandler) {
 	p.eventSystem.Subscribe(MergeConfigEventTopic, &eventListener{handler: handler})
 }
 
-func (p *Provider) load() error {
+// ProvideFromRaw returns a new Provider whose configuration is loaded from the given byte representation.
+// The function expects a valid `yaml` representation.
+// The new provider inherit the same config file used by this provider.
+func (p *Provider) ProvideFromRaw(raw []byte) (*Provider, error) {
+	newProvider := &Provider{
+		eventSystem: simple.NewEventBus(),
+	}
+	if err := newProvider.loadFromRaw(raw); err != nil {
+		return nil, err
+	}
+	newProvider.Backend.SetConfigFile(p.ConfigFileUsed())
+
+	return newProvider, nil
+}
+
+func (p *Provider) loadFromPath(path string) error {
 	p.Backend = viper.New()
-	err := p.initViper(p.Backend, CmdRoot)
+	err := p.initViper(p.Backend, CmdRoot, path)
 	if err != nil {
 		return err
 	}
 
 	err = p.Backend.ReadInConfig() // Find and read the config file
-	if err != nil {                // Handle errors reading the config file
+	if err != nil {
+		// Handle errors reading the config file
 		// The version of Viper we use claims the config type isn't supported when in fact the file hasn't been found
 		// Display a more helpful message to avoid confusing the user.
 		if strings.Contains(fmt.Sprint(err), "Unsupported Config Type") {
@@ -185,6 +200,22 @@ func (p *Provider) load() error {
 	return nil
 }
 
+func (p *Provider) loadFromRaw(raw []byte) error {
+	p.Backend = viper.New()
+	p.Backend.SetConfigType("yaml")
+
+	// read configuration
+	if err := p.Backend.ReadConfig(bytes.NewReader(raw)); err != nil {
+		return errors.Wrapf(err, "failed to read configuration from raw [%s]", hash.Hashable(raw))
+	}
+	// post process
+	if err := p.substituteEnv(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // Manually override keys if the respective environment variable is set, because viper doesn't do
 // that for UnmarshalKey values (see https://github.com/spf13/viper/pull/1699).
 // Example: CORE_LOGGING_FORMAT sets logging.format.
@@ -260,9 +291,9 @@ func setDeepValue(m map[string]any, keys []string, value any) error {
 // the configuration we need.  If Backend == nil, we will initialize the global
 // Viper instance
 // ----------------------------------------------------------------------------------
-func (p *Provider) initViper(v *viper.Viper, configName string) error {
-	if len(p.confPath) != 0 {
-		AddConfigPath(v, p.confPath)
+func (p *Provider) initViper(v *viper.Viper, configName string, confPath string) error {
+	if len(confPath) != 0 {
+		AddConfigPath(v, confPath)
 	}
 
 	var altPath = os.Getenv("FSCNODE_CFG_PATH")

platform/view/services/config/provider_test.go

@@ -33,6 +33,21 @@ func TestReadFile(t *testing.T) {
 	testMerge(t, p)
 }
 
+func TestProvideFromRaw(t *testing.T) {
+	p, err := NewProvider("./testdata")
+	assert.NoError(t, err)
+
+	// read content of ./testdata/core.yaml
+	raw, err := os.ReadFile("./testdata/core.yaml")
+	require.NoError(t, err)
+	newProvider, err := p.ProvideFromRaw(raw)
+	require.NoError(t, err)
+
+	// newProvider should pass the same tests as p
+	testBasics(t, newProvider)
+	testMerge(t, newProvider)
+}
+
 func TestEnvSubstitution(t *testing.T) {
 	_ = os.Setenv("CORE_FSC_KVS_PERSISTENCE_OPTS_DATASOURCE", "new data source")
 	_ = os.Setenv("CORE_STR", "new=string=with=characters.\\AND.CAPS")
@@ -97,16 +112,16 @@ func testMerge(t *testing.T, p *Provider) {
 	require.NoError(t, err)
 	require.NoError(t, p.MergeConfig(merge2Raw))
 
-	networkName := p.GetString("fabric.network1.name")
+	networkName := p.GetString(Join("fabric", "network1", "name"))
 	assert.Equal(t, "pineapple", networkName)
 
 	merge3Raw, err := os.ReadFile("./testdata/merge3.yaml")
 	require.NoError(t, err)
 	require.NoError(t, p.MergeConfig(merge3Raw))
 
-	networkName = p.GetString("fabric.network1.name")
+	networkName = p.GetString(Join("fabric", "network1", "name"))
 	assert.Equal(t, "pineapple", networkName)
-	networkName = p.GetString("fabric.network2.name")
+	networkName = p.GetString(Join("fabric", "network2", "name"))
 	assert.Equal(t, "strawberry", networkName)
 
 	testBasics(t, p)