feat: signet-node (#2)

Author: rswanson

pkg/signet_node/constants.go

@@ -0,0 +1,51 @@
+package signet_node
+
+// Resource defaults
+const (
+	// Storage defaults
+	DefaultStorageSize  = "150Gi"
+	DefaultStorageClass = "aws-gp3"
+
+	// StatefulSet defaults
+	DefaultReplicas = 1
+
+	// Resource allocation defaults
+	DefaultCPULimit      = "2"
+	DefaultMemoryLimit   = "16Gi"
+	DefaultCPURequest    = "2"
+	DefaultMemoryRequest = "4Gi"
+
+	// Port defaults
+	MetricsPort          = 9001
+	RpcPort              = 8545
+	WsPort               = 8546
+	AuthRpcPort          = 8551
+	DiscoveryPort        = 30303
+	ConsensusHttpPort    = 4000
+	ConsensusMetricsPort = 5054
+	HostIpcPort          = 8547
+	RollupHttpPort       = 8645
+	RollupWsPort         = 8646
+
+	// Component name
+	ComponentKind = "the-builder:index:SignetNode"
+)
+
+// Resource name suffixes
+const (
+	ServiceSuffix        = "-service"
+	StatefulSetSuffix    = "-set"
+	ConfigMapSuffix      = "-configmap"
+	PvcSuffix            = "-data"
+	SecretSuffix         = "-secret"
+	VirtualServiceSuffix = "-vservice"
+)
+
+// Resource names
+const (
+	SignetNodeName      = "signet-node"
+	LighthouseName      = "lighthouse"
+	ExecutionJwtName    = "execution-jwt"
+	RollupDataName      = "rollup-data"
+	ExecutionConfigName = "exex-configmap"
+)

pkg/signet_node/helpers.go

@@ -0,0 +1,180 @@
+package signet_node
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"unicode"
+
+	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
+	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// CreatePersistentVolumeClaim creates a new PVC with the given name and size
+func CreatePersistentVolumeClaim(
+	ctx *pulumi.Context,
+	name string,
+	namespace pulumi.StringInput,
+	storageSize pulumi.StringInput,
+	storageClass string,
+	component pulumi.Resource,
+) (*corev1.PersistentVolumeClaim, error) {
+	if storageSize == nil {
+		storageSize = pulumi.String(DefaultStorageSize)
+	}
+
+	if storageClass == "" {
+		storageClass = DefaultStorageClass
+	}
+
+	pvc, err := corev1.NewPersistentVolumeClaim(ctx, name, &corev1.PersistentVolumeClaimArgs{
+		Metadata: &metav1.ObjectMetaArgs{
+			Name: pulumi.String(name),
+			Labels: pulumi.StringMap{
+				"app.kubernetes.io/name":    pulumi.String(name),
+				"app.kubernetes.io/part-of": pulumi.String(name),
+			},
+			Namespace: namespace,
+		},
+		Spec: &corev1.PersistentVolumeClaimSpecArgs{
+			AccessModes: pulumi.StringArray{pulumi.String("ReadWriteOnce")},
+			Resources: &corev1.VolumeResourceRequirementsArgs{
+				Requests: pulumi.StringMap{
+					"storage": storageSize,
+				},
+			},
+			StorageClassName: pulumi.String(storageClass),
+		},
+	}, pulumi.Parent(component))
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create PVC %s: %w", name, err)
+	}
+
+	return pvc, nil
+}
+
+// CreateResourceLabels creates a consistent set of Kubernetes labels for resources
+func CreateResourceLabels(name string) pulumi.StringMap {
+	return pulumi.StringMap{
+		"app":                       pulumi.String(name),
+		"app.kubernetes.io/name":    pulumi.String(name),
+		"app.kubernetes.io/part-of": pulumi.String(name),
+	}
+}
+
+// CreateEnvironmentVars creates environment variables from the SignetNodeEnv struct
+func CreateEnvironmentVars(env SignetNodeEnv) corev1.EnvVarArray {
+	result := corev1.EnvVarArray{}
+
+	// Process all string inputs from the struct's tags
+	envVarMap := GetEnvironmentVarsFromStruct(env)
+	for name, value := range envVarMap {
+		result = append(result, &corev1.EnvVarArgs{
+			Name:  pulumi.String(name),
+			Value: value.(pulumi.StringInput),
+		})
+	}
+
+	return result
+}
+
+// GetEnvironmentVarsFromStruct uses reflection to extract environment variables from struct tags
+func GetEnvironmentVarsFromStruct(env SignetNodeEnv) map[string]pulumi.Input {
+	result := make(map[string]pulumi.Input)
+
+	t := reflect.TypeOf(env)
+	v := reflect.ValueOf(env)
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+
+		// Get the field value
+		fieldValue := v.Field(i).Interface()
+
+		// Skip nil values
+		if fieldValue == nil {
+			continue
+		}
+
+		// Convert camelCase to SNAKE_CASE for env var name
+		envName := CamelToSnake(field.Name)
+
+		// Add to map
+		result[envName] = fieldValue.(pulumi.Input)
+	}
+
+	return result
+}
+
+// CamelToSnake converts a camelCase string to SNAKE_CASE
+func CamelToSnake(s string) string {
+	var result strings.Builder
+
+	// Handle consecutive uppercase characters (acronyms)
+	for i, r := range s {
+		if unicode.IsUpper(r) {
+			// Add underscore if not the first character and either:
+			// 1. Previous character is lowercase, or
+			// 2. Not the last character and next character is lowercase (end of acronym)
+			needsUnderscore := i > 0 && (unicode.IsLower(rune(s[i-1])) ||
+				(i < len(s)-1 && unicode.IsLower(rune(s[i+1])) && i > 1 && unicode.IsUpper(rune(s[i-1]))))
+
+			if needsUnderscore {
+				result.WriteRune('_')
+			}
+			result.WriteRune(unicode.ToUpper(r))
+		} else {
+			result.WriteRune(unicode.ToUpper(r))
+		}
+	}
+	return result.String()
+}
+
+// GetResourceName returns a consistent name for a resource
+func GetResourceName(baseName string, resourceType string) string {
+	switch resourceType {
+	case "service":
+		return fmt.Sprintf("%s%s", baseName, ServiceSuffix)
+	case "statefulset":
+		return fmt.Sprintf("%s%s", baseName, StatefulSetSuffix)
+	case "configmap":
+		return fmt.Sprintf("%s%s", baseName, ConfigMapSuffix)
+	case "pvc":
+		return fmt.Sprintf("%s%s", baseName, PvcSuffix)
+	case "secret":
+		return fmt.Sprintf("%s%s", baseName, SecretSuffix)
+	case "virtualservice":
+		return fmt.Sprintf("%s%s", baseName, VirtualServiceSuffix)
+	default:
+		return baseName
+	}
+}
+
+// ResourceRequirements returns consistent resource requirements for pods
+func NewResourceRequirements(cpuLimit, memoryLimit, cpuRequest, memoryRequest string) *corev1.ResourceRequirementsArgs {
+	if cpuLimit == "" {
+		cpuLimit = DefaultCPULimit
+	}
+	if memoryLimit == "" {
+		memoryLimit = DefaultMemoryLimit
+	}
+	if cpuRequest == "" {
+		cpuRequest = DefaultCPURequest
+	}
+	if memoryRequest == "" {
+		memoryRequest = DefaultMemoryRequest
+	}
+
+	return &corev1.ResourceRequirementsArgs{
+		Limits: pulumi.StringMap{
+			"cpu":    pulumi.String(cpuLimit),
+			"memory": pulumi.String(memoryLimit),
+		},
+		Requests: pulumi.StringMap{
+			"cpu":    pulumi.String(cpuRequest),
+			"memory": pulumi.String(memoryRequest),
+		},
+	}
+}

pkg/signet_node/helpers_test.go

@@ -0,0 +1,105 @@
+package signet_node
+
+import (
+	"testing"
+
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCamelToSnake(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"HostZenithAddress", "HOST_ZENITH_ADDRESS"},
+		{"RpcPort", "RPC_PORT"},
+		{"SignetChainId", "SIGNET_CHAIN_ID"},
+		{"BaseFeeRecipient", "BASE_FEE_RECIPIENT"},
+		{"HostStartTimestamp", "HOST_START_TIMESTAMP"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			result := CamelToSnake(test.input)
+			assert.Equal(t, test.expected, result)
+		})
+	}
+}
+
+func TestGetEnvironmentVarsFromStruct(t *testing.T) {
+	env := SignetNodeEnv{
+		HostZenithAddress: pulumi.String("0x123"),
+		RpcPort:           pulumi.String("8545"),
+		WsRpcPort:         pulumi.String("8546"),
+	}
+
+	result := GetEnvironmentVarsFromStruct(env)
+
+	assert.NotNil(t, result["HOST_ZENITH_ADDRESS"])
+	assert.NotNil(t, result["RPC_PORT"])
+	assert.NotNil(t, result["WS_RPC_PORT"])
+	assert.Equal(t, 3, len(result))
+}
+
+func TestCreateResourceLabels(t *testing.T) {
+	name := "test-resource"
+	labels := CreateResourceLabels(name)
+
+	assert.Equal(t, pulumi.String(name), labels["app"])
+	assert.Equal(t, pulumi.String(name), labels["app.kubernetes.io/name"])
+	assert.Equal(t, pulumi.String(name), labels["app.kubernetes.io/part-of"])
+}
+
+func TestGetResourceName(t *testing.T) {
+	tests := []struct {
+		baseName     string
+		resourceType string
+		expected     string
+	}{
+		{"signet-node", "service", "signet-node-service"},
+		{"lighthouse", "statefulset", "lighthouse-set"},
+		{"execution", "configmap", "execution-configmap"},
+		{"data", "pvc", "data-data"},
+		{"jwt", "secret", "jwt-secret"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.resourceType, func(t *testing.T) {
+			result := GetResourceName(test.baseName, test.resourceType)
+			assert.Equal(t, test.expected, result)
+		})
+	}
+}
+
+func TestResourceRequirements(t *testing.T) {
+	// Test with default values
+	resources := NewResourceRequirements("", "", "", "")
+
+	// Check that resources is not nil
+	assert.NotNil(t, resources)
+
+	// Verify the structure indirectly by checking key presence
+	stringMap := resources.Limits.(pulumi.StringMap)
+	assert.Contains(t, stringMap, "cpu")
+	assert.Contains(t, stringMap, "memory")
+	assert.Equal(t, pulumi.String(DefaultCPULimit), stringMap["cpu"])
+	assert.Equal(t, pulumi.String(DefaultMemoryLimit), stringMap["memory"])
+
+	requestsMap := resources.Requests.(pulumi.StringMap)
+	assert.Contains(t, requestsMap, "cpu")
+	assert.Contains(t, requestsMap, "memory")
+	assert.Equal(t, pulumi.String(DefaultCPURequest), requestsMap["cpu"])
+	assert.Equal(t, pulumi.String(DefaultMemoryRequest), requestsMap["memory"])
+
+	// Test with custom values
+	customResources := NewResourceRequirements("4", "32Gi", "2", "16Gi")
+
+	customLimitsMap := customResources.Limits.(pulumi.StringMap)
+	assert.Equal(t, pulumi.String("4"), customLimitsMap["cpu"])
+	assert.Equal(t, pulumi.String("32Gi"), customLimitsMap["memory"])
+
+	customRequestsMap := customResources.Requests.(pulumi.StringMap)
+	assert.Equal(t, pulumi.String("2"), customRequestsMap["cpu"])
+	assert.Equal(t, pulumi.String("16Gi"), customRequestsMap["memory"])
+}