From 0f89db1893fc754f582b40118d601815cfd15210 Mon Sep 17 00:00:00 2001 From: Julian Sommer <115516918+juliansommer@users.noreply.github.com> Date: Thu, 23 Apr 2026 10:46:16 +1000 Subject: [PATCH] chore: extract validation logic from gateway function --- .../ec2/account/DescribeAccountAttributes.go | 2 -- spinifex/gateway/ec2/eip/AssociateAddress.go | 18 ++++++++++---- .../gateway/ec2/eip/DisassociateAddress.go | 18 ++++++++++---- spinifex/gateway/ec2/eip/ReleaseAddress.go | 18 ++++++++++---- .../gateway/ec2/igw/AttachInternetGateway.go | 24 ++++++++++++------- .../gateway/ec2/igw/DeleteInternetGateway.go | 18 ++++++++++---- .../gateway/ec2/igw/DetachInternetGateway.go | 24 ++++++++++++------- .../gateway/ec2/instance/GetConsoleOutput.go | 16 +++++++++++-- .../gateway/ec2/instance/RebootInstances.go | 15 ++++++++++-- .../ec2/instance/RebootInstances_test.go | 2 +- .../gateway/ec2/instance/StartInstances.go | 17 ++++++++++--- .../ec2/instance/StartInstances_test.go | 3 ++- .../gateway/ec2/instance/StopInstances.go | 16 +++++++++++-- .../ec2/instance/StopInstances_test.go | 3 ++- .../ec2/instance/TerminateInstances.go | 16 +++++++++++-- .../ec2/instance/TerminateInstances_test.go | 3 ++- .../placementgroup/CreatePlacementGroup.go | 24 ++++++++++++------- .../placementgroup/DeletePlacementGroup.go | 18 ++++++++++---- .../gateway/ec2/vpc/CreateNetworkInterface.go | 18 ++++++++++---- spinifex/gateway/ec2/vpc/CreateSubnet.go | 24 ++++++++++++------- spinifex/gateway/ec2/vpc/CreateVpc.go | 18 ++++++++++---- .../gateway/ec2/vpc/DeleteNetworkInterface.go | 18 ++++++++++---- spinifex/gateway/ec2/vpc/DeleteSubnet.go | 18 ++++++++++---- spinifex/gateway/ec2/vpc/DeleteVpc.go | 18 ++++++++++---- .../gateway/ec2/vpc/DescribeVpcAttribute.go | 24 ++++++++++++------- .../vpc/ModifyNetworkInterfaceAttribute.go | 18 ++++++++++---- .../gateway/ec2/vpc/ModifySubnetAttribute.go | 18 ++++++++++---- .../gateway/ec2/vpc/ModifyVpcAttribute.go | 18 ++++++++++---- spinifex/gateway/elbv2/CreateListener.go | 24 ++++++++++++------- spinifex/gateway/elbv2/CreateLoadBalancer.go | 18 ++++++++++---- spinifex/gateway/elbv2/CreateTargetGroup.go | 18 ++++++++++---- spinifex/gateway/elbv2/DeleteListener.go | 18 ++++++++++---- spinifex/gateway/elbv2/DeleteLoadBalancer.go | 18 ++++++++++---- spinifex/gateway/elbv2/DeleteTargetGroup.go | 18 ++++++++++---- spinifex/gateway/elbv2/DeregisterTargets.go | 24 ++++++++++++------- .../elbv2/DescribeLoadBalancerAttributes.go | 18 ++++++++++---- .../elbv2/DescribeTargetGroupAttributes.go | 18 ++++++++++---- .../gateway/elbv2/DescribeTargetHealth.go | 18 ++++++++++---- spinifex/gateway/elbv2/GetLBConfig.go | 18 ++++++++++---- spinifex/gateway/elbv2/LBAgentHeartbeat.go | 18 ++++++++++---- .../elbv2/ModifyLoadBalancerAttributes.go | 24 ++++++++++++------- .../elbv2/ModifyTargetGroupAttributes.go | 24 ++++++++++++------- spinifex/gateway/elbv2/RegisterTargets.go | 24 ++++++++++++------- 43 files changed, 535 insertions(+), 212 deletions(-) diff --git a/spinifex/gateway/ec2/account/DescribeAccountAttributes.go b/spinifex/gateway/ec2/account/DescribeAccountAttributes.go index ac7358ca4..9f80c985a 100644 --- a/spinifex/gateway/ec2/account/DescribeAccountAttributes.go +++ b/spinifex/gateway/ec2/account/DescribeAccountAttributes.go @@ -9,8 +9,6 @@ import ( // DescribeAccountAttributes returns static account attributes for the Spinifex platform func DescribeAccountAttributes(input *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) { - slog.Debug("DescribeAccountAttributes called") - // Build set of requested attribute names for filtering requestedAttrs := make(map[string]bool) for _, name := range input.AttributeNames { diff --git a/spinifex/gateway/ec2/eip/AssociateAddress.go b/spinifex/gateway/ec2/eip/AssociateAddress.go index 1b3ba4940..6e35b82be 100644 --- a/spinifex/gateway/ec2/eip/AssociateAddress.go +++ b/spinifex/gateway/ec2/eip/AssociateAddress.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateAssociateAddressInput validates the input parameters +func ValidateAssociateAddressInput(input *ec2.AssociateAddressInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.AllocationId == nil || *input.AllocationId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // AssociateAddress handles the EC2 AssociateAddress API call. func AssociateAddress(input *ec2.AssociateAddressInput, natsConn *nats.Conn, accountID string) (ec2.AssociateAddressOutput, error) { var output ec2.AssociateAddressOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.AllocationId == nil || *input.AllocationId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateAssociateAddressInput(input); err != nil { + return output, err } svc := handlers_ec2_eip.NewNATSEIPService(natsConn) diff --git a/spinifex/gateway/ec2/eip/DisassociateAddress.go b/spinifex/gateway/ec2/eip/DisassociateAddress.go index e9fcbc333..d444fe0e4 100644 --- a/spinifex/gateway/ec2/eip/DisassociateAddress.go +++ b/spinifex/gateway/ec2/eip/DisassociateAddress.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDisassociateAddressInput validates the input parameters +func ValidateDisassociateAddressInput(input *ec2.DisassociateAddressInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.AssociationId == nil || *input.AssociationId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DisassociateAddress handles the EC2 DisassociateAddress API call. func DisassociateAddress(input *ec2.DisassociateAddressInput, natsConn *nats.Conn, accountID string) (ec2.DisassociateAddressOutput, error) { var output ec2.DisassociateAddressOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.AssociationId == nil || *input.AssociationId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDisassociateAddressInput(input); err != nil { + return output, err } svc := handlers_ec2_eip.NewNATSEIPService(natsConn) diff --git a/spinifex/gateway/ec2/eip/ReleaseAddress.go b/spinifex/gateway/ec2/eip/ReleaseAddress.go index e0f2362ba..cdd963731 100644 --- a/spinifex/gateway/ec2/eip/ReleaseAddress.go +++ b/spinifex/gateway/ec2/eip/ReleaseAddress.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateReleaseAddressInput validates the input parameters +func ValidateReleaseAddressInput(input *ec2.ReleaseAddressInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.AllocationId == nil || *input.AllocationId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // ReleaseAddress handles the EC2 ReleaseAddress API call. func ReleaseAddress(input *ec2.ReleaseAddressInput, natsConn *nats.Conn, accountID string) (ec2.ReleaseAddressOutput, error) { var output ec2.ReleaseAddressOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.AllocationId == nil || *input.AllocationId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateReleaseAddressInput(input); err != nil { + return output, err } svc := handlers_ec2_eip.NewNATSEIPService(natsConn) diff --git a/spinifex/gateway/ec2/igw/AttachInternetGateway.go b/spinifex/gateway/ec2/igw/AttachInternetGateway.go index 1bf21179b..e6f42c655 100644 --- a/spinifex/gateway/ec2/igw/AttachInternetGateway.go +++ b/spinifex/gateway/ec2/igw/AttachInternetGateway.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateAttachInternetGatewayInput validates the input parameters +func ValidateAttachInternetGatewayInput(input *ec2.AttachInternetGatewayInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.InternetGatewayId == nil || *input.InternetGatewayId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if input.VpcId == nil || *input.VpcId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // AttachInternetGateway handles the EC2 AttachInternetGateway API call func AttachInternetGateway(input *ec2.AttachInternetGatewayInput, natsConn *nats.Conn, accountID string) (ec2.AttachInternetGatewayOutput, error) { var output ec2.AttachInternetGatewayOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.InternetGatewayId == nil || *input.InternetGatewayId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if input.VpcId == nil || *input.VpcId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateAttachInternetGatewayInput(input); err != nil { + return output, err } svc := handlers_ec2_igw.NewNATSIGWService(natsConn) diff --git a/spinifex/gateway/ec2/igw/DeleteInternetGateway.go b/spinifex/gateway/ec2/igw/DeleteInternetGateway.go index 721defa43..1c8e04092 100644 --- a/spinifex/gateway/ec2/igw/DeleteInternetGateway.go +++ b/spinifex/gateway/ec2/igw/DeleteInternetGateway.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteInternetGatewayInput validates the input parameters +func ValidateDeleteInternetGatewayInput(input *ec2.DeleteInternetGatewayInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.InternetGatewayId == nil || *input.InternetGatewayId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteInternetGateway handles the EC2 DeleteInternetGateway API call func DeleteInternetGateway(input *ec2.DeleteInternetGatewayInput, natsConn *nats.Conn, accountID string) (ec2.DeleteInternetGatewayOutput, error) { var output ec2.DeleteInternetGatewayOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.InternetGatewayId == nil || *input.InternetGatewayId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteInternetGatewayInput(input); err != nil { + return output, err } svc := handlers_ec2_igw.NewNATSIGWService(natsConn) diff --git a/spinifex/gateway/ec2/igw/DetachInternetGateway.go b/spinifex/gateway/ec2/igw/DetachInternetGateway.go index 5e97dab82..7603819cd 100644 --- a/spinifex/gateway/ec2/igw/DetachInternetGateway.go +++ b/spinifex/gateway/ec2/igw/DetachInternetGateway.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDetachInternetGatewayInput validates the input parameters +func ValidateDetachInternetGatewayInput(input *ec2.DetachInternetGatewayInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.InternetGatewayId == nil || *input.InternetGatewayId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if input.VpcId == nil || *input.VpcId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DetachInternetGateway handles the EC2 DetachInternetGateway API call func DetachInternetGateway(input *ec2.DetachInternetGatewayInput, natsConn *nats.Conn, accountID string) (ec2.DetachInternetGatewayOutput, error) { var output ec2.DetachInternetGatewayOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.InternetGatewayId == nil || *input.InternetGatewayId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if input.VpcId == nil || *input.VpcId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDetachInternetGatewayInput(input); err != nil { + return output, err } svc := handlers_ec2_igw.NewNATSIGWService(natsConn) diff --git a/spinifex/gateway/ec2/instance/GetConsoleOutput.go b/spinifex/gateway/ec2/instance/GetConsoleOutput.go index ca6b1c9eb..857ae1e51 100644 --- a/spinifex/gateway/ec2/instance/GetConsoleOutput.go +++ b/spinifex/gateway/ec2/instance/GetConsoleOutput.go @@ -8,15 +8,27 @@ import ( "time" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/mulgadc/spinifex/spinifex/utils" "github.com/nats-io/nats.go" ) +// ValidateGetConsoleOutputInput validates the input parameters +func ValidateGetConsoleOutputInput(input *ec2.GetConsoleOutputInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.InstanceId == nil || *input.InstanceId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // GetConsoleOutput retrieves console output for a specific instance via NATS. // Routes directly to the node running the instance via ec2.{instanceID}.GetConsoleOutput. func GetConsoleOutput(input *ec2.GetConsoleOutputInput, natsConn *nats.Conn, accountID string) (*ec2.GetConsoleOutputOutput, error) { - if input.InstanceId == nil || *input.InstanceId == "" { - return nil, fmt.Errorf("InstanceId is required") + if err := ValidateGetConsoleOutputInput(input); err != nil { + return nil, err } jsonData, err := json.Marshal(input) diff --git a/spinifex/gateway/ec2/instance/RebootInstances.go b/spinifex/gateway/ec2/instance/RebootInstances.go index cae94eeb1..ed7ffaf73 100644 --- a/spinifex/gateway/ec2/instance/RebootInstances.go +++ b/spinifex/gateway/ec2/instance/RebootInstances.go @@ -14,12 +14,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateRebootInstancesInput validates the input parameters +func ValidateRebootInstancesInput(input *ec2.RebootInstancesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if len(input.InstanceIds) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // RebootInstances sends reboot commands to specified instances via NATS. // Unlike stop+start, reboot keeps the instance running and sends a QMP system_reset. // Returns an empty response on success (AWS returns no state-change data). func RebootInstances(input *ec2.RebootInstancesInput, natsConn *nats.Conn, accountID string) (*ec2.RebootInstancesOutput, error) { - if len(input.InstanceIds) == 0 { - return nil, fmt.Errorf("no instance IDs provided") + if err := ValidateRebootInstancesInput(input); err != nil { + return nil, err } slog.Info("RebootInstances: Processing request", "instance_count", len(input.InstanceIds)) diff --git a/spinifex/gateway/ec2/instance/RebootInstances_test.go b/spinifex/gateway/ec2/instance/RebootInstances_test.go index 0079e8ee9..85631077a 100644 --- a/spinifex/gateway/ec2/instance/RebootInstances_test.go +++ b/spinifex/gateway/ec2/instance/RebootInstances_test.go @@ -70,7 +70,7 @@ func TestRebootInstances_EmptyInstanceIds(t *testing.T) { _, err := RebootInstances(input, nc, "123456789012") require.Error(t, err) - assert.Contains(t, err.Error(), "no instance IDs provided") + assert.Equal(t, awserrors.ErrorMissingParameter, err.Error()) } func TestRebootInstances_NATSRequestFails(t *testing.T) { diff --git a/spinifex/gateway/ec2/instance/StartInstances.go b/spinifex/gateway/ec2/instance/StartInstances.go index 805267ba4..f4c8da133 100644 --- a/spinifex/gateway/ec2/instance/StartInstances.go +++ b/spinifex/gateway/ec2/instance/StartInstances.go @@ -3,11 +3,11 @@ package gateway_ec2_instance import ( "encoding/json" "errors" - "fmt" "log/slog" "time" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/mulgadc/spinifex/spinifex/utils" "github.com/nats-io/nats.go" ) @@ -17,11 +17,22 @@ type startStoppedInstanceRequest struct { InstanceID string `json:"instance_id"` } +// ValidateStartInstancesInput validates the input parameters +func ValidateStartInstancesInput(input *ec2.StartInstancesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if len(input.InstanceIds) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // StartInstances sends start requests to the ec2.start queue group topic. // Any available daemon can pick up the request and launch the stopped instance. func StartInstances(input *ec2.StartInstancesInput, natsConn *nats.Conn, accountID string) (*ec2.StartInstancesOutput, error) { - if len(input.InstanceIds) == 0 { - return nil, fmt.Errorf("no instance IDs provided") + if err := ValidateStartInstancesInput(input); err != nil { + return nil, err } slog.Info("StartInstances: Processing request", "instance_count", len(input.InstanceIds)) diff --git a/spinifex/gateway/ec2/instance/StartInstances_test.go b/spinifex/gateway/ec2/instance/StartInstances_test.go index babdfd4a5..aeea76531 100644 --- a/spinifex/gateway/ec2/instance/StartInstances_test.go +++ b/spinifex/gateway/ec2/instance/StartInstances_test.go @@ -6,6 +6,7 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/nats-io/nats.go" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -82,7 +83,7 @@ func TestStartInstances_EmptyInstanceIds(t *testing.T) { _, err := StartInstances(input, nc, "123456789012") require.Error(t, err) - assert.Contains(t, err.Error(), "no instance IDs provided") + assert.Equal(t, awserrors.ErrorMissingParameter, err.Error()) } func TestStartInstances_NilInstanceIdSkipped(t *testing.T) { diff --git a/spinifex/gateway/ec2/instance/StopInstances.go b/spinifex/gateway/ec2/instance/StopInstances.go index 9a101380e..59427ba53 100644 --- a/spinifex/gateway/ec2/instance/StopInstances.go +++ b/spinifex/gateway/ec2/instance/StopInstances.go @@ -8,16 +8,28 @@ import ( "time" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/mulgadc/spinifex/spinifex/types" "github.com/mulgadc/spinifex/spinifex/utils" "github.com/nats-io/nats.go" ) +// ValidateStopInstancesInput validates the input parameters +func ValidateStopInstancesInput(input *ec2.StopInstancesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if len(input.InstanceIds) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // StopInstances sends stop commands to specified instances via NATS // Uses system_powerdown with stop_instance attribute to prevent auto-restart on daemon boot func StopInstances(input *ec2.StopInstancesInput, natsConn *nats.Conn, accountID string) (*ec2.StopInstancesOutput, error) { - if len(input.InstanceIds) == 0 { - return nil, fmt.Errorf("no instance IDs provided") + if err := ValidateStopInstancesInput(input); err != nil { + return nil, err } slog.Info("StopInstances: Processing request", "instance_count", len(input.InstanceIds)) diff --git a/spinifex/gateway/ec2/instance/StopInstances_test.go b/spinifex/gateway/ec2/instance/StopInstances_test.go index 104a857f1..d16111a57 100644 --- a/spinifex/gateway/ec2/instance/StopInstances_test.go +++ b/spinifex/gateway/ec2/instance/StopInstances_test.go @@ -6,6 +6,7 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/mulgadc/spinifex/spinifex/types" "github.com/nats-io/nats.go" "github.com/stretchr/testify/assert" @@ -83,7 +84,7 @@ func TestStopInstances_EmptyInstanceIds(t *testing.T) { _, err := StopInstances(input, nc, "123456789012") require.Error(t, err) - assert.Contains(t, err.Error(), "no instance IDs provided") + assert.Equal(t, awserrors.ErrorMissingParameter, err.Error()) } func TestStopInstances_NilInstanceIdSkipped(t *testing.T) { diff --git a/spinifex/gateway/ec2/instance/TerminateInstances.go b/spinifex/gateway/ec2/instance/TerminateInstances.go index 024081363..588fc5acc 100644 --- a/spinifex/gateway/ec2/instance/TerminateInstances.go +++ b/spinifex/gateway/ec2/instance/TerminateInstances.go @@ -8,6 +8,7 @@ import ( "time" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/mulgadc/spinifex/spinifex/types" "github.com/mulgadc/spinifex/spinifex/utils" "github.com/nats-io/nats.go" @@ -18,11 +19,22 @@ type terminateStoppedInstanceRequest struct { InstanceID string `json:"instance_id"` } +// ValidateTerminateInstancesInput validates the input parameters +func ValidateTerminateInstancesInput(input *ec2.TerminateInstancesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if len(input.InstanceIds) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // TerminateInstances sends terminate commands to specified instances via NATS // Uses system_powerdown with stop_instance attribute to prevent restart func TerminateInstances(input *ec2.TerminateInstancesInput, natsConn *nats.Conn, accountID string) (*ec2.TerminateInstancesOutput, error) { - if len(input.InstanceIds) == 0 { - return nil, fmt.Errorf("no instance IDs provided") + if err := ValidateTerminateInstancesInput(input); err != nil { + return nil, err } slog.Info("TerminateInstances: Processing request", "instance_count", len(input.InstanceIds)) diff --git a/spinifex/gateway/ec2/instance/TerminateInstances_test.go b/spinifex/gateway/ec2/instance/TerminateInstances_test.go index 71b04b703..876d34391 100644 --- a/spinifex/gateway/ec2/instance/TerminateInstances_test.go +++ b/spinifex/gateway/ec2/instance/TerminateInstances_test.go @@ -6,6 +6,7 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/mulgadc/spinifex/spinifex/awserrors" "github.com/mulgadc/spinifex/spinifex/types" "github.com/nats-io/nats.go" "github.com/stretchr/testify/assert" @@ -83,7 +84,7 @@ func TestTerminateInstances_EmptyInstanceIds(t *testing.T) { _, err := TerminateInstances(input, nc, "123456789012") require.Error(t, err) - assert.Contains(t, err.Error(), "no instance IDs provided") + assert.Equal(t, awserrors.ErrorMissingParameter, err.Error()) } func TestTerminateInstances_NilInstanceIdSkipped(t *testing.T) { diff --git a/spinifex/gateway/ec2/placementgroup/CreatePlacementGroup.go b/spinifex/gateway/ec2/placementgroup/CreatePlacementGroup.go index b3e8be0a4..36bd3887e 100644 --- a/spinifex/gateway/ec2/placementgroup/CreatePlacementGroup.go +++ b/spinifex/gateway/ec2/placementgroup/CreatePlacementGroup.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreatePlacementGroupInput validates the input parameters +func ValidateCreatePlacementGroupInput(input *ec2.CreatePlacementGroupInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.GroupName == nil || *input.GroupName == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if input.Strategy == nil || *input.Strategy == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreatePlacementGroup handles the EC2 CreatePlacementGroup API call. func CreatePlacementGroup(input *ec2.CreatePlacementGroupInput, natsConn *nats.Conn, accountID string) (ec2.CreatePlacementGroupOutput, error) { var output ec2.CreatePlacementGroupOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.GroupName == nil || *input.GroupName == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if input.Strategy == nil || *input.Strategy == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreatePlacementGroupInput(input); err != nil { + return output, err } svc := handlers_ec2_placementgroup.NewNATSPlacementGroupService(natsConn) diff --git a/spinifex/gateway/ec2/placementgroup/DeletePlacementGroup.go b/spinifex/gateway/ec2/placementgroup/DeletePlacementGroup.go index 33ca644be..36bb4c0f5 100644 --- a/spinifex/gateway/ec2/placementgroup/DeletePlacementGroup.go +++ b/spinifex/gateway/ec2/placementgroup/DeletePlacementGroup.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeletePlacementGroupInput validates the input parameters +func ValidateDeletePlacementGroupInput(input *ec2.DeletePlacementGroupInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.GroupName == nil || *input.GroupName == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeletePlacementGroup handles the EC2 DeletePlacementGroup API call. func DeletePlacementGroup(input *ec2.DeletePlacementGroupInput, natsConn *nats.Conn, accountID string) (ec2.DeletePlacementGroupOutput, error) { var output ec2.DeletePlacementGroupOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.GroupName == nil || *input.GroupName == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeletePlacementGroupInput(input); err != nil { + return output, err } svc := handlers_ec2_placementgroup.NewNATSPlacementGroupService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/CreateNetworkInterface.go b/spinifex/gateway/ec2/vpc/CreateNetworkInterface.go index 008c402e2..f7694f8ab 100644 --- a/spinifex/gateway/ec2/vpc/CreateNetworkInterface.go +++ b/spinifex/gateway/ec2/vpc/CreateNetworkInterface.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreateNetworkInterfaceInput validates the input parameters +func ValidateCreateNetworkInterfaceInput(input *ec2.CreateNetworkInterfaceInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.SubnetId == nil || *input.SubnetId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreateNetworkInterface handles the EC2 CreateNetworkInterface API call func CreateNetworkInterface(input *ec2.CreateNetworkInterfaceInput, natsConn *nats.Conn, accountID string) (ec2.CreateNetworkInterfaceOutput, error) { var output ec2.CreateNetworkInterfaceOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.SubnetId == nil || *input.SubnetId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreateNetworkInterfaceInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/CreateSubnet.go b/spinifex/gateway/ec2/vpc/CreateSubnet.go index 76eeb597b..e3281afad 100644 --- a/spinifex/gateway/ec2/vpc/CreateSubnet.go +++ b/spinifex/gateway/ec2/vpc/CreateSubnet.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreateSubnetInput validates the input parameters +func ValidateCreateSubnetInput(input *ec2.CreateSubnetInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.VpcId == nil || *input.VpcId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if input.CidrBlock == nil || *input.CidrBlock == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreateSubnet handles the EC2 CreateSubnet API call func CreateSubnet(input *ec2.CreateSubnetInput, natsConn *nats.Conn, accountID string) (ec2.CreateSubnetOutput, error) { var output ec2.CreateSubnetOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.VpcId == nil || *input.VpcId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if input.CidrBlock == nil || *input.CidrBlock == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreateSubnetInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/CreateVpc.go b/spinifex/gateway/ec2/vpc/CreateVpc.go index 98e5d37e7..162bfb55f 100644 --- a/spinifex/gateway/ec2/vpc/CreateVpc.go +++ b/spinifex/gateway/ec2/vpc/CreateVpc.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreateVpcInput validates the input parameters +func ValidateCreateVpcInput(input *ec2.CreateVpcInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.CidrBlock == nil || *input.CidrBlock == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreateVpc handles the EC2 CreateVpc API call func CreateVpc(input *ec2.CreateVpcInput, natsConn *nats.Conn, accountID string) (ec2.CreateVpcOutput, error) { var output ec2.CreateVpcOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.CidrBlock == nil || *input.CidrBlock == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreateVpcInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/DeleteNetworkInterface.go b/spinifex/gateway/ec2/vpc/DeleteNetworkInterface.go index 1ae33a436..4c71867da 100644 --- a/spinifex/gateway/ec2/vpc/DeleteNetworkInterface.go +++ b/spinifex/gateway/ec2/vpc/DeleteNetworkInterface.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteNetworkInterfaceInput validates the input parameters +func ValidateDeleteNetworkInterfaceInput(input *ec2.DeleteNetworkInterfaceInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.NetworkInterfaceId == nil || *input.NetworkInterfaceId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteNetworkInterface handles the EC2 DeleteNetworkInterface API call func DeleteNetworkInterface(input *ec2.DeleteNetworkInterfaceInput, natsConn *nats.Conn, accountID string) (ec2.DeleteNetworkInterfaceOutput, error) { var output ec2.DeleteNetworkInterfaceOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.NetworkInterfaceId == nil || *input.NetworkInterfaceId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteNetworkInterfaceInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/DeleteSubnet.go b/spinifex/gateway/ec2/vpc/DeleteSubnet.go index 0934c65f1..9ad34a6eb 100644 --- a/spinifex/gateway/ec2/vpc/DeleteSubnet.go +++ b/spinifex/gateway/ec2/vpc/DeleteSubnet.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteSubnetInput validates the input parameters +func ValidateDeleteSubnetInput(input *ec2.DeleteSubnetInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.SubnetId == nil || *input.SubnetId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteSubnet handles the EC2 DeleteSubnet API call func DeleteSubnet(input *ec2.DeleteSubnetInput, natsConn *nats.Conn, accountID string) (ec2.DeleteSubnetOutput, error) { var output ec2.DeleteSubnetOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.SubnetId == nil || *input.SubnetId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteSubnetInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/DeleteVpc.go b/spinifex/gateway/ec2/vpc/DeleteVpc.go index eaf2c444b..8c2a832e2 100644 --- a/spinifex/gateway/ec2/vpc/DeleteVpc.go +++ b/spinifex/gateway/ec2/vpc/DeleteVpc.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteVpcInput validates the input parameters +func ValidateDeleteVpcInput(input *ec2.DeleteVpcInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.VpcId == nil || *input.VpcId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteVpc handles the EC2 DeleteVpc API call func DeleteVpc(input *ec2.DeleteVpcInput, natsConn *nats.Conn, accountID string) (ec2.DeleteVpcOutput, error) { var output ec2.DeleteVpcOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.VpcId == nil || *input.VpcId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteVpcInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/DescribeVpcAttribute.go b/spinifex/gateway/ec2/vpc/DescribeVpcAttribute.go index 781147682..bb0df28fc 100644 --- a/spinifex/gateway/ec2/vpc/DescribeVpcAttribute.go +++ b/spinifex/gateway/ec2/vpc/DescribeVpcAttribute.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDescribeVpcAttributeInput validates the input parameters +func ValidateDescribeVpcAttributeInput(input *ec2.DescribeVpcAttributeInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.VpcId == nil || *input.VpcId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if input.Attribute == nil || *input.Attribute == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DescribeVpcAttribute handles the EC2 DescribeVpcAttribute API call func DescribeVpcAttribute(input *ec2.DescribeVpcAttributeInput, natsConn *nats.Conn, accountID string) (ec2.DescribeVpcAttributeOutput, error) { var output ec2.DescribeVpcAttributeOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.VpcId == nil || *input.VpcId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if input.Attribute == nil || *input.Attribute == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDescribeVpcAttributeInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/ModifyNetworkInterfaceAttribute.go b/spinifex/gateway/ec2/vpc/ModifyNetworkInterfaceAttribute.go index 0d24c49e0..3769e5e76 100644 --- a/spinifex/gateway/ec2/vpc/ModifyNetworkInterfaceAttribute.go +++ b/spinifex/gateway/ec2/vpc/ModifyNetworkInterfaceAttribute.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateModifyNetworkInterfaceAttributeInput validates the input parameters +func ValidateModifyNetworkInterfaceAttributeInput(input *ec2.ModifyNetworkInterfaceAttributeInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.NetworkInterfaceId == nil || *input.NetworkInterfaceId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // ModifyNetworkInterfaceAttribute handles the EC2 ModifyNetworkInterfaceAttribute API call func ModifyNetworkInterfaceAttribute(input *ec2.ModifyNetworkInterfaceAttributeInput, natsConn *nats.Conn, accountID string) (ec2.ModifyNetworkInterfaceAttributeOutput, error) { var output ec2.ModifyNetworkInterfaceAttributeOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.NetworkInterfaceId == nil || *input.NetworkInterfaceId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateModifyNetworkInterfaceAttributeInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/ModifySubnetAttribute.go b/spinifex/gateway/ec2/vpc/ModifySubnetAttribute.go index df651749d..df3f0195a 100644 --- a/spinifex/gateway/ec2/vpc/ModifySubnetAttribute.go +++ b/spinifex/gateway/ec2/vpc/ModifySubnetAttribute.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateModifySubnetAttributeInput validates the input parameters +func ValidateModifySubnetAttributeInput(input *ec2.ModifySubnetAttributeInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.SubnetId == nil || *input.SubnetId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // ModifySubnetAttribute handles the EC2 ModifySubnetAttribute API call func ModifySubnetAttribute(input *ec2.ModifySubnetAttributeInput, natsConn *nats.Conn, accountID string) (ec2.ModifySubnetAttributeOutput, error) { var output ec2.ModifySubnetAttributeOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.SubnetId == nil || *input.SubnetId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateModifySubnetAttributeInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/ec2/vpc/ModifyVpcAttribute.go b/spinifex/gateway/ec2/vpc/ModifyVpcAttribute.go index 7420452ac..2e75f1cd5 100644 --- a/spinifex/gateway/ec2/vpc/ModifyVpcAttribute.go +++ b/spinifex/gateway/ec2/vpc/ModifyVpcAttribute.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateModifyVpcAttributeInput validates the input parameters +func ValidateModifyVpcAttributeInput(input *ec2.ModifyVpcAttributeInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.VpcId == nil || *input.VpcId == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // ModifyVpcAttribute handles the EC2 ModifyVpcAttribute API call func ModifyVpcAttribute(input *ec2.ModifyVpcAttributeInput, natsConn *nats.Conn, accountID string) (ec2.ModifyVpcAttributeOutput, error) { var output ec2.ModifyVpcAttributeOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.VpcId == nil || *input.VpcId == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateModifyVpcAttributeInput(input); err != nil { + return output, err } svc := handlers_ec2_vpc.NewNATSVPCService(natsConn) diff --git a/spinifex/gateway/elbv2/CreateListener.go b/spinifex/gateway/elbv2/CreateListener.go index 41e8ec099..876deed8a 100644 --- a/spinifex/gateway/elbv2/CreateListener.go +++ b/spinifex/gateway/elbv2/CreateListener.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreateListenerInput validates the input parameters +func ValidateCreateListenerInput(input *elbv2.CreateListenerInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if len(input.DefaultActions) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreateListener handles the ELBv2 CreateListener API call. func CreateListener(input *elbv2.CreateListenerInput, natsConn *nats.Conn, accountID string) (elbv2.CreateListenerOutput, error) { var output elbv2.CreateListenerOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if len(input.DefaultActions) == 0 { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreateListenerInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/CreateLoadBalancer.go b/spinifex/gateway/elbv2/CreateLoadBalancer.go index 3e27ca263..aec75e01d 100644 --- a/spinifex/gateway/elbv2/CreateLoadBalancer.go +++ b/spinifex/gateway/elbv2/CreateLoadBalancer.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreateLoadBalancerInput validates the input parameters +func ValidateCreateLoadBalancerInput(input *elbv2.CreateLoadBalancerInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.Name == nil || *input.Name == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreateLoadBalancer handles the ELBv2 CreateLoadBalancer API call. func CreateLoadBalancer(input *elbv2.CreateLoadBalancerInput, natsConn *nats.Conn, accountID string) (elbv2.CreateLoadBalancerOutput, error) { var output elbv2.CreateLoadBalancerOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.Name == nil || *input.Name == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreateLoadBalancerInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/CreateTargetGroup.go b/spinifex/gateway/elbv2/CreateTargetGroup.go index ef94b4fec..bb03ed371 100644 --- a/spinifex/gateway/elbv2/CreateTargetGroup.go +++ b/spinifex/gateway/elbv2/CreateTargetGroup.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateCreateTargetGroupInput validates the input parameters +func ValidateCreateTargetGroupInput(input *elbv2.CreateTargetGroupInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.Name == nil || *input.Name == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // CreateTargetGroup handles the ELBv2 CreateTargetGroup API call. func CreateTargetGroup(input *elbv2.CreateTargetGroupInput, natsConn *nats.Conn, accountID string) (elbv2.CreateTargetGroupOutput, error) { var output elbv2.CreateTargetGroupOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.Name == nil || *input.Name == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateCreateTargetGroupInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DeleteListener.go b/spinifex/gateway/elbv2/DeleteListener.go index 00462e17b..d233adb41 100644 --- a/spinifex/gateway/elbv2/DeleteListener.go +++ b/spinifex/gateway/elbv2/DeleteListener.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteListenerInput validates the input parameters +func ValidateDeleteListenerInput(input *elbv2.DeleteListenerInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.ListenerArn == nil || *input.ListenerArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteListener handles the ELBv2 DeleteListener API call. func DeleteListener(input *elbv2.DeleteListenerInput, natsConn *nats.Conn, accountID string) (elbv2.DeleteListenerOutput, error) { var output elbv2.DeleteListenerOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.ListenerArn == nil || *input.ListenerArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteListenerInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DeleteLoadBalancer.go b/spinifex/gateway/elbv2/DeleteLoadBalancer.go index dc930320e..3b423c1e1 100644 --- a/spinifex/gateway/elbv2/DeleteLoadBalancer.go +++ b/spinifex/gateway/elbv2/DeleteLoadBalancer.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteLoadBalancerInput validates the input parameters +func ValidateDeleteLoadBalancerInput(input *elbv2.DeleteLoadBalancerInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteLoadBalancer handles the ELBv2 DeleteLoadBalancer API call. func DeleteLoadBalancer(input *elbv2.DeleteLoadBalancerInput, natsConn *nats.Conn, accountID string) (elbv2.DeleteLoadBalancerOutput, error) { var output elbv2.DeleteLoadBalancerOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteLoadBalancerInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DeleteTargetGroup.go b/spinifex/gateway/elbv2/DeleteTargetGroup.go index 90d5553c0..673fc2d47 100644 --- a/spinifex/gateway/elbv2/DeleteTargetGroup.go +++ b/spinifex/gateway/elbv2/DeleteTargetGroup.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeleteTargetGroupInput validates the input parameters +func ValidateDeleteTargetGroupInput(input *elbv2.DeleteTargetGroupInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeleteTargetGroup handles the ELBv2 DeleteTargetGroup API call. func DeleteTargetGroup(input *elbv2.DeleteTargetGroupInput, natsConn *nats.Conn, accountID string) (elbv2.DeleteTargetGroupOutput, error) { var output elbv2.DeleteTargetGroupOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeleteTargetGroupInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DeregisterTargets.go b/spinifex/gateway/elbv2/DeregisterTargets.go index 065591935..df101604e 100644 --- a/spinifex/gateway/elbv2/DeregisterTargets.go +++ b/spinifex/gateway/elbv2/DeregisterTargets.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDeregisterTargetsInput validates the input parameters +func ValidateDeregisterTargetsInput(input *elbv2.DeregisterTargetsInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if len(input.Targets) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DeregisterTargets handles the ELBv2 DeregisterTargets API call. func DeregisterTargets(input *elbv2.DeregisterTargetsInput, natsConn *nats.Conn, accountID string) (elbv2.DeregisterTargetsOutput, error) { var output elbv2.DeregisterTargetsOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if len(input.Targets) == 0 { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDeregisterTargetsInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DescribeLoadBalancerAttributes.go b/spinifex/gateway/elbv2/DescribeLoadBalancerAttributes.go index 61add9f37..59f827d06 100644 --- a/spinifex/gateway/elbv2/DescribeLoadBalancerAttributes.go +++ b/spinifex/gateway/elbv2/DescribeLoadBalancerAttributes.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDescribeLoadBalancerAttributesInput validates the input parameters +func ValidateDescribeLoadBalancerAttributesInput(input *elbv2.DescribeLoadBalancerAttributesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DescribeLoadBalancerAttributes handles the ELBv2 DescribeLoadBalancerAttributes API call. func DescribeLoadBalancerAttributes(input *elbv2.DescribeLoadBalancerAttributesInput, natsConn *nats.Conn, accountID string) (elbv2.DescribeLoadBalancerAttributesOutput, error) { var output elbv2.DescribeLoadBalancerAttributesOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDescribeLoadBalancerAttributesInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DescribeTargetGroupAttributes.go b/spinifex/gateway/elbv2/DescribeTargetGroupAttributes.go index 541e95f8d..5046931a1 100644 --- a/spinifex/gateway/elbv2/DescribeTargetGroupAttributes.go +++ b/spinifex/gateway/elbv2/DescribeTargetGroupAttributes.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDescribeTargetGroupAttributesInput validates the input parameters +func ValidateDescribeTargetGroupAttributesInput(input *elbv2.DescribeTargetGroupAttributesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DescribeTargetGroupAttributes handles the ELBv2 DescribeTargetGroupAttributes API call. func DescribeTargetGroupAttributes(input *elbv2.DescribeTargetGroupAttributesInput, natsConn *nats.Conn, accountID string) (elbv2.DescribeTargetGroupAttributesOutput, error) { var output elbv2.DescribeTargetGroupAttributesOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDescribeTargetGroupAttributesInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/DescribeTargetHealth.go b/spinifex/gateway/elbv2/DescribeTargetHealth.go index d06640068..62704d0fa 100644 --- a/spinifex/gateway/elbv2/DescribeTargetHealth.go +++ b/spinifex/gateway/elbv2/DescribeTargetHealth.go @@ -9,15 +9,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateDescribeTargetHealthInput validates the input parameters +func ValidateDescribeTargetHealthInput(input *elbv2.DescribeTargetHealthInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // DescribeTargetHealth handles the ELBv2 DescribeTargetHealth API call. func DescribeTargetHealth(input *elbv2.DescribeTargetHealthInput, natsConn *nats.Conn, accountID string) (elbv2.DescribeTargetHealthOutput, error) { var output elbv2.DescribeTargetHealthOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateDescribeTargetHealthInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/GetLBConfig.go b/spinifex/gateway/elbv2/GetLBConfig.go index d1b0e4e87..bea59e4c7 100644 --- a/spinifex/gateway/elbv2/GetLBConfig.go +++ b/spinifex/gateway/elbv2/GetLBConfig.go @@ -8,15 +8,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateGetLBConfigInput validates the input parameters +func ValidateGetLBConfigInput(input *handlers_elbv2.GetLBConfigInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.LBID == nil || *input.LBID == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // GetLBConfig handles the ELBv2 GetLBConfig API call. func GetLBConfig(input *handlers_elbv2.GetLBConfigInput, natsConn *nats.Conn, accountID string) (handlers_elbv2.GetLBConfigOutput, error) { var output handlers_elbv2.GetLBConfigOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.LBID == nil || *input.LBID == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateGetLBConfigInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/LBAgentHeartbeat.go b/spinifex/gateway/elbv2/LBAgentHeartbeat.go index f02a5dd6f..8ab430a69 100644 --- a/spinifex/gateway/elbv2/LBAgentHeartbeat.go +++ b/spinifex/gateway/elbv2/LBAgentHeartbeat.go @@ -8,15 +8,23 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateLBAgentHeartbeatInput validates the input parameters +func ValidateLBAgentHeartbeatInput(input *handlers_elbv2.LBAgentHeartbeatInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.LBID == nil || *input.LBID == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // LBAgentHeartbeat handles the ELBv2 LBAgentHeartbeat API call. func LBAgentHeartbeat(input *handlers_elbv2.LBAgentHeartbeatInput, natsConn *nats.Conn, accountID string) (handlers_elbv2.LBAgentHeartbeatOutput, error) { var output handlers_elbv2.LBAgentHeartbeatOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.LBID == nil || *input.LBID == "" { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateLBAgentHeartbeatInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/ModifyLoadBalancerAttributes.go b/spinifex/gateway/elbv2/ModifyLoadBalancerAttributes.go index 6a806de5a..39fa656e3 100644 --- a/spinifex/gateway/elbv2/ModifyLoadBalancerAttributes.go +++ b/spinifex/gateway/elbv2/ModifyLoadBalancerAttributes.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateModifyLoadBalancerAttributesInput validates the input parameters +func ValidateModifyLoadBalancerAttributesInput(input *elbv2.ModifyLoadBalancerAttributesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if len(input.Attributes) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // ModifyLoadBalancerAttributes handles the ELBv2 ModifyLoadBalancerAttributes API call. func ModifyLoadBalancerAttributes(input *elbv2.ModifyLoadBalancerAttributesInput, natsConn *nats.Conn, accountID string) (elbv2.ModifyLoadBalancerAttributesOutput, error) { var output elbv2.ModifyLoadBalancerAttributesOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.LoadBalancerArn == nil || *input.LoadBalancerArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if len(input.Attributes) == 0 { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateModifyLoadBalancerAttributesInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/ModifyTargetGroupAttributes.go b/spinifex/gateway/elbv2/ModifyTargetGroupAttributes.go index 1e0845d0f..8f826e28c 100644 --- a/spinifex/gateway/elbv2/ModifyTargetGroupAttributes.go +++ b/spinifex/gateway/elbv2/ModifyTargetGroupAttributes.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateModifyTargetGroupAttributesInput validates the input parameters +func ValidateModifyTargetGroupAttributesInput(input *elbv2.ModifyTargetGroupAttributesInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if len(input.Attributes) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // ModifyTargetGroupAttributes handles the ELBv2 ModifyTargetGroupAttributes API call. func ModifyTargetGroupAttributes(input *elbv2.ModifyTargetGroupAttributesInput, natsConn *nats.Conn, accountID string) (elbv2.ModifyTargetGroupAttributesOutput, error) { var output elbv2.ModifyTargetGroupAttributesOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if len(input.Attributes) == 0 { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateModifyTargetGroupAttributesInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn) diff --git a/spinifex/gateway/elbv2/RegisterTargets.go b/spinifex/gateway/elbv2/RegisterTargets.go index 68b4493a7..0f116953b 100644 --- a/spinifex/gateway/elbv2/RegisterTargets.go +++ b/spinifex/gateway/elbv2/RegisterTargets.go @@ -9,18 +9,26 @@ import ( "github.com/nats-io/nats.go" ) +// ValidateRegisterTargetsInput validates the input parameters +func ValidateRegisterTargetsInput(input *elbv2.RegisterTargetsInput) error { + if input == nil { + return errors.New(awserrors.ErrorInvalidParameterValue) + } + if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { + return errors.New(awserrors.ErrorMissingParameter) + } + if len(input.Targets) == 0 { + return errors.New(awserrors.ErrorMissingParameter) + } + return nil +} + // RegisterTargets handles the ELBv2 RegisterTargets API call. func RegisterTargets(input *elbv2.RegisterTargetsInput, natsConn *nats.Conn, accountID string) (elbv2.RegisterTargetsOutput, error) { var output elbv2.RegisterTargetsOutput - if input == nil { - return output, errors.New(awserrors.ErrorInvalidParameterValue) - } - if input.TargetGroupArn == nil || *input.TargetGroupArn == "" { - return output, errors.New(awserrors.ErrorMissingParameter) - } - if len(input.Targets) == 0 { - return output, errors.New(awserrors.ErrorMissingParameter) + if err := ValidateRegisterTargetsInput(input); err != nil { + return output, err } svc := handlers_elbv2.NewNATSELBv2Service(natsConn)