actionmailbox 0.1.0

data/lib/action_mailbox/callbacks.rb

@@ -0,0 +1,32 @@
+require "active_support/callbacks"
+
+module ActionMailbox
+  # Defines the callbacks related to processing.
+  module Callbacks
+    extend  ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    TERMINATOR = ->(mailbox, chain) do
+      chain.call
+      mailbox.finished_processing?
+    end
+
+    included do
+      define_callbacks :process, terminator: TERMINATOR, skip_after_callbacks_if_terminated: true
+    end
+
+    module ClassMethods
+      def before_processing(*methods, &block)
+        set_callback(:process, :before, *methods, &block)
+      end
+
+      def after_processing(*methods, &block)
+        set_callback(:process, :after, *methods, &block)
+      end
+
+      def around_processing(*methods, &block)
+        set_callback(:process, :around, *methods, &block)
+      end
+    end
+  end
+end

data/lib/action_mailbox/engine.rb

@@ -0,0 +1,34 @@
+require "rails/engine"
+
+module ActionMailbox
+  class Engine < Rails::Engine
+    isolate_namespace ActionMailbox
+    config.eager_load_namespaces << ActionMailbox
+
+    config.action_mailbox = ActiveSupport::OrderedOptions.new
+    config.action_mailbox.incinerate_after = 30.days
+
+    config.action_mailbox.queues = ActiveSupport::InheritableOptions.new \
+      incineration: :action_mailbox_incineration, routing: :action_mailbox_routing
+
+    initializer "action_mailbox.config" do
+      config.after_initialize do |app|
+        ActionMailbox.logger = app.config.action_mailbox.logger || Rails.logger
+        ActionMailbox.incinerate_after = app.config.action_mailbox.incinerate_after || 30.days
+        ActionMailbox.queues = app.config.action_mailbox.queues || {}
+      end
+    end
+
+    initializer "action_mailbox.ingress" do
+      config.after_initialize do |app|
+        if ActionMailbox.ingress = app.config.action_mailbox.ingress.presence
+          config.to_prepare do
+            if ingress_controller_class = "ActionMailbox::Ingresses::#{ActionMailbox.ingress.to_s.classify}::InboundEmailsController".safe_constantize
+              ingress_controller_class.prepare
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_mailbox/mail_ext.rb

@@ -0,0 +1,4 @@
+require "mail"
+
+# The hope is to upstream most of these basic additions to the Mail gem's Mail object. But until then, here they lay!
+Dir["#{File.expand_path(File.dirname(__FILE__))}/mail_ext/*"].each { |path| require "action_mailbox/mail_ext/#{File.basename(path)}" }

data/lib/action_mailbox/mail_ext/address_equality.rb

@@ -0,0 +1,5 @@
+class Mail::Address
+  def ==(other_address)
+    other_address.is_a?(Mail::Address) && to_s == other_address.to_s
+  end
+end

data/lib/action_mailbox/mail_ext/address_wrapping.rb

@@ -0,0 +1,5 @@
+class Mail::Address
+  def self.wrap(address)
+    address.is_a?(Mail::Address) ? address : Mail::Address.new(address)
+  end
+end

data/lib/action_mailbox/mail_ext/addresses.rb

@@ -0,0 +1,25 @@
+class Mail::Message
+  def from_address
+    header[:from]&.address_list&.addresses&.first
+  end
+
+  def recipients_addresses
+    to_addresses + cc_addresses + bcc_addresses + x_original_to_addresses
+  end
+
+  def to_addresses
+    Array(header[:to]&.address_list&.addresses)
+  end
+
+  def cc_addresses
+    Array(header[:cc]&.address_list&.addresses)
+  end
+
+  def bcc_addresses
+    Array(header[:bcc]&.address_list&.addresses)
+  end
+
+  def x_original_to_addresses
+    Array(header[:x_original_to]).collect { |header| Mail::Address.new header.to_s }
+  end
+end

data/lib/action_mailbox/mail_ext/from_source.rb

@@ -0,0 +1,5 @@
+module Mail
+  def self.from_source(source)
+    Mail.new Mail::Utilities.binary_unsafe_to_crlf(source.to_s)
+  end
+end

data/lib/action_mailbox/mail_ext/recipients.rb

@@ -0,0 +1,5 @@
+class Mail::Message
+  def recipients
+    Array(to) + Array(cc) + Array(bcc) + Array(header[:x_original_to]).map(&:to_s)
+  end
+end

data/lib/action_mailbox/postfix_relayer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "action_mailbox/version"
+require "net/http"
+require "uri"
+
+module ActionMailbox
+  class PostfixRelayer
+    class Result < Struct.new(:output)
+      def success?
+        !failure?
+      end
+
+      def failure?
+        output.match?(/\A[45]\.\d{1,3}\.\d{1,3}(\s|\z)/)
+      end
+    end
+
+    CONTENT_TYPE = "message/rfc822"
+    USER_AGENT   = "Action Mailbox Postfix relayer v#{ActionMailbox::VERSION}"
+
+    attr_reader :uri, :username, :password
+
+    def initialize(url:, username: "actionmailbox", password:)
+      @uri, @username, @password = URI(url), username, password
+    end
+
+    def relay(source)
+      case response = post(source)
+      when Net::HTTPSuccess
+        Result.new "2.0.0 Successfully relayed message to Postfix ingress"
+      when Net::HTTPUnauthorized
+        Result.new "4.7.0 Invalid credentials for Postfix ingress"
+      else
+        Result.new "4.0.0 HTTP #{response.code}"
+      end
+    rescue IOError, SocketError, SystemCallError => error
+      Result.new "4.4.2 Network error relaying to Postfix ingress: #{error.message}"
+    rescue Timeout::Error
+      Result.new "4.4.2 Timed out relaying to Postfix ingress"
+    rescue => error
+      Result.new "4.0.0 Error relaying to Postfix ingress: #{error.message}"
+    end
+
+    private
+      def post(source)
+        client.post uri, source,
+          "Content-Type"  => CONTENT_TYPE,
+          "User-Agent"    => USER_AGENT,
+          "Authorization" => "Basic #{Base64.strict_encode64(username + ":" + password)}"
+      end
+
+      def client
+        @client ||= Net::HTTP.new(uri.host, uri.port).tap do |connection|
+          if uri.scheme == "https"
+            require "openssl"
+
+            connection.use_ssl     = true
+            connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          end
+
+          connection.open_timeout = 1
+          connection.read_timeout = 10
+        end
+      end
+  end
+end

data/lib/action_mailbox/router.rb

@@ -0,0 +1,38 @@
+# Encapsulates the routes that live on the ApplicationMailbox and performs the actual routing when
+# an inbound_email is received.
+class ActionMailbox::Router
+  class RoutingError < StandardError; end
+
+  def initialize
+    @routes = []
+  end
+
+  def add_routes(routes)
+    routes.each do |(address, mailbox_name)|
+      add_route address, to: mailbox_name
+    end
+  end
+
+  def add_route(address, to:)
+    routes.append Route.new(address, to: to)
+  end
+
+  def route(inbound_email)
+    if mailbox = match_to_mailbox(inbound_email)
+      mailbox.receive(inbound_email)
+    else
+      inbound_email.bounced!
+
+      raise RoutingError
+    end
+  end
+
+  private
+    attr_reader :routes
+
+    def match_to_mailbox(inbound_email)
+      routes.detect { |route| route.match?(inbound_email) }.try(:mailbox_class)
+    end
+end
+
+require "action_mailbox/router/route"

data/lib/action_mailbox/router/route.rb

@@ -0,0 +1,38 @@
+# Encapsulates a route, which can then be matched against an inbound_email and provide a lookup of the matching
+# mailbox class. See examples for the different route addresses and how to use them in the `ActionMailbox::Base`
+# documentation.
+class ActionMailbox::Router::Route
+  attr_reader :address, :mailbox_name
+
+  def initialize(address, to:)
+    @address, @mailbox_name = address, to
+
+    ensure_valid_address
+  end
+
+  def match?(inbound_email)
+    case address
+    when :all
+      true
+    when String
+      inbound_email.mail.recipients.any? { |recipient| address.casecmp?(recipient) }
+    when Regexp
+      inbound_email.mail.recipients.any? { |recipient| address.match?(recipient) }
+    when Proc
+      address.call(inbound_email)
+    else
+      address.match?(inbound_email)
+    end
+  end
+
+  def mailbox_class
+    "#{mailbox_name.to_s.camelize}Mailbox".constantize
+  end
+
+  private
+    def ensure_valid_address
+      unless [ Symbol, String, Regexp, Proc ].any? { |klass| address.is_a?(klass) } || address.respond_to?(:match?)
+        raise ArgumentError, "Expected a Symbol, String, Regexp, Proc, or matchable, got #{address.inspect}"
+      end
+    end
+end

data/lib/action_mailbox/routing.rb

@@ -0,0 +1,20 @@
+module ActionMailbox
+  # See `ActionMailbox::Base` for how to specify routing.
+  module Routing
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :router, default: ActionMailbox::Router.new
+    end
+
+    class_methods do
+      def routing(routes)
+        router.add_routes(routes)
+      end
+
+      def route(inbound_email)
+        router.route(inbound_email)
+      end
+    end
+  end
+end

data/lib/action_mailbox/test_case.rb

@@ -0,0 +1,8 @@
+require "action_mailbox/test_helper"
+require "active_support/test_case"
+
+module ActionMailbox
+  class TestCase < ActiveSupport::TestCase
+    include ActionMailbox::TestHelper
+  end
+end

data/lib/action_mailbox/test_helper.rb

@@ -0,0 +1,42 @@
+require "mail"
+
+module ActionMailbox
+  module TestHelper
+    # Create an `InboundEmail` record using an eml fixture in the format of message/rfc822
+    # referenced with +fixture_name+ located in +test/fixtures/files/fixture_name+.
+    def create_inbound_email_from_fixture(fixture_name, status: :processing)
+      create_inbound_email_from_source file_fixture(fixture_name).read, status: status
+    end
+
+    # Create an `InboundEmail` by specifying it using `Mail.new` options. Example:
+    #
+    #   create_inbound_email_from_mail(from: "david@loudthinking.com", subject: "Hello!")
+    def create_inbound_email_from_mail(status: :processing, **mail_options)
+      create_inbound_email_from_source Mail.new(mail_options).to_s, status: status
+    end
+
+    # Create an `InboundEmail` using the raw rfc822 `source` as text.
+    def create_inbound_email_from_source(source, status: :processing)
+      ActionMailbox::InboundEmail.create_and_extract_message_id! source, status: status
+    end
+
+
+    # Create an `InboundEmail` from fixture using the same arguments as `create_inbound_email_from_fixture`
+    # and immediately route it to processing.
+    def receive_inbound_email_from_fixture(*args)
+      create_inbound_email_from_fixture(*args).tap(&:route)
+    end
+
+    # Create an `InboundEmail` from fixture using the same arguments as `create_inbound_email_from_mail`
+    # and immediately route it to processing.
+    def receive_inbound_email_from_mail(**kwargs)
+      create_inbound_email_from_mail(**kwargs).tap(&:route)
+    end
+
+    # Create an `InboundEmail` from fixture using the same arguments as `create_inbound_email_from_source`
+    # and immediately route it to processing.
+    def receive_inbound_email_from_source(**kwargs)
+      create_inbound_email_from_source(**kwargs).tap(&:route)
+    end
+  end
+end

data/lib/action_mailbox/version.rb

@@ -0,0 +1,3 @@
+module ActionMailbox
+  VERSION = '0.1.0'
+end

data/lib/tasks/ingress.rake

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+namespace :action_mailbox do
+  namespace :ingress do
+    desc "Pipe an inbound email from STDIN to the Postfix ingress (URL and INGRESS_PASSWORD required)"
+    task :postfix do
+      require "active_support"
+      require "active_support/core_ext/object/blank"
+      require "action_mailbox/postfix_relayer"
+
+      url, password = ENV.values_at("URL", "INGRESS_PASSWORD")
+
+      if url.blank? || password.blank?
+        print "4.3.5 URL and INGRESS_PASSWORD are required"
+        exit 1
+      end
+
+      ActionMailbox::PostfixRelayer.new(url: url, password: password).relay(STDIN.read).tap do |result|
+        print result.output
+        exit result.success?
+      end
+    end
+  end
+end

data/lib/tasks/install.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+namespace :action_mailbox do
+  # Prevent migration installation task from showing up twice.
+  Rake::Task["install:migrations"].clear_comments
+
+  desc "Copy over the migration"
+  task install: %w[ environment run_installer copy_migrations ]
+
+  task :run_installer do
+    installer_template = File.expand_path("../templates/installer.rb", __dir__)
+    system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{installer_template}"
+  end
+
+  task :copy_migrations do
+    Rake::Task["active_storage:install:migrations"].invoke
+    Rake::Task["railties:install:migrations"].reenable # Otherwise you can't run 2 migration copy tasks in one invocation
+    Rake::Task["action_mailbox:install:migrations"].invoke
+  end
+end

data/lib/templates/installer.rb

@@ -0,0 +1,4 @@
+say "Copying application_mailbox.rb to app/mailboxes"
+copy_file "#{__dir__}/mailboxes/application_mailbox.rb", "app/mailboxes/application_mailbox.rb"
+
+environment "# Prepare the ingress controller used to receive mail\n# config.action_mailbox.ingress = :amazon\n\n", env: 'production'

data/lib/templates/mailboxes/application_mailbox.rb

@@ -0,0 +1,3 @@
+class ApplicationMailbox < ActionMailbox::Base
+  # route /something/i => :somewhere
+end

data/test/controllers/ingresses/amazon/inbound_emails_controller_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+ActionMailbox::Ingresses::Amazon::InboundEmailsController.verifier =
+  Module.new { def self.authentic?(message); true; end }
+
+class ActionMailbox::Ingresses::Amazon::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup { ActionMailbox.ingress = :amazon }
+
+  test "receiving an inbound email from Amazon" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      post rails_amazon_inbound_emails_url, params: { content: file_fixture("../files/welcome.eml").read }, as: :json
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+end

data/test/controllers/ingresses/mailgun/inbound_emails_controller_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+ENV["MAILGUN_INGRESS_API_KEY"] = "tbsy84uSV1Kt3ZJZELY2TmShPRs91E3yL4tzf96297vBCkDWgL"
+
+class ActionMailbox::Ingresses::Mailgun::InboundEmailsControllerTest < ActionDispatch::IntegrationTest
+  setup { ActionMailbox.ingress = :mailgun }
+
+  test "receiving an inbound email from Mailgun" do
+    assert_difference -> { ActionMailbox::InboundEmail.count }, +1 do
+      travel_to "2018-10-09 15:15:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read
+      }
+    end
+
+    assert_response :no_content
+
+    inbound_email = ActionMailbox::InboundEmail.last
+    assert_equal file_fixture("../files/welcome.eml").read, inbound_email.raw_email.download
+    assert_equal "0CB459E0-0336-41DA-BC88-E6E28C697DDB@37signals.com", inbound_email.message_id
+  end
+
+  test "rejecting a delayed inbound email from Mailgun" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      travel_to "2018-10-09 15:26:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read
+      }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "rejecting a forged inbound email from Mailgun" do
+    assert_no_difference -> { ActionMailbox::InboundEmail.count } do
+      travel_to "2018-10-09 15:15:00 EDT"
+      post rails_mailgun_inbound_emails_url, params: {
+        timestamp: 1539112500,
+        token: "Zx8mJBiGmiiyyfWnho3zKyjCg2pxLARoCuBM7X9AKCioShGiMX",
+        signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+        "body-mime" => file_fixture("../files/welcome.eml").read
+      }
+    end
+
+    assert_response :unauthorized
+  end
+
+  test "raising when the configured Mailgun API key is nil" do
+    switch_key_to nil do
+      assert_raises ArgumentError do
+        travel_to "2018-10-09 15:15:00 EDT"
+        post rails_mailgun_inbound_emails_url, params: {
+          timestamp: 1539112500,
+          token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+          signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+          "body-mime" => file_fixture("../files/welcome.eml").read
+        }
+      end
+    end
+  end
+
+  test "raising when the configured Mailgun API key is blank" do
+    switch_key_to "" do
+      assert_raises ArgumentError do
+        travel_to "2018-10-09 15:15:00 EDT"
+        post rails_mailgun_inbound_emails_url, params: {
+          timestamp: 1539112500,
+          token: "7VwW7k6Ak7zcTwoSoNm7aTtbk1g67MKAnsYLfUB7PdszbgR5Xi",
+          signature: "ef24c5225322217bb065b80bb54eb4f9206d764e3e16abab07f0a64d1cf477cc",
+          "body-mime" => file_fixture("../files/welcome.eml").read
+        }
+      end
+    end
+  end
+
+  private
+    def switch_key_to(new_key)
+      previous_key, ENV["MAILGUN_INGRESS_API_KEY"] = ENV["MAILGUN_INGRESS_API_KEY"], new_key
+      yield
+    ensure
+      ENV["MAILGUN_INGRESS_API_KEY"] = previous_key
+    end
+end