Oas bot 32239425179/ufw

examples/ufw/go.mod

@@ -0,0 +1,15 @@
+module github.com/stackitcloud/stackit-sdk-go/examples/ufw
+
+go 1.25.9
+
+replace github.com/stackitcloud/stackit-sdk-go/services/ufw => ../../services/ufw
+
+require (
+	github.com/stackitcloud/stackit-sdk-go/core v0.26.0
+	github.com/stackitcloud/stackit-sdk-go/services/ufw v0.0.0-00010101000000-000000000000
+)
+
+require (
+	github.com/golang-jwt/jwt/v5 v5.3.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+)

examples/ufw/ufw.go

@@ -0,0 +1,240 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+	ufw "github.com/stackitcloud/stackit-sdk-go/services/ufw/v1api"
+	"github.com/stackitcloud/stackit-sdk-go/services/ufw/v1api/wait"
+)
+
+func main() {
+	region := "eu01"              // Region where the resources will be created
+	projectId := "PROJECT_ID"     // UUID of your STACKIT project
+	instanceId := "INSTANCE_ID"   // UUID of the instance to which the firewall rule will be attached
+	productType := "PRODUCT_TYPE" // Type of the instance to which the firewall rule will be attached (e.g. "redis", but you can get them from provider-options route)
+	ufwRuleType := "ACL"          // Type of the rule that you want to create (ACL, SecurityRule, PublicIp, but you can get them from provider-options route
+
+	ctx := context.Background()
+
+	token := ""
+	ufwClient, err := ufw.NewAPIClient(config.WithToken(token))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Creating API client: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Create a new firewall rule
+	description := "Created from SDK"
+	rulePayloadToCreate := ufw.CreateRulePayload{
+		InstanceId:  instanceId,
+		Product:     productType,
+		SourceIP:    "11.11.11.11/32",
+		Type:        ufwRuleType,
+		Description: &description,
+	}
+
+	createdRuleResponse, err := createFirewallRule(ctx, ufwClient, projectId, region, &rulePayloadToCreate)
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Error when creating firewall rule: %v\n", err)
+		return
+	}
+
+	fmt.Printf("Created firewall rule response: %+v\n", createdRuleResponse)
+
+	// Get the firewall rule
+	testGetRule, err := getFirewallRule(ctx, ufwClient, projectId, region, *createdRuleResponse.RefId)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Error when getting firewall rule: %v\n", err)
+		return
+	}
+
+	fmt.Printf("Firewall rule details: %+v\n", testGetRule)
+
+	if err := verifyPayloadMatch(testGetRule, rulePayloadToCreate); err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Verification failed after creation:\n%v\n", err)
+		return
+	}
+	fmt.Println("Created rule fields verified successfully.")
+
+	// Update the firewall rule
+	rulePayloadToUpdate := ufw.UpdateRulePayload{
+		SourceIP: "22.22.22.22/32",
+	}
+
+	updatedRuleResponse, err := updateFirewallRule(ctx, ufwClient, projectId, region, *createdRuleResponse.RefId, rulePayloadToUpdate)
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Error when updating firewall rule: %v\n", err)
+		return
+	}
+
+	fmt.Printf("Updated firewall rule details: %+v\n", updatedRuleResponse)
+
+	testGetRule, err = getFirewallRule(ctx, ufwClient, projectId, region, *updatedRuleResponse.RefId)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Error when getting updated firewall rule: %v\n", err)
+		return
+	}
+
+	if err := verifyPayloadMatch(testGetRule, rulePayloadToUpdate); err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Verification failed after update:\n%v\n", err)
+		return
+	}
+	fmt.Println("Updated rule fields verified successfully.")
+
+	// Delete the firewall rule
+	err = deleteFirewallRule(ctx, ufwClient, projectId, region, *updatedRuleResponse.RefId)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Error when deleting firewall rule: %v\n", err)
+		return
+	}
+
+	_, err = getFirewallRule(ctx, ufwClient, projectId, region, *updatedRuleResponse.RefId)
+	if !strings.Contains(err.Error(), "404") {
+		fmt.Fprintf(os.Stderr, "[UFW] Error while verifying deleted rule: %v\n", err)
+		return
+	}
+
+	// List all firewall rules
+	listUFWRules(ctx, ufwClient, projectId, region)
+
+	fmt.Println("All firewall rules successfully tested and cleaned up.")
+}
+
+func listUFWRules(ctx context.Context, ufwClient *ufw.APIClient, projectId, region string) {
+	listRulesResponse, err := ufwClient.DefaultAPI.ListRules(ctx, projectId, region).Execute()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[UFW] Error when listing firewall rules: %v\n", err)
+		return
+	}
+
+	fmt.Println("List of firewall rules:")
+	for i := range listRulesResponse.Rules {
+		fmt.Printf("%+v\n", listRulesResponse.Rules[i])
+	}
+}
+
+func getFirewallRule(ctx context.Context, ufwClient *ufw.APIClient, projectId, region, ruleId string) (*ufw.RuleResponse, error) {
+	return ufwClient.DefaultAPI.GetRule(ctx, projectId, region, ruleId).Execute()
+}
+
+func createFirewallRule(ctx context.Context, ufwClient *ufw.APIClient, projectId, region string, payload *ufw.CreateRulePayload) (*ufw.SecurityRuleSuccessfullyCreatedResponse, error) {
+	createdFirewallRule, err := ufwClient.DefaultAPI.CreateRule(ctx, projectId, region).CreateRulePayload(*payload).Execute()
+	if err != nil {
+		return nil, err
+	}
+
+	createdFirewallRuleId := createdFirewallRule.RefId
+	fmt.Printf("Created firewall rule with ID: %s\n", *createdFirewallRuleId)
+
+	_, err = wait.CreateRuleWaitHandler(ctx, ufwClient.DefaultAPI, projectId, region, *createdFirewallRuleId).WaitWithContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return createdFirewallRule, nil
+}
+
+func updateFirewallRule(ctx context.Context, ufwClient *ufw.APIClient, projectId, region, ruleId string, payload ufw.UpdateRulePayload) (*ufw.SecurityRuleSuccessfullyCreatedResponse, error) {
+	updatedFirewallRule, err := ufwClient.DefaultAPI.UpdateRule(ctx, projectId, region, ruleId).UpdateRulePayload(payload).Execute()
+	if err != nil {
+		return nil, err
+	}
+
+	fmt.Printf("Updated firewall rule with ID: %s\n", *updatedFirewallRule.RefId)
+
+	_, err = wait.UpdateRuleWaitHandler(ctx, ufwClient.DefaultAPI, projectId, region, *updatedFirewallRule.RefId).WaitWithContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return updatedFirewallRule, nil
+}
+
+func deleteFirewallRule(ctx context.Context, ufwClient *ufw.APIClient, projectId, region, ruleId string) error {
+	deleteRuleResponse, err := ufwClient.DefaultAPI.DeleteRule(ctx, projectId, region, ruleId).Execute()
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Deleted firewall rule with ID: %s\n", ruleId)
+	fmt.Printf("Deleted firewall rule response: %+v\n", deleteRuleResponse)
+
+	_, err = wait.DeleteRuleWaitHandler(ctx, ufwClient.DefaultAPI, projectId, region, ruleId).WaitWithContext(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func verifyPayloadMatch(actual, expected any) error {
+	var mismatches []string
+
+	actualVal := reflect.ValueOf(actual)
+	if actualVal.Kind() == reflect.Pointer {
+		actualVal = actualVal.Elem()
+	}
+
+	expectedVal := reflect.ValueOf(expected)
+	if expectedVal.Kind() == reflect.Pointer {
+		expectedVal = expectedVal.Elem()
+	}
+
+	expectedType := expectedVal.Type()
+
+	for i := 0; i < expectedVal.NumField(); i++ {
+		fieldName := expectedType.Field(i).Name
+
+		if fieldName == "AdditionalProperties" {
+			continue // AdditionalProperties field is not part of the API response struct
+		}
+
+		if fieldName == "Description" {
+			continue // Description field is overridden by the API, will be fixed in the future
+		}
+
+		expectedField := expectedVal.Field(i)
+
+		// Look for a matching field in the API response struct
+		actualField := actualVal.FieldByName(fieldName)
+		if !actualField.IsValid() {
+			continue // Field exists in payload but not in response struct, safe to skip
+		}
+
+		// Dereference pointers cleanly to get string representations
+		expStr := formatReflectValue(expectedField)
+		actStr := formatReflectValue(actualField)
+
+		// Skip uninitialized/nil fields in the expected payload
+		// (e.g. fields omitted from an UpdateRulePayload)
+		if expStr == "" || expStr == "<nil>" {
+			continue
+		}
+
+		if expStr != actStr {
+			mismatches = append(mismatches, fmt.Sprintf("%s: expected %q, got %q", fieldName, expStr, actStr))
+		}
+	}
+
+	if len(mismatches) > 0 {
+		return fmt.Errorf("field mismatches found:\n- %s", strings.Join(mismatches, "\n- "))
+	}
+	return nil
+}
+
+func formatReflectValue(v reflect.Value) string {
+	if v.Kind() == reflect.Pointer {
+		if v.IsNil() {
+			return "<nil>"
+		}
+		v = v.Elem()
+	}
+	return fmt.Sprintf("%v", v.Interface())
+}

go.work

@@ -38,6 +38,7 @@ use (
 	./examples/sqlserverflex
 	./examples/telemetrylink
 	./examples/telemetryrouter
+	./examples/ufw
 	./examples/valkey
 	./examples/vpn
 	./examples/waiter

services/ufw/go.mod

@@ -2,7 +2,10 @@ module github.com/stackitcloud/stackit-sdk-go/services/ufw
 
 go 1.25
 
-require github.com/stackitcloud/stackit-sdk-go/core v0.26.0
+require (
+	github.com/google/go-cmp v0.7.0
+	github.com/stackitcloud/stackit-sdk-go/core v0.26.0
+)
 
 require (
 	github.com/golang-jwt/jwt/v5 v5.3.1 // indirect

services/ufw/v1api/wait/wait.go

@@ -0,0 +1,85 @@
+package wait
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"time"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/wait"
+	ufw "github.com/stackitcloud/stackit-sdk-go/services/ufw/v1api"
+)
+
+type RuleStatus string
+
+const (
+	RuleStatusActive   RuleStatus = "Active"
+	RuleStatusCreating RuleStatus = "Creating"
+	RuleStatusUpdating RuleStatus = "Updating"
+	RuleStatusPending  RuleStatus = "Pending"
+	RuleStatusDeleting RuleStatus = "Deleting"
+	RuleStatusError    RuleStatus = "Error"
+)
+
+func CreateRuleWaitHandler(ctx context.Context, a ufw.DefaultAPI, projectId, region, ruleId string) *wait.AsyncActionHandler[ufw.RuleResponse] {
+	waitConfig := wait.WaiterHelper[ufw.RuleResponse, RuleStatus]{
+		FetchInstance: a.GetRule(ctx, projectId, region, ruleId).Execute,
+		GetState: func(ruleResp *ufw.RuleResponse) (RuleStatus, error) {
+			if ruleResp == nil {
+				return "", errors.New("empty response")
+			}
+			if ruleResp.Status == nil {
+				return "", errors.New("status is missing")
+			}
+			return RuleStatus(*ruleResp.Status), nil
+		},
+		ActiveState: []RuleStatus{RuleStatusActive},
+		ErrorState:  []RuleStatus{RuleStatusError},
+	}
+
+	handler := wait.New(waitConfig.Wait())
+	handler.SetTimeout(5 * time.Minute)
+	return handler
+}
+
+func UpdateRuleWaitHandler(ctx context.Context, a ufw.DefaultAPI, projectId, region, ruleId string) *wait.AsyncActionHandler[ufw.RuleResponse] {
+	waitConfig := wait.WaiterHelper[ufw.RuleResponse, RuleStatus]{
+		FetchInstance: a.GetRule(ctx, projectId, region, ruleId).Execute,
+		GetState: func(ruleResp *ufw.RuleResponse) (RuleStatus, error) {
+			if ruleResp == nil {
+				return "", errors.New("empty response")
+			}
+			if ruleResp.Status == nil {
+				return "", errors.New("status is missing")
+			}
+			return RuleStatus(*ruleResp.Status), nil
+		},
+		ActiveState: []RuleStatus{RuleStatusActive},
+		ErrorState:  []RuleStatus{RuleStatusError},
+	}
+
+	handler := wait.New(waitConfig.Wait())
+	handler.SetTimeout(5 * time.Minute)
+	return handler
+}
+
+func DeleteRuleWaitHandler(ctx context.Context, a ufw.DefaultAPI, projectId, region, ruleId string) *wait.AsyncActionHandler[ufw.RuleResponse] {
+	waitConfig := wait.WaiterHelper[ufw.RuleResponse, RuleStatus]{
+		FetchInstance: a.GetRule(ctx, projectId, region, ruleId).Execute,
+		GetState: func(ruleResp *ufw.RuleResponse) (RuleStatus, error) {
+			if ruleResp == nil {
+				return "", errors.New("empty response")
+			}
+			if ruleResp.Status == nil {
+				return "", errors.New("status is missing")
+			}
+			return RuleStatus(*ruleResp.Status), nil
+		},
+		ErrorState:                 []RuleStatus{RuleStatusError},
+		DeleteHttpErrorStatusCodes: []int{http.StatusNotFound},
+	}
+
+	handler := wait.New(waitConfig.Wait())
+	handler.SetTimeout(5 * time.Minute)
+	return handler
+}