X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=lib%2Fsup%2Fimap.rb;h=3daa3d46d149cfb5546894b7a0891b42a8b2c624;hb=19837918ab2a025c82695be2a27900335b5c3f97;hp=a3dca4775939d54b2f9902a679c9f4f5014f99ee;hpb=f1abd6a52e639a62e211e7de17dd8e8b9eea9362;p=sup

diff --git a/lib/sup/imap.rb b/lib/sup/imap.rb
index a3dca47..3daa3d4 100644
--- a/lib/sup/imap.rb
+++ b/lib/sup/imap.rb
@@ -27,12 +27,14 @@ require 'time'
 
 ## fuck you, imap committee. you managed to design something as shitty
 ## as mbox but goddamn THIRTY YEARS LATER.
-
 module Redwood
 
 class IMAP < Source
   SCAN_INTERVAL = 60 # seconds
 
+  ## upon these errors we'll try to rereconnect a few times
+  RECOVERABLE_ERRORS = [ Errno::EPIPE, Errno::ETIMEDOUT ]
+
   attr_reader_cloned :labels
   attr_accessor :username, :password
 
@@ -72,92 +74,117 @@ class IMAP < Source
   end
 
   def raw_header id
-    @mutex.synchronize do
-      connect
-      header, flags = get_imap_fields id, 'RFC822.HEADER', 'FLAGS'
-      header = "Status: RO\n" + header if flags.include? :Seen # fake an mbox-style read header
-      header.gsub(/\r\n/, "\n")
-    end
+    unsynchronized_scan_mailbox
+    header, flags = get_imap_fields id, 'RFC822.HEADER', 'FLAGS'
+    header = header + "Status: RO\n" if flags.include? :Seen # fake an mbox-style read header # TODO: improve source-marked-as-read reporting system
+    header.gsub(/\r\n/, "\n")
   end
+  synchronized :raw_header
 
   def raw_full_message id
-    @mutex.synchronize do
-      connect
-      get_imap_fields(id, 'RFC822').first.gsub(/\r\n/, "\n")
-    end
+    unsynchronized_scan_mailbox
+    get_imap_fields(id, 'RFC822').first.gsub(/\r\n/, "\n")
   end
+  synchronized :raw_full_message
 
   def connect
-    return false if broken?
-    return true if @imap
-
-    say "Connecting to IMAP server #{host}:#{port}..."
+    return if broken? || @imap
+    safely { } # do nothing!
+  end
+  synchronized :connect
 
-    ## ok, this is FUCKING ANNOYING.
-    ##
-    ## what imap.rb likes to do is, if an exception occurs, catch it
-    ## and re-raise it on the calling thread. seems reasonable. but
-    ## what that REALLY means is that the only way to reasonably
-    ## initialize imap is in its own thread, because otherwise, you
-    ## will never be able to catch the exception it raises on the
-    ## calling thread, and the backtrace will not make any sense at
-    ## all, and you will waste HOURS of your life on this fucking
-    ## problem.
-    ##
-    ## FUCK!!!!!!!!!
+  def scan_mailbox
+    return if @last_scan && (Time.now - @last_scan) < SCAN_INTERVAL
+    last_id = safely do
+      @imap.examine mailbox
+      @imap.responses["EXISTS"].last
+    end
+    @last_scan = Time.now
 
-    exception = nil
-    Redwood::reporting_thread do
-      begin
-        #raise Net::IMAP::ByeResponseError, "simulated imap failure"
-        @imap = Net::IMAP.new host, port, ssl?
-        say "Logging in..."
-        @imap.authenticate 'LOGIN', @username, @password
-        scan_mailbox
-        say "Successfully connected to #{@parsed_uri}."
-      rescue SocketError, Net::IMAP::Error, SourceError => e
-        exception = e
-      ensure
-        shutup
-      end
-    end.join
+    return if last_id == @ids.length
 
-    die_from exception, :while => "connecting" if exception
+    Redwood::log "fetching IMAP headers #{(@ids.length + 1) .. last_id}"
+    values = safely { @imap.fetch((@ids.length + 1) .. last_id, ['RFC822.SIZE', 'INTERNALDATE']) }
+    values.each do |v|
+      id = make_id v
+      @ids << id
+      @imap_ids[id] = v.seqno
+    end
   end
+  synchronized :scan_mailbox
 
   def each
-    @mutex.synchronize { connect or raise SourceError, broken_msg }
+    ids = 
+      @mutex.synchronize do
+        unsynchronized_scan_mailbox
+        @ids
+      end
 
-    start = @ids.index(cur_offset || start_offset) or die_from "Unknown message id #{cur_offset || start_offset}.", :suggest_rebuild => true # couldn't find the most recent email
+    start = ids.index(cur_offset || start_offset) or die_from "Unknown message id #{cur_offset || start_offset}.", :suggest_rebuild => true # couldn't find the most recent email
 
-    start.upto(@ids.length - 1) do |i|         
-      id = @ids[i]
+    start.upto(ids.length - 1) do |i|         
+      id = ids[i]
       self.cur_offset = id
       yield id, labels
     end
   end
 
   def start_offset
-    @mutex.synchronize { connect }
+    unsynchronized_scan_mailbox
     @ids.first
   end
+  synchronized :start_offset
 
   def end_offset
-    @mutex.synchronize do
-      begin
-        connect
-        scan_mailbox
-      rescue SocketError, Net::IMAP::Error => e
-        die_from e, :while => "scanning mailbox"
-      end
-    end
+    unsynchronized_scan_mailbox
     @ids.last
   end
+  synchronized :end_offset
 
   def pct_done; 100.0 * (@ids.index(cur_offset) || 0).to_f / (@ids.length - 1).to_f; end
 
 private
 
+  def unsafe_connect
+    say "Connecting to IMAP server #{host}:#{port}..."
+
+    ## apparently imap.rb does a lot of threaded stuff internally and
+    ## if an exception occurs, it will catch it and re-raise it on the
+    ## calling thread. but i can't seem to catch that exception, so
+    ## i've resorted to initializing it in its own thread. surely
+    ## there's a better way.
+    exception = nil
+    ::Thread.new do
+      begin
+        #raise Net::IMAP::ByeResponseError, "simulated imap failure"
+        @imap = Net::IMAP.new host, port, ssl?
+        say "Logging in..."
+
+        ## although RFC1730 claims that "If an AUTHENTICATE command
+        ## fails with a NO response, the client may try another", in
+        ## practice it seems like they can also send a BAD response.
+        begin
+          @imap.authenticate 'CRAM-MD5', @username, @password
+        rescue Net::IMAP::BadResponseError, Net::IMAP::NoResponseError => e
+          Redwood::log "CRAM-MD5 authentication failed: #{e.class}. Trying LOGIN auth..."
+          begin
+            @imap.authenticate 'LOGIN', @username, @password
+          rescue Net::IMAP::BadResponseError, Net::IMAP::NoResponseError => e
+            Redwood::log "LOGIN authentication failed: #{e.class}. Trying plain-text LOGIN..."
+            @imap.login @username, @password
+          end
+        end
+        say "Successfully connected to #{@parsed_uri}."
+      rescue Exception => e
+        exception = e
+      ensure
+        shutup
+      end
+    end.join
+
+    raise exception if exception
+  end
+
   def say s
     @say_id = BufferManager.say s, @say_id if BufferManager.instantiated?
     Redwood::log s
@@ -168,29 +195,13 @@ private
     @say_id = nil
   end
 
-  def scan_mailbox
-    return if @last_scan && (Time.now - @last_scan) < SCAN_INTERVAL
-
-    @imap.examine mailbox
-    last_id = @imap.responses["EXISTS"].last
-    @last_scan = Time.now
-    return if last_id == @ids.length
-    Redwood::log "fetching IMAP headers #{(@ids.length + 1) .. last_id}"
-    values = @imap.fetch((@ids.length + 1) .. last_id, ['RFC822.SIZE', 'INTERNALDATE'])
-    values.each do |v|
-      id = make_id v
-      @ids << id
-      @imap_ids[id] = v.seqno
-    end
-  end
-
   def die_from e, opts={}
     @imap = nil
 
     message =
       case e
       when Exception
-        "Error while #{opts[:while]}: #{e.message.chomp}."
+        "Error while #{opts[:while]}: #{e.message.chomp} (#{e.class.name})."
       when String
         e
       end
@@ -199,7 +210,7 @@ private
 
     self.broken_msg = message
     Redwood::log message
-    BufferManager.flash "Error communicating with IMAP server. See log for details."
+    BufferManager.flash "Error communicating with IMAP server. See log for details." if BufferManager.instantiated?
     raise SourceError, message
   end
   
@@ -211,26 +222,38 @@ private
   end
 
   def get_imap_fields id, *fields
-    retries = 0
-    f = nil
+    raise SourceError, broken_msg if broken?
     imap_id = @imap_ids[id] or die_from "Unknown message id #{id}.", :suggest_rebuild => true
+
+    retried = false
+    results = safely { @imap.fetch imap_id, (fields + ['RFC822.SIZE', 'INTERNALDATE']).uniq }.first
+    got_id = make_id results
+    die_from "IMAP message mismatch: requested #{id}, got #{got_id}.", :suggest_rebuild => true unless got_id == id
+
+    fields.map { |f| results.attr[f] }
+  end
+
+  ## execute a block, connected if unconnected, re-connected up to 3
+  ## times if a recoverable error occurs, and properly dying if an
+  ## unrecoverable error occurs.
+  def safely
+    retries = 0
     begin
-      f = @imap.fetch imap_id, (fields + ['RFC822.SIZE', 'INTERNALDATE']).uniq
-      got_id = make_id f[0]
-      die_from "IMAP message mismatch: requested #{id}, got #{got_id}.", :suggest_rebuild => true unless id == got_id
-    rescue SocketError, Net::IMAP::Error => e
-      die_from e, :while => "communicating with IMAP server"
-    rescue Errno::EPIPE
-      if (retries += 1) <= 3
-        @imap = nil
-        connect
-        retry
+      begin
+        unsafe_connect unless @imap
+        yield
+      rescue *RECOVERABLE_ERRORS
+        if (retries += 1) <= 3
+          @imap = nil
+          retry
+        end
+        raise
       end
+    rescue Net, SocketError, Net::IMAP::Error, SystemCallError => e
+      die_from e, :while => "communicating with IMAP server"
     end
-    die_from "Null IMAP field '#{field}' for message with id #{id} imap id #{imap_id}." if f.nil?
-
-    fields.map { |field| f[0].attr[field] }
   end
+
 end
 
 Redwood::register_yaml(IMAP, %w(uri username password cur_offset usual archived id))