pkg/settings/cresettings: HTTPAction s/RateLimit/CallLimit

Author: jmank88

pkg/capabilities/capabilities.go

@@ -3,6 +3,7 @@ package capabilities
 import (
 	"context"
 	"fmt"
+	"iter"
 	"regexp"
 	"strings"
 	"time"
@@ -155,6 +156,30 @@ type CapabilityRequest struct {
 	CapabilityId string
 }
 
+// ParseID parsed a capability ID in form of: `{name}:{label1_key}_{labe1_value}:{label2_key}_{label2_value}@{version}`
+func ParseID(id string) (name string, labels iter.Seq2[string, string], version string) {
+	if i := strings.LastIndex(id, "@"); i != -1 {
+		version = id[i+1:]
+		id = id[:i]
+	}
+	if parts := strings.Split(id, ":"); len(parts) >= 1 {
+		name = parts[0]
+		labels = func(yield func(string, string) bool) {
+			for _, label := range parts[1:] {
+				kv := strings.SplitN(label, "_", 2)
+				var v string
+				if len(kv) == 2 {
+					v = kv[1]
+				}
+				if !yield(kv[0], v) {
+					return
+				}
+			}
+		}
+	}
+	return
+}
+
 type RegisterToWorkflowRequest struct {
 	Metadata RegistrationMetadata
 	Config   *values.Map

pkg/capabilities/capabilities_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"maps"
 	"strings"
 	"testing"
 
@@ -275,3 +276,29 @@ func TestOCRTriggerEvent_ToMapFromMap(t *testing.T) {
 	})
 
 }
+
+func TestParseID(t *testing.T) {
+	for _, tc := range []struct {
+		id      string
+		name    string
+		labels  map[string]string
+		version string
+	}{
+		{id: "foo", name: "foo"},
+		{id: "[email protected]", name: "foo", version: "1.0.0"},
+		{id: "foo:[email protected]", name: "foo", labels: map[string]string{"k": "v"}, version: "1.0.0"},
+		{id: "foo:k_v:k2_v2:[email protected]", name: "foo", labels: map[string]string{"k": "v", "k2": "v2", "k3": ""}, version: "1.0.0"},
+		//TODO more
+	} {
+		t.Run(tc.id, func(t *testing.T) {
+			if tc.labels == nil {
+				tc.labels = map[string]string{}
+			}
+
+			name, labels, version := ParseID(tc.id)
+			assert.Equal(t, tc.name, name)
+			assert.Equal(t, tc.labels, maps.Collect(labels))
+			assert.Equal(t, tc.version, version)
+		})
+	}
+}

pkg/settings/cresettings/defaults.json

@@ -49,18 +49,17 @@
 			"FilterTopicsPerSlotLimit": "10"
 		},
 		"HTTPAction": {
-			"RateLimit": "every30s:3",
+			"CallLimit": "3",
 			"ResponseSizeLimit": "10kb",
 			"ConnectionTimeout": "10s",
 			"RequestSizeLimit": "100kb",
 			"CacheAgeLimit": "10m0s"
 		},
 		"ChainWrite": {
-			"RateLimit": "every30s:3",
 			"TargetsLimit": "3",
 			"ReportSizeLimit": "1kb",
 			"EVM": {
-				"TransactionGasLimit": "500000"
+				"TransactionGasLimit": "5000000"
 			}
 		},
 		"ChainRead": {

pkg/settings/cresettings/defaults.toml

@@ -50,19 +50,18 @@ FilterAddressLimit = '5'
 FilterTopicsPerSlotLimit = '10'
 
 [PerWorkflow.HTTPAction]
-RateLimit = 'every30s:3'
+CallLimit = '3'
 ResponseSizeLimit = '10kb'
 ConnectionTimeout = '10s'
 RequestSizeLimit = '100kb'
 CacheAgeLimit = '10m0s'
 
 [PerWorkflow.ChainWrite]
-RateLimit = 'every30s:3'
 TargetsLimit = '3'
 ReportSizeLimit = '1kb'
 
 [PerWorkflow.ChainWrite.EVM]
-TransactionGasLimit = '500000'
+TransactionGasLimit = '5000000'
 
 [PerWorkflow.ChainRead]
 CallLimit = '3'

pkg/settings/cresettings/settings.go

@@ -82,18 +82,17 @@ var Default = Schema{
 			EventSizeLimit:           Size(5 * config.KByte),
 		},
 		HTTPAction: httpAction{
-			RateLimit:         Rate(rate.Every(30*time.Second), 3),
+			CallLimit:         Int(3),
 			ResponseSizeLimit: Size(10 * config.KByte),
 			ConnectionTimeout: Duration(10 * time.Second),
 			RequestSizeLimit:  Size(100 * config.KByte),
 			CacheAgeLimit:     Duration(10 * time.Minute),
 		},
 		ChainWrite: chainWrite{
-			RateLimit:       Rate(rate.Every(30*time.Second), 3),
 			TargetsLimit:    Int(3),
 			ReportSizeLimit: Size(config.KByte),
 			EVM: evmChainWrite{
-				TransactionGasLimit: Uint64(500_000),
+				TransactionGasLimit: Uint64(5_000_000),
 			},
 		},
 		ChainRead: chainRead{
@@ -177,14 +176,13 @@ type logTrigger struct {
 	FilterTopicsPerSlotLimit Setting[int] `unit:"{topic}"`
 }
 type httpAction struct {
-	RateLimit         Setting[config.Rate]
+	CallLimit         Setting[int] `unit:"{call}"`
 	ResponseSizeLimit Setting[config.Size]
 	ConnectionTimeout Setting[time.Duration]
 	RequestSizeLimit  Setting[config.Size]
 	CacheAgeLimit     Setting[time.Duration]
 }
 type chainWrite struct {
-	RateLimit       Setting[config.Rate]
 	TargetsLimit    Setting[int] `unit:"{target}"`
 	ReportSizeLimit Setting[config.Size]
 

pkg/settings/cresettings/settings_test.go

@@ -83,7 +83,7 @@ func TestSchema_Unmarshal(t *testing.T) {
 			"EventRateLimit": "every13s:6"
 		},
 		"HTTPAction": {
-			"RateLimit": "every3s:5",
+			"CallLimit": "5",
 			"CacheAgeLimit": "5m"
 		},
 		"ChainWrite": {
@@ -107,7 +107,7 @@ func TestSchema_Unmarshal(t *testing.T) {
 	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)
-	assert.Equal(t, config.Rate{Limit: rate.Every(3 * time.Second), Burst: 5}, cfg.PerWorkflow.HTTPAction.RateLimit.DefaultValue)
+	assert.Equal(t, 5, cfg.PerWorkflow.HTTPAction.CallLimit.DefaultValue)
 	assert.Equal(t, 5*time.Minute, cfg.PerWorkflow.HTTPAction.CacheAgeLimit.DefaultValue)
 	assert.Equal(t, uint64(500000), cfg.PerWorkflow.ChainWrite.EVM.TransactionGasLimit.DefaultValue)
 	assert.Equal(t, 3, cfg.PerWorkflow.ChainRead.CallLimit.DefaultValue)