gitlab-mail_room 0.0.7 → 0.0.12

data/.ruby-version

@@ -1 +1 @@
-2.6.0
+2.7.2

data/.travis.yml

@@ -1,10 +1,17 @@
 language: ruby
 rvm:
-  - 2.3.0
-  - 2.4
   - 2.5
   - 2.6
+  - 2.7
+  - 3.0
+  - truffleruby
 services:
-  - redis-server
-script: bundle exec rspec spec
-sudo: false
+  - redis
+script:
+  - bundle exec rspec spec
+
+jobs:
+  - language: ruby
+    rvm: 2.7
+    script:
+      - bundle exec rubocop

data/README.md

@@ -20,7 +20,14 @@ The fork is useful as we can post quick fixes to our own fork and release fixes
 
 ## README
 
-mail_room is a configuration based process that will idle on IMAP connections and execute a delivery method when a new message is received. Examples of delivery methods include:
+mail_room is a configuration based process that will listen for incoming
+e-mail and execute a delivery method when a new message is
+received. mail_room supports the following methods for receiving e-mail:
+
+* IMAP
+* [Microsoft Graph API](https://docs.microsoft.com/en-us/graph/api/resources/mail-api-overview?view=graph-rest-1.0)
+
+Examples of delivery methods include:
 
 * POST to a delivery URL (Postback)
 * Queue a job to Sidekiq or Que for later processing (Sidekiq or Que)
@@ -55,6 +62,9 @@ You will also need to install `faraday` or `letter_opener` if you use the `postb
 
 ```yaml
 ---
+:health_check:
+  :address: "127.0.0.1"
+  :port: 8080
 :mailboxes:
   -
     :email: "user1@gmail.com"
@@ -114,11 +124,103 @@ You will also need to install `faraday` or `letter_opener` if you use the `postb
           :host: 127.0.0.1
           :port: 26379
       :worker: EmailReceiverWorker
+  -
+    :email: "user7@outlook365.com"
+    :password: "password"
+    :name: "inbox"
+    :inbox_method: microsoft_graph
+    :inbox_options:
+      :tenant_id: 12345
+      :client_id: ABCDE
+      :client_secret: YOUR-SECRET-HERE
+      :poll_interval: 60
+    :delivery_method: sidekiq
+    :delivery_options:
+      :redis_url: redis://localhost:6379
+      :worker: EmailReceiverWorker
 ```
 
 **Note:** If using `delete_after_delivery`, you also probably want to use
 `expunge_deleted` unless you really know what you're doing.
 
+## health_check ##
+
+Requires `webrick` gem to be installed.
+
+This option enables an HTTP server that listens to a bind address
+defined by `address` and `port`. The following endpoints are supported:
+
+* `/liveness`: This returns a 200 status code with `OK` as the body if
+the server is running. Otherwise, it returns a 500 status code.
+
+This feature is not included in upstream `mail_room` and is specific to GitLab.
+
+## inbox_method
+
+By default, IMAP mode is assumed for reading a mailbox.
+
+### IMAP Server Configuration ##
+
+You can set per-mailbox configuration for the IMAP server's `host` (default: 'imap.gmail.com'), `port` (default: 993), `ssl` (default: true), and `start_tls` (default: false).
+
+If you want to set additional options for IMAP SSL you can pass a YAML hash to match [SSLContext#set_params](http://docs.ruby-lang.org/en/2.2.0/OpenSSL/SSL/SSLContext.html#method-i-set_params). If you set `verify_mode` to `:none` it'll replace with the appropriate constant.
+
+If you're seeing the error `Please log in via your web browser: https://support.google.com/mail/accounts/answer/78754 (Failure)`, you need to configure your Gmail account to allow less secure apps to access it: https://support.google.com/accounts/answer/6010255.
+
+### Microsoft Graph configuration
+
+To use the Microsoft Graph API instead of IMAP to read e-mail, you will
+need to create an application in the Azure Active Directory. See the
+[Microsoft instructions](https://docs.microsoft.com/en-us/azure/active-directory/develop/quickstart-register-app) for more details:
+
+1. Sign in to the [Azure portal](https://portal.azure.com).
+1. Search for and select `Azure Active Directory`.
+1. Under `Manage`, select `App registrations` > `New registration`.
+1. Enter a `Name` for your application, such as `MailRoom`. Users of your app might see this name, and you can change it later.
+1. If `Supported account types` is listed, select the appropriate option.
+1. Leave `Redirect URI` blank. This is not needed.
+1. Select `Register`.
+1. Under `Manage`, select `Certificates & secrets`.
+1. Under `Client secrets`, select `New client secret`, and enter a name.
+1. Under `Expires`, select `Never`, unless you plan on updating the credentials every time it expires.
+1. Select `Add`. Record the secret value in a safe location for use in a later step.
+1. Under `Manage`, select `API Permissions` > `Add a permission`. Select `Microsoft Graph`.
+1. Select `Application permissions`.
+1. Under the `Mail` node, select `Mail.ReadWrite`, and then select Add permissions.
+1. If `User.Read` is listed in the permission list, you can delete this.
+1. Click `Grant admin consent` for these permissions.
+
+#### Restrict mailbox access
+
+Note that for MailRoom to work as a service account, this application
+must have the `Mail.ReadWrite` to read/write mail in *all*
+mailboxes. However, while this appears to be security risk,
+we can configure an application access policy to limit the
+mailbox access for this account. [Follow these instructions](https://docs.microsoft.com/en-us/graph/auth-limit-mailbox-access)
+to setup PowerShell and configure this policy.
+
+#### MailRoom config for Microsoft Graph
+
+In the MailRoom configuration, set `inbox_method` to `microsoft_graph`.
+You will also need:
+
+* The client and tenant ID from the `Overview` section in the Azure app page
+* The client secret created earlier
+
+Fill in `inbox_options` with these values:
+
+```yaml
+    :inbox_method: microsoft_graph
+    :inbox_options:
+      :tenant_id: 12345
+      :client_id: ABCDE
+      :client_secret: YOUR-SECRET-HERE
+      :poll_interval: 60
+```
+
+By default, MailRoom will poll for new messages every 60 seconds. `poll_interval` configures the number of
+seconds to poll. Setting the value to 0 or under will default to 60 seconds.
+
 ## delivery_method ##
 
 ### postback ###
@@ -263,20 +365,12 @@ it's probably because the content-type is set to Faraday's default, which is  `H
 ## idle_timeout ##
 
 By default, the IDLE command will wait for 29 minutes (in order to keep the server connection happy).
-If you'd prefer not to wait that long, you can pass `imap_timeout` in seconds for your mailbox configuration.
+If you'd prefer not to wait that long, you can pass `idle_timeout` in seconds for your mailbox configuration.
 
 ## Search Command ##
 
 This setting allows configuration of the IMAP search command sent to the server. This still defaults 'UNSEEN'. You may find that 'NEW' works better for you.
 
-## IMAP Server Configuration ##
-
-You can set per-mailbox configuration for the IMAP server's `host` (default: 'imap.gmail.com'), `port` (default: 993), `ssl` (default: true), and `start_tls` (default: false).
-
-If you want to set additional options for IMAP SSL you can pass a YAML hash to match [SSLContext#set_params](http://docs.ruby-lang.org/en/2.2.0/OpenSSL/SSL/SSLContext.html#method-i-set_params). If you set `verify_mode` to `:none` it'll replace with the appropriate constant.
-
-If you're seeing the error `Please log in via your web browser: https://support.google.com/mail/accounts/answer/78754 (Failure)`, you need to configure your Gmail account to allow less secure apps to access it: https://support.google.com/accounts/answer/6010255.
-
 ## Running in Production ##
 
 I suggest running with either upstart or init.d. Check out this wiki page for some example scripts for both: https://github.com/tpitale/mail_room/wiki/Init-Scripts-for-Running-mail_room

data/Rakefile

@@ -3,4 +3,4 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/lib/mail_room.rb

@@ -7,8 +7,10 @@ end
 
 require "mail_room/version"
 require "mail_room/configuration"
+require "mail_room/health_check"
 require "mail_room/mailbox"
 require "mail_room/mailbox_watcher"
+require "mail_room/message"
 require "mail_room/connection"
 require "mail_room/coordinator"
 require "mail_room/cli"

data/lib/mail_room/arbitration/redis.rb

@@ -31,7 +31,7 @@ module MailRoom
         # Any subsequent failure in the instance which gets the lock will be dealt
         # with by the expiration, at which time another instance can pick up the
         # message and try again.
-        client.set(key, 1, {:nx => true, :ex => expiration})
+        client.set(key, 1, {nx: true, ex: expiration})
       end
 
       private

data/lib/mail_room/cli.rb

@@ -42,7 +42,7 @@ module MailRoom
       end.parse!(args)
 
       self.configuration = Configuration.new(options)
-      self.coordinator = Coordinator.new(configuration.mailboxes)
+      self.coordinator = Coordinator.new(configuration.mailboxes, configuration.health_check)
     end
 
     # Start the coordinator running, sets up signal traps

data/lib/mail_room/configuration.rb

@@ -4,7 +4,7 @@ module MailRoom
   # Wraps configuration for a set of individual mailboxes with global config
   # @author Tony Pitale
   class Configuration
-    attr_accessor :mailboxes, :log_path, :quiet
+    attr_accessor :mailboxes, :log_path, :quiet, :health_check
 
     # Initialize a new configuration of mailboxes
     def initialize(options={})
@@ -18,6 +18,7 @@ module MailRoom
           config_file = YAML.load(erb.result)
 
           set_mailboxes(config_file[:mailboxes])
+          set_health_check(config_file[:health_check])
         rescue => e
           raise e unless quiet
         end
@@ -32,5 +33,14 @@ module MailRoom
         self.mailboxes << Mailbox.new(attributes)
       end
     end
+
+    # Builds the health checker from YAML configuration
+    #
+    # @param health_check_config nil or a Hash containing :address and :port
+    def set_health_check(health_check_config)
+      return unless health_check_config
+
+      self.health_check = HealthCheck.new(health_check_config)
+    end
   end
 end

data/lib/mail_room/connection.rb

@@ -1,197 +1,21 @@
+# frozen_string_literal: true
+
 module MailRoom
   class Connection
+    attr_reader :mailbox, :new_message_handler
+
     def initialize(mailbox)
       @mailbox = mailbox
-
-      # log in and set the mailbox
-      reset
-      setup
     end
 
     def on_new_message(&block)
       @new_message_handler = block
     end
 
-    # is the connection logged in?
-    # @return [Boolean]
-    def logged_in?
-      @logged_in
-    end
-
-    # is the connection blocked idling?
-    # @return [Boolean]
-    def idling?
-      @idling
-    end
-
-    # is the imap connection closed?
-    # @return [Boolean]
-    def disconnected?
-      imap.disconnected?
-    end
-
-    # is the connection ready to idle?
-    # @return [Boolean]
-    def ready_to_idle?
-      logged_in? && !idling?
-    end
-
-    def quit
-      stop_idling
-      reset
-    end
-
     def wait
-      begin
-        # in case we missed any between idles
-        process_mailbox
-
-        idle
-
-        process_mailbox
-      rescue Net::IMAP::Error, IOError => e
-        @mailbox.logger.warn({ context: @mailbox.context, action: "Disconnected. Resetting...", error: e.message })
-        reset
-        setup
-      end
-    end
-
-    private
-
-    def reset
-      @imap = nil
-      @logged_in = false
-      @idling = false
-    end
-
-    def setup
-      @mailbox.logger.info({ context: @mailbox.context, action: "Starting TLS session" })
-      start_tls
-
-      @mailbox.logger.info({ context: @mailbox.context, action: "Logging into mailbox" })
-      log_in
-
-      @mailbox.logger.info({ context: @mailbox.context, action: "Setting mailbox" })
-      set_mailbox
-    end
-
-    # build a net/imap connection to google imap
-    def imap
-      @imap ||= Net::IMAP.new(@mailbox.host, :port => @mailbox.port, :ssl => @mailbox.ssl_options)
-    end
-
-    # start a TLS session
-    def start_tls
-      imap.starttls if @mailbox.start_tls
-    end
-
-    # send the imap login command to google
-    def log_in
-      imap.login(@mailbox.email, @mailbox.password)
-      @logged_in = true
-    end
-
-    # select the mailbox name we want to use
-    def set_mailbox
-      imap.select(@mailbox.name) if logged_in?
-    end
-
-    # is the response for a new message?
-    # @param response [Net::IMAP::TaggedResponse] the imap response from idle
-    # @return [Boolean]
-    def message_exists?(response)
-      response.respond_to?(:name) && response.name == 'EXISTS'
-    end
-
-    # @private
-    def idle_handler
-      lambda {|response| imap.idle_done if message_exists?(response)}
+      raise NotImplementedError
     end
 
-    # maintain an imap idle connection
-    def idle
-      return unless ready_to_idle?
-
-      @mailbox.logger.info({ context: @mailbox.context, action: "Idling" })
-      @idling = true
-
-      imap.idle(@mailbox.idle_timeout, &idle_handler)
-    ensure
-      @idling = false
-    end
-
-    # trigger the idle to finish and wait for the thread to finish
-    def stop_idling
-      return unless idling?
-
-      imap.idle_done
-
-      # idling_thread.join
-      # self.idling_thread = nil
-    end
-
-    def process_mailbox
-      return unless @new_message_handler
-      @mailbox.logger.info({ context: @mailbox.context, action: "Processing started" })
-
-      msgs = new_messages
-
-      any_deletions = msgs.
-                      # deliver each new message, collect success
-                      map(&@new_message_handler).
-                      # include messages with success
-                      zip(msgs).
-                      # filter failed deliveries, collect message
-                      select(&:first).map(&:last).
-                      # scrub delivered messages
-                      map { |message| scrub(message) }.
-                      any?
-
-      imap.expunge if @mailbox.expunge_deleted && any_deletions
-    end
-
-    def scrub(message)
-      if @mailbox.delete_after_delivery
-        imap.store(message.seqno, "+FLAGS", [Net::IMAP::DELETED])
-        true
-      end
-    end
-
-    # @private
-    # fetch all messages for the new message ids
-    def new_messages
-      # Both of these calls may results in
-      #   imap raising an EOFError, we handle
-      #   this exception in the watcher
-      messages_for_ids(new_message_ids)
-    end
-
-    # TODO: label messages?
-    #   @imap.store(id, "+X-GM-LABELS", [label])
-
-    # @private
-    # search for all new (unseen) message ids
-    # @return [Array<Integer>] message ids
-    def new_message_ids
-      # uid_search still leaves messages UNSEEN
-      all_unread = imap.uid_search(@mailbox.search_command)
-
-      all_unread = all_unread.slice(0, @mailbox.limit_max_unread) unless @mailbox.limit_max_unread.nil? || @mailbox.limit_max_unread == 0
-
-      to_deliver = all_unread.select { |uid| @mailbox.deliver?(uid) }
-      @mailbox.logger.info({ context: @mailbox.context, action: "Getting new messages", unread: {count: all_unread.count, ids: all_unread}, to_be_delivered: { count: to_deliver.count, ids: to_deliver } })
-      to_deliver
-    end
-
-    # @private
-    # fetch the email for all given ids in RFC822 format
-    # @param ids [Array<Integer>] list of message ids
-    # @return [Array<Net::IMAP::FetchData>] the net/imap messages for the given ids
-    def messages_for_ids(uids)
-      return [] if uids.empty?
-
-      # uid_fetch marks as SEEN, will not be re-fetched for UNSEEN
-      imap.uid_fetch(uids, "RFC822")
-    end
+    def quit; end
   end
 end