tuktuk 0.6.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9b23aad601ecb20c8e9f2a61ca0c5d8740fe08fb
-  data.tar.gz: ccd26989dcc9cf8ea0cd124bc117cd8aa4ebe337
+SHA256:
+  metadata.gz: 94130469fa773ef26742e1811c40e3dcf6898acf537439470c72c1341cf555c8
+  data.tar.gz: 215936b8fe1b176a642f1c77f04f282f6df1f31e66381b62db09963c81a16044
 SHA512:
-  metadata.gz: 573938ae9b56c2fea03e8cf19ae133b298e146232813b022ee2cc17e275e68cf98a353e4863eec720da3a898a7e78d3ba59926963db846bc02f215cb87eaf92f
-  data.tar.gz: 0fb02b910a04a3f0e2472e7e65264add4eed11cc12a46f68b3a1adf820f9ff615392d24a65831da98aafa95f0a909d828f68454192111706aad905ee5fc487a1
+  metadata.gz: 7f8907098711e0e7447165913bf300f956cf72b192f9458f7d6e4b7a2560f2aef12bbe784c9b27cd017d294cb4d4e005a61e595f816148012ee48ce015e51639
+  data.tar.gz: 9f08addb37fd31f1dd1226377746053e424c3386f6a51fcd1e2eff28beb4e786fb603a259877112bd3e23474395780a1a5ec394dc27650058183ac97bce7369d

data/.github/workflows/ruby.yml

@@ -0,0 +1,19 @@
+name: Ruby
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        gem install rspec
+        bundle install --jobs 4 --retry 3
+        rspec

data/README.md

@@ -193,6 +193,49 @@ config.action_mailer.tuktuk_settings = {
 }
 ```
 
+# Example SPK/DKIM/DMARC settings
+
+If you're sending email from yoursite.com, the SPF record should be set for the APEX/root host, and look like this:
+
+    v=spf1 ip4:[ipv4_address] ip6:[ipv6_address] mx a include:[other_host] ~all 
+
+For example:
+
+    v=spf1 ip4:12.34.56.78 ip6:2600:3c05::f07c:92ff:fe48:b2fd mx a include:mailgun.org ~all 
+
+This tells the receiving server to accept email sent from a) the addresses explicitly mentioned (`ip4` and `ip6`), 
+b) from the hosts mentioned in the `include` statements, as well as c) the hosts listed as `MX` and `A` records for that domain.
+
+As for DKIM, you should add two TXT records. The first is a simple, short one that goes under the `_domainkey` host, 
+and should contain the following:
+
+    t=y;o=~;
+
+Then, a second DKIM record should be placed under `[selector]._domainkey` (e.g. `mailer._domainkey`), and should look like this:
+
+    k=rsa; p=MIIBIBANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA[...]DAQAB (public key)
+    
+And finally, your DMARC record goes under the `_dmarc` host, and goes like this:
+
+    v=DMARC1; p=none; rua=mailto:postmaster@yoursite.com; ruf=mailto:postmaster@yoursite.com
+
+So, in summary:
+
+    (SPF)   @.yoursite.com                     --> v=spf1 ip4:[ipv4_address] ip6:[ipv6_address] mx a include:[other_host] ~all 
+    (DKIM1) _domainkey.yoursite.com            --> t=y;o=~;
+    (DKIM2) [selector]._domainkey.yoursite.com --> k=rsa; p=MIIBIBANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA[...]DAQAB
+    (DMARC) _dmarc.yoursite.com                --> v=DMARC1; p=none; rua=mailto:postmaster@yoursite.com; ruf=mailto:postmaster@yoursite.com
+
+Now, to check wether your records are OK, you can use the `dig` command like follows:
+
+    dig yoursite.com TXT +short # should output the SPF record, under the root domain
+    dig mailer._domainkey.yoursite.com TXT +short # should output the DKIM record containing the key
+    dig _domainkey.yoursite.com TXT +short # should output the other (short) DKIM 
+    dig _dmarc.yoursite.com TXT +short # should output the DMARC record
+    
+Remember you can query your DNS server directly with the `dig` command by adding `@name.server.com` 
+after the `dig` command (e.g. `dig @ns1.linode.com yoursite.com TXT`).
+
 # Contributions
 
 You're more than welcome. Send a pull request, including tests, and make sure you don't break anything. That's it.

data/lib/tuktuk/tuktuk.rb

@@ -20,6 +20,16 @@ DEFAULTS = {
   :log_to       => nil # $stdout,
 }
 
+# overwrite Net::SMTP#quit since the connection might have been closed
+# before we got a chance to say goodbye. swallow the error in that case.
+class Net::SMTP
+  def quit
+    getok('QUIT')
+  rescue EOFError => e
+    # nil
+  end
+end
+
 module Tuktuk
 
   class << self
@@ -30,16 +40,19 @@ module Tuktuk
 
     def deliver(message, opts = {})
       # raise 'Please pass a valid message object.' unless message[:to]
+      bcc = opts.delete(:bcc) || []
+      bcc = [bcc] if bcc.is_a?(String)
+
       self.options = opts if opts.any?
       mail = Package.build(message)
-      response = lookup_and_deliver(mail)
+      response = lookup_and_deliver(mail, bcc)
       return response, mail
     end
 
     # same as deliver but raises error. used by ActionMailer
-    def deliver!(mail)
+    def deliver!(mail, opts = {})
       @logger = Rails.logger if defined?(Rails) and !config[:log_to]
-      resp, email = deliver(mail)
+      resp, email = deliver(mail, opts)
       if resp.is_a?(Exception)
         raise resp
       else
@@ -89,7 +102,9 @@ module Tuktuk
       hash = {}
       array.each_with_index do |message, i|
         mail = Package.build(message, i)
-        raise "Invalid destination count: #{mail.destinations.count}" if mail.destinations.count != 1
+        if mail.destinations.count != 1
+          raise ArgumentError, "Invalid destination count: #{mail.destinations.count}"
+        end
 
         if to = mail.destinations.first and domain = get_domain(to)
           domain = domain.downcase
@@ -109,7 +124,7 @@ module Tuktuk
       servers.any? && servers
     end
 
-    def lookup_and_deliver(mail, attempt = 1)
+    def lookup_and_deliver(mail, bcc = [])
       if mail.destinations.empty?
         raise "No destinations found! You need to pass a :to field."
       end
@@ -127,9 +142,10 @@ module Tuktuk
         last_error = nil
         servers.each do |server|
           begin
-            response = send_now(mail, server, to)
+            response = send_now(mail, server, to, bcc)
             break
           rescue Exception => e # explicitly rescue Exception so we catch Timeout:Error's too
+            logger.error "Error: #{e}"
             last_error = e
           end
         end
@@ -210,14 +226,15 @@ module Tuktuk
       responses
     end
 
-    def send_now(mail, server, to)
+    def send_now(mail, server, to, bcc = [])
       logger.info "#{to} - Delivering email at #{server}..."
+      logger.info "Including these destinations: #{bcc.inspect}" if bcc && bcc.any?
       from = get_from(mail)
 
       response = nil
       socket = init_connection(server)
       socket.start(get_helo_domain(from), nil, nil, nil) do |smtp|
-        response = smtp.send_message(get_raw_mail(mail), from, to)
+        response = smtp.send_message(get_raw_mail(mail), from, to, *bcc)
         logger.info "#{to} - [SENT] #{response.message.strip}"
       end
 
@@ -234,7 +251,7 @@ module Tuktuk
           begin
             resp = smtp.send_message(get_raw_mail(mail), get_from(mail), mail.to)
             smtp.send(:getok, 'RSET') if server['hotmail'] # fix for '503 Sender already specified'
-          rescue Net::SMTPFatalError => e # error code 5xx, except for 500, like: 550 Mailbox not found
+          rescue Net::SMTPFatalError, Net::SMTPServerBusy => e # error code 5xx, except for 500, like: 550 Mailbox not found
             resp = Bounce.type(e)
           end
           responses[mail] = resp
@@ -243,8 +260,8 @@ module Tuktuk
       end
 
       responses
-    rescue => e # SMTPServerBusy, SMTPSyntaxError, SMTPUnsupportedCommand, SMTPUnknownError (unexpected reply code)
-      logger.error "[SERVER ERROR: #{server}] #{e.message}"
+    rescue Exception => e # SMTPServerBusy, SMTPSyntaxError, SMTPUnsupportedCommand, SMTPUnknownError (unexpected reply code)
+      logger.error "[SERVER ERROR: #{server}] #{e.class} -> #{e.message}"
       @last_error = e
       responses
     end

data/lib/tuktuk/version.rb

@@ -1,7 +1,7 @@
 module Tuktuk
   MAJOR = 0
-  MINOR = 6
-  PATCH = 3
+  MINOR = 8
+  PATCH = 0
 
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/spec/deliver_spec.rb

@@ -1,8 +1,142 @@
 require './lib/tuktuk/tuktuk'
 require 'rspec/mocks'
 
+def email(attrs = {})
+  { :to => "user#{rand(1000)}@domain.com",
+    :from => 'me@company.com',
+    :subject => 'Test email',
+    :body => 'Hello world.'
+  }.merge(attrs)
+end
+
 describe 'deliver' do
 
+  before(:each) do
+    @mock_smtp = double('Net::SMTP', enable_starttls_auto: true, :read_timeout= => true, :open_timeout= => true)
+    @mock_conn = double('SMTP Connection')
+    @mock_smtp.stub(:start).and_yield(@mock_conn)
+    @mock_resp = double('SMTP::Response', message: '250 OK')
+
+    Net::SMTP.stub(:new).and_return(@mock_smtp)
+  end
+
+  describe 'single recipient' do
+
+    describe 'when destination is valid (has MX servers)' do
+
+      before do
+        @servers = ['mx1.domain.com', 'mx2.domain.com', 'mx3.domain.com']
+        Tuktuk.stub(:smtp_servers_for_domain).and_return(@servers)
+      end
+
+      it 'sends message' do
+        msg = email
+        expect(@mock_conn).to receive(:send_message).with(String, msg[:from], msg[:to]).and_return(@mock_resp)
+        Tuktuk.deliver(msg)
+      end
+
+      describe 'and bcc is given' do
+
+        let(:bcc_email) { 'bcc@test.com' }
+
+        it 'includes it in destination list' do
+          msg = email
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to], bcc_email).and_return(@mock_resp)
+          Tuktuk.deliver(msg, bcc: [bcc_email])
+        end
+
+        it 'also works if not passed as array' do
+          msg = email
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to], bcc_email).and_return(@mock_resp)
+          Tuktuk.deliver(msg, bcc: bcc_email)
+        end
+
+      end
+
+    end
+
+  end
+
+  describe 'multiple recipients (string list)' do
+
+    describe 'when destination is valid (has MX servers)' do
+
+      before do
+        @servers = ['mx1.domain.com', 'mx2.domain.com', 'mx3.domain.com']
+        Tuktuk.stub(:smtp_servers_for_domain).and_return(@servers)
+      end
+
+      it 'sends message' do
+        msg = email(to: 'some@one.com, another@one.com')
+        expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].split(', ').first).and_return(@mock_resp)
+        expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].split(', ').last).and_return(@mock_resp)
+        Tuktuk.deliver(msg)
+      end
+
+      describe 'and bcc is given' do
+
+        let(:bcc_email) { 'bcc@test.com' }
+
+        it 'includes it in destination list' do
+          msg = email(to: 'some@one.com, another@one.com')
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].split(', ').first, bcc_email).and_return(@mock_resp)
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].split(', ').last, bcc_email).and_return(@mock_resp)
+          Tuktuk.deliver(msg, bcc: [bcc_email])
+        end
+
+        it 'also works if not passed as array' do
+          msg = email(to: 'some@one.com, another@one.com')
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].split(', ').first, bcc_email).and_return(@mock_resp)
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].split(', ').last, bcc_email).and_return(@mock_resp)
+          Tuktuk.deliver(msg, bcc: bcc_email)
+        end
+
+      end
+
+    end
+
+  end
+
+  describe 'multiple recipients (array)' do
+
+    describe 'when destination is valid (has MX servers)' do
+
+      before do
+        @servers = ['mx1.domain.com', 'mx2.domain.com', 'mx3.domain.com']
+        Tuktuk.stub(:smtp_servers_for_domain).and_return(@servers)
+      end
+
+      it 'sends message' do
+        msg = email(to: ['some@one.com', 'another@one.com'])
+        expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].first).and_return(@mock_resp)
+        expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].last).and_return(@mock_resp)
+        Tuktuk.deliver(msg)
+      end
+
+      describe 'and bcc is given' do
+
+        let(:bcc_email) { 'bcc@test.com' }
+
+        it 'includes it in destination list' do
+          msg = email(to: ['some@one.com', 'another@one.com'])
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].first, bcc_email).and_return(@mock_resp)
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].last, bcc_email).and_return(@mock_resp)
+          Tuktuk.deliver(msg, bcc: [bcc_email])
+        end
+
+        it 'also works if not passed as array' do
+          msg = email(to: ['some@one.com', 'another@one.com'])
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].first, bcc_email).and_return(@mock_resp)
+          expect(@mock_conn).to receive(:send_message).with(instance_of(String), msg[:from], msg[:to].last, bcc_email).and_return(@mock_resp)
+          Tuktuk.deliver(msg, bcc: bcc_email)
+        end
+
+      end
+
+    end
+
+  end
+
 end
 
 describe 'deliver many' do
@@ -17,7 +151,7 @@ describe 'deliver many' do
     it 'raises' do
       lambda do
         Tuktuk.deliver_many []
-      end.should raise_error
+      end.should raise_error(ArgumentError)
     end
 
   end
@@ -26,8 +160,8 @@ describe 'deliver many' do
 
     it 'raises' do
       lambda do
-        Tuktuk.deliver_many [ email, email(:to => 'one@user.com, two@user.com')]
-      end.should raise_error
+        Tuktuk.deliver_many [ email, email(:to => 'one@user.com, two@user.com') ]
+      end.should raise_error(ArgumentError)
     end
 
   end
@@ -89,7 +223,7 @@ describe 'deliver many' do
           end
 
           it 'starts by delivering to first one' do
-            Tuktuk.should_receive(:send_many_now).once.with('mx1.domain.com', [1]).and_return([[1,'ok']])
+            Tuktuk.should_receive(:send_many_now).once.with('mx1.domain.com', [1]).and_return([[1, 'ok']])
             Tuktuk.send(:lookup_and_deliver_by_domain, 'domain.com', [1])
           end
 
@@ -178,7 +312,7 @@ describe 'deliver many' do
             describe 'and other servers are down' do
 
               before do
-                # TODO: for some reason the :init_connection on line  138 is affecting this
+                # TODO: for some reason the :init_connection on line 138 is affecting this
                 # this test should pass when running on its own
                 # Tuktuk.should_receive(:init_connection).once.with('mx1.domain.com').and_return(@mock_smtp)
                 # Tuktuk.should_receive(:init_connection).once.with('mx2.domain.com').and_raise('Unable to connect.')
@@ -204,12 +338,4 @@ describe 'deliver many' do
 
   end
 
-  def email(attrs = {})
-    { :to => "user#{rand(1000)}@domain.com",
-      :from => 'me@company.com',
-      :subject => 'Test email',
-      :body => 'Hello world.'
-    }.merge(attrs)
-  end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tuktuk
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Tomás Pollak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-03 00:00:00.000000000 Z
+date: 2020-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -88,6 +88,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - Gemfile
 - README.md
@@ -123,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: tuktuk
-rubygems_version: 2.6.13
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: SMTP client for Ruby with DKIM support.