remailer 0.4.8 → 0.4.10

data/VERSION

@@ -1 +1 @@
-0.4.8
+0.4.10

data/lib/remailer/connection.rb

@@ -77,9 +77,28 @@ class Remailer::Connection < EventMachine::Connection
       host_port = proxy_options[:port] || SOCKS5_PORT
     end
 
+    establish!(host_name, host_port, options)
+  end
+
+  # Warns about supplying a Proc which does not appear to accept the required
+  # number of arguments.
+  def self.warn_about_arguments(proc, range)
+    unless (range.include?(proc.arity) or proc.arity == -1)
+      STDERR.puts "Callback must accept #{[ range.min, range.max ].uniq.join(' to ')} arguments but accepts #{proc.arity}"
+    end
+  end
+  
+  def self.establish!(host_name, host_port, options)
     EventMachine.connect(host_name, host_port, self, options)
 
   rescue EventMachine::ConnectionError => e
+    report_exception(e, options)
+
+    false
+  end
+
+  # Handles callbacks driven by exceptions before an instance could be created.
+  def self.report_exception(e)
     case (options[:connect])
     when Proc
       options[:connect].call(false, e.to_s)
@@ -111,14 +130,6 @@ class Remailer::Connection < EventMachine::Connection
     false
   end
   
-  # Warns about supplying a Proc which does not appear to accept the required
-  # number of arguments.
-  def self.warn_about_arguments(proc, range)
-    unless (range.include?(proc.arity) or proc.arity == -1)
-      STDERR.puts "Callback must accept #{[ range.min, range.max ].uniq.join(' to ')} arguments but accepts #{proc.arity}"
-    end
-  end
-
   # == Instance Methods =====================================================
   
   # EventMachine will call this constructor and it is not to be called
@@ -264,17 +275,27 @@ class Remailer::Connection < EventMachine::Connection
   # This implements the EventMachine::Connection#unbind method to capture
   # a connection closed event.
   def unbind
+    return if (@unbound)
+    
     @connected = false
+    @unbound = true
     @interpreter = nil
 
     if (@active_message)
       if (callback = @active_message[:callback])
         callback.call(nil)
+        @active_message = nil
       end
     end
     
     send_callback(:on_disconnect)
   end
+  
+  # Returns true if the connection has been unbound by EventMachine, false
+  # otherwise.
+  def unbound?
+    !!@unbound
+  end
 
   # This implements the EventMachine::Connection#receive_data method that
   # is called each time new data is received from the socket.
@@ -284,9 +305,9 @@ class Remailer::Connection < EventMachine::Connection
     @buffer ||= ''
     @buffer << data
 
-    if (@interpreter)
-      @interpreter.process(@buffer) do |reply|
-        debug_notification(:receive, "[#{@interpreter.label}] #{reply.inspect}")
+    if (interpreter = @interpreter)
+      interpreter.process(@buffer) do |reply|
+        debug_notification(:receive, "[#{interpreter.label}] #{reply.inspect}")
       end
     else
       error_notification(:out_of_band, "Receiving data before a protocol has been established.")
@@ -308,7 +329,11 @@ class Remailer::Connection < EventMachine::Connection
   # Returns the current state of the active interpreter, or nil if no state
   # is assigned.
   def state
-    @interpreter and @interpreter.state
+    if (interpreter = @interpreter)
+      @interpreter.state
+    else
+      nil
+    end
   end
 
   # Sends a single line to the remote host with the appropriate CR+LF
@@ -322,14 +347,20 @@ class Remailer::Connection < EventMachine::Connection
   end
 
   def resolve_hostname(hostname)
-    # FIXME: Elminitate this potentially blocking call by using an async
-    #        resolver if available.
     record = Socket.gethostbyname(hostname)
     
     # FIXME: IPv6 Support here
-    debug_notification(:resolved, record && record.last.unpack('CCCC').join('.'))
+    address = (record and record[3])
+    
+    if (address)
+      debug_notification(:resolver, "Address #{hostname} resolved as #{address.unpack('CCCC').join('.')}")
+    else
+      debug_notification(:resolver, "Address #{hostname} could not be resolved")
+    end
+    
+    yield(address) if (block_given?)
 
-    record and record.last
+    address
   rescue
     nil
   end
@@ -339,6 +370,12 @@ class Remailer::Connection < EventMachine::Connection
     @timeout_at = Time.now + @timeout
   end
   
+  # Returns the number of seconds remaining until a timeout will occur, or
+  # nil if no time-out is pending.
+  def time_remaning
+    @timeout_at and (@timeout_at.to_i - Time.now.to_i)
+  end
+  
   # Checks for a timeout condition, and if one is detected, will close the
   # connection and send appropriate callbacks.
   def check_for_timeouts!
@@ -362,8 +399,8 @@ class Remailer::Connection < EventMachine::Connection
       
       message = "Timed out before a connection could be established to #{remote_options[:host]}:#{remote_options[:port]}"
       
-      if (@interpreter)
-        message << " using #{@interpreter.label}"
+      if (interpreter = @interpreter)
+        message << " using #{interpreter.label}"
       end
       
       connect_notification(false, message)
@@ -408,13 +445,20 @@ class Remailer::Connection < EventMachine::Connection
 
   # EventMachine: Closes down the connection.
   def close_connection
-    send_callback(:on_disconnect)
+    return if (@closed)
+
+    unless (@timed_out)
+      send_callback(:on_disconnect)
+    end
+
     debug_notification(:closed, "Connection closed")
+    
     super
 
     @connected = false
     @closed = true
     @timeout_at = nil
+    @interpreter = nil
   end
   alias_method :close, :close_connection
 
@@ -493,7 +537,9 @@ class Remailer::Connection < EventMachine::Connection
   end
 
   def message_callback(reply_code, reply_message)
-    if (callback = (@active_message and @active_message[:callback]))
+    active_message = @active_message
+    
+    if (callback = (active_message and active_message[:callback]))
       # The callback is screened in advance when assigned to ensure that it
       # has only 1 or 2 arguments. There should be no else here.
       case (callback.arity)

data/lib/remailer/connection/smtp_interpreter.rb

@@ -121,11 +121,7 @@ class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
     interpret(220) do
       delegate.start_tls
       
-      if (delegate.requires_authentication?)
-        enter_state(:auth)
-      else
-        enter_state(:established)
-      end
+      enter_state(:helo)
     end
   end
 
@@ -138,20 +134,10 @@ class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
       enter_state(:established)
     end
     
-    interpret(535) do |message, continues|
-      if (@error)
-        @error << ' '
-        
-        if (message.match(/^(\S+)/).to_s == @error.match(/^(\S+)/).to_s)
-          @error << message.sub(/^\S+/, '')
-        else
-          @error << message
-        end
-      else
+    interpret(535) do |reply_message, continues|
+      handle_reply_continuation(535, reply_message, continues) do |reply_code, reply_message|
         @error = message
-      end
 
-      unless (continues)
         enter_state(:quit)
       end
     end
@@ -218,11 +204,23 @@ class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
       end
     end
     
-    interpret(250) do
-      if (delegate.active_message[:test])
+    interpret(250) do |reply_message, continues|
+      handle_reply_continuation(250, reply_message, continues) do |reply_code, reply_message|
+        if (delegate.active_message[:test])
+          delegate_call(:after_message_sent, reply_code, reply_message)
+
+          enter_state(:reset)
+        else
+          enter_state(:data)
+        end
+      end
+    end
+    
+    interpret(500..599) do |reply_code, reply_message, continues|
+      handle_reply_continuation(reply_code, reply_message, continues) do |reply_code, reply_message|
+        delegate_call(:after_message_sent, reply_code, reply_message)
+
         enter_state(:reset)
-      else
-        enter_state(:data)
       end
     end
   end
@@ -251,8 +249,10 @@ class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
       delegate.send_line(".")
     end
     
-    default do |reply_code, reply_message|
-      delegate_call(:after_message_sent, reply_code, reply_message)
+    default do |reply_code, reply_message, continues|
+      handle_reply_continuation(reply_code, reply_message, continues) do |reply_code, reply_message|
+        delegate_call(:after_message_sent, reply_code, reply_message)
+      end
 
       enter_state(:sent)
     end
@@ -300,14 +300,16 @@ class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
     end
   end
   
-  on_error do |reply_code, reply_message|
-    delegate.message_callback(reply_code, reply_message)
-    delegate.debug_notification(:error, "[#{@state}] #{reply_code} #{reply_message}")
-    delegate.error_notification(reply_code, reply_message)
-    
-    delegate.active_message = nil
-    
-    enter_state(delegate.protocol ? :reset : :terminated)
+  on_error do |reply_code, reply_message, continues|
+    handle_reply_continuation(reply_code, reply_message, continues) do |reply_code, reply_message|
+      delegate.message_callback(reply_code, reply_message)
+      delegate.debug_notification(:error, "[#{@state}] #{reply_code} #{reply_message}")
+      delegate.error_notification(reply_code, reply_message)
+
+      delegate.active_message = nil
+
+      enter_state(@state == :initialized ? :terminated : :reset)
+    end
   end
 
   # == Instance Methods =====================================================
@@ -315,6 +317,22 @@ class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
   def label
     'SMTP'
   end
+  
+  def handle_reply_continuation(reply_code, reply_message, continues)
+    @reply_message ||= ''
+    
+    if (preamble = @reply_message.split(/\s/).first)
+      reply_message.sub!(/^#{preamble}/, '')
+    end
+    
+    @reply_message << reply_message.gsub(/\s+/, ' ')
+    
+    unless (continues)
+      yield(reply_code, @reply_message)
+
+      @reply_message = nil
+    end
+  end
 
   def will_interpret?(proc, args)
     # Can only interpret blocks if the last part of the message has been

data/lib/remailer/connection/socks5_interpreter.rb

@@ -82,9 +82,10 @@ class Remailer::Connection::Socks5Interpreter < Remailer::Interpreter
   
   state :resolving_destination do
     enter do
-      # FIX: Use an async resolver here
-      @destination_address = delegate.resolve_hostname(delegate.options[:host])
-      enter_state(:connect_through_proxy)
+      delegate.resolve_hostname(delegate.options[:host]) do |address|
+        @destination_address = address
+        enter_state(:connect_through_proxy)
+      end
     end
   end
   
@@ -104,7 +105,7 @@ class Remailer::Connection::Socks5Interpreter < Remailer::Interpreter
           ].pack('CCCCA4n')
         )
       else
-        delegate.send_callback(:error_connecting, "Could not resolve hostname #{delegate.options[:host]}")
+        @error_message = "Could not resolve hostname #{delegate.options[:host]}"
         enter_state(:failed)
       end
     end
@@ -169,10 +170,15 @@ class Remailer::Connection::Socks5Interpreter < Remailer::Interpreter
   
   state :failed do
     enter do
-      message = "Proxy server returned error code #{@reply}: #{SOCKS5_REPLY[@reply]}"
-      delegate.debug_notification(:error, message)
+      if (@error_message)
+        delegate.debug_notification(:error, @error_message)
+        delegate.error_notification("SOCKS5", @error_message)
+      else
+        message = "Proxy server returned error code #{@reply}: #{SOCKS5_REPLY[@reply]}"
+        delegate.debug_notification(:error, message)
+        delegate.error_notification("SOCKS5_#{@reply}", message)
+      end
       delegate.connect_notification(false, message)
-      delegate.error_notification("SOCKS5_#{@reply}", message)
       delegate.close_connection
     end
     

data/lib/remailer/interpreter.rb

@@ -231,6 +231,8 @@ class Remailer::Interpreter
         case (response)
         when Regexp
           match_result = response.match(object)
+        when Range
+          response.include?(object)
         else
           response === object
         end
@@ -249,6 +251,8 @@ class Remailer::Interpreter
           end
         when String
           args[0].sub!(matched, '')
+        when Range
+          # Keep as-is
         else
           args.shift
         end

data/remailer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{remailer}
-  s.version = "0.4.8"
+  s.version = "0.4.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Scott Tadman}]
-  s.date = %q{2011-05-15}
+  s.date = %q{2011-07-05}
   s.description = %q{EventMachine SMTP Mail User Agent}
   s.email = %q{scott@twg.ca}
   s.extra_rdoc_files = [
@@ -38,7 +38,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = %q{http://github.com/twg/remailer}
   s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.2}
+  s.rubygems_version = %q{1.8.5}
   s.summary = %q{Reactor-Ready SMTP Mailer}
   s.test_files = [
     "test/config.example.rb",

metadata

@@ -2,7 +2,7 @@
 name: remailer
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.8
+  version: 0.4.10
 platform: ruby
 authors: 
 - Scott Tadman
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-15 00:00:00 Z
+date: 2011-07-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
@@ -74,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.2
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Reactor-Ready SMTP Mailer