tuktuk 0.3.1 → 0.4.4

data/lib/tuktuk/package.rb

@@ -1,16 +1,22 @@
 require 'mail'
 
+class Mail::Message
+  attr_accessor :array_index
+end
+
 module Package
 
   class << self
 
-    def new(message)
+    def new(message, index = nil)
       mail = message[:html_body] ? mixed(message) : plain(message)
+      mail.array_index = index if index
       mail.charset = 'UTF-8'
 
       mail['In-Reply-To'] = message[:in_reply_to] if message[:in_reply_to]
       mail['List-Archive'] = message[:list_archive] if message[:list_archive]
       mail['List-Id'] = message[:list_id] if message[:list_id]
+      mail['X-Mailer'] = "Tuktuk SMTP v#{Tuktuk::VERSION}"
 
       if message[:return_path]
         mail['Return-Path'] = message[:return_path]

data/lib/tuktuk/tuktuk.rb

@@ -1,14 +1,17 @@
 require 'net/smtp'
 require 'dkim'
 require 'logger'
+require 'work_queue'
+
 %w(package cache dns).each { |lib| require "tuktuk/#{lib}" }
 require 'tuktuk/version' unless defined?(Tuktuk::VERSION)
 
 DEFAULTS = {
   :retry_sleep  => 10,
   :max_attempts => 3,
-  :read_timeout => nil,
-  :open_timeout => nil,
+  :max_workers  => 0,
+  :read_timeout => 20,
+  :open_timeout => 20,
   :verify_ssl   => true,
   :log_to       => nil # $stdout,
 }
@@ -27,11 +30,16 @@ module Tuktuk
     def deliver(message, opts = {})
       self.options = opts if opts.any?
       mail = Package.new(message)
-      mail['X-Mailer'] = "Tuktuk SMTP v#{VERSION}"
       response = lookup_and_deliver(mail)
       return response, mail
     end
 
+    def deliver_many(messages, opts = {})
+      self.options = opts if opts.any?
+      messages_by_domain = reorder_by_domain(messages)
+      lookup_and_deliver_many(messages_by_domain)
+    end
+
     def options=(hash)
       if dkim_opts = hash.delete(:dkim)
         self.dkim = dkim_opts
@@ -59,16 +67,12 @@ module Tuktuk
       @logger ||= Logger.new(config[:log_to])
     end
 
-    def get_domain(email_address)
-      email_address && email_address.to_s[/@([a-z0-9\._-]+)/i, 1]
-    end
-
     def success(to)
       logger.info("#{to} - Successfully sent!")
     end
 
     def error(mail, to, error, attempt)
-      if attempt < config[:max_attempts] and (error.is_a?(EOFError) || error.is_a?(TimeoutError))
+      if attempt < config[:max_attempts] and (error.is_a?(EOFError) || error.is_a?(Timeout::Error))
         logger.info "#{to} - Got #{error.class.name} error. Retrying after #{config[:retry_sleep]} secs..."
         sleep config[:retry_sleep]
         lookup_and_deliver(mail, attempt+1)
@@ -78,26 +82,44 @@ module Tuktuk
       end
     end
 
+    def get_domain(email_address)
+      email_address && email_address.to_s[/@([a-z0-9\._-]+)/i, 1]
+    end
+
+    def reorder_by_domain(array)
+      hash = {}
+      array.each_with_index do |message, i|
+        mail = Package.new(message, i)
+        raise "Invalid destination count: #{mail.destinations.count}" if mail.destinations.count != 1
+
+        if to = mail.destinations.first and domain = get_domain(to)
+          hash[domain] = [] if hash[domain].nil?
+          hash[domain].push(mail)
+        end
+      end
+      hash
+    end
+
     def smtp_servers_for_domain(domain)
       unless servers = cache.get(domain)
         if servers = DNS.get_mx(domain) and servers.any?
           cache.set(domain, servers)
-        else
-          raise DNSError, "No MX records found for domain #{domain}."
         end
       end
-      servers
+      servers.any? && servers
     end
 
     def lookup_and_deliver(mail, attempt = 1)
-      raise MissingFieldsError, "No destinations found! You need to pass a :to field." if mail.destinations.empty?
+      if mail.destinations.empty?
+        raise MissingFieldsError, "No destinations found! You need to pass a :to field."
+      end
 
       response = nil
       mail.destinations.each do |to|
 
         domain = get_domain(to)
         servers = smtp_servers_for_domain(domain)
-        error(mail, to, DNSError.new("Unknown host: #{domain}"), attempt) && next if servers.empty?
+        error(mail, to, DNSError.new("No MX records for domain #{domain}"), attempt) && next if servers.empty?
 
         last_error = nil
         servers.each do |server|
@@ -113,13 +135,129 @@ module Tuktuk
       response
     end
 
+    def lookup_and_deliver_many(by_domain)
+      if config[:max_workers] && config[:max_workers] > 0
+        lookup_and_deliver_many_threaded(by_domain)
+      else
+        lookup_and_deliver_many_sync(by_domain)
+      end
+    end
+
+    def lookup_and_deliver_many_threaded(by_domain)
+      queue = WorkQueue.new(config[:max_workers])
+      responses = []
+
+      by_domain.each do |domain, mails|
+        queue.enqueue_b(domain, mails) do |domain, mails|
+          # send emails and then assign responses to array according to mail index
+          rr = lookup_and_deliver_by_domain(domain, mails)
+          rr.each do |resp, mail|
+            responses[mail.array_index] = [resp, mail]
+          end
+        end # worker
+      end
+
+      queue.join
+      responses
+    end
+
+    def lookup_and_deliver_many_sync(by_domain)
+      responses = []
+      by_domain.each do |domain, mails|
+        # send emails and then assign responses to array according to mail index
+        rr = lookup_and_deliver_by_domain(domain, mails)
+        rr.each do |resp, mail|
+          responses[mail.array_index] = [resp, mail]
+        end
+      end
+      responses
+    end
+
+    def lookup_and_deliver_by_domain(domain, mails)
+      responses = []
+
+      unless servers = smtp_servers_for_domain(domain)
+        err = DNSError.new("No MX Records for domain #{domain}")
+        mails.each {|mail| responses.push [err, mail] }
+        return responses
+      end
+
+      last_error = nil
+      servers.each do |server|
+        begin
+          send_many_now(server, mails).each do |mail, resp|
+            responses.push [resp, mail]
+          end
+          break
+        rescue => e
+          # logger.error e.message
+          last_error = e
+        end
+      end
+
+      if last_error # got error at server level, mark all messages with errors
+        mails.each {|mail| responses.push [last_error, mail] }
+      end
+
+      responses
+    end
+
     def send_now(mail, server, to)
       logger.info "#{to} - Delivering email at #{server}..."
+      from = get_from(mail)
+
+      response = nil
+      server = 'localhost' if ENV['DEBUG']
+      smtp = init_connection(server)
+      smtp.start(get_helo_domain(from), nil, nil, nil) do |smtp|
+        response = smtp.send_message(get_raw_mail(mail), from, to)
+        logger.info "#{to} - [SENT] #{response.message.strip}"
+      end
+
+      success(to)
+      response
+    end
+
+    def send_many_now(server, mails)
+      logger.info "Delivering #{mails.count} mails at #{server}..."
+      responses = {}
+      timeout_error = nil
 
-      raw_mail = use_dkim? ? Dkim.sign(mail.to_s).to_s : mail.to_s
-      from = mail.return_path || mail.sender || mail.from_addrs.first
-      helo_domain = Dkim::domain || config[:helo_domain] || get_domain(from)
+      server = 'localhost' if ENV['DEBUG']
+      smtp = init_connection(server)
+      smtp.start(get_helo_domain, nil, nil, nil) do |smtp|
+        mails.each do |mail|
+          unless timeout_error
+            begin
+              resp = smtp.send_message(get_raw_mail(mail), get_from(mail), mail.to)
+            rescue Net::SMTPError, EOFError, Timeout::Error => e # may be Net::SMTPFatalError (550 Mailbox not found)
+              # logger.error e.inspect
+              timeout_error = e if e.is_a?(Timeout::Error)
+              resp = e
+            end
+          end
+          responses[mail] = timeout_error || resp
+          status = resp.is_a?(Net::SMTP::Response) ? 'SENT' : 'ERROR'
+          logger.info "#{mail.to} [#{status}] #{responses[mail].message.strip}" # both error and response have this method
+        end
+      end
+
+      responses
+    end
+
+    def get_raw_mail(mail)
+      use_dkim? ? Dkim.sign(mail.to_s).to_s : mail.to_s
+    end
+
+    def get_from(mail)
+      mail.return_path || mail.sender || mail.from_addrs.first
+    end
 
+    def get_helo_domain(from = nil)
+      Dkim::domain || config[:helo_domain] || (from && get_domain(from))
+    end
+
+    def init_connection(server)
       context = OpenSSL::SSL::SSLContext.new
       context.verify_mode = config[:verify_ssl] ?
         OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
@@ -128,15 +266,7 @@ module Tuktuk
       smtp.enable_starttls_auto(context)
       smtp.read_timeout = config[:read_timeout] if config[:read_timeout]
       smtp.open_timeout = config[:open_timeout] if config[:open_timeout]
-
-      response = nil
-      smtp.start(helo_domain, nil, nil, nil) do |smtp|
-        response = smtp.send_message(raw_mail, from, to)
-        logger.info "#{to} - #{response.message.strip}"
-      end
-
-      success(to)
-      response
+      smtp
     end
 
   end

data/lib/tuktuk/version.rb

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

data/tuktuk.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "net-dns", "= 0.6.1"
   s.add_runtime_dependency "mail", "~> 2.3"
   s.add_runtime_dependency "dkim", "~> 0.0.2"
+  s.add_runtime_dependency 'work_queue', '~> 2.5.0'
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tuktuk
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-07 00:00:00.000000000 Z
+date: 2013-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: work_queue
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
 description: Easy way of sending DKIM-signed emails from Ruby, no dependencies needed.
 email:
 - tomas@forkhq.com