diff --git a/go.mod b/go.mod index 377a183e2..3d7e2ae9e 100644 --- a/go.mod +++ b/go.mod @@ -5,7 +5,7 @@ go 1.24.1 require ( github.com/aws/aws-sdk-go-v2 v1.38.0 github.com/aws/aws-sdk-go-v2/config v1.31.0 - github.com/aws/aws-sdk-go-v2/service/ec2 v1.243.0 + github.com/aws/aws-sdk-go-v2/service/ec2 v1.244.0 github.com/aws/aws-sdk-go-v2/service/ssm v1.63.0 github.com/mattn/go-isatty v0.0.20 github.com/onsi/ginkgo/v2 v2.23.4 diff --git a/go.sum b/go.sum index 6b99817d1..70b7ac919 100644 --- a/go.sum +++ b/go.sum @@ -12,8 +12,8 @@ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.3 h1:joyyUFhiTQQmVK6ImzN github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.3/go.mod h1:+vNIyZQP3b3B1tSLI0lxvrU9cfM7gpdRXMFfm67ZcPc= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo= -github.com/aws/aws-sdk-go-v2/service/ec2 v1.243.0 h1:s7mU5Zfa1ksg86BGjYKU03Bs63m5MY1ps4jOZFayBwM= -github.com/aws/aws-sdk-go-v2/service/ec2 v1.243.0/go.mod h1:EeWmteKqZjaMj45MUmPET1SisFI+HkqWIRQoyjMivcc= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.244.0 h1:KfETrpt7yv2nkSrjOltgmKyAl8scbzYc4TFtZeoV6uc= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.244.0/go.mod h1:EeWmteKqZjaMj45MUmPET1SisFI+HkqWIRQoyjMivcc= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.0 h1:6+lZi2JeGKtCraAj1rpoZfKqnQ9SptseRZioejfUOLM= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.0/go.mod h1:eb3gfbVIxIoGgJsi9pGne19dhCBpK6opTYpQqAmdy44= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.3 h1:ieRzyHXypu5ByllM7Sp4hC5f/1Fy5wqxqY0yB85hC7s= diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md index d5c9ff229..8a517fd55 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md @@ -1,3 +1,7 @@ +# v1.244.0 (2025-08-14) + +* **Feature**: This release adds ModifyInstanceConnectEndpoint API to update configurations on existing EC2 Instance Connect Endpoints and improves IPv6 support through dualstack DNS names for EC2 Instance Connect Endpoints. + # v1.243.0 (2025-08-12) * **Feature**: Release to allow route table association with a PublicIpv4Pool. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeVpcEndpointAssociations.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeVpcEndpointAssociations.go index 5f7e4f23f..0b5626f8e 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeVpcEndpointAssociations.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeVpcEndpointAssociations.go @@ -53,8 +53,6 @@ type DescribeVpcEndpointAssociationsInput struct { // // - resource-configuration-group-arn - The Amazon Resource Name (ARN) of the // resource configuration of type GROUP. - // - // - service-network-resource-association-id - The ID of the association. Filters []types.Filter // The maximum page size. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceConnectEndpoint.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceConnectEndpoint.go new file mode 100644 index 000000000..fba94e745 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyInstanceConnectEndpoint.go @@ -0,0 +1,228 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ec2 + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Modifies the specified EC2 Instance Connect Endpoint. +// +// For more information, see [Modify an EC2 Instance Connect Endpoint] in the Amazon EC2 User Guide. +// +// [Modify an EC2 Instance Connect Endpoint]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-ec2-instance-connect-endpoint.html +func (c *Client) ModifyInstanceConnectEndpoint(ctx context.Context, params *ModifyInstanceConnectEndpointInput, optFns ...func(*Options)) (*ModifyInstanceConnectEndpointOutput, error) { + if params == nil { + params = &ModifyInstanceConnectEndpointInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ModifyInstanceConnectEndpoint", params, optFns, c.addOperationModifyInstanceConnectEndpointMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ModifyInstanceConnectEndpointOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ModifyInstanceConnectEndpointInput struct { + + // The ID of the EC2 Instance Connect Endpoint to modify. + // + // This member is required. + InstanceConnectEndpointId *string + + // Checks whether you have the required permissions for the operation, without + // actually making the request, and provides an error response. If you have the + // required permissions, the error response is DryRunOperation . Otherwise, it is + // UnauthorizedOperation . + DryRun *bool + + // The new IP address type for the EC2 Instance Connect Endpoint. + // + // PreserveClientIp is only supported on IPv4 EC2 Instance Connect Endpoints. To + // use PreserveClientIp , the value for IpAddressType must be ipv4 . + IpAddressType types.IpAddressType + + // Indicates whether the client IP address is preserved as the source. The + // following are the possible values. + // + // - true - Use the client IP address as the source. + // + // - false - Use the network interface IP address as the source. + // + // PreserveClientIp=true is only supported on IPv4 EC2 Instance Connect Endpoints. + // If modifying PreserveClientIp to true , either the endpoint's existing + // IpAddressType must be ipv4 , or if modifying IpAddressType in the same request, + // the new value must be ipv4 . + // + // Default: false + PreserveClientIp *bool + + // Changes the security groups for the EC2 Instance Connect Endpoint. The new set + // of groups you specify replaces the current set. You must specify at least one + // group, even if it's just the default security group in the VPC. You must specify + // the ID of the security group, not the name. + SecurityGroupIds []string + + noSmithyDocumentSerde +} + +type ModifyInstanceConnectEndpointOutput struct { + + // The return value of the request. Returns true if the specified product code is + // owned by the requester and associated with the specified instance. + Return *bool + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationModifyInstanceConnectEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + err = stack.Serialize.Add(&awsEc2query_serializeOpModifyInstanceConnectEndpoint{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsEc2query_deserializeOpModifyInstanceConnectEndpoint{}, middleware.After) + if err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, "ModifyInstanceConnectEndpoint"); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + + if err = addlegacyEndpointContextSetter(stack, options); err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = addClientRequestID(stack); err != nil { + return err + } + if err = addComputeContentLength(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRetry(stack, options); err != nil { + return err + } + if err = addRawResponseToMetadata(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack); err != nil { + return err + } + if err = addSpanRetryLoop(stack, options); err != nil { + return err + } + if err = addClientUserAgent(stack, options); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err = addTimeOffsetBuild(stack, c); err != nil { + return err + } + if err = addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpModifyInstanceConnectEndpointValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opModifyInstanceConnectEndpoint(options.Region), middleware.Before); err != nil { + return err + } + if err = addRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err = addInterceptAttempt(stack, options); err != nil { + return err + } + if err = addInterceptExecution(stack, options); err != nil { + return err + } + if err = addInterceptBeforeSerialization(stack, options); err != nil { + return err + } + if err = addInterceptAfterSerialization(stack, options); err != nil { + return err + } + if err = addInterceptBeforeSigning(stack, options); err != nil { + return err + } + if err = addInterceptAfterSigning(stack, options); err != nil { + return err + } + if err = addInterceptTransmit(stack, options); err != nil { + return err + } + if err = addInterceptBeforeDeserialization(stack, options); err != nil { + return err + } + if err = addInterceptAfterDeserialization(stack, options); err != nil { + return err + } + if err = addSpanInitializeStart(stack); err != nil { + return err + } + if err = addSpanInitializeEnd(stack); err != nil { + return err + } + if err = addSpanBuildRequestStart(stack); err != nil { + return err + } + if err = addSpanBuildRequestEnd(stack); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opModifyInstanceConnectEndpoint(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + OperationName: "ModifyInstanceConnectEndpoint", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go index d5d480844..1941d54f3 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go @@ -52098,6 +52098,101 @@ func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(r } } +type awsEc2query_deserializeOpModifyInstanceConnectEndpoint struct { +} + +func (*awsEc2query_deserializeOpModifyInstanceConnectEndpoint) ID() string { + return "OperationDeserializer" +} + +func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + defer endTimer() + defer span.End() + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response, &metadata) + } + output := &ModifyInstanceConnectEndpointOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + body := io.TeeReader(response.Body, ringBuffer) + rootDecoder := xml.NewDecoder(body) + t, err := smithyxml.FetchRootElement(rootDecoder) + if err == io.EOF { + return out, metadata, nil + } + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) + err = awsEc2query_deserializeOpDocumentModifyInstanceConnectEndpointOutput(&output, decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + return out, metadata, err +} + +func awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) + if err != nil { + return err + } + awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) + if len(errorComponents.Code) != 0 { + errorCode = errorComponents.Code + } + if len(errorComponents.Message) != 0 { + errorMessage = errorComponents.Message + } + errorBody.Seek(0, io.SeekStart) + switch { + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + type awsEc2query_deserializeOpModifyInstanceCpuOptions struct { } @@ -83946,6 +84041,12 @@ func awsEc2query_deserializeDocumentEc2InstanceConnectEndpoint(v **types.Ec2Inst sv.PreserveClientIp = ptr.Bool(xtv) } + case strings.EqualFold("publicDnsNames", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceConnectEndpointPublicDnsNames(&sv.PublicDnsNames, nodeDecoder); err != nil { + return err + } + case strings.EqualFold("securityGroupIdSet", t.Name.Local): nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) if err := awsEc2query_deserializeDocumentSecurityGroupIdSet(&sv.SecurityGroupIds, nodeDecoder); err != nil { @@ -95884,6 +95985,116 @@ func awsEc2query_deserializeDocumentInstanceCapacity(v **types.InstanceCapacity, return nil } +func awsEc2query_deserializeDocumentInstanceConnectEndpointDnsNames(v **types.InstanceConnectEndpointDnsNames, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceConnectEndpointDnsNames + if *v == nil { + sv = &types.InstanceConnectEndpointDnsNames{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("dnsName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.DnsName = ptr.String(xtv) + } + + case strings.EqualFold("fipsDnsName", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv := string(val) + sv.FipsDnsName = ptr.String(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + +func awsEc2query_deserializeDocumentInstanceConnectEndpointPublicDnsNames(v **types.InstanceConnectEndpointPublicDnsNames, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *types.InstanceConnectEndpointPublicDnsNames + if *v == nil { + sv = &types.InstanceConnectEndpointPublicDnsNames{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("dualstack", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceConnectEndpointDnsNames(&sv.Dualstack, nodeDecoder); err != nil { + return err + } + + case strings.EqualFold("ipv4", t.Name.Local): + nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) + if err := awsEc2query_deserializeDocumentInstanceConnectEndpointDnsNames(&sv.Ipv4, nodeDecoder); err != nil { + return err + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeDocumentInstanceConnectEndpointSet(v *[]types.Ec2InstanceConnectEndpoint, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -188620,6 +188831,58 @@ func awsEc2query_deserializeOpDocumentModifyInstanceCapacityReservationAttribute return nil } +func awsEc2query_deserializeOpDocumentModifyInstanceConnectEndpointOutput(v **ModifyInstanceConnectEndpointOutput, decoder smithyxml.NodeDecoder) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + var sv *ModifyInstanceConnectEndpointOutput + if *v == nil { + sv = &ModifyInstanceConnectEndpointOutput{} + } else { + sv = *v + } + + for { + t, done, err := decoder.Token() + if err != nil { + return err + } + if done { + break + } + originalDecoder := decoder + decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) + switch { + case strings.EqualFold("return", t.Name.Local): + val, err := decoder.Value() + if err != nil { + return err + } + if val == nil { + break + } + { + xtv, err := strconv.ParseBool(string(val)) + if err != nil { + return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) + } + sv.Return = ptr.Bool(xtv) + } + + default: + // Do nothing and ignore the unexpected tag element + err = decoder.Decoder.Skip() + if err != nil { + return err + } + + } + decoder = originalDecoder + } + *v = sv + return nil +} + func awsEc2query_deserializeOpDocumentModifyInstanceCpuOptionsOutput(v **ModifyInstanceCpuOptionsOutput, decoder smithyxml.NodeDecoder) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json index b5c4a371b..bc4a59087 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json @@ -568,6 +568,7 @@ "api_op_ModifyImageAttribute.go", "api_op_ModifyInstanceAttribute.go", "api_op_ModifyInstanceCapacityReservationAttributes.go", + "api_op_ModifyInstanceConnectEndpoint.go", "api_op_ModifyInstanceCpuOptions.go", "api_op_ModifyInstanceCreditSpecification.go", "api_op_ModifyInstanceEventStartTime.go", diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go index 1dcbdaa3d..9ab53e130 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go @@ -3,4 +3,4 @@ package ec2 // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.243.0" +const goModuleVersion = "1.244.0" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go index 16f0101b9..c99ab0c87 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go @@ -39008,6 +39008,76 @@ func (m *awsEc2query_serializeOpModifyInstanceCapacityReservationAttributes) Han return next.HandleSerialize(ctx, in) } +type awsEc2query_serializeOpModifyInstanceConnectEndpoint struct { +} + +func (*awsEc2query_serializeOpModifyInstanceConnectEndpoint) ID() string { + return "OperationSerializer" +} + +func (m *awsEc2query_serializeOpModifyInstanceConnectEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + defer endTimer() + defer span.End() + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*ModifyInstanceConnectEndpointInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + operationPath := "/" + if len(request.Request.URL.Path) == 0 { + request.Request.URL.Path = operationPath + } else { + request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath) + if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' { + request.Request.URL.Path += "/" + } + } + request.Request.Method = "POST" + httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") + + bodyWriter := bytes.NewBuffer(nil) + bodyEncoder := query.NewEncoder(bodyWriter) + body := bodyEncoder.Object() + body.Key("Action").String("ModifyInstanceConnectEndpoint") + body.Key("Version").String("2016-11-15") + + if err := awsEc2query_serializeOpDocumentModifyInstanceConnectEndpointInput(input, bodyEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + err = bodyEncoder.Encode() + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + endTimer() + span.End() + return next.HandleSerialize(ctx, in) +} + type awsEc2query_serializeOpModifyInstanceCpuOptions struct { } @@ -76464,6 +76534,40 @@ func awsEc2query_serializeOpDocumentModifyInstanceCapacityReservationAttributesI return nil } +func awsEc2query_serializeOpDocumentModifyInstanceConnectEndpointInput(v *ModifyInstanceConnectEndpointInput, value query.Value) error { + object := value.Object() + _ = object + + if v.DryRun != nil { + objectKey := object.Key("DryRun") + objectKey.Boolean(*v.DryRun) + } + + if v.InstanceConnectEndpointId != nil { + objectKey := object.Key("InstanceConnectEndpointId") + objectKey.String(*v.InstanceConnectEndpointId) + } + + if len(v.IpAddressType) > 0 { + objectKey := object.Key("IpAddressType") + objectKey.String(string(v.IpAddressType)) + } + + if v.PreserveClientIp != nil { + objectKey := object.Key("PreserveClientIp") + objectKey.Boolean(*v.PreserveClientIp) + } + + if v.SecurityGroupIds != nil { + objectKey := object.FlatKey("SecurityGroupId") + if err := awsEc2query_serializeDocumentSecurityGroupIdStringListRequest(v.SecurityGroupIds, objectKey); err != nil { + return err + } + } + + return nil +} + func awsEc2query_serializeOpDocumentModifyInstanceCpuOptionsInput(v *ModifyInstanceCpuOptionsInput, value query.Value) error { object := value.Object() _ = object diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go index f0a436714..190532984 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go @@ -2044,6 +2044,9 @@ const ( Ec2InstanceConnectEndpointStateDeleteInProgress Ec2InstanceConnectEndpointState = "delete-in-progress" Ec2InstanceConnectEndpointStateDeleteComplete Ec2InstanceConnectEndpointState = "delete-complete" Ec2InstanceConnectEndpointStateDeleteFailed Ec2InstanceConnectEndpointState = "delete-failed" + Ec2InstanceConnectEndpointStateUpdateInProgress Ec2InstanceConnectEndpointState = "update-in-progress" + Ec2InstanceConnectEndpointStateUpdateComplete Ec2InstanceConnectEndpointState = "update-complete" + Ec2InstanceConnectEndpointStateUpdateFailed Ec2InstanceConnectEndpointState = "update-failed" ) // Values returns all known values for Ec2InstanceConnectEndpointState. Note that @@ -2059,6 +2062,9 @@ func (Ec2InstanceConnectEndpointState) Values() []Ec2InstanceConnectEndpointStat "delete-in-progress", "delete-complete", "delete-failed", + "update-in-progress", + "update-complete", + "update-failed", } } diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go index 2bc66b3b4..1f8c86b6a 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go @@ -4459,6 +4459,9 @@ type Ec2InstanceConnectEndpoint struct { // Default: true PreserveClientIp *bool + // The public DNS names of the endpoint. + PublicDnsNames *InstanceConnectEndpointPublicDnsNames + // The security groups associated with the endpoint. If you didn't specify a // security group, the default security group for your VPC is associated with the // endpoint. @@ -7735,6 +7738,33 @@ type InstanceCapacity struct { noSmithyDocumentSerde } +// The DNS names of the endpoint. +type InstanceConnectEndpointDnsNames struct { + + // The DNS name of the EC2 Instance Connect Endpoint. + DnsName *string + + // The Federal Information Processing Standards (FIPS) compliant DNS name of the + // EC2 Instance Connect Endpoint. + FipsDnsName *string + + noSmithyDocumentSerde +} + +// The public DNS names of the endpoint, including IPv4-only and dualstack DNS +// names. +type InstanceConnectEndpointPublicDnsNames struct { + + // The dualstack DNS name of the EC2 Instance Connect Endpoint. A dualstack DNS + // name supports connections from both IPv4 and IPv6 clients. + Dualstack *InstanceConnectEndpointDnsNames + + // The IPv4-only DNS name of the EC2 Instance Connect Endpoint. + Ipv4 *InstanceConnectEndpointDnsNames + + noSmithyDocumentSerde +} + // Describes a Reserved Instance listing state. type InstanceCount struct { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go index 823b3d93c..d47f9741b 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go @@ -7190,6 +7190,26 @@ func (m *validateOpModifyInstanceCapacityReservationAttributes) HandleInitialize return next.HandleInitialize(ctx, in) } +type validateOpModifyInstanceConnectEndpoint struct { +} + +func (*validateOpModifyInstanceConnectEndpoint) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpModifyInstanceConnectEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ModifyInstanceConnectEndpointInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpModifyInstanceConnectEndpointInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpModifyInstanceCpuOptions struct { } @@ -11066,6 +11086,10 @@ func addOpModifyInstanceCapacityReservationAttributesValidationMiddleware(stack return stack.Initialize.Add(&validateOpModifyInstanceCapacityReservationAttributes{}, middleware.After) } +func addOpModifyInstanceConnectEndpointValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpModifyInstanceConnectEndpoint{}, middleware.After) +} + func addOpModifyInstanceCpuOptionsValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpModifyInstanceCpuOptions{}, middleware.After) } @@ -18469,6 +18493,21 @@ func validateOpModifyInstanceCapacityReservationAttributesInput(v *ModifyInstanc } } +func validateOpModifyInstanceConnectEndpointInput(v *ModifyInstanceConnectEndpointInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceConnectEndpointInput"} + if v.InstanceConnectEndpointId == nil { + invalidParams.Add(smithy.NewErrParamRequired("InstanceConnectEndpointId")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpModifyInstanceCpuOptionsInput(v *ModifyInstanceCpuOptionsInput) error { if v == nil { return nil diff --git a/vendor/modules.txt b/vendor/modules.txt index ec0b43d3a..a2cbe25e2 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -50,7 +50,7 @@ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 # github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 ## explicit; go 1.22 github.com/aws/aws-sdk-go-v2/internal/ini -# github.com/aws/aws-sdk-go-v2/service/ec2 v1.243.0 +# github.com/aws/aws-sdk-go-v2/service/ec2 v1.244.0 ## explicit; go 1.22 github.com/aws/aws-sdk-go-v2/service/ec2 github.com/aws/aws-sdk-go-v2/service/ec2/internal/endpoints