require 'delegate' require 'net/imap' require 'mail' module Agents class ImapFolderAgent < Agent cannot_receive_events! can_dry_run! default_schedule "every_30m" description <<-MD The Imap Folder Agent checks an IMAP server in specified folders and creates Events based on new mails found since the last run. In the first visit to a folder, this agent only checks for the initial status and does not create events. Specify an IMAP server to connect with `host`, and set `ssl` to true if the server supports IMAP over SSL. Specify `port` if you need to connect to a port other than standard (143 or 993 depending on the `ssl` value). Specify login credentials in `username` and `password`. List the names of folders to check in `folders`. To narrow mails by conditions, build a `conditions` hash with the following keys: - `subject` - `body` Specify a regular expression to match against the decoded subject/body of each mail. Use the `(?i)` directive for case-insensitive search. For example, a pattern `(?i)alert` will match "alert", "Alert"or "ALERT". You can also make only a part of a pattern to work case-insensitively: `Re: (?i:alert)` will match either "Re: Alert" or "Re: alert", but not "RE: alert". When a mail has multiple non-attachment text parts, they are prioritized according to the `mime_types` option (which see below) and the first part that matches a "body" pattern, if specified, will be chosen as the "body" value in a created event. Named captures will appear in the "matches" hash in a created event. - `from`, `to`, `cc` Specify a shell glob pattern string that is matched against mail addresses extracted from the corresponding header values of each mail. Patterns match addresses in case insensitive manner. Multiple pattern strings can be specified in an array, in which case a mail is selected if any of the patterns matches. (i.e. patterns are OR'd) - `mime_types` Specify an array of MIME types to tell which non-attachment part of a mail among its text/* parts should be used as mail body. The default value is `['text/plain', 'text/enriched', 'text/html']`. - `is_unread` Setting this to true or false means only mails that is marked as unread or read respectively, are selected. If this key is unspecified or set to null, it is ignored. - `has_attachment` Setting this to true or false means only mails that does or does not have an attachment are selected. If this key is unspecified or set to null, it is ignored. Set `mark_as_read` to true to mark found mails as read. Each agent instance memorizes the highest UID of mails that are found in the last run for each watched folder, so even if you change a set of conditions so that it matches mails that are missed previously, or if you alter the flag status of already found mails, they will not show up as new events. Also, in order to avoid duplicated notification it keeps a list of Message-Id's of 100 most recent mails, so if multiple mails of the same Message-Id are found, you will only see one event out of them. MD event_description <<-MD Events look like this: { "folder": "INBOX", "subject": "...", "from": "Nanashi ", "to": ["Jane "], "cc": [], "date": "2014-05-10T03:47:20+0900", "mime_type": "text/plain", "body": "Hello,\n\n...", "matches": { } } MD IDCACHE_SIZE = 100 FNM_FLAGS = [:FNM_CASEFOLD, :FNM_EXTGLOB].inject(0) { |flags, sym| if File.const_defined?(sym) flags | File.const_get(sym) else flags end } def working? event_created_within?(interpolated['expected_update_period_in_days']) && !recent_error_logs? end def default_options { 'expected_update_period_in_days' => "1", 'host' => 'imap.gmail.com', 'ssl' => true, 'username' => 'your.account', 'password' => 'your.password', 'folders' => %w[INBOX], 'conditions' => {} } end def validate_options %w[host username password].each { |key| String === options[key] or errors.add(:base, '%s is required and must be a string' % key) } if options['port'].present? errors.add(:base, "port must be a positive integer") unless is_positive_integer?(options['port']) end %w[ssl mark_as_read].each { |key| if options[key].present? if boolify(options[key]).nil? errors.add(:base, '%s must be a boolean value' % key) end end } case mime_types = options['mime_types'] when nil when Array mime_types.all? { |mime_type| String === mime_type && mime_type.start_with?('text/') } or errors.add(:base, 'mime_types may only contain strings that match "text/*".') if mime_types.empty? errors.add(:base, 'mime_types should not be empty') end else errors.add(:base, 'mime_types must be an array') end case folders = options['folders'] when nil when Array folders.all? { |folder| String === folder } or errors.add(:base, 'folders may only contain strings') if folders.empty? errors.add(:base, 'folders should not be empty') end else errors.add(:base, 'folders must be an array') end case conditions = options['conditions'] when Hash conditions.each { |key, value| value.present? or next case key when 'subject', 'body' case value when String begin Regexp.new(value) rescue errors.add(:base, 'conditions.%s contains an invalid regexp' % key) end else errors.add(:base, 'conditions.%s contains a non-string object' % key) end when 'from', 'to', 'cc' Array(value).each { |pattern| case pattern when String begin glob_match?(pattern, '') rescue errors.add(:base, 'conditions.%s contains an invalid glob pattern' % key) end else errors.add(:base, 'conditions.%s contains a non-string object' % key) end } when 'is_unread', 'has_attachment' case boolify(value) when true, false else errors.add(:base, 'conditions.%s must be a boolean value or null' % key) end end } else errors.add(:base, 'conditions must be a hash') end if options['expected_update_period_in_days'].present? errors.add(:base, "Invalid expected_update_period_in_days format") unless is_positive_integer?(options['expected_update_period_in_days']) end end def check each_unread_mail { |mail, notified| message_id = mail.message_id body_parts = mail.body_parts(mime_types) matched_part = nil matches = {} interpolated['conditions'].all? { |key, value| case key when 'subject' value.present? or next true re = Regexp.new(value) if m = re.match(mail.scrubbed(:subject)) m.names.each { |name| matches[name] = m[name] } true else false end when 'body' value.present? or next true re = Regexp.new(value) matched_part = body_parts.find { |part| if m = re.match(part.scrubbed(:decoded)) m.names.each { |name| matches[name] = m[name] } true else false end } when 'from', 'to', 'cc' value.present? or next true begin # Mail::Field really needs to define respond_to_missing? # so we could use try(:addresses) here. addresses = mail.header[key].addresses rescue NoMethodError next false end addresses.any? { |address| Array(value).any? { |pattern| glob_match?(pattern, address) } } when 'has_attachment' boolify(value) == mail.has_attachment? when 'is_unread' true # already filtered out by each_unread_mail else log 'Unknown condition key ignored: %s' % key true end } or next if notified.include?(mail.message_id) log 'Ignoring mail: %s (already notified)' % message_id else matched_part ||= body_parts.first if matched_part mime_type = matched_part.mime_type body = matched_part.scrubbed(:decoded) else mime_type = 'text/plain' body = '' end log 'Emitting an event for mail: %s' % message_id create_event :payload => { 'folder' => mail.folder, 'subject' => mail.scrubbed(:subject), 'from' => mail.from_addrs.first, 'to' => mail.to_addrs, 'cc' => mail.cc_addrs, 'date' => (mail.date.iso8601 rescue nil), 'mime_type' => mime_type, 'body' => body, 'matches' => matches, 'has_attachment' => mail.has_attachment?, } notified << mail.message_id if mail.message_id end if boolify(interpolated['mark_as_read']) log 'Marking as read' mail.mark_as_read unless dry_run? end } end def each_unread_mail host, port, ssl, username = interpolated.values_at(:host, :port, :ssl, :username) ssl = boolify(ssl) port = (Integer(port) if port.present?) log "Connecting to #{host}#{':%d' % port if port}#{' via SSL' if ssl}" Client.open(host, port: port, ssl: ssl) { |imap| log "Logging in as #{username}" imap.login(username, interpolated[:password]) # 'lastseen' keeps a hash of { uidvalidity => lastseenuid, ... } lastseen, seen = self.lastseen, self.make_seen # 'notified' keeps an array of message-ids of {IDCACHE_SIZE} # most recent notified mails. notified = self.notified interpolated['folders'].each { |folder| log "Selecting the folder: %s" % folder imap.select(folder) uidvalidity = imap.uidvalidity lastseenuid = lastseen[uidvalidity] if lastseenuid.nil? maxseq = imap.responses['EXISTS'].last log "Recording the initial status: %s" % pluralize(maxseq, 'existing mail') if maxseq > 0 seen[uidvalidity] = imap.fetch(maxseq, 'UID').last.attr['UID'] end next end seen[uidvalidity] = lastseenuid is_unread = boolify(interpolated['conditions']['is_unread']) uids = imap.uid_fetch((lastseenuid + 1)..-1, 'FLAGS'). each_with_object([]) { |data, ret| uid, flags = data.attr.values_at('UID', 'FLAGS') seen[uidvalidity] = uid next if uid <= lastseenuid case is_unread when nil, !flags.include?(:Seen) ret << uid end } log pluralize(uids.size, case is_unread when true 'new unread mail' when false 'new read mail' else 'new mail' end) next if uids.empty? imap.uid_fetch_mails(uids).each { |mail| yield mail, notified } } self.notified = notified self.lastseen = seen save! } ensure log 'Connection closed' end def mime_types interpolated['mime_types'] || %w[text/plain text/enriched text/html] end def lastseen Seen.new(memory['lastseen']) end def lastseen= value memory.delete('seen') # obsolete key memory['lastseen'] = value end def make_seen Seen.new end def notified Notified.new(memory['notified']) end def notified= value memory['notified'] = value end private def is_positive_integer?(value) Integer(value) >= 0 rescue false end def glob_match?(pattern, value) File.fnmatch?(pattern, value, FNM_FLAGS) end def pluralize(count, noun) "%d %s" % [count, noun.pluralize(count)] end class Client < ::Net::IMAP class << self def open(host, *args) imap = new(host, *args) yield imap ensure imap.disconnect unless imap.nil? end end attr_reader :uidvalidity def select(folder) ret = super(@folder = folder) @uidvalidity = responses['UIDVALIDITY'].last ret end def fetch(*args) super || [] end def uid_fetch(*args) super || [] end def uid_fetch_mails(set) uid_fetch(set, 'RFC822.HEADER').map { |data| Message.new(self, data, folder: @folder, uidvalidity: @uidvalidity) } end end class Seen < Hash def initialize(hash = nil) super() if hash # Deserialize a JSON hash which keys are strings hash.each { |uidvalidity, uid| self[uidvalidity.to_i] = uid } end end def []=(uidvalidity, uid) # Update only if the new value is larger than the current value if (curr = self[uidvalidity]).nil? || curr <= uid super end end end class Notified < Array def initialize(array = nil) super() replace(array) if array end def <<(value) slice!(0...-IDCACHE_SIZE) if size > IDCACHE_SIZE super end end class Message < SimpleDelegator DEFAULT_BODY_MIME_TYPES = %w[text/plain text/enriched text/html] attr_reader :uid, :folder, :uidvalidity module Scrubbed def scrubbed(method) (@scrubbed ||= {})[method.to_sym] ||= __send__(method).try(:scrub) { |bytes| "<#{bytes.unpack('H*')[0]}>" } end end include Scrubbed def initialize(client, fetch_data, props = {}) @client = client props.each { |key, value| instance_variable_set(:"@#{key}", value) } attr = fetch_data.attr @uid = attr['UID'] super(Mail.read_from_string(attr['RFC822.HEADER'])) end def has_attachment? @has_attachment ||= if data = @client.uid_fetch(@uid, 'BODYSTRUCTURE').first struct_has_attachment?(data.attr['BODYSTRUCTURE']) else false end end def fetch @parsed ||= if data = @client.uid_fetch(@uid, 'BODY.PEEK[]').first Mail.read_from_string(data.attr['BODY[]']) else Mail.read_from_string('') end end def body_parts(mime_types = DEFAULT_BODY_MIME_TYPES) mail = fetch if mail.multipart? mail.body.set_sort_order(mime_types) mail.body.sort_parts! mail.all_parts else [mail] end.select { |part| if part.multipart? || part.attachment? || !part.text? || !mime_types.include?(part.mime_type) false else part.extend(Scrubbed) true end } end def mark_as_read @client.uid_store(@uid, '+FLAGS', [:Seen]) end private def struct_has_attachment?(struct) struct.multipart? && ( struct.subtype == 'MIXED' || struct.parts.any? { |part| struct_has_attachment?(part) } ) end end end end