feature: builder session manager env var config

eth/backend.go

@@ -318,7 +318,7 @@
 		Service:   backends.NewEthBackendServer(s.APIBackend),
 	})
 
-	sessionManager := suave_builder.NewSessionManager(s.blockchain, &suave_builder.Config{})
+	sessionManager := suave_builder.NewSessionManager(s.blockchain, suave_builder.NewConfigFromEnv()))
 
 	apis = append(apis, rpc.API{
 		Namespace: "suavex",

suave/builder/session_manager.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"os"
+	"strconv"
 	"sync"
 	"time"
 
@@ -37,6 +39,38 @@ type Config struct {
 	MaxConcurrentSessions int
 }
 
+func getEnvAsUint64(key string, defaultVal uint64) uint64 {
+	valStr := os.Getenv(key)
+	if val, err := strconv.ParseUint(valStr, 10, 64); err == nil {
+		return val
+	}
+	return defaultVal
+}
+
+func getEnvAsInt(key string, defaultVal int) int {
+	valStr := os.Getenv(key)
+	if val, err := strconv.Atoi(valStr); err == nil {
+		return val
+	}
+	return defaultVal
+}
+
+func getEnvAsDuration(key string, defaultVal time.Duration) time.Duration {
+	valStr := os.Getenv(key)
+	if val, err := time.ParseDuration(valStr); err == nil {
+		return val
+	}
+	return defaultVal
+}
+
+func NewConfigFromEnv() *Config {
+	return &Config{
+		GasCeil:               getEnvAsUint64("GAS_CEIL", 1000000000000000000),
+		SessionIdleTimeout:    getEnvAsDuration("SESSION_IDLE_TIMEOUT", 5*time.Second),
+		MaxConcurrentSessions: getEnvAsInt("MAX_CONCURRENT_SESSIONS", 16),
+	}
+}
+
 type SessionManager struct {
 	sem           chan struct{}
 	sessions      map[string]*builder
@@ -47,14 +81,8 @@ type SessionManager struct {
 }
 
 func NewSessionManager(blockchain blockchain, config *Config) *SessionManager {
-	if config.GasCeil == 0 {
-		config.GasCeil = 1000000000000000000
-	}
-	if config.SessionIdleTimeout == 0 {
-		config.SessionIdleTimeout = 5 * time.Second
-	}
-	if config.MaxConcurrentSessions <= 0 {
-		config.MaxConcurrentSessions = 16 // chosen arbitrarily
+	if config == nil {
+		panic("empty session manager config")
 	}
 
 	sem := make(chan struct{}, config.MaxConcurrentSessions)

suave/builder/session_manager_test.go

@@ -18,9 +18,9 @@ import (
 )
 
 func TestSessionManager_SessionTimeout(t *testing.T) {
-	mngr, _ := newSessionManager(t, &Config{
-		SessionIdleTimeout: 500 * time.Millisecond,
-	})
+	config := NewConfigFromEnv()
+	config.SessionIdleTimeout = 500 * time.Millisecond
+	mngr, _ := newSessionManager(t, config)
 
 	id, err := mngr.NewSession(context.TODO())
 	require.NoError(t, err)
@@ -36,10 +36,10 @@ func TestSessionManager_MaxConcurrentSessions(t *testing.T) {
 
 	const d = time.Millisecond * 100
 
-	mngr, _ := newSessionManager(t, &Config{
-		MaxConcurrentSessions: 1,
-		SessionIdleTimeout:    d,
-	})
+	config := NewConfigFromEnv()
+	config.MaxConcurrentSessions = 1
+	config.SessionIdleTimeout = d
+	mngr, _ := newSessionManager(t, config)
 
 	t.Run("SessionAvailable", func(t *testing.T) {
 		sess, err := mngr.NewSession(context.TODO())
@@ -69,9 +69,9 @@ func TestSessionManager_MaxConcurrentSessions(t *testing.T) {
 }
 
 func TestSessionManager_SessionRefresh(t *testing.T) {
-	mngr, _ := newSessionManager(t, &Config{
-		SessionIdleTimeout: 500 * time.Millisecond,
-	})
+	config := NewConfigFromEnv()
+	config.SessionIdleTimeout = 500 * time.Millisecond
+	mngr, _ := newSessionManager(t, config)
 
 	id, err := mngr.NewSession(context.TODO())
 	require.NoError(t, err)
@@ -95,8 +95,7 @@ func TestSessionManager_SessionRefresh(t *testing.T) {
 }
 
 func TestSessionManager_StartSession(t *testing.T) {
-	// test that the session starts and it can simulate transactions
-	mngr, bMock := newSessionManager(t, &Config{})
+	mngr, bMock := newSessionManager(t, NewConfigFromEnv())
 
 	id, err := mngr.NewSession(context.TODO())
 	require.NoError(t, err)
@@ -107,17 +106,13 @@ func TestSessionManager_StartSession(t *testing.T) {
 	require.NotNil(t, receipt)
 }
 
-func newSessionManager(t *testing.T, cfg *Config) (*SessionManager, *blockchainMock) {
-	if cfg == nil {
-		cfg = &Config{}
-	}
-
+func newSessionManager(t *testing.T, config *Config) (*SessionManager, *blockchainMock) {
 	state := newMockState(t)
 
 	bMock := &blockchainMock{
 		state: state,
 	}
-	return NewSessionManager(bMock, cfg), bMock
+	return NewSessionManager(bMock, config), bMock
 }
 
 type blockchainMock struct {