ar_mailer_aws 0.0.4 → 0.1.0

data/lib/ar_mailer_aws/clients/mandrill.rb

@@ -0,0 +1,53 @@
+require 'mandrill'
+require 'mandrill/api'
+require 'mail'
+
+module ArMailerAWS
+  module Clients
+    class Mandrill < Base
+
+      REJECT_HEADERS = ['From', 'To', 'Subject']
+
+      def initialize(options={})
+        super
+        @service = ::Mandrill::API.new settings[:key]
+      end
+
+      def send_emails(emails)
+        emails.each do |email|
+          return if exceed_quota?
+          begin
+            check_rate
+            send_email(email)
+          rescue => e
+            handle_email_error(e, email)
+          end
+        end
+      end
+
+      def send_email(email)
+        log "send email to #{email.to}"
+        email_json_hash = email_json(email)
+        client_log email_json_hash, :debug
+        resp = @service.messages.send email_json_hash
+        client_log resp, :debug
+        email.destroy
+        @sent_count += 1
+      end
+
+      def email_json(email)
+        mail = Mail.new(email.mail)
+        headers = mail.header.reject{|h| REJECT_HEADERS.include?(h.name) }.map { |h| [h.name, h.value] }.to_hash
+        {
+            'subject' => mail.subject.to_s.force_encoding('UTF-8'),
+            'html' => mail.body.to_s.force_encoding('UTF-8'),
+            'headers' => headers,
+            'from_email' => email.from,
+            'track_opens' => false,
+            'track_clicks' => false,
+            'to' => [{'email' => email.to, 'type' => 'to'}]
+        }
+      end
+    end
+  end
+end

data/lib/ar_mailer_aws/clients/smtp.rb

@@ -0,0 +1,45 @@
+require 'net/smtp'
+
+module ArMailerAWS
+  module Clients
+    class SMTP < Base
+
+      def send_emails(emails)
+        session = Net::SMTP.new(settings[:address], settings[:port])
+        session.enable_starttls_auto if settings[:enable_starttls_auto]
+        begin
+          session.start(settings[:domain], settings[:user_name], settings[:password], settings[:authentication]) do |smtp|
+            emails.each do |email|
+              begin
+                break if exceed_quota?
+                send_email(smtp, email)
+              rescue Net::SMTPFatalError => e
+                handle_email_error(e, email, email_error: true)
+                session.reset
+              rescue Net::SMTPServerBusy
+                log 'server too busy, stopping delivery cycle'
+                return
+              rescue Net::SMTPUnknownError, Net::SMTPSyntaxError, TimeoutError, Timeout::Error => e
+                handle_email_error(e, email, email_error: true)
+                session.reset
+              rescue => e
+                handle_email_error(e, email)
+              end
+            end
+          end
+        rescue => e
+          log "ERROR in SMTP session: #{e.message}\n   #{e.backtrace.join("\n   ")}", :error
+          ArMailerAWS.error_proc.call(nil, e) if ArMailerAWS.error_proc
+        end
+      end
+
+      def send_email(smtp, email)
+        log "send email to #{email.to}"
+        client_log smtp.send_message(email.mail, email.from, email.to)
+        email.destroy
+        @sent_count += 1
+      end
+
+    end
+  end
+end

data/lib/ar_mailer_aws/options_parser.rb

@@ -0,0 +1,107 @@
+module ArMailerAWS
+  class OptionsParser
+
+    def self.parse_options(all_args)
+      start_i = all_args.index('--').try(:succ) || 0
+      args = all_args[start_i..-1]
+      new(args).parse
+    end
+
+    def initialize(args)
+      @args = args
+      @options = OpenStruct.new
+    end
+
+    def parse
+      option_parser.parse!(@args)
+      @options
+    end
+
+    def option_parser
+      OptionParser.new do |opts|
+        @options.batch_size = 100
+        @options.delay = 180
+        @options.quota = 10_000
+        @options.rate = 5
+        @options.max_age = 3600 * 24 * 7
+        @options.max_attempts = 5
+
+        opts.banner = <<-TXT.strip_heredoc
+          Usage: ar_mailer_aws <command> <options> -- <application options>
+
+          * where <command> is one of:
+            start         start an instance of the application
+            stop          stop all instances of the application
+            restart       stop all instances and restart them afterwards
+            reload        send a SIGHUP to all instances of the application
+            run           start the application and stay on top
+            zap           set the application to a stopped state
+            status        show status (PID) of application instances
+
+          * where <options> may contain several of the following:
+
+              -t, --ontop                      Stay on top (does not daemonize)
+              -f, --force                      Force operation
+              -n, --no_wait                    Do not wait for processes to stop
+
+          * and where <application options> may contain several of the following:
+
+        TXT
+
+        opts.on('-b', '--batch-size BATCH_SIZE', 'Maximum number of emails to send per delay',
+                "Default: #{@options.batch_size}", Integer) do |batch_size|
+          @options.batch_size = batch_size
+        end
+
+        opts.on('-d', '--delay DELAY', 'Delay between checks for new mail in the database',
+                "Default: #{@options.delay}", Integer) do |delay|
+          @options.delay = delay
+        end
+
+        opts.on('-q', '--quota QUOTA', 'Daily quota for sending emails', "Default: #{@options.quota}", Integer) do |quota|
+          @options.quota = quota
+        end
+
+        opts.on('-r', '--rate RATE', 'Maximum number of emails send per second',
+                "Default: #{@options.rate}", Integer) do |rate|
+          @options.rate = rate
+        end
+
+        opts.on('-a', '--max-attempts MAX_ATTEMPTS',
+                'Maximum attempts count for an email.',
+                'After this it will be removed from the queue.',
+                'Set to 0 to disable queue cleanup.',
+                "Default: #{@options.max_attempts}", Integer) do |max_attempts|
+          @options.max_attempts = max_attempts
+        end
+
+        opts.on('-m', '--max-age MAX_AGE',
+                'Maximum age for an email. After this',
+                'it will be removed from the queue.',
+                'Set to 0 to disable queue cleanup.',
+                "Default: #{@options.max_age} seconds", Integer) do |max_age|
+          @options.max_age = max_age
+        end
+
+        opts.on('-p', '--pid-dir DIRECTORY', 'Directory for storing pid file',
+                'Default: Stored in current directory (named `ar_mailer_aws.pid`)') do |pid_dir|
+          @options.pid_dir = pid_dir
+        end
+
+        opts.on('--app-name APP_NAME', 'Name for the daemon app',
+                'Default: ar_mailer_aws') do |app_name|
+          @options.app_name = app_name
+        end
+
+        opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+          @options.verbose = v
+        end
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/ar_mailer_aws/version.rb

@@ -1,3 +1,3 @@
 module ArMailerAWS
-  VERSION = '0.0.4'
+  VERSION = '0.1.0'
 end

data/lib/generators/ar_mailer_aws/templates/ar_mailer_aws.rb

@@ -1,10 +1,50 @@
+# Your system wide Amazon config
 AWS.config(
     :access_key_id => 'YOUR_ACCESS_KEY_ID',
     :secret_access_key => 'YOUR_SECRET_ACCESS_KEY'
 )
 
+ArMailerAWS.setup do |config|
+  # Current delivery method
+  config.client = :amazon_ses
+
+  # Delivery method client log i.e. smtp, amazon, mandrill
+  # config.client_logger = Logger.new('path/to/log/file')
+
+  # Configure your delivery method client
+  config.client_config = {
+      # Amazon SES config, system wide config will be used if not defined
+      # amazon_ses: {
+      #     access_key_id: 'YOUR_ACCESS_KEY_ID',
+      #     secret_access_key: 'YOUR_SECRET_ACCESS_KEY',
+      #     log_level: :debug
+      #     #region: 'eu-west-1',
+      # },
+
+      # Mandrill config
+      # mandrill: {
+      #     key: 'YOUR_MANDRILL_KEY'
+      # },
+
+      # Your smtp config, just like rails `smtp_settings`
+      # smtp: Rails.application.config.action_mailer.smtp_settings
+  }
+
+  # `ar_mailer_aws` logger i.e. mailer daemon
+  #config.logger = Logger.new('path/to/log/file')
+
+  # Error notification handler
+  #config.error_proc = lambda do |email, exception|
+  #  ExceptionNotifier.notify_exception(exception, data: {email: email.try(:attributes)})
+  #end
+
+  # batch email class
 <% if class_name != 'BatchEmail' -%>
-ArMailerAWS.email_class = '<%= class_name %>'
+  email_class = '<%= class_name %>'
+<% else -%>
+  # email_class = 'BatchEmail'
 <% end -%>
+end
 
-#ActionMailer::Base.delivery_method = :ar_mailer_aws
+# Set as default delivery method
+# ActionMailer::Base.delivery_method = :ar_mailer_aws

data/lib/generators/ar_mailer_aws/templates/migration.rb

@@ -4,6 +4,7 @@ class <%= migration_class_name.gsub(/::/, '') %> < ActiveRecord::Migration
       t.string :from
       t.string :to
       t.text :mail, limit: 16777215
+      t.integer :send_attempts_count, default: 0
       t.datetime :last_send_attempt_at
       t.datetime :created_at
     end

data/spec/ar_mailer_aws/ar_mailer_aws_spec.rb

@@ -4,18 +4,19 @@ describe ArMailerAWS do
 
   it 'setup yields ArMailerAWS' do
     ArMailerAWS.setup do |config|
-      config.should == ArMailerAWS
+      expect(config).to eq ArMailerAWS
     end
   end
 
-  describe '#run', focus: true do
+  describe '#run' do
     before do
-      @sender = ArMailerAWS::Sender.new(delay: 1)
-      ArMailerAWS::Sender.stub(:new).and_return(@sender)
+      allow(ArMailerAWS).to receive(:client_config).and_return({amazon_ses: {}})
+      @client = ArMailerAWS::Clients::AmazonSES.new(delay: 1)
+      allow(ArMailerAWS::Clients::AmazonSES).to receive(:new).and_return(@client)
     end
 
     it 'run sender' do
-      @sender.should_receive(:send_batch).twice
+      expect(@client).to receive(:send_batch).twice
       begin
         Timeout::timeout(1.5) do
           ArMailerAWS.run({})
@@ -23,6 +24,42 @@ describe ArMailerAWS do
       rescue Timeout::Error
       end
     end
+  end
+
+  describe '#find_client_klass' do
+    context 'option as Symbol' do
+      it 'resolve symbol to class' do
+        allow(ArMailerAWS).to receive(:client).and_return(:smtp)
+        expect(ArMailerAWS.find_client_klass).to eq ArMailerAWS::Clients::SMTP
+      end
+
+      it 'resolve symbol to class 2' do
+        allow(ArMailerAWS).to receive(:client).and_return(:amazon_ses)
+        expect(ArMailerAWS.find_client_klass).to eq ArMailerAWS::Clients::AmazonSES
+      end
+    end
+
+    context 'option as Class' do
+      before do
+        allow(ArMailerAWS).to receive(:client).and_return(Object)
+      end
 
+      it 'return direct value' do
+        expect(ArMailerAWS.find_client_klass).to eq Object
+      end
+    end
+
+    context 'resolve from client_config' do
+      it 'resolve symbol to class' do
+        allow(ArMailerAWS).to receive(:client_config).and_return({smtp: {}})
+        expect(ArMailerAWS.find_client_klass).to eq ArMailerAWS::Clients::SMTP
+      end
+
+      it 'resolve symbol to class 2' do
+        allow(ArMailerAWS).to receive(:client_config).and_return({amazon_ses: {}})
+        expect(ArMailerAWS.find_client_klass).to eq ArMailerAWS::Clients::AmazonSES
+      end
+    end
   end
+
 end

data/spec/ar_mailer_aws/clients/amazon_ses_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+def create_email(options={})
+  BatchEmail.create!({from: 'from@example.com', to: 'to@example.com', mail: 'email content'}.update(options))
+end
+
+describe ArMailerAWS::Clients::AmazonSES do
+
+  it 'supply ses options to AWS::SimpleEmailService initializer' do
+    ArMailerAWS.client_config = {amazon_ses: {a: 1}}
+    expect(AWS::SimpleEmailService).to receive(:new).with({a: 1})
+    ArMailerAWS::Clients::AmazonSES.new
+  end
+
+  context 'sending' do
+    before do
+      BatchEmail.delete_all
+    end
+
+    describe '#send_emails' do
+      before do
+        @client = ArMailerAWS::Clients::AmazonSES.new(quota: 100)
+        allow(@client.service).to receive(:send_raw_email)
+        allow(@client.service).to receive(:quotas).and_return({sent_last_24_hours: 0})
+      end
+
+      context 'success' do
+        it 'send email via ses' do
+          2.times { create_email }
+          expect(@client.service).to receive(:send_raw_email).twice
+          @client.send_emails(@client.model.all)
+        end
+
+        it 'remove sent emails' do
+          2.times { create_email }
+          expect {
+            @client.send_emails(@client.model.all)
+          }.to change { @client.model.count }.from(2).to(0)
+        end
+      end
+
+      context 'error' do
+        it 'call error_proc' do
+          email = create_email
+          exception = StandardError.new
+          ArMailerAWS.error_proc = proc {}
+          expect(ArMailerAWS.error_proc).to receive(:call).with(email, exception)
+          expect(@client.service).to receive(:send_raw_email).and_raise(exception)
+          @client.send_emails([email])
+        end
+
+        it 'update last_send_attempt_at column' do
+          email = create_email
+          exception = StandardError.new
+          expect(@client.service).to receive(:send_raw_email).and_raise(exception)
+          @client.send_emails([email])
+          expect(email.reload.last_send_attempt_at).not_to be_nil
+        end
+      end
+
+      context 'rate' do
+        it 'call not more the rate times per second' do
+          5.times { create_email }
+          @client.options.rate = 2
+          expect(@client.service).to receive(:send_raw_email).twice
+          begin
+            Timeout::timeout(1) do
+              @client.send_emails(@client.model.all)
+            end
+          rescue Timeout::Error
+          end
+        end
+      end
+
+      context 'quota' do
+        it 'not exceed quota' do
+          10.times { create_email }
+          @client.options.quota = 5
+          expect {
+            @client.send_emails(@client.model.all)
+          }.to change { @client.model.count }.by(-5)
+        end
+
+        it 'consider sent_last_24_hours from ses' do
+          10.times { create_email }
+          allow(@client.service).to receive(:quotas).and_return({sent_last_24_hours: 10})
+          @client.options.quota = 15
+          expect {
+            @client.send_emails(@client.model.all)
+          }.to change { @client.model.count }.by(-5)
+        end
+      end
+    end
+
+  end
+end

data/spec/ar_mailer_aws/clients/base_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+def create_email(options={})
+  BatchEmail.create!({from: 'from@example.com', to: 'to@example.com', mail: 'email content'}.update(options))
+end
+
+describe ArMailerAWS::Clients::Base do
+
+  it 'convert Hash options to OpenStruct' do
+    client = ArMailerAWS::Clients::Base.new
+    expect(client.options.class.name).to eq 'OpenStruct'
+  end
+
+  it 'get default emails model' do
+    expect(ArMailerAWS::Clients::Base.new.model.name).to eq 'BatchEmail'
+  end
+
+  context 'sending' do
+    before do
+      BatchEmail.delete_all
+    end
+
+    describe '#find_emails' do
+      it 'batch_size emails' do
+        5.times { create_email }
+        @client = ArMailerAWS::Clients::Base.new(batch_size: 3)
+        expect(@client.find_emails.length).to eq 3
+      end
+
+      it 'ignore emails last_send_attempt_at < 300 seconds ago' do
+        2.times { create_email }
+        2.times { create_email(last_send_attempt_at: Time.now - 100) }
+        @client = ArMailerAWS::Clients::Base.new(batch_size: 3)
+        expect(@client.find_emails.length).to eq 2
+      end
+    end
+
+    describe '#cleanup' do
+      it 'do nothing if max_age zero and max_attempts zero' do
+        @client = ArMailerAWS::Clients::Base.new(max_age: 0, max_attempts: 0)
+        expect(@client.model).not_to receive(:where)
+        @client.cleanup
+      end
+
+      it 'remove emails with last_send_attempt_at and create_at greater then max_age' do
+        2.times { create_email }
+        2.times { create_email(last_send_attempt_at: Time.now, created_at: Time.now - 4000) }
+
+        @client = ArMailerAWS::Clients::Base.new(max_age: 3600)
+        expect {
+          @client.cleanup
+        }.to change { @client.model.count }.from(4).to(2)
+      end
+
+      it 'remove emails with send_attempts_count greater then max_attempts' do
+        2.times { create_email }
+        2.times { create_email(send_attempts_count: 11) }
+
+        @client = ArMailerAWS::Clients::Base.new(max_attempts: 10)
+        expect { @client.cleanup }.to change { @client.model.count }.from(4).to(2)
+      end
+    end
+
+    describe '#send_emails' do
+      it 'raise not implemented error' do
+        expect{ ArMailerAWS::Clients::Base.new.send_emails([]) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#send_batch' do
+      before do
+        @client = ArMailerAWS::Clients::Base.new
+        allow(@client).to receive(:send_emails)
+      end
+
+      it 'no pending emails' do
+        expect(@client).to receive(:cleanup)
+        expect(@client).to receive(:find_emails).and_return([])
+        expect(@client).not_to receive(:send_emails)
+        @client.send_batch
+      end
+
+      it 'no pending emails' do
+        expect(@client).to receive(:find_emails).and_return([create_email])
+        expect(@client).to receive(:send_emails)
+        @client.send_batch
+      end
+    end
+
+  end
+end