rgrove-larch 1.0.0.7 → 1.0.0.8

data/bin/larch

@@ -24,18 +24,18 @@ EOS
 
     text "\nCopy Options:"
     opt :from_folder,      "Source folder to copy from", :short => :none, :default => 'INBOX'
-    opt :from_pass,        "Source server password (Default: prompt)", :short => :none, :type => :string
-    opt :from_user,        "Source server username (Default: prompt)", :short => :none, :type => :string
+    opt :from_pass,        "Source server password (default: prompt)", :short => :none, :type => :string
+    opt :from_user,        "Source server username (default: prompt)", :short => :none, :type => :string
     opt :to_folder,        "Destination folder to copy to", :short => :none, :default => 'INBOX'
-    opt :to_pass,          "Destination server password (Default: prompt)", :short => :none, :type => :string
-    opt :to_user,          "Destination server username (Default: prompt)", :short => :none, :type => :string
+    opt :to_pass,          "Destination server password (default: prompt)", :short => :none, :type => :string
+    opt :to_user,          "Destination server username (default: prompt)", :short => :none, :type => :string
 
     text "\nGeneral Options:"
     # opt :dry_run,          "Don't actually do anything.", :short => '-n'
     opt :fast_scan,        "Use a faster (but less accurate) method to scan mailboxes. This may result in messages being re-copied.", :short => :none
     opt :max_retries,      "Maximum number of times to retry after a recoverable error", :short => :none, :default => 3
     opt :no_create_folder, "Don't create destination folders that don't already exist", :short => :none
-    opt :ssl_certs,        "Path to a trusted certificate bundle to use to verify server SSL certificates", :short => :none
+    opt :ssl_certs,        "Path to a trusted certificate bundle to use to verify server SSL certificates", :short => :none, :type => :string
     opt :ssl_verify,       "Verify server SSL certificates", :short => :none
     opt :verbosity,        "Output verbosity: debug, info, warn, error, or fatal", :short => '-V', :default => 'info'
   end
@@ -52,45 +52,45 @@ EOS
   end
 
   # Create URIs.
-  options[:from]      = URI(options[:from])
-  options[:to]        = URI(options[:to])
-  options[:from].path = '/' + CGI.escape(options[:from_folder].gsub(/^\//, ''))
-  options[:to].path   = '/' + CGI.escape(options[:to_folder].gsub(/^\//, ''))
-
-  # Prompt for usernames and passwords if necessary.
-  unless options[:from_user]
-    options[:from_user] = ask("Source username (#{options[:from].host}): ")
-  end
+  uri_from = URI(options[:from])
+  uri_to   = URI(options[:to])
 
-  unless options[:from_pass]
-    options[:from_pass] = ask("Source password (#{options[:from].host}): ") {|q| q.echo = false }
+  if options[:from_folder_given] || options[:to_folder_given]
+    uri_from.path = '/' + CGI.escape(options[:from_folder].gsub(/^\//, ''))
+    uri_to.path   = '/' + CGI.escape(options[:to_folder].gsub(/^\//, ''))
   end
 
-  unless options[:to_user]
-    options[:to_user] = ask("Destination username (#{options[:to].host}): ")
-  end
+  # Usernames and passwords specified as arguments override those in the URIs
+  uri_from.user     = CGI.escape(options[:from_user]) if options[:from_user]
+  uri_from.password = CGI.escape(options[:from_pass]) if options[:from_pass]
+  uri_to.user       = CGI.escape(options[:to_user]) if options[:to_user]
+  uri_to.password   = CGI.escape(options[:to_pass]) if options[:to_pass]
 
-  unless options[:to_pass]
-    options[:to_pass] = ask("Destination password (#{options[:to].host}): ") {|q| q.echo = false }
-  end
+  # If usernames/passwords aren't specified in either URIs or args, then prompt.
+  uri_from.user     ||= CGI.escape(ask("Source username (#{uri_from.host}): "))
+  uri_from.password ||= CGI.escape(ask("Source password (#{uri_from.host}): ") {|q| q.echo = false })
+  uri_to.user       ||= CGI.escape(ask("Destination username (#{uri_to.host}): "))
+  uri_to.password   ||= CGI.escape(ask("Destination password (#{uri_to.host}): ") {|q| q.echo = false })
 
   # Go go go!
   init(options[:verbosity])
 
   Net::IMAP.debug = true if @log.level == :insane
 
-  source = IMAP.new(options[:from], options[:from_user], options[:from_pass],
+  imap_from = Larch::IMAP.new(uri_from,
       :fast_scan   => options[:fast_scan],
       :max_retries => options[:max_retries],
       :ssl_certs   => options[:ssl_certs] || nil,
-      :ssl_verify  => options[:ssl_verify])
+      :ssl_verify  => options[:ssl_verify]
+  )
 
-  dest = IMAP.new(options[:to], options[:to_user], options[:to_pass],
+  imap_to = Larch::IMAP.new(uri_to,
       :create_mailbox => !options[:no_create_folder],
       :fast_scan      => options[:fast_scan],
       :max_retries    => options[:max_retries],
       :ssl_certs      => options[:ssl_certs] || nil,
-      :ssl_verify     => options[:ssl_verify])
+      :ssl_verify     => options[:ssl_verify]
+  )
 
   unless RUBY_PLATFORM =~ /mswin|mingw|bccwin|wince|java/
     begin
@@ -101,5 +101,5 @@ EOS
     end
   end
 
-  copy(source, dest)
+  copy_folder(imap_from, imap_to)
 end

data/lib/larch.rb

@@ -11,6 +11,7 @@ require 'uri'
 
 require 'larch/errors'
 require 'larch/imap'
+require 'larch/imap/mailbox'
 require 'larch/logger'
 require 'larch/version'
 
@@ -27,128 +28,55 @@ module Larch
       @total  = 0
     end
 
-    # Copies messages from _source_ to _dest_ if they don't already exist in
-    # _dest_. Both _source_ and _dest_ must be instances of Larch::IMAP.
-    def copy(source, dest)
-      raise ArgumentError, "source must be a Larch::IMAP instance" unless source.is_a?(IMAP)
-      raise ArgumentError, "dest must be a Larch::IMAP instance" unless dest.is_a?(IMAP)
-
-      msgq  = SizedQueue.new(8)
-      mutex = Mutex.new
+    def copy_folder(imap_from, imap_to)
+      raise ArgumentError, "source must be a Larch::IMAP instance" unless imap_from.is_a?(IMAP)
+      raise ArgumentError, "dest must be a Larch::IMAP instance" unless imap_to.is_a?(IMAP)
 
       @copied = 0
       @failed = 0
       @total  = 0
 
-      @log.info "copying messages from #{source.uri} to #{dest.uri}"
+      mailbox_from_name = imap_from.uri_mailbox || 'INBOX'
+      mailbox_to_name   = imap_to.uri_mailbox || 'INBOX'
 
-      source.connect
-      dest.connect
+      @log.info "copying messages from #{imap_from.host}/#{mailbox_from_name} to #{imap_to.host}/#{mailbox_to_name}"
 
-      source_thread = Thread.new do
-        begin
-          source.scan_mailbox
-          mutex.synchronize { @total = source.length }
-
-          source.each do |id|
-            next if dest.has_message?(id)
-
-            begin
-              Thread.current[:fetching] = true
-              msgq << source.peek(id)
-              Thread.current[:fetching] = false
-
-            rescue Larch::IMAP::Error => e
-              # TODO: Keep failed message envelopes in a buffer for later output?
-              mutex.synchronize { @failed += 1 }
-              @log.error e.message
-              next
-            end
-          end
+      imap_from.connect
+      imap_to.connect
 
-        rescue Larch::WatchdogException => e
-          Thread.current[:fetching] = false
-          @log.debug "#{source.username}@#{source.host}: watchdog exception"
-          source.noop
-          retry
+      mailbox_from = imap_from.mailbox(mailbox_from_name)
+      mailbox_to   = imap_to.mailbox(mailbox_to_name)
 
-        rescue => e
-          @log.fatal "#{source.username}@#{source.host}: #{e.class.name}: #{e.message}"
-          Kernel.abort
+      @total = mailbox_from.length
 
-        ensure
-          msgq << :finished
-        end
-      end
+      mailbox_from.each do |id|
+        next if mailbox_to.has_message?(id)
 
-      dest_thread = Thread.new do
         begin
-          dest.scan_mailbox
+          msg = mailbox_from.peek(id)
 
-          while msg = msgq.pop do
-            break if msg == :finished
-
-            if msg.envelope.from
-              env_from = msg.envelope.from.first
-              from = "#{env_from.mailbox}@#{env_from.host}"
-            else
-              from = '?'
-            end
+          if msg.envelope.from
+            env_from = msg.envelope.from.first
+            from = "#{env_from.mailbox}@#{env_from.host}"
+          else
+            from = '?'
+          end
 
-            @log.info "copying message: #{from} - #{msg.envelope.subject}"
+          @log.info "copying message: #{from} - #{msg.envelope.subject}"
 
-            Thread.current[:last_id] = msg.id
-            dest << msg
-
-            mutex.synchronize { @copied += 1 }
-          end
+          mailbox_to << msg
+          @copied += 1
 
         rescue Larch::IMAP::Error => e
-          mutex.synchronize { @failed += 1 }
+          # TODO: Keep failed message envelopes in a buffer for later output?
+          @failed += 1
           @log.error e.message
-          retry
-
-        rescue Larch::WatchdogException => e
-          Thread.current[:last_id] = nil
-          @log.debug "#{dest.username}@#{dest.host}: watchdog exception"
-          dest.noop
-          retry
-
-        rescue => e
-          @log.fatal "#{dest.username}@#{dest.host}: #{e.class.name}: #{e.message}"
-          Kernel.abort
-        end
-      end
-
-      watchdog_thread = Thread.new do
-        source_flags = 0
-        dest_flags   = 0
-        dest_lastid  = nil
-
-        loop do
-          sleep 10
-
-          if msgq.length == 0 && source_thread[:fetching] && (source_flags += 1) > 1
-              source_flags = 0
-              source_thread.raise(WatchdogException)
-          end
-
-          if dest_thread[:last_id]
-            if dest_lastid == dest_thread[:last_id] && (dest_flags += 1) > 2
-              dest_flags  = 0
-              dest_lastid = nil
-              dest_thread.raise(WatchdogException)
-            else
-              dest_lastid = dest_thread[:last_id]
-            end
-          end
+          next
         end
       end
 
-      dest_thread.join
-
-      source.disconnect
-      dest.disconnect
+      imap_from.disconnect
+      imap_to.disconnect
 
     rescue => e
       @log.fatal e.message

data/lib/larch/errors.rb

@@ -5,6 +5,7 @@ module Larch
   class IMAP
     class Error < Larch::Error; end
     class FatalError < Error; end
-    class NotFoundError < Error; end
+    class MailboxNotFoundError < Error; end
+    class MessageNotFoundError < Error; end
   end
 end

data/lib/larch/imap.rb

@@ -6,34 +6,23 @@ module Larch
 # required reading if you're doing anything with IMAP in Ruby:
 # http://sup.rubyforge.org
 class IMAP
-  attr_reader :username
-
-  # Maximum number of messages to fetch at once.
-  MAX_FETCH_COUNT = 1024
-
-  # Regex to capture the individual fields in an IMAP fetch command.
-  REGEX_FIELDS = /([0-9A-Z\.]+\[[^\]]+\](?:<[0-9\.]+>)?|[0-9A-Z\.]+)/
-
-  # Regex to capture a Message-Id header.
-  REGEX_MESSAGE_ID = /message-id\s*:\s*(\S+)/i
+  attr_reader :conn, :options
 
   # URI format validation regex.
   REGEX_URI = URI.regexp(['imap', 'imaps'])
 
-  # Minimum time (in seconds) allowed between mailbox scans.
-  SCAN_INTERVAL = 60
-
   # Larch::IMAP::Message represents a transferable IMAP message which can be
   # passed between Larch::IMAP instances.
   Message = Struct.new(:id, :envelope, :rfc822, :flags, :internaldate)
 
   # Initializes a new Larch::IMAP instance that will connect to the specified
-  # IMAP URI and authenticate using the specified _username_ and _password_.
+  # IMAP URI.
   #
-  # The following options may also be specified:
+  # In addition to the URI, the following options may also be specified:
   #
   # [:create_mailbox]
-  #   If +true+, the specified mailbox will be created if necessary.
+  #   If +true+, mailboxes that don't already exist will be created if
+  #   necessary.
   #
   # [:fast_scan]
   #   If +true+, a faster but less accurate method will be used to scan
@@ -58,32 +47,25 @@ class IMAP
   #   certificate bundle specified in +ssl_certs+. By default, server SSL
   #   certificates are not verified.
   #
-  def initialize(uri, username, password, options = {})
+  def initialize(uri, options = {})
     raise ArgumentError, "not an IMAP URI: #{uri}" unless uri.is_a?(URI) || uri =~ REGEX_URI
-    raise ArgumentError, "must provide a username and password" unless username && password
     raise ArgumentError, "options must be a Hash" unless options.is_a?(Hash)
 
-    @uri       = uri.is_a?(URI) ? uri : URI(uri)
-    @username  = username
-    @password  = password
-    @options   = {:max_retries => 3, :ssl_verify => false}.merge(options)
+    @options = {:max_retries => 3, :ssl_verify => false}.merge(options)
+    @uri     = uri.is_a?(URI) ? uri : URI(uri)
 
-    @ids       = {}
-    @imap      = nil
-    @last_id   = 0
-    @last_scan = nil
-    @mutex     = Mutex.new
+    raise ArgumentError, "must provide a username and password" unless @uri.user && @uri.password
 
-    # Valid mailbox states are :closed (no mailbox open), :examined (mailbox
-    # open and read-only), or :selected (mailbox open and read-write).
-    @mailbox_state = :closed
+    @conn      = nil
+    @mailboxes = {}
+    @mutex     = Mutex.new
 
     # Create private convenience methods (debug, info, warn, etc.) to make
     # logging easier.
     Logger::LEVELS.each_key do |level|
       IMAP.class_eval do
         define_method(level) do |msg|
-          Larch.log.log(level, "#{@username}@#{host}: #{msg}")
+          Larch.log.log(level, "#{username}@#{host}: #{msg}")
         end
 
         private level
@@ -91,37 +73,19 @@ class IMAP
     end
   end
 
-  # Appends the specified Larch::IMAP::Message to this mailbox if it doesn't
-  # already exist. Returns +true+ if the message was appended successfully,
-  # +false+ if the message already exists in the mailbox.
-  def append(message)
-    raise ArgumentError, "must provide a Larch::IMAP::Message object" unless message.is_a?(Message)
-    return false if has_message?(message)
-
-    safely do
-      imap_select(!!@options[:create_mailbox])
-
-      debug "appending message: #{message.id}"
-      @imap.append(mailbox, message.rfc822, message.flags, message.internaldate)
-    end
-
-    true
-  end
-  alias << append
-
   # Connects to the IMAP server and logs in if a connection hasn't already been
   # established.
   def connect
-    return if @imap
+    return if @conn
     safely {} # connect, but do nothing else
   end
 
   # Closes the IMAP connection if one is currently open.
   def disconnect
-    return unless @imap
+    return unless @conn
 
     begin
-      @imap.disconnect
+      @conn.disconnect
     rescue Errno::ENOTCONN => e
       debug "#{e.class.name}: #{e.message}"
     end
@@ -131,47 +95,11 @@ class IMAP
     info "disconnected"
   end
 
-  # Iterates through Larch message ids in this mailbox, yielding each one to the
-  # provided block.
-  def each
-    scan_mailbox
-    ids = @ids
-
-    ids.each_key {|id| yield id }
-  end
-
-  # Gets a Net::IMAP::Envelope for the specified message id.
-  def envelope(message_id)
-    scan_mailbox
-    uid = @ids[message_id]
-
-    raise NotFoundError, "message not found: #{message_id}" if uid.nil?
-
-    debug "fetching envelope: #{message_id}"
-    imap_uid_fetch([uid], 'ENVELOPE').first.attr['ENVELOPE']
-  end
-
-  # Fetches a Larch::IMAP::Message struct representing the message with the
-  # specified Larch message id.
-  def fetch(message_id, peek = false)
-    scan_mailbox
-    uid = @ids[message_id]
-
-    raise NotFoundError, "message not found: #{message_id}" if uid.nil?
-
-    debug "#{peek ? 'peeking at' : 'fetching'} message: #{message_id}"
-    data = imap_uid_fetch([uid], [(peek ? 'BODY.PEEK[]' : 'BODY[]'), 'FLAGS', 'INTERNALDATE', 'ENVELOPE']).first
-
-    Message.new(message_id, data.attr['ENVELOPE'], data.attr['BODY[]'],
-        data.attr['FLAGS'], Time.parse(data.attr['INTERNALDATE']))
-  end
-  alias [] fetch
-
-  # Returns +true+ if a message with the specified Larch <em>message_id</em>
-  # exists in this mailbox, +false+ otherwise.
-  def has_message?(message_id)
-    scan_mailbox
-    @ids.has_key?(message_id)
+  # Iterates through all mailboxes in the account, yielding each one as a
+  # Larch::IMAP::Mailbox instance to the given block.
+  def each_mailbox
+    update_mailboxes
+    @mailboxes.each_value {|mailbox| yield mailbox }
   end
 
   # Gets the IMAP hostname.
@@ -179,26 +107,39 @@ class IMAP
     @uri.host
   end
 
-  # Gets the number of messages in this mailbox.
-  def length
-    scan_mailbox
-    @ids.length
-  end
-  alias size length
+  # Gets a Larch::IMAP::Mailbox instance representing the specified mailbox. If
+  # the mailbox doesn't exist and the +:create_mailbox+ option is +false+, or if
+  # +:create_mailbox+ is +true+ and mailbox creation fails, a
+  # Larch::IMAP::MailboxNotFoundError will be raised.
+  def mailbox(name)
+    retries = 0
 
-  # Gets the IMAP mailbox.
-  def mailbox
-    mb = @uri.path[1..-1]
-    mb.nil? || mb.empty? ? 'INBOX' : CGI.unescape(mb)
+    begin
+      @mailboxes.fetch(name) do
+        update_mailboxes
+        return @mailboxes[name] if @mailboxes.has_key?(name)
+        raise MailboxNotFoundError, "mailbox not found: #{name}"
+      end
+
+    rescue MailboxNotFoundError => e
+      raise unless @options[:create_mailbox] && retries == 0
+
+      info "creating mailbox: #{name}"
+      safely { @conn.create(name) }
+
+      retries += 1
+      retry
+    end
   end
 
+  # Sends an IMAP NOOP command.
   def noop
-    safely { @imap.noop }
+    safely { @conn.noop }
   end
 
-  # Same as fetch, but doesn't mark the message as seen.
-  def peek(message_id)
-    fetch(message_id, true)
+  # Gets the IMAP password.
+  def password
+    CGI.unescape(@uri.password)
   end
 
   # Gets the IMAP port number.
@@ -206,50 +147,52 @@ class IMAP
     @uri.port || (ssl? ? 993 : 143)
   end
 
-  # Fetches message headers from the current mailbox.
-  def scan_mailbox
-    return if @last_scan && (Time.now - @last_scan) < SCAN_INTERVAL
+  # Connect if necessary, execute the given block, retry up to 3 times if a
+  # recoverable error occurs, die if an unrecoverable error occurs.
+  def safely
+    safe_connect
+
+    retries = 0
 
     begin
-      imap_examine
-    rescue Error => e
-      return if @options[:create_mailbox]
-      raise
-    end
+      yield
 
-    last_id = safely { @imap.responses['EXISTS'].last }
+    rescue Errno::ECONNRESET,
+           Errno::ENOTCONN,
+           Errno::EPIPE,
+           Errno::ETIMEDOUT,
+           Net::IMAP::ByeResponseError,
+           OpenSSL::SSL::SSLError => e
 
-    @mutex.synchronize { @last_scan = Time.now }
-    return if last_id == @last_id
+      raise unless (retries += 1) <= @options[:max_retries]
 
-    range = (@last_id + 1)..last_id
+      info "#{e.class.name}: #{e.message} (reconnecting)"
 
-    @mutex.synchronize { @last_id = last_id }
+      reset
+      sleep 1 * retries
+      safe_connect
+      retry
 
-    info "fetching message headers #{range}" <<
-        (@options[:fast_scan] ? ' (fast scan)' : '')
+    rescue Net::IMAP::BadResponseError,
+           Net::IMAP::NoResponseError,
+           Net::IMAP::ResponseParseError => e
 
-    fields = if @options[:fast_scan]
-      ['UID', 'RFC822.SIZE', 'INTERNALDATE']
-    else
-      "(UID BODY.PEEK[HEADER.FIELDS (MESSAGE-ID)] RFC822.SIZE INTERNALDATE)"
-    end
+      raise unless (retries += 1) <= @options[:max_retries]
 
-    imap_fetch(range, fields).each do |data|
-      id = create_id(data)
+      info "#{e.class.name}: #{e.message} (will retry)"
 
-      unless uid = data.attr['UID']
-        error "UID not in IMAP response for message: #{id}"
-        next
-      end
+      sleep 1 * retries
+      retry
+    end
 
-      if Larch.log.level == :debug && @ids.has_key?(id)
-        envelope = imap_uid_fetch([uid], 'ENVELOPE').first.attr['ENVELOPE']
-        debug "duplicate message? #{id} (Subject: #{envelope.subject})"
-      end
+  rescue Larch::Error => e
+    raise
 
-      @mutex.synchronize { @ids[id] = uid }
-    end
+  rescue Net::IMAP::Error => e
+    raise Error, "#{e.class.name}: #{e.message} (giving up)"
+
+  rescue => e
+    raise FatalError, "#{e.class.name}: #{e.message} (cannot recover)"
   end
 
   # Gets the SSL status.
@@ -262,126 +205,29 @@ class IMAP
     @uri.to_s
   end
 
-  private
-
-  # Creates an id suitable for uniquely identifying a specific message across
-  # servers (we hope).
-  #
-  # If the given message data includes a valid Message-Id header, then that will
-  # be used to generate an MD5 hash. Otherwise, the hash will be generated based
-  # on the message's RFC822.SIZE and INTERNALDATE.
-  def create_id(data)
-    ['RFC822.SIZE', 'INTERNALDATE'].each do |a|
-      raise FatalError, "requested data not in IMAP response: #{a}" unless data.attr[a]
-    end
-
-    if data.attr['BODY[HEADER.FIELDS (MESSAGE-ID)]'] =~ REGEX_MESSAGE_ID
-      Digest::MD5.hexdigest($1)
-    else
-      Digest::MD5.hexdigest(sprintf('%d%d', data.attr['RFC822.SIZE'],
-          Time.parse(data.attr['INTERNALDATE']).to_i))
-    end
-  end
-
-  # Examines the mailbox. If _force_ is true, the mailbox will be examined even
-  # if it is already selected (which isn't necessary unless you want to ensure
-  # that it's in a read-only state).
-  def imap_examine(force = false)
-    return if @mailbox_state == :examined || (!force && @mailbox_state == :selected)
-
-    safely do
-      begin
-        @mutex.synchronize { @mailbox_state = :closed }
-
-        debug "examining mailbox: #{mailbox}"
-        @imap.examine(mailbox)
-
-        @mutex.synchronize { @mailbox_state = :examined }
-
-      rescue Net::IMAP::NoResponseError => e
-        raise Error, "unable to examine mailbox: #{e.message}"
-      end
-    end
-  end
-
-  # Fetches the specified _fields_ for the specified message sequence id(s) from
-  # the IMAP server.
-  def imap_fetch(ids, fields)
-    ids  = ids.to_a
-    data = []
-    pos  = 0
-
-    while pos < ids.length
-      safely do
-        imap_examine
-
-        data += @imap.fetch(ids[pos, MAX_FETCH_COUNT], fields)
-        pos  += MAX_FETCH_COUNT
-      end
-    end
-
-    data
+  # Gets the IMAP mailbox specified in the URI, or +nil+ if none.
+  def uri_mailbox
+    mb = @uri.path[1..-1]
+    mb.nil? || mb.empty? ? nil : CGI.unescape(mb)
   end
 
-  # Selects the mailbox if it is not already selected. If the mailbox does not
-  # exist and _create_ is +true+, it will be created. Otherwise, a
-  # Larch::IMAP::Error will be raised.
-  def imap_select(create = false)
-    return if @mailbox_state == :selected
-
-    safely do
-      begin
-        @mutex.synchronize { @mailbox_state = :closed }
-
-        debug "selecting mailbox: #{mailbox}"
-        @imap.select(mailbox)
-
-        @mutex.synchronize { @mailbox_state = :selected }
-
-      rescue Net::IMAP::NoResponseError => e
-        raise Error, "unable to select mailbox: #{e.message}" unless create
-
-        info "creating mailbox: #{mailbox}"
-
-        begin
-          @imap.create(mailbox)
-          retry
-        rescue => e
-          raise Error, "unable to create mailbox: #{e.message}"
-        end
-      end
-    end
+  # Gets the IMAP username.
+  def username
+    CGI.unescape(@uri.user)
   end
 
-  # Fetches the specified _fields_ for the specified UID(s) from the IMAP
-  # server.
-  def imap_uid_fetch(uids, fields)
-    uids = uids.to_a
-    data = []
-    pos  = 0
-
-    while pos < uids.length
-      safely do
-        imap_examine
-
-        data += @imap.uid_fetch(uids[pos, MAX_FETCH_COUNT], fields)
-        pos  += MAX_FETCH_COUNT
-      end
-    end
-
-    data
-  end
+  private
 
   # Resets the connection and mailbox state.
   def reset
     @mutex.synchronize do
-      @imap          = nil
-      @mailbox_state = :closed
+      @conn = nil
+      @mailboxes.each_value {|mb| mb.reset }
     end
   end
 
   def safe_connect
-    return if @imap
+    return if @conn
 
     retries = 0
 
@@ -410,54 +256,6 @@ class IMAP
     raise FatalError, "#{e.class.name}: #{e.message} (cannot recover)"
   end
 
-  # Connect if necessary, execute the given block, retry up to 3 times if a
-  # recoverable error occurs, die if an unrecoverable error occurs.
-  def safely
-    safe_connect
-
-    retries = 0
-
-    begin
-      yield
-
-    rescue Errno::ECONNRESET,
-           Errno::ENOTCONN,
-           Errno::EPIPE,
-           Errno::ETIMEDOUT,
-           Net::IMAP::ByeResponseError,
-           OpenSSL::SSL::SSLError => e
-
-      raise unless (retries += 1) <= @options[:max_retries]
-
-      info "#{e.class.name}: #{e.message} (reconnecting)"
-
-      reset
-      sleep 1 * retries
-      safe_connect
-      retry
-
-    rescue Net::IMAP::BadResponseError,
-           Net::IMAP::NoResponseError,
-           Net::IMAP::ResponseParseError => e
-
-      raise unless (retries += 1) <= @options[:max_retries]
-
-      info "#{e.class.name}: #{e.message} (will retry)"
-
-      sleep 1 * retries
-      retry
-    end
-
-  rescue Larch::Error => e
-    raise
-
-  rescue Net::IMAP::Error => e
-    raise Error, "#{e.class.name}: #{e.message} (giving up)"
-
-  rescue => e
-    raise FatalError, "#{e.class.name}: #{e.message} (cannot recover)"
-  end
-
   def unsafe_connect
     info "connecting..."
 
@@ -465,7 +263,7 @@ class IMAP
 
     Thread.new do
       begin
-        @imap = Net::IMAP.new(host, port, ssl?,
+        @conn = Net::IMAP.new(host, port, ssl?,
             ssl? && @options[:ssl_verify] ? @options[:ssl_certs] : nil,
             @options[:ssl_verify])
 
@@ -473,7 +271,7 @@ class IMAP
 
         auth_methods = ['PLAIN']
         tried        = []
-        capability   = @imap.capability
+        capability   = @conn.capability
 
         ['LOGIN', 'CRAM-MD5'].each do |method|
           auth_methods << method if capability.include?("AUTH=#{method}")
@@ -485,9 +283,9 @@ class IMAP
           debug "authenticating using #{method}"
 
           if method == 'PLAIN'
-            @imap.login(@username, @password)
+            @conn.login(username, password)
           else
-            @imap.authenticate(method, @username, @password)
+            @conn.authenticate(method, username, password)
           end
 
           info "authenticated using #{method}"
@@ -506,6 +304,21 @@ class IMAP
 
     raise exception if exception
   end
+
+  def update_mailboxes
+    list = safely { @conn.list('', '*') }
+
+    @mutex.synchronize do
+      # Remove cached mailboxes that no longer exist.
+      @mailboxes.delete_if {|k, v| !list.any?{|mb| mb.name == k}}
+
+      # Update cached mailboxes.
+      list.each do |mb|
+        @mailboxes[mb.name] ||= Mailbox.new(self, mb.name, mb.delim, mb.attr)
+      end
+    end
+  end
+
 end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rgrove-larch
 version: !ruby/object:Gem::Version 
-  version: 1.0.0.7
+  version: 1.0.0.8
 platform: ruby
 authors: 
 - Ryan Grove
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-26 00:00:00 -07:00
+date: 2009-04-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency