aws-sdk-rails 4.1.0 → 4.2.0

data/lib/aws/rails/action_mailbox/rspec/subscription_confirmation.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Aws
-  module Rails
-    module ActionMailbox
-      module RSpec
-        # @api private
-        class SubscriptionConfirmation
-          def initialize(authentic: true, topic: 'topic:arn:default')
-            @authentic = authentic
-            @topic = topic
-          end
-
-          def url
-            '/rails/action_mailbox/ses/inbound_emails'
-          end
-
-          def headers
-            { 'content-type' => 'application/json' }
-          end
-
-          def params
-            {
-              'Type' => 'SubscriptionConfirmation',
-              'TopicArn' => @topic,
-              'SubscribeURL' => 'http://example.com/subscribe'
-            }
-          end
-
-          def authentic?
-            @authentic
-          end
-        end
-      end
-    end
-  end
-end

data/lib/aws/rails/action_mailbox/s3_client.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'aws-sdk-s3'
-
-module Aws
-  module Rails
-    module ActionMailbox
-      # @api private
-      class S3Client
-        class << self
-          def client
-            @client ||= build_client
-          end
-
-          private
-
-          def build_client
-            client = Aws::S3::Client.new(
-              **::Rails.configuration.action_mailbox.ses.s3_client_options
-            )
-            client.config.user_agent_frameworks << 'aws-sdk-rails'
-            client
-          end
-        end
-      end
-    end
-  end
-end

data/lib/aws/rails/action_mailbox/sns_message_verifier.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'aws-sdk-sns'
-
-module Aws
-  module Rails
-    module ActionMailbox
-      # @api private
-      class SnsMessageVerifier
-        class << self
-          def verifier
-            @verifier ||= Aws::SNS::MessageVerifier.new
-          end
-        end
-      end
-    end
-  end
-end

data/lib/aws/rails/action_mailbox/sns_notification.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require 'aws-sdk-sns'
-require 'aws/rails/action_mailbox/s3_client'
-require 'aws/rails/action_mailbox/sns_message_verifier'
-
-module Aws
-  module Rails
-    module ActionMailbox
-      # @api private
-      class SnsNotification
-        class MessageContentError < StandardError; end
-
-        def initialize(request_body)
-          @request_body = request_body
-        end
-
-        def subscription_confirmed?
-          (200..299).cover?(confirmation_response.code.to_i)
-        end
-
-        def verified?
-          SnsMessageVerifier.verifier.authentic?(@request_body)
-        end
-
-        def topic
-          notification.fetch(:TopicArn)
-        end
-
-        def type
-          notification.fetch(:Type)
-        end
-
-        def message_content
-          raise MessageContentError, 'Incoming emails must have notificationType `Received`' unless receipt?
-
-          if content_in_s3?
-            s3_content
-          else
-            return message[:content] unless destination
-
-            "X-Original-To: #{destination}\n#{message[:content]}"
-          end
-        end
-
-        private
-
-        def notification
-          @notification ||= JSON.parse(@request_body, symbolize_names: true)
-        rescue JSON::ParserError => e
-          Rails.logger.warn("Unable to parse SNS notification: #{e}")
-          nil
-        end
-
-        def s3_content
-          S3Client
-            .client
-            .get_object(key: key, bucket: bucket)
-            .body
-            .string
-        end
-
-        def message
-          @message ||= JSON.parse(notification[:Message], symbolize_names: true)
-        end
-
-        def destination
-          message.dig(:mail, :destination)&.first
-        end
-
-        def action
-          return unless message[:receipt]
-
-          message.fetch(:receipt).fetch(:action)
-        end
-
-        def bucket
-          action.fetch(:bucketName)
-        end
-
-        def key
-          action.fetch(:objectKey)
-        end
-
-        def content_in_s3?
-          action&.fetch(:type) == 'S3'
-        end
-
-        def receipt?
-          message.fetch(:notificationType) == 'Received'
-        end
-
-        def confirmation_response
-          @confirmation_response ||= Net::HTTP.get_response(URI(notification[:SubscribeURL]))
-        end
-      end
-    end
-  end
-end

data/lib/aws/rails/middleware/ebs_sqs_active_job_middleware.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module Aws
-  module Rails
-    # Middleware to handle requests from the SQS Daemon present on Elastic Beanstalk worker environments.
-    class EbsSqsActiveJobMiddleware
-      INTERNAL_ERROR_MESSAGE = 'Failed to execute job - see Rails log for more details.'
-      INTERNAL_ERROR_RESPONSE = [500, { 'Content-Type' => 'text/plain' }, [INTERNAL_ERROR_MESSAGE]].freeze
-      FORBIDDEN_MESSAGE = 'Request with aws-sqsd user agent was made from untrusted address.'
-      FORBIDDEN_RESPONSE = [403, { 'Content-Type' => 'text/plain' }, [FORBIDDEN_MESSAGE]].freeze
-
-      def initialize(app)
-        @app = app
-        @logger = ::Rails.logger
-      end
-
-      def call(env)
-        request = ActionDispatch::Request.new(env)
-
-        # Pass through unless user agent is the SQS Daemon
-        return @app.call(env) unless from_sqs_daemon?(request)
-
-        @logger.debug('aws-sdk-rails middleware detected call from Elastic Beanstalk SQS Daemon.')
-
-        # Only accept requests from this user agent if it is from localhost or a docker host in case of forgery.
-        unless request.local? || sent_from_docker_host?(request)
-          @logger.warn("SQSD request detected from untrusted address #{request.ip}; returning 403 forbidden.")
-          return FORBIDDEN_RESPONSE
-        end
-
-        # Execute job or periodic task based on HTTP request context
-        periodic_task?(request) ? execute_periodic_task(request) : execute_job(request)
-      end
-
-      private
-
-      def execute_job(request)
-        # Jobs queued from the Active Job SQS adapter contain the JSON message in the request body.
-        job = Aws::Json.load(request.body.string)
-        job_name = job['job_class']
-        @logger.debug("Executing job: #{job_name}")
-
-        begin
-          ActiveJob::Base.execute(job)
-        rescue NoMethodError, NameError => e
-          @logger.error("Job #{job_name} could not resolve to a class that inherits from Active Job.")
-          @logger.error("Error: #{e}")
-          return INTERNAL_ERROR_RESPONSE
-        end
-
-        [200, { 'Content-Type' => 'text/plain' }, ["Successfully ran job #{job_name}."]]
-      end
-
-      def execute_periodic_task(request)
-        # The beanstalk worker SQS Daemon will add the 'X-Aws-Sqsd-Taskname' for periodic tasks set in cron.yaml.
-        job_name = request.headers['X-Aws-Sqsd-Taskname']
-        @logger.debug("Creating and executing periodic task: #{job_name}")
-
-        begin
-          job = job_name.constantize.new
-          job.perform_now
-        rescue NoMethodError, NameError => e
-          @logger.error("Periodic task #{job_name} could not resolve to an Active Job class - check the spelling in cron.yaml.")
-          @logger.error("Error: #{e}.")
-          return INTERNAL_ERROR_RESPONSE
-        end
-
-        [200, { 'Content-Type' => 'text/plain' }, ["Successfully ran periodic task #{job_name}."]]
-      end
-
-      # The beanstalk worker SQS Daemon sets a specific User-Agent headers that begins with 'aws-sqsd'.
-      def from_sqs_daemon?(request)
-        current_user_agent = request.headers['User-Agent']
-
-        !current_user_agent.nil? && current_user_agent.start_with?('aws-sqsd')
-      end
-
-      # The beanstalk worker SQS Daemon will add the custom 'X-Aws-Sqsd-Taskname' header for periodic tasks set in cron.yaml.
-      def periodic_task?(request)
-        !request.headers['X-Aws-Sqsd-Taskname'].nil? && request.headers['X-Aws-Sqsd-Taskname'].present?
-      end
-
-      def sent_from_docker_host?(request)
-        app_runs_in_docker_container? && default_gw_ips.include?(request.ip)
-      end
-
-      def app_runs_in_docker_container?
-        @app_runs_in_docker_container ||= in_docker_container_with_cgroup1? || in_docker_container_with_cgroup2?
-      end
-
-      def in_docker_container_with_cgroup1?
-        File.exist?('/proc/1/cgroup') && File.read('/proc/1/cgroup') =~ %r{/docker/}
-      end
-
-      def in_docker_container_with_cgroup2?
-        File.exist?('/proc/self/mountinfo') && File.read('/proc/self/mountinfo') =~ %r{/docker/containers/}
-      end
-
-      def default_gw_ips
-        default_gw_ips = ['172.17.0.1']
-
-        if File.exist?('/proc/net/route')
-          File.open('/proc/net/route').each_line do |line|
-            fields = line.strip.split
-            next if fields.size != 11
-
-            # Destination == 0.0.0.0 and Flags & RTF_GATEWAY != 0
-            if fields[1] == '00000000' && (fields[3].hex & 0x2) != 0
-              default_gw_ips << IPAddr.new_ntoh([fields[2].hex].pack('L')).to_s
-            end
-          end
-        end
-
-        default_gw_ips
-      end
-    end
-  end
-end

data/lib/aws/rails/ses_mailer.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'aws-sdk-ses'
-
-module Aws
-  module Rails
-    # Provides a delivery method for ActionMailer that uses Amazon Simple Email
-    # Service.
-    #
-    # Once you have an SES delivery method you can configure Rails to
-    # use this for ActionMailer in your environment configuration
-    # (e.g. RAILS_ROOT/config/environments/production.rb)
-    #
-    #     config.action_mailer.delivery_method = :ses
-    #
-    # Uses the AWS SDK for Ruby's credential provider chain when creating an SES
-    # client instance.
-    class SesMailer
-      # @param [Hash] options Passes along initialization options to
-      #   [Aws::SES::Client.new](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SES/Client.html#initialize-instance_method).
-      def initialize(options = {})
-        @client = SES::Client.new(options)
-        @client.config.user_agent_frameworks << 'aws-sdk-rails'
-      end
-
-      # Rails expects this method to exist, and to handle a Mail::Message object
-      # correctly. Called during mail delivery.
-      def deliver!(message)
-        params = {
-          raw_message: { data: message.to_s },
-          source: message.smtp_envelope_from, # defaults to From header
-          destinations: message.smtp_envelope_to # defaults to destinations (To,Cc,Bcc)
-        }
-        @client.send_raw_email(params).tap do |response|
-          message.header[:ses_message_id] = response.message_id
-        end
-      end
-
-      # ActionMailer expects this method to be present and to return a hash.
-      def settings
-        {}
-      end
-    end
-  end
-end
-
-# This is for backwards compatibility after introducing support for SESv2.
-# The old mailer is now replaced with the new SES (v1) mailer.
-Aws::Rails::Mailer = Aws::Rails::SesMailer

data/lib/aws/rails/sesv2_mailer.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'aws-sdk-sesv2'
-
-module Aws
-  module Rails
-    # Provides a delivery method for ActionMailer that uses Amazon Simple Email
-    # Service V2.
-    #
-    # Once you have an SESv2 delivery method you can configure Rails to
-    # use this for ActionMailer in your environment configuration
-    # (e.g. RAILS_ROOT/config/environments/production.rb)
-    #
-    #     config.action_mailer.delivery_method = :sesv2
-    #
-    # Uses the AWS SDK for Ruby's credential provider chain when creating an SESV2
-    # client instance.
-    class Sesv2Mailer
-      # @param [Hash] options Passes along initialization options to
-      #   [Aws::SESV2::Client.new](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SESV2/Client.html#initialize-instance_method).
-      def initialize(options = {})
-        @client = SESV2::Client.new(options)
-        @client.config.user_agent_frameworks << 'aws-sdk-rails'
-      end
-
-      # Rails expects this method to exist, and to handle a Mail::Message object
-      # correctly. Called during mail delivery.
-      def deliver!(message)
-        params = { content: { raw: { data: message.to_s } } }
-        # smtp_envelope_from will default to the From address *without* sender names.
-        # By omitting this param, SESv2 will correctly use sender names from the mail headers.
-        # We should only use smtp_envelope_from when it was explicitly set (instance variable set)
-        params[:from_email_address] = message.smtp_envelope_from if message.instance_variable_get(:@smtp_envelope_from)
-        params[:destination] = {
-          to_addresses: to_addresses(message),
-          cc_addresses: message.cc,
-          bcc_addresses: message.bcc
-        }
-
-        @client.send_email(params).tap do |response|
-          message.header[:ses_message_id] = response.message_id
-        end
-      end
-
-      # ActionMailer expects this method to be present and to return a hash.
-      def settings
-        {}
-      end
-
-      private
-
-      # smtp_envelope_to will default to the full destinations (To, Cc, Bcc)
-      # SES v2 API prefers each component split out into a destination hash.
-      # When smtp_envelope_to was set, use it explicitly for to_address only.
-      def to_addresses(message)
-        message.instance_variable_get(:@smtp_envelope_to) ? message.smtp_envelope_to : message.to
-      end
-    end
-  end
-end

data/lib/aws/rails/sqs_active_job/configuration.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-module Aws
-  module Rails
-    # Configuration for AWS SQS ActiveJob.
-    module SqsActiveJob
-      # Use +Aws::Rails::SqsActiveJob.config+ to access the singleton config instance.
-      class Configuration
-        # Default configuration options
-        # @api private
-        DEFAULTS = {
-          max_messages: 10,
-          shutdown_timeout: 15,
-          retry_standard_errors: true, # TODO: Remove in next MV
-          queues: {},
-          logger: ::Rails.logger,
-          message_group_id: 'SqsActiveJobGroup',
-          excluded_deduplication_keys: ['job_id']
-        }.freeze
-
-        # @api private
-        attr_accessor :queues, :max_messages, :visibility_timeout,
-                      :shutdown_timeout, :client, :logger,
-                      :async_queue_error_handler, :message_group_id
-
-        attr_reader :excluded_deduplication_keys
-
-        # Don't use this method directly: Configuration is a singleton class, use
-        # +Aws::Rails::SqsActiveJob.config+ to access the singleton config.
-        #
-        # @param [Hash] options
-        # @option options [Hash[Symbol, String]] :queues A mapping between the
-        #   active job queue name and the SQS Queue URL. Note: multiple active
-        #   job queues can map to the same SQS Queue URL.
-        #
-        # @option options  [Integer] :max_messages
-        #    The max number of messages to poll for in a batch.
-        #
-        # @option options [Integer] :visibility_timeout
-        #   If unset, the visibility timeout configured on the
-        #   SQS queue will be used.
-        #   The visibility timeout is the number of seconds
-        #   that a message will not be processable by any other consumers.
-        #   You should set this value to be longer than your expected job runtime
-        #   to prevent other processes from picking up an running job.
-        #   See the (SQS Visibility Timeout Documentation)[https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html]
-        #
-        # @option options [Integer] :shutdown_timeout
-        #   the amount of time to wait
-        #   for a clean shutdown.  Jobs that are unable to complete in this time
-        #   will not be deleted from the SQS queue and will be retryable after
-        #   the visibility timeout.
-        #
-        # @ option options [Boolean] :retry_standard_errors
-        #   If `true`, StandardErrors raised by ActiveJobs are left on the queue
-        #   and will be retried (pending the SQS Queue's redrive/DLQ/maximum receive settings).
-        #   This behavior overrides the standard Rails ActiveJob
-        #   [Retry/Discard for failed jobs](https://guides.rubyonrails.org/active_job_basics.html#retrying-or-discarding-failed-jobs)
-        #   behavior.  When set to `true` the retries provided by this will be
-        #   on top of any retries configured on the job with `retry_on`.
-        #   When `false`, retry behavior is fully configured
-        #   through `retry_on`/`discard_on` on the ActiveJobs.
-        #
-        # @option options [ActiveSupport::Logger] :logger Logger to use
-        #   for the poller.
-        #
-        # @option options [String] :config_file
-        #   Override file to load configuration from. If not specified will
-        #   attempt to load from config/aws_sqs_active_job.yml.
-        #
-        # @option options [String] :message_group_id (SqsActiveJobGroup)
-        #  The message_group_id to use for queueing messages on a fifo queues.
-        #  Applies only to jobs queued on FIFO queues.
-        #  See the (SQS FIFO Documentation)[https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html]
-        #
-        # @option options [Callable] :async_queue_error_handler An error handler
-        #   to be called when the async active job adapter experiances an error
-        #   queueing a job.  Only applies when
-        #   +active_job.queue_adapter = :sqs_async+.  Called with:
-        #   [error, job, job_options]
-        #
-        # @option options [SQS::Client] :client SQS Client to use. A default
-        #   client will be created if none is provided.
-        #
-        # @option options [Array] :excluded_deduplication_keys (['job_id'])
-        #   The type of keys stored in the array should be String or Symbol.
-        #   Using this option, job_id is implicitly added to the keys.
-
-        def initialize(options = {})
-          options[:config_file] ||= config_file if File.exist?(config_file)
-          options = DEFAULTS
-                    .merge(file_options(options))
-                    .merge(options)
-          set_attributes(options)
-        end
-
-        def excluded_deduplication_keys=(keys)
-          @excluded_deduplication_keys = keys.map(&:to_s) | ['job_id']
-        end
-
-        def client
-          @client ||= begin
-            client = Aws::SQS::Client.new
-            client.config.user_agent_frameworks << 'aws-sdk-rails'
-            client
-          end
-        end
-
-        # Return the queue_url for a given job_queue name
-        def queue_url_for(job_queue)
-          job_queue = job_queue.to_sym
-          raise ArgumentError, "No queue defined for #{job_queue}" unless queues.key? job_queue
-
-          queues[job_queue]
-        end
-
-        # @api private
-        def to_s
-          to_h.to_s
-        end
-
-        # @api private
-        def to_h
-          h = {}
-          instance_variables.each do |v|
-            v_sym = v.to_s.delete('@').to_sym
-            val = instance_variable_get(v)
-            h[v_sym] = val
-          end
-          h
-        end
-
-        private
-
-        # Set accessible attributes after merged options.
-        def set_attributes(options)
-          options.each_key do |opt_name|
-            instance_variable_set("@#{opt_name}", options[opt_name])
-            client.config.user_agent_frameworks << 'aws-sdk-rails' if opt_name == :client
-          end
-        end
-
-        def file_options(options = {})
-          file_path = config_file_path(options)
-          if file_path
-            load_from_file(file_path)
-          else
-            {}
-          end
-        end
-
-        def config_file
-          file = ::Rails.root.join("config/aws_sqs_active_job/#{::Rails.env}.yml")
-          file = ::Rails.root.join('config/aws_sqs_active_job.yml') unless File.exist?(file)
-          file
-        end
-
-        # Load options from YAML file
-        def load_from_file(file_path)
-          opts = load_yaml(file_path) || {}
-          opts.deep_symbolize_keys
-        end
-
-        # @return [String] Configuration path found in environment or YAML file.
-        def config_file_path(options)
-          options[:config_file] || ENV.fetch('AWS_SQS_ACTIVE_JOB_CONFIG_FILE', nil)
-        end
-
-        def load_yaml(file_path)
-          require 'erb'
-          source = ERB.new(File.read(file_path)).result
-
-          # Avoid incompatible changes with Psych 4.0.0
-          # https://bugs.ruby-lang.org/issues/17866
-          begin
-            YAML.safe_load(source, aliases: true) || {}
-          rescue ArgumentError
-            YAML.safe_load(source) || {}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/aws/rails/sqs_active_job/deduplication.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Aws
-  module Rails
-    # SQS ActiveJob modules
-    module SqsActiveJob
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :excluded_deduplication_keys
-      end
-
-      # class methods for SQS ActiveJob.
-      module ClassMethods
-        def deduplicate_without(*keys)
-          self.excluded_deduplication_keys = keys.map(&:to_s) | ['job_id']
-        end
-      end
-    end
-  end
-end

data/lib/aws/rails/sqs_active_job/executor.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module Aws
-  module Rails
-    module SqsActiveJob
-      # CLI runner for polling for SQS ActiveJobs
-      class Executor
-        DEFAULTS = {
-          min_threads: 0,
-          max_threads: Integer(Concurrent.available_processor_count || Concurrent.processor_count),
-          auto_terminate: true,
-          idletime: 60, # 1 minute
-          fallback_policy: :abort # Concurrent::RejectedExecutionError must be handled
-        }.freeze
-
-        def initialize(options = {})
-          @executor = Concurrent::ThreadPoolExecutor.new(DEFAULTS.merge(options))
-          @retry_standard_errors = options[:retry_standard_errors]
-          @logger = options[:logger] || ActiveSupport::Logger.new($stdout)
-          @task_complete = Concurrent::Event.new
-        end
-
-        def execute(message)
-          post_task(message)
-        rescue Concurrent::RejectedExecutionError
-          # no capacity, wait for a task to complete
-          @task_complete.reset
-          @task_complete.wait
-          retry
-        end
-
-        def shutdown(timeout = nil)
-          @executor.shutdown
-          clean_shutdown = @executor.wait_for_termination(timeout)
-          if clean_shutdown
-            @logger.info 'Clean shutdown complete.  All executing jobs finished.'
-          else
-            @logger.info "Timeout (#{timeout}) exceeded.  Some jobs may not have " \
-                         'finished cleanly.  Unfinished jobs will not be removed from ' \
-                         'the queue and can be ru-run once their visibility timeout ' \
-                         'passes.'
-          end
-        end
-
-        private
-
-        def post_task(message)
-          @executor.post(message) do |message|
-            job = JobRunner.new(message)
-            @logger.info("Running job: #{job.id}[#{job.class_name}]")
-            job.run
-            message.delete
-          rescue Aws::Json::ParseError => e
-            @logger.error "Unable to parse message body: #{message.data.body}. Error: #{e}."
-          rescue StandardError => e
-            job_msg = job ? "#{job.id}[#{job.class_name}]" : 'unknown job'
-            @logger.info "Error processing job #{job_msg}: #{e}"
-            @logger.debug e.backtrace.join("\n")
-
-            if @retry_standard_errors && !job.exception_executions?
-              @logger.info(
-                'retry_standard_errors is enabled and job has not ' \
-                "been retried by Rails.  Leaving #{job_msg} in the queue."
-              )
-            else
-              message.delete
-            end
-          ensure
-            @task_complete.set
-          end
-        end
-      end
-    end
-  end
-end