diff options
Diffstat (limited to 'actionmailbox/app/models')
5 files changed, 151 insertions, 0 deletions
diff --git a/actionmailbox/app/models/action_mailbox/inbound_email.rb b/actionmailbox/app/models/action_mailbox/inbound_email.rb new file mode 100644 index 0000000000..88df7a929a --- /dev/null +++ b/actionmailbox/app/models/action_mailbox/inbound_email.rb @@ -0,0 +1,45 @@ +# frozen_string_literal: true + +require "mail" + +# The `InboundEmail` is an Active Record that keeps a reference to the raw email stored in Active Storage +# and tracks the status of processing. By default, incoming emails will go through the following lifecycle: +# +# * Pending: Just received by one of the ingress controllers and scheduled for routing. +# * Processing: During active processing, while a specific mailbox is running its #process method. +# * Delivered: Successfully processed by the specific mailbox. +# * Failed: An exception was raised during the specific mailbox's execution of the `#process` method. +# * Bounced: Rejected processing by the specific mailbox and bounced to sender. +# +# Once the `InboundEmail` has reached the status of being either `delivered`, `failed`, or `bounced`, +# it'll count as having been `#processed?`. Once processed, the `InboundEmail` will be scheduled for +# automatic incineration at a later point. +# +# When working with an `InboundEmail`, you'll usually interact with the parsed version of the source, +# which is available as a `Mail` object from `#mail`. But you can also access the raw source directly +# using the `#source` method. +# +# Examples: +# +# inbound_email.mail.from # => 'david@loudthinking.com' +# inbound_email.source # Returns the full rfc822 source of the email as text +class ActionMailbox::InboundEmail < ActiveRecord::Base + self.table_name = "action_mailbox_inbound_emails" + + include Incineratable, MessageId, Routable + + has_one_attached :raw_email + enum status: %i[ pending processing delivered failed bounced ] + + def mail + @mail ||= Mail.from_source(source) + end + + def source + @source ||= raw_email.download + end + + def processed? + delivered? || failed? || bounced? + end +end diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/incineratable.rb b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable.rb new file mode 100644 index 0000000000..825e300648 --- /dev/null +++ b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +# Ensure that the `InboundEmail` is automatically scheduled for later incineration if the status has been +# changed to `processed`. The later incineration will be invoked at the time specified by the +# `ActionMailbox.incinerate_after` time using the `IncinerationJob`. +module ActionMailbox::InboundEmail::Incineratable + extend ActiveSupport::Concern + + included do + after_update_commit :incinerate_later, if: -> { status_previously_changed? && processed? } + end + + def incinerate_later + ActionMailbox::IncinerationJob.schedule self + end + + def incinerate + Incineration.new(self).run + end +end diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/incineratable/incineration.rb b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable/incineration.rb new file mode 100644 index 0000000000..4656f359bf --- /dev/null +++ b/actionmailbox/app/models/action_mailbox/inbound_email/incineratable/incineration.rb @@ -0,0 +1,24 @@ +# frozen_string_literal: true + +# Command class for carrying out the actual incineration of the `InboundMail` that's been scheduled +# for removal. Before the incineration – which really is just a call to `#destroy!` – is run, we verify +# that it's both eligible (by virtue of having already been processed) and time to do so (that is, +# the `InboundEmail` was processed after the `incinerate_after` time). +class ActionMailbox::InboundEmail::Incineratable::Incineration + def initialize(inbound_email) + @inbound_email = inbound_email + end + + def run + @inbound_email.destroy! if due? && processed? + end + + private + def due? + @inbound_email.updated_at < ActionMailbox.incinerate_after.ago.end_of_day + end + + def processed? + @inbound_email.processed? + end +end diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/message_id.rb b/actionmailbox/app/models/action_mailbox/inbound_email/message_id.rb new file mode 100644 index 0000000000..244a2e439b --- /dev/null +++ b/actionmailbox/app/models/action_mailbox/inbound_email/message_id.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +# The `Message-ID` as specified by rfc822 is supposed to be a unique identifier for that individual email. +# That makes it an ideal tracking token for debugging and forensics, just like `X-Request-Id` does for +# web request. +# +# If an inbound email does not, against the rfc822 mandate, specify a Message-ID, one will be generated +# using the approach from `Mail::MessageIdField`. +module ActionMailbox::InboundEmail::MessageId + extend ActiveSupport::Concern + + included do + before_save :generate_missing_message_id + end + + class_methods do + # Create a new `InboundEmail` from the raw `source` of the email, which be uploaded as a Active Storage + # attachment called `raw_email`. Before the upload, extract the Message-ID from the `source` and set + # it as an attribute on the new `InboundEmail`. + def create_and_extract_message_id!(source, **options) + create! message_id: extract_message_id(source), **options do |inbound_email| + inbound_email.raw_email.attach io: StringIO.new(source), filename: "message.eml", content_type: "message/rfc822" + end + end + + private + def extract_message_id(source) + Mail.from_source(source).message_id rescue nil + end + end + + private + def generate_missing_message_id + self.message_id ||= Mail::MessageIdField.new.message_id.tap do |message_id| + logger.warn "Message-ID couldn't be parsed or is missing. Generated a new Message-ID: #{message_id}" + end + end +end diff --git a/actionmailbox/app/models/action_mailbox/inbound_email/routable.rb b/actionmailbox/app/models/action_mailbox/inbound_email/routable.rb new file mode 100644 index 0000000000..58d67eb20c --- /dev/null +++ b/actionmailbox/app/models/action_mailbox/inbound_email/routable.rb @@ -0,0 +1,24 @@ +# frozen_string_literal: true + +# A newly received `InboundEmail` will not be routed synchronously as part of ingress controller's receival. +# Instead, the routing will be done asynchronously, using a `RoutingJob`, to ensure maximum parallel capacity. +# +# By default, all newly created `InboundEmail` records that have the status of `pending`, which is the default, +# will be scheduled for automatic, deferred routing. +module ActionMailbox::InboundEmail::Routable + extend ActiveSupport::Concern + + included do + after_create_commit :route_later, if: :pending? + end + + # Enqueue a `RoutingJob` for this `InboundEmail`. + def route_later + ActionMailbox::RoutingJob.perform_later self + end + + # Route this `InboundEmail` using the routing rules declared on the `ApplicationMailbox`. + def route + ApplicationMailbox.route self + end +end |