configuration with docs

adecaro · adecaro · commit 70d8ad3b6c96 · 2026-02-20T15:36:05.000+01:00
Signed-off-by: Angelo De Caro &lt;adc@zurich.ibm.com&gt;
diff --git a/docs/core-token.md b/docs/core-token.md
@@ -73,6 +73,22 @@ token:
       workers: 10
       # queueSize is the size of the event buffer. Defaults to 1000.
       queueSize: 1000
+  
+  # fabricx configuration for FabricX-specific settings
+  fabricx:
+    # lookup configuration for the lookup service
+    lookup:
+      # permanent lookup configuration
+      permanent:
+        # interval is the polling interval for permanent lookups. Defaults to 1m.
+        interval: 1m
+      # one-time lookup configuration
+      once:
+        # deadline is the maximum time to wait for a one-time lookup. Defaults to 5m.
+        deadline: 5m
+        # interval is the polling interval for one-time lookups. Defaults to 2s.
+        interval: 2s
+        
   tms:
     mytms: # unique name of this token management system
       network: default # the name of the network this TMS refers to (Fabric, etc.)
@@ -217,4 +233,27 @@ Default values:
 - delivery.blockProcessParallelism: 10
 - delivery.lruSize: 30
 - delivery.lruBuffer: 15
-- delivery.listenerTimeout: 10s
+- delivery.listenerTimeout: 10s
+
+---
+
+## Optional: token.fabricx.lookup
+
+If not specified, the default configuration is:
+
+```yaml
+token:
+  fabricx:
+    lookup:
+      permanent:
+        interval: 1m
+      once:
+        deadline: 5m
+        interval: 2s
+```
+
+Default values:
+
+- permanent.interval: 1m
+- once.deadline: 5m
+- once.interval: 2s
diff --git a/token/services/network/fabricx/driver.go b/token/services/network/fabricx/driver.go
@@ -90,7 +90,7 @@ func NewDriver(
 		queryExecutorProvider:      queryExecutorProvider,
 		keyTranslator:              kt,
 		flmProvider:                finality2.NewNotificationServiceBased(queryServiceProvider, finalityProvider, q),
-		llmProvider:                lookup2.NewQueryServiceBased(queryServiceProvider, q),
+		llmProvider:                lookup2.NewQueryServiceBased(queryServiceProvider, q, lookup2.NewConfig(configService)),
 		EndorsementServiceProvider: endorsement.NewServiceProvider(
 			configs,
 			viewManager,
diff --git a/token/services/network/fabricx/lookup/config.go b/token/services/network/fabricx/lookup/config.go
@@ -0,0 +1,76 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package lookup
+
+import "time"
+
+const (
+	// PermanentInterval is the configuration key for the polling interval of permanent lookups
+	PermanentInterval = "token.fabricx.lookup.permanent.interval"
+	// OnceDeadline is the configuration key for the deadline of one-time lookups
+	OnceDeadline = "token.fabricx.lookup.once.deadline"
+	// OnceInterval is the configuration key for the polling interval of one-time lookups
+	OnceInterval = "token.fabricx.lookup.once.interval"
+
+	// DefaultPermanentInterval is the default polling interval for permanent lookups
+	DefaultPermanentInterval = 1 * time.Minute
+	// DefaultOnceDeadline is the default deadline for one-time lookups
+	DefaultOnceDeadline = 5 * time.Minute
+	// DefaultOnceInterval is the default polling interval for one-time lookups
+	DefaultOnceInterval = 2 * time.Second
+)
+
+// ConfigGetter models the configuration getter for the lookup service
+type ConfigGetter interface {
+	// PermanentInterval returns the polling interval for permanent lookups
+	PermanentInterval() time.Duration
+	// OnceDeadline returns the deadline for one-time lookups
+	OnceDeadline() time.Duration
+	// OnceInterval returns the polling interval for one-time lookups
+	OnceInterval() time.Duration
+}
+
+//go:generate counterfeiter -o mock/configuration.go -fake-name Configuration . Configuration
+type Configuration interface {
+	GetDuration(key string) time.Duration
+}
+
+// NewConfig creates a new ConfigGetter
+func NewConfig(configuration Configuration) *serviceConfig {
+	return &serviceConfig{configuration: configuration}
+}
+
+type serviceConfig struct {
+	configuration Configuration
+}
+
+// PermanentInterval returns the polling interval for permanent lookups
+func (c *serviceConfig) PermanentInterval() time.Duration {
+	if v := c.configuration.GetDuration(PermanentInterval); v > 0 {
+		return v
+	}
+
+	return DefaultPermanentInterval
+}
+
+// OnceDeadline returns the deadline for one-time lookups
+func (c *serviceConfig) OnceDeadline() time.Duration {
+	if v := c.configuration.GetDuration(OnceDeadline); v > 0 {
+		return v
+	}
+
+	return DefaultOnceDeadline
+}
+
+// OnceInterval returns the polling interval for one-time lookups
+func (c *serviceConfig) OnceInterval() time.Duration {
+	if v := c.configuration.GetDuration(OnceInterval); v > 0 {
+		return v
+	}
+
+	return DefaultOnceInterval
+}
diff --git a/token/services/network/fabricx/lookup/config_test.go b/token/services/network/fabricx/lookup/config_test.go
@@ -0,0 +1,109 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package lookup_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabricx/lookup"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabricx/lookup/mock"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewConfig(t *testing.T) {
+	m := &mock.Configuration{}
+	cfg := lookup.NewConfig(m)
+	assert.NotNil(t, cfg)
+}
+
+func TestServiceConfig_PermanentInterval(t *testing.T) {
+	t.Run("returns value from configuration when > 0", func(t *testing.T) {
+		m := &mock.Configuration{}
+		expected := 2 * time.Minute
+		m.GetDurationReturns(expected)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, expected, cfg.PermanentInterval())
+		assert.Equal(t, 1, m.GetDurationCallCount())
+		assert.Equal(t, lookup.PermanentInterval, m.GetDurationArgsForCall(0))
+	})
+
+	t.Run("returns default when configuration returns 0", func(t *testing.T) {
+		m := &mock.Configuration{}
+		m.GetDurationReturns(0)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, lookup.DefaultPermanentInterval, cfg.PermanentInterval())
+	})
+
+	t.Run("returns default when configuration returns negative", func(t *testing.T) {
+		m := &mock.Configuration{}
+		m.GetDurationReturns(-1 * time.Second)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, lookup.DefaultPermanentInterval, cfg.PermanentInterval())
+	})
+}
+
+func TestServiceConfig_OnceDeadline(t *testing.T) {
+	t.Run("returns value from configuration when > 0", func(t *testing.T) {
+		m := &mock.Configuration{}
+		expected := 10 * time.Minute
+		m.GetDurationReturns(expected)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, expected, cfg.OnceDeadline())
+		assert.Equal(t, 1, m.GetDurationCallCount())
+		assert.Equal(t, lookup.OnceDeadline, m.GetDurationArgsForCall(0))
+	})
+
+	t.Run("returns default when configuration returns 0", func(t *testing.T) {
+		m := &mock.Configuration{}
+		m.GetDurationReturns(0)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, lookup.DefaultOnceDeadline, cfg.OnceDeadline())
+	})
+
+	t.Run("returns default when configuration returns negative", func(t *testing.T) {
+		m := &mock.Configuration{}
+		m.GetDurationReturns(-1 * time.Second)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, lookup.DefaultOnceDeadline, cfg.OnceDeadline())
+	})
+}
+
+func TestServiceConfig_OnceInterval(t *testing.T) {
+	t.Run("returns value from configuration when > 0", func(t *testing.T) {
+		m := &mock.Configuration{}
+		expected := 5 * time.Second
+		m.GetDurationReturns(expected)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, expected, cfg.OnceInterval())
+		assert.Equal(t, 1, m.GetDurationCallCount())
+		assert.Equal(t, lookup.OnceInterval, m.GetDurationArgsForCall(0))
+	})
+
+	t.Run("returns default when configuration returns 0", func(t *testing.T) {
+		m := &mock.Configuration{}
+		m.GetDurationReturns(0)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, lookup.DefaultOnceInterval, cfg.OnceInterval())
+	})
+
+	t.Run("returns default when configuration returns negative", func(t *testing.T) {
+		m := &mock.Configuration{}
+		m.GetDurationReturns(-1 * time.Second)
+		cfg := lookup.NewConfig(m)
+
+		assert.Equal(t, lookup.DefaultOnceInterval, cfg.OnceInterval())
+	})
+}
diff --git a/token/services/network/fabricx/lookup/lookup.go b/token/services/network/fabricx/lookup/lookup.go
@@ -49,6 +49,7 @@ type Listener = lookup.Listener
 type NSListenerManager struct {
 	queue        Queue
 	queryService QueryService
+	config       ConfigGetter
 
 	mu        sync.RWMutex
 	listeners map[string][]Listener
@@ -58,10 +59,12 @@ type NSListenerManager struct {
 func NewNSListenerManager(
 	queue Queue,
 	qs QueryService,
+	config ConfigGetter,
 ) *NSListenerManager {
 	return &NSListenerManager{
 		queue:        queue,
 		queryService: qs,
+		config:       config,
 		listeners:    make(map[string][]Listener),
 	}
 }
@@ -85,7 +88,7 @@ func (n *NSListenerManager) AddPermanentLookupListener(namespace string, key str
 		Namespace:    namespace,
 		Key:          key,
 		Listener:     listener,
-		Interval:     1 * time.Minute,
+		Interval:     n.config.PermanentInterval(),
 	})
 }
 
@@ -106,8 +109,8 @@ func (n *NSListenerManager) AddLookupListener(namespace string, key string, list
 		Key:          key,
 		Listener:     l,
 		Original:     listener,
-		Deadline:     time.Now().Add(5 * time.Minute),
-		Interval:     2 * time.Second,
+		Deadline:     time.Now().Add(n.config.OnceDeadline()),
+		Interval:     n.config.OnceInterval(),
 	})
 }
 
@@ -159,13 +162,15 @@ func (n *NSListenerManager) isRegistered(key string, listener Listener) bool {
 type NSListenerManagerProvider struct {
 	QueryServiceProvider QueryServiceProvider
 	queue                Queue
+	config               ConfigGetter
 }
 
 // NewQueryServiceBased creates a new NSListenerManagerProvider
-func NewQueryServiceBased(queryServiceProvider QueryServiceProvider, queue Queue) lookup.ListenerManagerProvider {
+func NewQueryServiceBased(queryServiceProvider QueryServiceProvider, queue Queue, config ConfigGetter) lookup.ListenerManagerProvider {
 	return &NSListenerManagerProvider{
 		QueryServiceProvider: queryServiceProvider,
 		queue:                queue,
+		config:               config,
 	}
 }
 
@@ -175,7 +180,7 @@ func (n *NSListenerManagerProvider) NewManager(network, channel string) (lookup.
 		return nil, errors.Wrapf(err, "failed getting query service")
 	}
 
-	return NewNSListenerManager(n.queue, qs), nil
+	return NewNSListenerManager(n.queue, qs, n.config), nil
 }
 
 // KeyCheck represents a key check event
diff --git a/token/services/network/fabricx/lookup/lookup_test.go b/token/services/network/fabricx/lookup/lookup_test.go
@@ -23,7 +23,7 @@ import (
 func TestNSListenerManager(t *testing.T) {
 	q := &mock.Queue{}
 	qs := &mock.QueryService{}
-	mgr := lookup.NewNSListenerManager(q, qs)
+	mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 
 	assert.True(t, mgr.PermanentLookupListenerSupported())
 
@@ -62,7 +62,7 @@ func TestKeyCheck_Process(t *testing.T) {
 		q := &mock.Queue{}
 		qs := &mock.QueryService{}
 		qs.GetStateReturns(&driver2.VaultValue{Raw: []byte("value")}, nil)
-		mgr := lookup.NewNSListenerManager(q, qs)
+		mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 		l := &mock.Listener{}
 		require.NoError(t, mgr.AddLookupListener("ns", "key", l))
 
@@ -77,7 +77,7 @@ func TestKeyCheck_Process(t *testing.T) {
 	t.Run("Removed", func(t *testing.T) {
 		q := &mock.Queue{}
 		qs := &mock.QueryService{}
-		mgr := lookup.NewNSListenerManager(q, qs)
+		mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 		l := &mock.Listener{}
 		require.NoError(t, mgr.AddLookupListener("ns", "key", l))
 
@@ -97,7 +97,7 @@ func TestKeyCheck_Process(t *testing.T) {
 		q := &mock.Queue{}
 		qs := &mock.QueryService{}
 		qs.GetStateReturns(nil, nil)
-		mgr := lookup.NewNSListenerManager(q, qs)
+		mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 		l := &mock.Listener{}
 		require.NoError(t, mgr.AddLookupListener("ns", "key", l))
 
@@ -119,7 +119,7 @@ func TestKeyCheck_Process(t *testing.T) {
 		q := &mock.Queue{}
 		qs := &mock.QueryService{}
 		qs.GetStateReturns(nil, nil)
-		mgr := lookup.NewNSListenerManager(q, qs)
+		mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 		l := &mock.Listener{}
 		require.NoError(t, mgr.AddLookupListener("ns", "key", l))
 
@@ -148,7 +148,7 @@ func TestPermanentKeyCheck_Process(t *testing.T) {
 		// 3rd call: changed value
 		qs.GetStateReturnsOnCall(2, &driver2.VaultValue{Raw: []byte("v2")}, nil)
 
-		mgr := lookup.NewNSListenerManager(q, qs)
+		mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 		l := &mock.Listener{}
 		require.NoError(t, mgr.AddPermanentLookupListener("ns", "key", l))
 
@@ -179,7 +179,7 @@ func TestPermanentKeyCheck_Process(t *testing.T) {
 	t.Run("Removed", func(t *testing.T) {
 		q := &mock.Queue{}
 		qs := &mock.QueryService{}
-		mgr := lookup.NewNSListenerManager(q, qs)
+		mgr := lookup.NewNSListenerManager(q, qs, lookup.NewConfig(&mock.Configuration{}))
 		l := &mock.Listener{}
 		require.NoError(t, mgr.AddPermanentLookupListener("ns", "key", l))
 
@@ -220,7 +220,7 @@ func TestNSListenerManagerProvider(t *testing.T) {
 	qsp := &mock.QueryServiceProvider{}
 	qsp.GetReturns(qs, nil)
 
-	p := lookup.NewQueryServiceBased(qsp, q)
+	p := lookup.NewQueryServiceBased(qsp, q, lookup.NewConfig(&mock.Configuration{}))
 
 	// Successful creation
 	mgr, err := p.NewManager("network", "channel")
diff --git a/token/services/network/fabricx/lookup/mock/configuration.go b/token/services/network/fabricx/lookup/mock/configuration.go
