pkg/settings/cresettings: add PerWorkflow.ChainAllowed

Author: jmank88

pkg/contexts/chains.go

@@ -0,0 +1,23 @@
+package contexts
+
+import (
+	"context"
+	"errors"
+)
+
+const chainSelectorCtxKey key = "chainSelectorCtx"
+
+// WithChainSelector returns a new context that includes the chain selector.
+// Use ChainSelectorValue to get the value.
+func WithChainSelector(ctx context.Context, cs uint64) context.Context {
+	return context.WithValue(ctx, chainSelectorCtxKey, cs)
+}
+
+// ChainSelectorValue returns the chain selector, if one was set via WithChainSelector.
+func ChainSelectorValue(ctx context.Context) (uint64, error) {
+	val := Value[uint64](ctx, chainSelectorCtxKey)
+	if val == 0 {
+		return 0, errors.New("context missing chain selector")
+	}
+	return val, nil
+}

pkg/settings/cresettings/defaults.json

@@ -41,6 +41,10 @@
 		"ConsensusCallsLimit": "2000",
 		"LogLineLimit": "1kb",
 		"LogEventLimit": "1000",
+		"ChainAllowed": {
+			"Default": "false",
+			"Values": {}
+		},
 		"CRONTrigger": {
 			"FastestScheduleInterval": "30s",
 			"RateLimit": "every30s:1"

pkg/settings/cresettings/defaults.toml

@@ -42,6 +42,11 @@ ConsensusCallsLimit = '2000'
 LogLineLimit = '1kb'
 LogEventLimit = '1000'
 
+[PerWorkflow.ChainAllowed]
+Default = 'false'
+
+[PerWorkflow.ChainAllowed.Values]
+
 [PerWorkflow.CRONTrigger]
 FastestScheduleInterval = '30s'
 RateLimit = 'every30s:1'

pkg/settings/cresettings/settings.go

@@ -103,6 +103,9 @@ var Default = Schema{
 		ConsensusCallsLimit:           Int(2000),
 		LogLineLimit:                  Size(config.KByte),
 		LogEventLimit:                 Int(1_000),
+		ChainAllowed: PerChainSelector(Bool(false), map[string]bool{
+			// none by default
+		}),
 
 		CRONTrigger: cronTrigger{
 			FastestScheduleInterval: Duration(30 * time.Second),
@@ -210,6 +213,8 @@ type Workflows struct {
 	LogLineLimit  Setting[config.Size]
 	LogEventLimit Setting[int] `unit:"{log}"`
 
+	ChainAllowed SettingMap[bool]
+
 	CRONTrigger cronTrigger
 	HTTPTrigger httpTrigger
 	LogTrigger  logTrigger

pkg/settings/cresettings/settings_test.go

@@ -74,6 +74,12 @@ func TestSchema_Unmarshal(t *testing.T) {
 	},
 	"PerWorkflow": {
 		"WASMMemoryLimit": "250mb",
+		"ChainAllowed": {
+			"Default": "false",
+			"Values": {
+				"1": "true"
+			}
+		},
 		"CRONTrigger": {
 			"RateLimit": "every10s:5"
 		},
@@ -103,6 +109,10 @@ func TestSchema_Unmarshal(t *testing.T) {
 	assert.Equal(t, 48*time.Hour, cfg.PerOrg.ZeroBalancePruningTimeout.DefaultValue)
 	assert.Equal(t, 99, cfg.PerOwner.WorkflowExecutionConcurrencyLimit.DefaultValue)
 	assert.Equal(t, 250*config.MByte, cfg.PerWorkflow.WASMMemoryLimit.DefaultValue)
+	assert.Equal(t, false, cfg.PerWorkflow.ChainAllowed.Default.DefaultValue)
+	assert.Equal(t, "true", cfg.PerWorkflow.ChainAllowed.Values["1"])
+	assert.NotNil(t, cfg.PerWorkflow.ChainAllowed.Default.Parse)
+	assert.NotNil(t, cfg.PerWorkflow.ChainAllowed.KeyFromCtx)
 	assert.Equal(t, config.Rate{Limit: rate.Every(10 * time.Second), Burst: 5}, cfg.PerWorkflow.CRONTrigger.RateLimit.DefaultValue)
 	assert.Equal(t, config.Rate{Limit: rate.Every(30 * time.Second), Burst: 3}, cfg.PerWorkflow.HTTPTrigger.RateLimit.DefaultValue)
 	assert.Equal(t, config.Rate{Limit: rate.Every(13 * time.Second), Burst: 6}, cfg.PerWorkflow.LogTrigger.EventRateLimit.DefaultValue)
@@ -142,11 +152,6 @@ func TestDefaultGetter(t *testing.T) {
 }`)
 	reinit() // set default vars
 
-	_ = `
-[workflow.test-wf-id]
-PerWorkflow.HTTPAction.CallLimit = 20
-`
-
 	// Default unchanged
 	got, err = limit.GetOrDefault(ctx, DefaultGetter)
 	require.NoError(t, err)
@@ -158,3 +163,70 @@ PerWorkflow.HTTPAction.CallLimit = 20
 	require.Equal(t, 20, got)
 
 }
+
+func TestDefaultGetter_SettingMap(t *testing.T) {
+	limit := Default.PerWorkflow.ChainAllowed
+
+	ctx := contexts.WithCRE(t.Context(), contexts.CRE{Owner: "owner-id", Workflow: "foo"})
+	ctx = contexts.WithChainSelector(ctx, 1234)
+	overrideCtx := contexts.WithCRE(t.Context(), contexts.CRE{Owner: "owner-id", Workflow: "test-wf-id"})
+	overrideCtx = contexts.WithChainSelector(overrideCtx, 1234)
+
+	// None allowed by default
+	got, err := limit.GetOrDefault(ctx, DefaultGetter)
+	require.NoError(t, err)
+	require.False(t, got)
+	got, err = limit.GetOrDefault(overrideCtx, DefaultGetter)
+	require.NoError(t, err)
+	require.False(t, got)
+
+	t.Cleanup(reinit) // restore default vars
+
+	// Org override to allow
+	t.Setenv(envNameSettings, `{
+	"workflow": {
+		"test-wf-id": {
+			"PerWorkflow": {
+				"ChainAllowed": {
+					"Values": {
+						"1234": "true"
+					}
+				}
+			}
+		}
+	}
+}`)
+	reinit() // set default vars
+	got, err = limit.GetOrDefault(ctx, DefaultGetter)
+	require.NoError(t, err)
+	require.False(t, got)
+	got, err = limit.GetOrDefault(overrideCtx, DefaultGetter)
+	require.NoError(t, err)
+	require.True(t, got)
+
+	// Org override to allow by default, but disallow some
+	t.Setenv(envNameSettings, `{
+	"workflow": {
+		"test-wf-id": {
+			"PerWorkflow": {
+				"ChainAllowed": {
+					"Default": true,
+					"Values": {
+						"1234": "false"
+					}
+				}
+			}
+		}
+	}
+}`)
+	reinit() // set default vars
+	got, err = limit.GetOrDefault(ctx, DefaultGetter)
+	require.NoError(t, err)
+	require.False(t, got)
+	got, err = limit.GetOrDefault(overrideCtx, DefaultGetter)
+	require.NoError(t, err)
+	require.False(t, got)
+	got, err = limit.GetOrDefault(contexts.WithChainSelector(overrideCtx, 42), DefaultGetter)
+	require.NoError(t, err)
+	require.True(t, got)
+}

pkg/settings/json.go

@@ -8,14 +8,16 @@ import (
 	"io/fs"
 	"maps"
 	"slices"
+	"strconv"
 	"strings"
 )
 
 // CombineJSONFiles reads a set of JSON config files and combines them in to one file. The expected inputs are:
-//	- global.json
-// 	- org/*.json
-// 	- owner/*.json
-// 	- workflow/*.json
+//   - global.json
+//   - org/*.json
+//   - owner/*.json
+//   - workflow/*.json
+//
 // The directory and file names translate to keys in the JSON structure, while the file extensions are discarded.
 // For example: owner/0x1234.json:Foo.Bar becomes owner.0x1234.Foo.Bar
 func CombineJSONFiles(files fs.FS) ([]byte, error) {
@@ -152,11 +154,17 @@ func (s *jsonSettings) get(key string) (string, error) {
 	}
 
 	field := parts[len(parts)-1]
-	switch t := m[field].(type) {
-	case string:
-		return t, nil
-	case json.Number:
-		return t.String(), nil
+	if val, ok := m[field]; ok {
+		switch t := val.(type) {
+		case string:
+			return t, nil
+		case json.Number:
+			return t.String(), nil
+		case bool:
+			return strconv.FormatBool(t), nil
+		default:
+			return "", fmt.Errorf("non-string value: %s: %t(%v)", key, val, val)
+		}
 	}
 	return "", nil // no value
 }
@@ -166,7 +174,7 @@ type jsonGetter struct {
 }
 
 // NewJSONGetter returns a static Getter backed by the given JSON.
-//TODO https://smartcontract-it.atlassian.net/browse/CAPPL-775
+// TODO https://smartcontract-it.atlassian.net/browse/CAPPL-775
 // NewJSONRegistry with polling & subscriptions
 func NewJSONGetter(b []byte) (Getter, error) {
 	s, err := newJSONSettings(b)

pkg/settings/keys.go

@@ -17,8 +17,9 @@ func (s Scope) rawKeys(ctx context.Context, key string) (keys []string, err erro
 			if i.IsTenantRequired() {
 				err = errors.Join(err, fmt.Errorf("empty %s key", i))
 			}
+		} else {
+			keys = append(keys, i.String()+"."+tenant+"."+key)
 		}
-		keys = append(keys, i.String()+"."+tenant+"."+key)
 	}
 	keys = append(keys, ScopeGlobal.String()+"."+key) // ScopeGlobal
 	return

pkg/settings/limits/bound.go

@@ -54,9 +54,8 @@ func newBoundLimiter[N Number](f Factory, bound settings.Setting[N]) (BoundLimit
 		updater: newUpdater[N](nil, func(ctx context.Context) (N, error) {
 			return bound.GetOrDefault(ctx, f.Settings)
 		}, nil),
-		defaultBound: bound.DefaultValue,
-		key:          bound.Key,
-		scope:        bound.Scope,
+		key:   bound.Key,
+		scope: bound.Scope,
 	}
 	b.updater.recordLimit = func(ctx context.Context, n N) { b.recordBound(ctx, n) }
 
@@ -115,7 +114,6 @@ func newBoundLimiter[N Number](f Factory, bound settings.Setting[N]) (BoundLimit
 
 type boundLimiter[N Number] struct {
 	*updater[N]
-	defaultBound N
 
 	key   string // optional
 	scope settings.Scope

pkg/settings/limits/errors.go

@@ -144,3 +144,24 @@ func (e ErrorQueueFull) Error() string {
 }
 
 var ErrQueueEmpty = fmt.Errorf("queue is empty")
+
+type ErrorNotAllowed struct {
+	Key string
+
+	Scope  settings.Scope
+	Tenant string
+}
+
+func (e ErrorNotAllowed) GRPCStatus() *status.Status {
+	return status.New(codes.PermissionDenied, e.Error())
+}
+
+func (e ErrorNotAllowed) Is(target error) bool {
+	_, ok := target.(ErrorNotAllowed) //nolint:errcheck // implementing errors.Is
+	return ok
+}
+
+func (e ErrorNotAllowed) Error() string {
+	which, who := errArgs(e.Key, e.Scope, e.Tenant)
+	return fmt.Sprintf("%slimited%s: not allowed", which, who)
+}

pkg/settings/limits/factory.go

@@ -31,10 +31,10 @@ func (f Factory) NewRateLimiter(rate settings.Setting[config.Rate]) (RateLimiter
 
 // MakeRateLimiter creates a RateLimiter for the given rate and configured by the Factory.
 // If Meter is set, the following metrics will be emitted
-//  - rate.*.limit - float gauge
-//  - rate.*.burst - int gauge
-//  - rate.*.usage - int counter
-//  - rate.*.denied - int histogram
+//   - rate.*.limit - float gauge
+//   - rate.*.burst - int gauge
+//   - rate.*.usage - int counter
+//   - rate.*.denied - int histogram
 func (f Factory) MakeRateLimiter(rate settings.Setting[config.Rate]) (RateLimiter, error) {
 	if rate.Scope == settings.ScopeGlobal {
 		return f.globalRateLimiter(rate)
@@ -49,10 +49,11 @@ func (f Factory) NewTimeLimiter(timeout settings.Setting[time.Duration]) (TimeLi
 
 // MakeTimeLimiter returns a TimeLimiter for given timeout, and configured by the Factory.
 // If Meter is set, the following metrics will be emitted
-//  - time.*.limit - float gauge
-//  - time.*.runtime - float gauge
-//  - time.*.success - int counter
-//  - time.*.timeout - int counter
+//   - time.*.limit - float gauge
+//   - time.*.runtime - float gauge
+//   - time.*.success - int counter
+//   - time.*.timeout - int counter
+//
 // Note: Unit will be ignored. All TimeLimiters emit seconds as "s".
 func (f Factory) MakeTimeLimiter(timeout settings.Setting[time.Duration]) (TimeLimiter, error) {
 	return f.newTimeLimiter(timeout)
@@ -65,10 +66,10 @@ func NewResourcePoolLimiter[N Number](f Factory, limit settings.Setting[N]) (Res
 
 // MakeResourcePoolLimiter returns a ResourcePoolLimiter for the given limit, and configured by the Factory.
 // If Meter is set, the following metrics will be emitted
-//  - resource.*.limit - gauge
-//  - resource.*.usage - gauge
-//  - resource.*.amount - histogram
-//  - resource.*.denied - histogram
+//   - resource.*.limit - gauge
+//   - resource.*.usage - gauge
+//   - resource.*.amount - histogram
+//   - resource.*.denied - histogram
 func MakeResourcePoolLimiter[N Number](f Factory, limit settings.Setting[N]) (ResourcePoolLimiter[N], error) {
 	if limit.Scope == settings.ScopeGlobal {
 		return newGlobalResourcePoolLimiter(f, limit)
@@ -78,21 +79,32 @@ func MakeResourcePoolLimiter[N Number](f Factory, limit settings.Setting[N]) (Re
 
 // MakeBoundLimiter returns a BoundLimiter for the given bound and configured by the Factory.
 // If Meter is set, the following metrics will be emitted
-//  - bound.*.limit - gauge
-//  - bound.*.usage - histogram
-//  - bound.*.denied - histogram
+//   - bound.*.limit - gauge
+//   - bound.*.usage - histogram
+//   - bound.*.denied - histogram
 func MakeBoundLimiter[N Number](f Factory, bound settings.Setting[N]) (BoundLimiter[N], error) {
 	return newBoundLimiter(f, bound)
 }
 
 // MakeQueueLimiter returns a QueueLimiter for the given limit and configured by the Factory.
 // If Meter is set, the following metrics will be emitted
-//  - queue.*.limit - int gauge
-//  - queue.*.usage - int gauge
-//  - queue.*.denied - int histogram
+//   - queue.*.limit - int gauge
+//   - queue.*.usage - int gauge
+//   - queue.*.denied - int histogram
 func MakeQueueLimiter[T any](f Factory, limit settings.Setting[int]) (QueueLimiter[T], error) {
 	if limit.Scope == settings.ScopeGlobal {
 		return newUnscopedQueue[T](f, limit)
 	}
 	return newScopedQueue[T](f, limit)
 }
+
+// MakeGateLimiter returns a GateLimiter for the given limit and configured by the factory.
+// If Meter is set, the following metrics will be emitted
+//   - gate.*.limit - int gauge
+//   - gate.*.usage - int counter
+//   - gate.*.denied - int counter
+//
+// OPT: accept an interface for limit
+func MakeGateLimiter(f Factory, limit settings.SettingMap[bool]) (GateLimiter, error) {
+	return newGateLimiter(f, limit)
+}