sup

lib/sup/source.rb (7492B) - raw

 require "sup/rfc2047"
 require "monitor"
 
 module Redwood
 
 class SourceError < StandardError
   def initialize *a
     raise "don't instantiate me!" if SourceError.is_a?(self.class)
     super
   end
 end
 class OutOfSyncSourceError < SourceError; end
 class FatalSourceError < SourceError; end
 
 class Source
   ## Implementing a new source should be easy, because Sup only needs
   ## to be able to:
   ##  1. See how many messages it contains
   ##  2. Get an arbitrary message
   ##  3. (optional) see whether the source has marked it read or not
   ##
   ## In particular, Sup doesn't need to move messages, mark them as
   ## read, delete them, or anything else. (Well, it's nice to be able
   ## to delete them, but that is optional.)
   ##
   ## Messages are identified internally based on the message id, and stored
   ## with an unique document id. Along with the message, source information
   ## that can contain arbitrary fields (set up by the source) is stored. This
   ## information will be passed back to the source when a message in the
   ## index (Sup database) needs to be identified to its source, e.g. when
   ## re-reading or modifying a unique message.
   ##
   ## To write a new source, subclass this class, and implement:
   ##
   ## - initialize
   ## - load_header offset
   ## - load_message offset
   ## - raw_header offset
   ## - raw_message offset
   ## - store_message (optional)
   ## - poll (loads new messages)
   ## - go_idle (optional)
   ##
   ## All exceptions relating to accessing the source must be caught
   ## and rethrown as FatalSourceErrors or OutOfSyncSourceErrors.
   ## OutOfSyncSourceErrors should be used for problems that a call to
   ## sup-sync will fix (namely someone's been playing with the source
   ## from another client); FatalSourceErrors can be used for anything
   ## else (e.g. the imap server is down or the maildir is missing.)
   ##
   ## Finally, be sure the source is thread-safe, since it WILL be
   ## pummelled from multiple threads at once.
   ##
   ## Examples for you to look at: mbox.rb and maildir.rb.
 
   bool_accessor :usual, :archived
   attr_reader :uri, :usual
   attr_accessor :id
 
   def initialize uri, usual=true, archived=false, id=nil
     raise ArgumentError, "id must be an integer: #{id.inspect}" unless id.is_a? Integer if id
 
     @uri = uri
     @usual = usual
     @archived = archived
     @id = id
 
     @poll_lock = Monitor.new
   end
 
   ## overwrite me if you have a disk incarnation
   def file_path; nil end
 
   def to_s; @uri.to_s; end
   def == o; o.uri == uri; end
   def is_source_for? uri; uri == @uri; end
 
   def read?; false; end
 
   ## release resources that are easy to reacquire. it is called
   ## after processing a source (e.g. polling) to prevent resource
   ## leaks (esp. file descriptors).
   def go_idle; end
 
   ## Returns an array containing all the labels that are natively
   ## supported by this source
   def supported_labels?; [] end
 
   ## Returns an array containing all the labels that are currently in
   ## the location filename
   def labels? info; [] end
 
   def fallback_date_for_message info; end
 
   ## Yields values of the form [Symbol, Hash]
   ## add: info, labels, progress
   ## delete: info, progress
   def poll
     unimplemented
   end
 
   def valid? info
     true
   end
 
   def synchronize &block
     @poll_lock.synchronize(&block)
   end
 
   def try_lock
     acquired = @poll_lock.try_enter
     if acquired
       debug "lock acquired for: #{self}"
     else
       debug "could not acquire lock for: #{self}"
     end
     acquired
   end
 
   def unlock
     @poll_lock.exit
     debug "lock released for: #{self}"
   end
 
   ## utility method to read a raw email header from an IO stream and turn it
   ## into a hash of key-value pairs. minor special semantics for certain headers.
   ##
   ## THIS IS A SPEED-CRITICAL SECTION. Everything you do here will have a
   ## significant effect on Sup's processing speed of email from ALL sources.
   ## Little things like string interpolation, regexp interpolation, += vs <<,
   ## all have DRAMATIC effects. BE CAREFUL WHAT YOU DO!
   def self.parse_raw_email_header f
     header = {}
     last = nil
 
     while(line = f.gets)
       case line
       ## these three can occur multiple times, and we want the first one
       when /^(Delivered-To|X-Original-To|Envelope-To):\s*(.*?)\s*$/i; header[last = $1.downcase] ||= $2
       ## regular header: overwrite (not that we should see more than one)
       ## TODO: figure out whether just using the first occurrence changes
       ## anything (which would simplify the logic slightly)
       when /^([^:\s]+):\s*(.*?)\s*$/i; header[last = $1.downcase] = $2
       when /^\r*$/; break # blank line signifies end of header
       else
         if last
           header[last] << " " unless header[last].empty?
           header[last] << line.strip
         end
       end
     end
 
     %w(subject from to cc bcc).each do |k|
       v = header[k] or next
       next unless Rfc2047.is_encoded? v
       header[k] = begin
         Rfc2047.decode_to $encoding, v
       rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence
         #debug "warning: error decoding RFC 2047 header (#{e.class.name}): #{e.message}"
         v
       end
     end
     header
   end
 
 protected
 
   ## convenience function
   def parse_raw_email_header f; self.class.parse_raw_email_header f end
 
   def Source.expand_filesystem_uri uri
     uri.gsub "~", File.expand_path("~")
   end
 
   def Source.encode_path_for_uri path
     path.gsub(Regexp.new("[#{Regexp.quote(URI_ENCODE_CHARS)}]")) { |c|
       c.each_byte.map { |x| sprintf("%%%02X", x) }.join
     }
   end
 end
 
 ## if you have a @labels instance variable, include this
 ## to serialize them nicely as an array, rather than as a
 ## nasty set.
 module SerializeLabelsNicely
   def before_marshal # can return an object
     c = clone
     c.instance_eval { @labels = (@labels.to_a.map { |l| l.to_s }).sort }
     c
   end
 
   def after_unmarshal!
     @labels = Set.new(@labels.to_a.map { |s| s.to_sym })
   end
 end
 
 class SourceManager
   include Redwood::Singleton
 
   def initialize
     @sources = {}
     @sources_dirty = false
     @source_mutex = Monitor.new
   end
 
   def [](id)
     @source_mutex.synchronize { @sources[id] }
   end
 
   def add_source source
     @source_mutex.synchronize do
       raise "duplicate source!" if @sources.include? source
       @sources_dirty = true
       max = @sources.max_of { |id, s| s.is_a?(DraftLoader) || s.is_a?(SentLoader) ? 0 : id }
       source.id ||= (max || 0) + 1
       ##source.id += 1 while @sources.member? source.id
       @sources[source.id] = source
     end
   end
 
   def sources
     ## favour the inbox by listing non-archived sources first
     @source_mutex.synchronize { @sources.values }.sort_by { |s| s.id }.partition { |s| !s.archived? }.flatten
   end
 
   def source_for uri
     expanded_uri = Source.expand_filesystem_uri(uri)
     sources.find { |s| s.is_source_for? expanded_uri }
   end
 
   def usual_sources; sources.find_all { |s| s.usual? }; end
   def unusual_sources; sources.find_all { |s| !s.usual? }; end
 
   def load_sources fn=Redwood::SOURCE_FN
     source_array = Redwood::load_yaml_obj(fn) || []
     @source_mutex.synchronize do
       @sources = Hash[*(source_array).map { |s| [s.id, s] }.flatten]
       @sources_dirty = false
     end
   end
 
   def save_sources fn=Redwood::SOURCE_FN, force=false
     @source_mutex.synchronize do
       if @sources_dirty || force
         Redwood::save_yaml_obj sources, fn, false, true
       end
       @sources_dirty = false
     end
   end
 end
 
 end