gitlab-mail_room 0.0.2

data/lib/mail_room/crash_handler.rb

@@ -0,0 +1,29 @@
+
+module MailRoom
+  class CrashHandler
+
+    attr_reader :error, :format
+
+    SUPPORTED_FORMATS = %w[json none]
+
+    def initialize(error:, format:)
+      @error = error
+      @format = format
+    end
+
+    def handle
+      if format == 'json'
+        puts json
+        return
+      end
+
+      raise error
+    end
+
+    private
+
+    def json
+      { time: Time.now, severity: :fatal, message: error.message, backtrace: error.backtrace }.to_json
+    end
+  end
+end

data/lib/mail_room/delivery.rb

@@ -0,0 +1,24 @@
+module MailRoom
+  module Delivery
+    def [](name)
+      require_relative("./delivery/#{name}")
+
+      case name
+      when "postback"
+        Delivery::Postback
+      when "logger"
+        Delivery::Logger
+      when "letter_opener"
+        Delivery::LetterOpener
+      when "sidekiq"
+        Delivery::Sidekiq
+      when "que"
+        Delivery::Que
+      else
+        Delivery::Noop
+      end
+    end
+
+    module_function :[]
+  end
+end

data/lib/mail_room/delivery/letter_opener.rb

@@ -0,0 +1,34 @@
+require 'erb'
+require 'mail'
+require 'letter_opener'
+
+module MailRoom
+  module Delivery
+    # LetterOpener Delivery method
+    # @author Tony Pitale
+    class LetterOpener
+      Options = Struct.new(:location) do
+        def initialize(mailbox)
+          location = mailbox.location || mailbox.delivery_options[:location]
+
+          super(location)
+        end
+      end
+
+      # Build a new delivery, hold the delivery options
+      # @param [MailRoom::Delivery::LetterOpener::Options]
+      def initialize(delivery_options)
+        @delivery_options = delivery_options
+      end
+
+      # Trigger `LetterOpener` to deliver our message
+      # @param message [String] the email message as a string, RFC822 format
+      def deliver(message)
+        method = ::LetterOpener::DeliveryMethod.new(:location => @delivery_options.location)
+        method.deliver!(Mail.read_from_string(message))
+
+        true
+      end
+    end
+  end
+end

data/lib/mail_room/delivery/logger.rb

@@ -0,0 +1,37 @@
+require 'logger'
+
+module MailRoom
+  module Delivery
+    # File/STDOUT Logger Delivery method
+    # @author Tony Pitale
+    class Logger
+      Options = Struct.new(:log_path) do
+        def initialize(mailbox)
+          log_path = mailbox.log_path || mailbox.delivery_options[:log_path]
+
+          super(log_path)
+        end
+      end
+
+      # Build a new delivery, hold the delivery options
+      #   open a file or stdout for IO depending on the options
+      # @param [MailRoom::Delivery::Logger::Options]
+      def initialize(delivery_options)
+        io = File.open(delivery_options.log_path, 'a') if delivery_options.log_path
+        io ||= STDOUT
+
+        io.sync = true
+
+        @logger = ::Logger.new(io)
+      end
+
+      # Write the message to our logger
+      # @param message [String] the email message as a string, RFC822 format
+      def deliver(message)
+        @logger.info message
+
+        true
+      end
+    end
+  end
+end

data/lib/mail_room/delivery/noop.rb

@@ -0,0 +1,22 @@
+module MailRoom
+  module Delivery
+    # Noop Delivery method
+    # @author Tony Pitale
+    class Noop
+      Options = Class.new do
+        def initialize(*)
+          super()
+        end
+      end
+
+      # build a new delivery, do nothing
+      def initialize(*)
+      end
+
+      # accept the delivery, do nothing
+      def deliver(*)
+        true
+      end
+    end
+  end
+end

data/lib/mail_room/delivery/postback.rb

@@ -0,0 +1,72 @@
+require 'faraday'
+
+module MailRoom
+  module Delivery
+    # Postback Delivery method
+    # @author Tony Pitale
+    class Postback
+      Options = Struct.new(:url, :token, :username, :password, :logger, :content_type) do
+        def initialize(mailbox)
+          url =
+            mailbox.delivery_url ||
+            mailbox.delivery_options[:delivery_url] ||
+            mailbox.delivery_options[:url]
+
+          token =
+            mailbox.delivery_token ||
+            mailbox.delivery_options[:delivery_token] ||
+            mailbox.delivery_options[:token]
+
+          username = mailbox.delivery_options[:username]
+          password = mailbox.delivery_options[:password]
+
+          logger = mailbox.logger
+
+          content_type = mailbox.delivery_options[:content_type]
+
+          super(url, token, username, password, logger, content_type)
+        end
+
+        def token_auth?
+          !self[:token].nil?
+        end
+
+        def basic_auth?
+          !self[:username].nil? && !self[:password].nil?
+        end
+      end
+
+      # Build a new delivery, hold the delivery options
+      # @param [MailRoom::Delivery::Postback::Options]
+      def initialize(delivery_options)
+        puts delivery_options
+        @delivery_options = delivery_options
+      end
+
+      # deliver the message using Faraday to the configured delivery_options url
+      # @param message [String] the email message as a string, RFC822 format
+      def deliver(message)
+        connection = Faraday.new
+
+        if @delivery_options.token_auth?
+          connection.token_auth @delivery_options.token
+        elsif @delivery_options.basic_auth?
+          connection.basic_auth(
+            @delivery_options.username,
+            @delivery_options.password
+          )
+        end
+
+        connection.post do |request|
+          request.url @delivery_options.url
+          request.body = message
+          # request.options[:timeout] = 3
+          request.headers['Content-Type'] = @delivery_options.content_type unless @delivery_options.content_type.nil?
+        end
+
+        @delivery_options.logger.info({ delivery_method: 'Postback', action: 'message pushed', url: @delivery_options.url })
+        true
+      end
+    end
+  end
+end

data/lib/mail_room/delivery/que.rb

@@ -0,0 +1,63 @@
+require 'pg'
+require 'json'
+
+module MailRoom
+  module Delivery
+    # Que Delivery method
+    # @author Tony Pitale
+    class Que
+      Options = Struct.new(:host, :port, :database, :username, :password, :queue, :priority, :job_class, :logger) do
+        def initialize(mailbox)
+          host = mailbox.delivery_options[:host] || "localhost"
+          port = mailbox.delivery_options[:port] || 5432
+          database = mailbox.delivery_options[:database]
+          username = mailbox.delivery_options[:username]
+          password = mailbox.delivery_options[:password]
+
+          queue = mailbox.delivery_options[:queue] || ''
+          priority = mailbox.delivery_options[:priority] || 100 # lowest priority for Que
+          job_class = mailbox.delivery_options[:job_class]
+          logger = mailbox.logger
+
+          super(host, port, database, username, password, queue, priority, job_class, logger)
+        end
+      end
+
+      attr_reader :options
+
+      # Build a new delivery, hold the mailbox configuration
+      # @param [MailRoom::Delivery::Que::Options]
+      def initialize(options)
+        @options = options
+      end
+
+      # deliver the message by pushing it onto the configured Sidekiq queue
+      # @param message [String] the email message as a string, RFC822 format
+      def deliver(message)
+        queue_job(message)
+        @options.logger.info({ delivery_method: 'Que', action: 'message pushed' })
+      end
+
+      private
+      def connection
+        PG.connect(connection_options)
+      end
+
+      def connection_options
+        {
+          host: options.host,
+          port: options.port,
+          dbname: options.database,
+          user: options.username,
+          password: options.password
+        }
+      end
+
+      def queue_job(*args)
+        sql = "INSERT INTO que_jobs (priority, job_class, queue, args) VALUES ($1, $2, $3, $4)"
+
+        connection.exec(sql, [options.priority, options.job_class, options.queue, JSON.dump(args)])
+      end
+    end
+  end
+end

data/lib/mail_room/delivery/sidekiq.rb

@@ -0,0 +1,88 @@
+require "redis"
+require "securerandom"
+require "json"
+require "charlock_holmes"
+
+module MailRoom
+  module Delivery
+    # Sidekiq Delivery method
+    # @author Douwe Maan
+    class Sidekiq
+      Options = Struct.new(:redis_url, :namespace, :sentinels, :queue, :worker, :logger) do
+        def initialize(mailbox)
+          redis_url = mailbox.delivery_options[:redis_url] || "redis://localhost:6379"
+          namespace = mailbox.delivery_options[:namespace]
+          sentinels = mailbox.delivery_options[:sentinels]
+          queue     = mailbox.delivery_options[:queue] || "default"
+          worker    = mailbox.delivery_options[:worker]
+          logger = mailbox.logger
+
+          super(redis_url, namespace, sentinels, queue, worker, logger)
+        end
+      end
+
+      attr_accessor :options
+
+      # Build a new delivery, hold the mailbox configuration
+      # @param [MailRoom::Delivery::Sidekiq::Options]
+      def initialize(options)
+        @options = options
+      end
+
+      # deliver the message by pushing it onto the configured Sidekiq queue
+      # @param message [String] the email message as a string, RFC822 format
+      def deliver(message)
+        item = item_for(message)
+
+        client.lpush("queue:#{options.queue}", JSON.generate(item))
+
+        @options.logger.info({ delivery_method: 'Sidekiq', action: 'message pushed' })
+        true
+      end
+
+      private
+
+      def client
+        @client ||= begin
+          sentinels = options.sentinels
+          redis_options = { url: options.redis_url }
+          redis_options[:sentinels] = sentinels if sentinels
+
+          redis = ::Redis.new(redis_options)
+
+          namespace = options.namespace
+          if namespace
+            require 'redis/namespace'
+            Redis::Namespace.new(namespace, redis: redis)
+          else
+            redis
+          end
+        end
+      end
+
+      def item_for(message)
+        {
+          'class'       => options.worker,
+          'args'        => [utf8_encode_message(message)],
+          'queue'       => options.queue,
+          'jid'         => SecureRandom.hex(12),
+          'retry'       => false,
+          'enqueued_at' => Time.now.to_f
+        }
+      end
+
+      def utf8_encode_message(message)
+        message = message.dup
+
+        message.force_encoding("UTF-8")
+        return message if message.valid_encoding?
+
+        detection = CharlockHolmes::EncodingDetector.detect(message)
+        return message unless detection && detection[:encoding]
+
+        # Convert non-UTF-8 body UTF-8 so it can be dumped as JSON.
+        CharlockHolmes::Converter.convert(message, detection[:encoding], 'UTF-8')
+      end
+    end
+  end
+end

data/lib/mail_room/logger/structured.rb

@@ -0,0 +1,21 @@
+require 'logger'
+require 'json'
+
+module MailRoom
+  module Logger
+    class Structured < ::Logger
+
+      def format_message(severity, timestamp, progname, message)
+        raise ArgumentError.new("Message must be a Hash") unless message.is_a? Hash
+
+        data = {}
+        data[:severity] = severity
+        data[:time] = timestamp || Time.now.to_s
+        # only accept a Hash
+        data.merge!(message)
+
+        data.to_json + "\n"
+      end
+    end
+  end
+end

data/lib/mail_room/mailbox.rb

@@ -0,0 +1,182 @@
+require "mail_room/delivery"
+require "mail_room/arbitration"
+
+module MailRoom
+  # Mailbox Configuration fields
+  MAILBOX_FIELDS = [
+    :email,
+    :password,
+    :host,
+    :port,
+    :ssl,
+    :start_tls,
+    :idle_timeout,
+    :search_command,
+    :name,
+    :delete_after_delivery,
+    :expunge_deleted,
+    :delivery_klass,
+    :delivery_method, # :noop, :logger, :postback, :letter_opener
+    :log_path, # for logger
+    :delivery_url, # for postback
+    :delivery_token, # for postback
+    :content_type, # for postback
+    :location, # for letter_opener
+    :delivery_options,
+    :arbitration_method,
+    :arbitration_options,
+    :logger
+  ]
+
+  ConfigurationError = Class.new(RuntimeError)
+  IdleTimeoutTooLarge = Class.new(RuntimeError)
+
+  # Holds configuration for each of the email accounts we wish to monitor
+  #   and deliver email to when new emails arrive over imap
+  Mailbox = Struct.new(*MAILBOX_FIELDS) do
+    # Keep it to 29 minutes or less
+    # The IMAP serve will close the connection after 30 minutes of inactivity
+    # (which sending IDLE and then nothing technically is), so we re-idle every
+    # 29 minutes, as suggested by the spec: https://tools.ietf.org/html/rfc2177
+    IMAP_IDLE_TIMEOUT = 29 * 60 # 29 minutes in in seconds
+
+    REQUIRED_CONFIGURATION = [:name, :email, :password, :host, :port]
+
+    # Default attributes for the mailbox configuration
+    DEFAULTS = {
+      :search_command => 'UNSEEN',
+      :delivery_method => 'postback',
+      :host => 'imap.gmail.com',
+      :port => 993,
+      :ssl => true,
+      :start_tls => false,
+      :idle_timeout => IMAP_IDLE_TIMEOUT,
+      :delete_after_delivery => false,
+      :expunge_deleted => false,
+      :delivery_options => {},
+      :arbitration_method => 'noop',
+      :arbitration_options => {},
+      :logger => {}
+    }
+
+    # Store the configuration and require the appropriate delivery method
+    # @param attributes [Hash] configuration options
+    def initialize(attributes={})
+      super(*DEFAULTS.merge(attributes).values_at(*members))
+
+      validate!
+    end
+
+    def logger
+      @logger ||=
+        case self[:logger]
+          when Logger
+            self[:logger]
+          else
+            self[:logger] ||= {}
+            MailRoom::Logger::Structured.new(normalize_log_path(self[:logger][:log_path]))
+        end
+    end
+
+    def delivery_klass
+      self[:delivery_klass] ||= Delivery[delivery_method]
+    end
+
+    def arbitration_klass
+      Arbitration[arbitration_method]
+    end
+
+    def delivery
+      @delivery ||= delivery_klass.new(parsed_delivery_options)
+    end
+
+    def arbitrator
+      @arbitrator ||= arbitration_klass.new(parsed_arbitration_options)
+    end
+
+    def deliver?(uid)
+      logger.info({context: context, uid: uid, action: "asking arbiter to deliver", arbitrator: arbitrator.class.name})
+
+      arbitrator.deliver?(uid)
+    end
+
+    # deliver the imap email message
+    # @param message [Net::IMAP::FetchData]
+    def deliver(message)
+      body = message.attr['RFC822']
+      return true unless body
+
+      logger.info({context: context, uid: message.attr['UID'], action: "sending to deliverer", deliverer: delivery.class.name, byte_size: message.attr['RFC822.SIZE']})
+      delivery.deliver(body)
+    end
+
+    # true, false, or ssl options hash
+    def ssl_options
+      replace_verify_mode(ssl)
+    end
+
+    def context
+      { email: self.email, name: self.name }
+    end
+
+    def validate!
+      if self[:idle_timeout] > IMAP_IDLE_TIMEOUT
+        raise IdleTimeoutTooLarge,
+              "Please use an idle timeout smaller than #{29*60} to prevent " \
+              "IMAP server disconnects"
+      end
+
+      REQUIRED_CONFIGURATION.each do |k|
+        if self[k].nil?
+          raise ConfigurationError,
+                "Field :#{k} is required in Mailbox: #{inspect}"
+        end
+      end
+    end
+
+    private
+
+    def parsed_arbitration_options
+      arbitration_klass::Options.new(self)
+    end
+
+    def parsed_delivery_options
+      delivery_klass::Options.new(self)
+    end
+
+    def replace_verify_mode(options)
+      return options unless options.is_a?(Hash)
+      return options unless options.has_key?(:verify_mode)
+
+      options[:verify_mode] = lookup_verify_mode(options[:verify_mode])
+
+      options
+    end
+
+    def lookup_verify_mode(verify_mode)
+      case verify_mode.to_sym
+        when :none
+          OpenSSL::SSL::VERIFY_NONE
+        when :peer
+          OpenSSL::SSL::VERIFY_PEER
+        when :client_once
+          OpenSSL::SSL::VERIFY_CLIENT_ONCE
+        when :fail_if_no_peer_cert
+          OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+      end
+    end
+
+    def normalize_log_path(log_path)
+      case log_path
+      when nil, ""
+        nil
+      when :stdout, "STDOUT"
+        STDOUT
+      when :stderr, "STDERR"
+        STDERR
+      else
+        log_path
+      end
+    end
+  end
+end