aws-sdk-s3control 1.53.0 → 1.55.0

data/lib/aws-sdk-s3control/plugins/arn.rb

@@ -6,8 +6,7 @@ require_relative '../arn/outpost_bucket_arn'
 module Aws
   module S3Control
     module Plugins
-      # When an ARN is provided for :bucket or :name in S3Control operations,
-      # this plugin resolves the request endpoint from the ARN when possible.
+      # Deprecated in favor of new endpoint generation.
       # @api private
       class ARN < Seahorse::Client::Plugin
         option(
@@ -23,156 +22,7 @@ client's region instead.
           resolve_s3_use_arn_region(cfg)
         end
 
-        # param validator is validate:50 (required to add account_id from arn)
-        # endpoint is build:90 (populates the URI for the first time)
-        # endpoint pattern is build:10 (prefix account id to host)
-        def add_handlers(handlers, _config)
-          handlers.add(ARNHandler, step: :validate, priority: 75)
-          handlers.add(UrlHandler)
-        end
-
-        # After extracting out any ARN input, resolve a new URL with it.
-        class UrlHandler < Seahorse::Client::Handler
-          def call(context)
-            if context.metadata[:s3_arn]
-              ARN.resolve_url!(
-                context.http_request.endpoint,
-                context.metadata[:s3_arn][:arn],
-                context.metadata[:s3_arn][:resolved_region],
-                context.metadata[:s3_arn][:fips],
-                context.metadata[:s3_arn][:dualstack],
-                # if regional_endpoint is false, a custom endpoint was provided
-                # in this case, we want to prefix the endpoint using the ARN
-                !context.config.regional_endpoint
-              )
-            end
-            @handler.call(context)
-          end
-        end
-
-        # This plugin will extract out any ARN input and set context for other
-        # plugins to use without having to translate the ARN again.
-        class ARNHandler < Seahorse::Client::Handler
-          def call(context)
-            arn_member = _arn_member(context.operation.input.shape)
-            if arn_member && (bucket = context.params[arn_member])
-              resolved_region, arn = ARN.resolve_arn!(
-                bucket,
-                context.config.region,
-                context.config.s3_use_arn_region
-              )
-              validate_outpost_dualstack!(context)
-              if arn
-                validate_config!(context, arn)
-
-                if arn.is_a?(OutpostAccessPointARN) ||
-                   arn.is_a?(OutpostBucketARN)
-                  set_outpost_header!(context, arn)
-                  # disable account_id prefix for outposts urls
-                  context.config.disable_host_prefix_injection = true
-                end
-                set_account_param!(context, arn)
-
-                # depending on the ARN's resource type, put the resource value
-                # back onto params
-                context.params[arn_member] = arn.input_member
-                context.metadata[:s3_arn] = {
-                  arn: arn,
-                  resolved_region: resolved_region,
-                  fips: context.config.use_fips_endpoint,
-                  dualstack: extract_dualstack_config!(context)
-                }
-              end
-            end
-            @handler.call(context)
-          end
-
-          private
-
-          # this validation has nothing to do with ARNs (can't be in
-          # validate_config!) outposts does not support dualstack, so operations
-          # using an outpost id should be validated too.
-          def validate_outpost_dualstack!(context)
-            if context.params[:outpost_id] && context[:use_dualstack_endpoint]
-              raise ArgumentError,
-                    'Cannot provide an Outpost ID when '\
-                    '`:use_dualstack_endpoint` is set to true.'
-            end
-          end
-
-          # This looks for BucketName or AccessPointName, but prefers BucketName
-          # for CreateAccessPoint because it contains both but should not have
-          # an Access Point ARN as AccessPointName.
-          def _arn_member(input)
-            input.members.each do |member, ref|
-              if ref.shape.name == 'BucketName' ||
-                 (ref.shape.name == 'AccessPointName' &&
-                  input.name != 'CreateAccessPointRequest')
-                return member
-              end
-            end
-          end
-
-          # other plugins use dualstack so disable it when we're done
-          def extract_dualstack_config!(context)
-            dualstack = context[:use_dualstack_endpoint]
-            context[:use_dualstack_endpoint] = false if dualstack
-            dualstack
-          end
-
-          def validate_config!(context, arn)
-            if !arn.support_dualstack? && context[:use_dualstack_endpoint]
-              raise ArgumentError,
-                    'Cannot provide an Outpost Access Point or Bucket ARN '\
-                    'when `:use_dualstack_endpoint` is set to true.'
-            end
-          end
-
-          def set_outpost_header!(context, arn)
-            context.http_request.headers['x-amz-outpost-id'] = arn.outpost_id
-          end
-
-          def set_account_param!(context, arn)
-            if context.params[:account_id] &&
-               context.params[:account_id] != arn.account_id
-              raise ArgumentError,
-                    'Cannot provide an Account ID that is different from the '\
-                    'Account ID in the ARN.'
-            end
-            context.params[:account_id] = arn.account_id
-          end
-        end
-
         class << self
-          # @api private
-          def resolve_arn!(member_value, region, use_arn_region)
-            if Aws::ARNParser.arn?(member_value)
-              arn = Aws::ARNParser.parse(member_value)
-              if arn.resource.include?('bucket')
-                s3_arn = Aws::S3Control::OutpostBucketARN.new(arn.to_h)
-              elsif arn.resource.include?('accesspoint')
-                s3_arn = Aws::S3Control::OutpostAccessPointARN.new(arn.to_h)
-              else
-                raise ArgumentError,
-                      'Only Outpost Bucket and Outpost Access Point ARNs are '\
-                      'currently supported.'
-              end
-              s3_arn.validate_arn!
-              validate_region_config!(s3_arn, region, use_arn_region)
-              region = s3_arn.region if use_arn_region
-              [region, s3_arn]
-            else
-              [region]
-            end
-          end
-
-          # @api private
-          def resolve_url!(url, arn, region, fips = false, dualstack = false, has_custom_endpoint = false)
-            custom_endpoint = url.host if has_custom_endpoint
-            url.host = arn.host_url(region, fips, dualstack, custom_endpoint)
-            url
-          end
-
           private
 
           def resolve_s3_use_arn_region(cfg)
@@ -189,17 +39,6 @@ client's region instead.
             end
             value
           end
-
-          def validate_region_config!(arn, region, use_arn_region)
-            if use_arn_region &&
-               !Aws::Partitions.partition(arn.partition).region?(region)
-              raise Aws::Errors::InvalidARNPartitionError
-            end
-
-            if !use_arn_region && region != arn.region
-              raise Aws::Errors::InvalidARNRegionError
-            end
-          end
         end
       end
     end

data/lib/aws-sdk-s3control/plugins/dualstack.rb

@@ -3,11 +3,11 @@
 module Aws
   module S3Control
     module Plugins
+      # Deprecated in favor of new endpoint generation.
       # @api private
       class Dualstack < Seahorse::Client::Plugin
-        def add_handlers(handlers, config)
+        def add_handlers(handlers, _config)
           handlers.add(OptionHandler, step: :initialize)
-          handlers.add(DualstackHandler, step: :build, priority: 11)
         end
 
         # @api private
@@ -18,39 +18,10 @@ module Aws
               dualstack = context.params.delete(:use_dualstack_endpoint)
             end
             dualstack = context.config.use_dualstack_endpoint if dualstack.nil?
-            # Raise if :endpoint and dualstack are both provided
-            if dualstack && !context.config.regional_endpoint
-              raise ArgumentError,
-                    'Cannot use both :use_dualstack_endpoint and :endpoint'
-            end
             context[:use_dualstack_endpoint] = dualstack
             @handler.call(context)
           end
         end
-
-        # @api private
-        class DualstackHandler < Seahorse::Client::Handler
-          def call(context)
-            # if it's a regional endpoint and not an ARN, then construct the
-            # endpoint. regional endpoint plugin uses the dualstack config
-            if context.config.regional_endpoint && !context.metadata[:s3_arn]
-              new_endpoint = Aws::Partitions::EndpointProvider.resolve(
-                context.config.region,
-                's3-control',
-                'regional',
-                {
-                  dualstack: context[:use_dualstack_endpoint],
-                  fips: context.config.use_fips_endpoint
-                }
-              )
-              endpoint = URI.parse(context.http_request.endpoint.to_s)
-              endpoint.host = URI.parse(new_endpoint).host
-              context.http_request.endpoint = endpoint
-            end
-            @handler.call(context)
-          end
-        end
-
       end
     end
   end

data/lib/aws-sdk-s3control/plugins/endpoints.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+
+module Aws::S3Control
+  module Plugins
+    class Endpoints < Seahorse::Client::Plugin
+      option(
+        :endpoint_provider,
+        doc_type: 'Aws::S3Control::EndpointProvider',
+        docstring: 'The endpoint provider used to resolve endpoints. Any '\
+                   'object that responds to `#resolve_endpoint(parameters)` '\
+                   'where `parameters` is a Struct similar to '\
+                   '`Aws::S3Control::EndpointParameters`'
+      ) do |cfg|
+        Aws::S3Control::EndpointProvider.new
+      end
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          # If endpoint was discovered, do not resolve or apply the endpoint.
+          unless context[:discovered_endpoint]
+            params = parameters_for_operation(context)
+            endpoint = context.config.endpoint_provider.resolve_endpoint(params)
+
+            context.http_request.endpoint = endpoint.url
+            apply_endpoint_headers(context, endpoint.headers)
+          end
+
+          context[:endpoint_params] = params
+          context[:auth_scheme] =
+            Aws::Endpoints.resolve_auth_scheme(context, endpoint)
+
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_endpoint_headers(context, headers)
+          headers.each do |key, values|
+            value = values
+              .compact
+              .map { |s| Seahorse::Util.escape_header_list_string(s.to_s) }
+              .join(',')
+
+            context.http_request.headers[key] = value
+          end
+        end
+
+        def parameters_for_operation(context)
+          case context.operation_name
+          when :create_access_point
+            Aws::S3Control::Endpoints::CreateAccessPoint.build(context)
+          when :create_access_point_for_object_lambda
+            Aws::S3Control::Endpoints::CreateAccessPointForObjectLambda.build(context)
+          when :create_bucket
+            Aws::S3Control::Endpoints::CreateBucket.build(context)
+          when :create_job
+            Aws::S3Control::Endpoints::CreateJob.build(context)
+          when :create_multi_region_access_point
+            Aws::S3Control::Endpoints::CreateMultiRegionAccessPoint.build(context)
+          when :delete_access_point
+            Aws::S3Control::Endpoints::DeleteAccessPoint.build(context)
+          when :delete_access_point_for_object_lambda
+            Aws::S3Control::Endpoints::DeleteAccessPointForObjectLambda.build(context)
+          when :delete_access_point_policy
+            Aws::S3Control::Endpoints::DeleteAccessPointPolicy.build(context)
+          when :delete_access_point_policy_for_object_lambda
+            Aws::S3Control::Endpoints::DeleteAccessPointPolicyForObjectLambda.build(context)
+          when :delete_bucket
+            Aws::S3Control::Endpoints::DeleteBucket.build(context)
+          when :delete_bucket_lifecycle_configuration
+            Aws::S3Control::Endpoints::DeleteBucketLifecycleConfiguration.build(context)
+          when :delete_bucket_policy
+            Aws::S3Control::Endpoints::DeleteBucketPolicy.build(context)
+          when :delete_bucket_tagging
+            Aws::S3Control::Endpoints::DeleteBucketTagging.build(context)
+          when :delete_job_tagging
+            Aws::S3Control::Endpoints::DeleteJobTagging.build(context)
+          when :delete_multi_region_access_point
+            Aws::S3Control::Endpoints::DeleteMultiRegionAccessPoint.build(context)
+          when :delete_public_access_block
+            Aws::S3Control::Endpoints::DeletePublicAccessBlock.build(context)
+          when :delete_storage_lens_configuration
+            Aws::S3Control::Endpoints::DeleteStorageLensConfiguration.build(context)
+          when :delete_storage_lens_configuration_tagging
+            Aws::S3Control::Endpoints::DeleteStorageLensConfigurationTagging.build(context)
+          when :describe_job
+            Aws::S3Control::Endpoints::DescribeJob.build(context)
+          when :describe_multi_region_access_point_operation
+            Aws::S3Control::Endpoints::DescribeMultiRegionAccessPointOperation.build(context)
+          when :get_access_point
+            Aws::S3Control::Endpoints::GetAccessPoint.build(context)
+          when :get_access_point_configuration_for_object_lambda
+            Aws::S3Control::Endpoints::GetAccessPointConfigurationForObjectLambda.build(context)
+          when :get_access_point_for_object_lambda
+            Aws::S3Control::Endpoints::GetAccessPointForObjectLambda.build(context)
+          when :get_access_point_policy
+            Aws::S3Control::Endpoints::GetAccessPointPolicy.build(context)
+          when :get_access_point_policy_for_object_lambda
+            Aws::S3Control::Endpoints::GetAccessPointPolicyForObjectLambda.build(context)
+          when :get_access_point_policy_status
+            Aws::S3Control::Endpoints::GetAccessPointPolicyStatus.build(context)
+          when :get_access_point_policy_status_for_object_lambda
+            Aws::S3Control::Endpoints::GetAccessPointPolicyStatusForObjectLambda.build(context)
+          when :get_bucket
+            Aws::S3Control::Endpoints::GetBucket.build(context)
+          when :get_bucket_lifecycle_configuration
+            Aws::S3Control::Endpoints::GetBucketLifecycleConfiguration.build(context)
+          when :get_bucket_policy
+            Aws::S3Control::Endpoints::GetBucketPolicy.build(context)
+          when :get_bucket_tagging
+            Aws::S3Control::Endpoints::GetBucketTagging.build(context)
+          when :get_bucket_versioning
+            Aws::S3Control::Endpoints::GetBucketVersioning.build(context)
+          when :get_job_tagging
+            Aws::S3Control::Endpoints::GetJobTagging.build(context)
+          when :get_multi_region_access_point
+            Aws::S3Control::Endpoints::GetMultiRegionAccessPoint.build(context)
+          when :get_multi_region_access_point_policy
+            Aws::S3Control::Endpoints::GetMultiRegionAccessPointPolicy.build(context)
+          when :get_multi_region_access_point_policy_status
+            Aws::S3Control::Endpoints::GetMultiRegionAccessPointPolicyStatus.build(context)
+          when :get_public_access_block
+            Aws::S3Control::Endpoints::GetPublicAccessBlock.build(context)
+          when :get_storage_lens_configuration
+            Aws::S3Control::Endpoints::GetStorageLensConfiguration.build(context)
+          when :get_storage_lens_configuration_tagging
+            Aws::S3Control::Endpoints::GetStorageLensConfigurationTagging.build(context)
+          when :list_access_points
+            Aws::S3Control::Endpoints::ListAccessPoints.build(context)
+          when :list_access_points_for_object_lambda
+            Aws::S3Control::Endpoints::ListAccessPointsForObjectLambda.build(context)
+          when :list_jobs
+            Aws::S3Control::Endpoints::ListJobs.build(context)
+          when :list_multi_region_access_points
+            Aws::S3Control::Endpoints::ListMultiRegionAccessPoints.build(context)
+          when :list_regional_buckets
+            Aws::S3Control::Endpoints::ListRegionalBuckets.build(context)
+          when :list_storage_lens_configurations
+            Aws::S3Control::Endpoints::ListStorageLensConfigurations.build(context)
+          when :put_access_point_configuration_for_object_lambda
+            Aws::S3Control::Endpoints::PutAccessPointConfigurationForObjectLambda.build(context)
+          when :put_access_point_policy
+            Aws::S3Control::Endpoints::PutAccessPointPolicy.build(context)
+          when :put_access_point_policy_for_object_lambda
+            Aws::S3Control::Endpoints::PutAccessPointPolicyForObjectLambda.build(context)
+          when :put_bucket_lifecycle_configuration
+            Aws::S3Control::Endpoints::PutBucketLifecycleConfiguration.build(context)
+          when :put_bucket_policy
+            Aws::S3Control::Endpoints::PutBucketPolicy.build(context)
+          when :put_bucket_tagging
+            Aws::S3Control::Endpoints::PutBucketTagging.build(context)
+          when :put_bucket_versioning
+            Aws::S3Control::Endpoints::PutBucketVersioning.build(context)
+          when :put_job_tagging
+            Aws::S3Control::Endpoints::PutJobTagging.build(context)
+          when :put_multi_region_access_point_policy
+            Aws::S3Control::Endpoints::PutMultiRegionAccessPointPolicy.build(context)
+          when :put_public_access_block
+            Aws::S3Control::Endpoints::PutPublicAccessBlock.build(context)
+          when :put_storage_lens_configuration
+            Aws::S3Control::Endpoints::PutStorageLensConfiguration.build(context)
+          when :put_storage_lens_configuration_tagging
+            Aws::S3Control::Endpoints::PutStorageLensConfigurationTagging.build(context)
+          when :update_job_priority
+            Aws::S3Control::Endpoints::UpdateJobPriority.build(context)
+          when :update_job_status
+            Aws::S3Control::Endpoints::UpdateJobStatus.build(context)
+          end
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(Handler, step: :build, priority: 75)
+      end
+    end
+  end
+end