imap-backup 2.2.2 → 3.2.1

data/lib/email/mboxrd/message.rb

@@ -10,9 +10,11 @@ module Email::Mboxrd
       cleaned = serialized.gsub(/^>(>*From)/, "\\1")
       # Serialized messages in this format *should* start with a line
       #   From xxx yy zz
+      # rubocop:disable Style/IfUnlessModifier
       if cleaned.start_with?("From ")
         cleaned = cleaned.sub(/^From .*[\r\n]*/, "")
       end
+      # rubocop:enable Style/IfUnlessModifier
       new(cleaned)
     end
 

data/lib/email/provider.rb

@@ -1,6 +1,8 @@
 module Email; end
 
 class Email::Provider
+  GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
+
   def self.for_address(address)
     case
     when address.end_with?("@fastmail.com")
@@ -27,7 +29,7 @@ class Email::Provider
   def host
     case provider
     when :gmail
-      "imap.gmail.com"
+      GMAIL_IMAP_SERVER
     when :fastmail
       "imap.fastmail.com"
     end

data/lib/gmail/authenticator.rb

@@ -0,0 +1,160 @@
+require "googleauth"
+require "google/auth/stores/in_memory_token_store"
+
+module Gmail; end
+
+class Gmail::Authenticator
+  class MalformedImapBackupToken < StandardError; end
+
+  class ImapBackupToken
+    attr_reader :token
+
+    def self.from(
+      access_token:,
+      client_id:,
+      client_secret:,
+      expiration_time_millis:,
+      refresh_token:
+    )
+      {
+        access_token: access_token,
+        client_id: client_id,
+        client_secret: client_secret,
+        expiration_time_millis: expiration_time_millis,
+        refresh_token: refresh_token
+      }.to_json
+    end
+
+    def initialize(token)
+      @token = token
+    end
+
+    def valid?
+      return false if !body
+      return false if !access_token
+      return false if !client_id
+      return false if !client_secret
+      return false if !expiration_time_millis
+      return false if !refresh_token
+
+      true
+    end
+
+    def access_token
+      body["access_token"]
+    end
+
+    def client_id
+      body["client_id"]
+    end
+
+    def client_secret
+      body["client_secret"]
+    end
+
+    def expiration_time_millis
+      body["expiration_time_millis"]
+    end
+
+    def refresh_token
+      body["refresh_token"]
+    end
+
+    private
+
+    def body
+      @body ||= JSON.parse(token)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+
+  GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
+  OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
+
+  attr_reader :email
+  attr_reader :token
+
+  def self.refresh_token?(text)
+    ImapBackupToken.new(text).valid?
+  end
+
+  def initialize(email:, token:)
+    @email = email
+    @token = token
+  end
+
+  def authorization_url
+    authorizer.get_authorization_url(base_url: OOB_URI)
+  end
+
+  def credentials
+    authorizer.get_credentials(email).tap do |c|
+      c.refresh! if c.expired?
+    end
+  end
+
+  def credentials_from_code(code)
+    authorizer.get_credentials_from_code(
+      user_id: email,
+      code: code,
+      base_url: OOB_URI
+    )
+  end
+
+  private
+
+  def auth_client_id
+    @auth_client_id = Google::Auth::ClientId.new(client_id, client_secret)
+  end
+
+  def authorizer
+    @authorizer ||= Google::Auth::UserAuthorizer.new(
+      auth_client_id, GMAIL_READ_SCOPE, token_store
+    )
+  end
+
+  def access_token
+    imap_backup_token.access_token
+  end
+
+  def client_id
+    imap_backup_token.client_id
+  end
+
+  def client_secret
+    imap_backup_token.client_secret
+  end
+
+  def expiration_time_millis
+    imap_backup_token.expiration_time_millis
+  end
+
+  def refresh_token
+    imap_backup_token.refresh_token
+  end
+
+  def imap_backup_token
+    @imap_backup_token ||=
+      ImapBackupToken.new(token).tap do |t|
+        raise MalformedImapBackupToken if !t.valid?
+      end
+  end
+
+  def store_token
+    {
+      "client_id" => client_id,
+      "access_token" => access_token,
+      "refresh_token" => refresh_token,
+      "scope": [GMAIL_READ_SCOPE],
+      "expiration_time_millis": expiration_time_millis
+    }.to_json
+  end
+
+  def token_store
+    @token_store ||=
+      Google::Auth::Stores::InMemoryTokenStore.new.tap do |t|
+        t.store(email, store_token)
+      end
+  end
+end

data/lib/google/auth/stores/in_memory_token_store.rb

@@ -0,0 +1,9 @@
+module Google; end
+module Google::Auth; end
+module Google::Auth::Stores; end
+
+class Google::Auth::Stores::InMemoryTokenStore < Hash
+  def load(id)
+    self[id]
+  end
+end

data/lib/imap/backup.rb

@@ -7,6 +7,7 @@ require "imap/backup/configuration/account"
 require "imap/backup/configuration/asker"
 require "imap/backup/configuration/connection_tester"
 require "imap/backup/configuration/folder_chooser"
+require "imap/backup/configuration/gmail_oauth2"
 require "imap/backup/configuration/list"
 require "imap/backup/configuration/setup"
 require "imap/backup/configuration/store"
@@ -28,7 +29,7 @@ module Imap::Backup
     attr_reader :logger
 
     def initialize
-      @logger = ::Logger.new(STDOUT)
+      @logger = ::Logger.new($stdout)
     end
   end
 

data/lib/imap/backup/account/connection.rb

@@ -1,9 +1,19 @@
 require "net/imap"
+require "gmail_xoauth"
+
+require "gmail/authenticator"
+require "retry_on_error"
 
 module Imap::Backup
   module Account; end
 
   class Account::Connection
+    class InvalidGmailOauth2RefreshToken < StandardError; end
+
+    include RetryOnError
+
+    LOGIN_RETRY_CLASSES = [EOFError, Errno::ECONNRESET, SocketError].freeze
+
     attr_reader :connection_options
     attr_reader :local_path
     attr_reader :password
@@ -13,7 +23,7 @@ module Imap::Backup
       @username = options[:username]
       @password = options[:password]
       @local_path = options[:local_path]
-      @backup_folders = options[:folders]
+      @config_folders = options[:folders]
       @server = options[:server]
       @connection_options = options[:connection_options] || {}
       @folders = nil
@@ -24,21 +34,24 @@ module Imap::Backup
       @folders ||=
         begin
           root = provider_root
-          @folders = imap.list(root, "*")
-          if @folders.nil?
-            Imap::Backup.logger.warn(
-              "Unable to get folder list for account #{username}"
-            )
+          mailbox_lists = imap.list(root, "*")
+
+          if mailbox_lists.nil?
+            message = "Unable to get folder list for account #{username}"
+            Imap::Backup.logger.info message
+            raise message
           end
-          @folders
+
+          utf7_encoded = mailbox_lists.map(&:name)
+          utf7_encoded.map { |n| Net::IMAP.decode_utf7(n) }
         end
     end
 
     def status
-      backup_folders.map do |folder|
-        f = Account::Folder.new(self, folder[:name])
-        s = Serializer::Mbox.new(local_path, folder[:name])
-        {name: folder[:name], local: s.uids, remote: f.uids}
+      backup_folders.map do |backup_folder|
+        f = Account::Folder.new(self, backup_folder[:name])
+        s = Serializer::Mbox.new(local_path, backup_folder[:name])
+        {name: backup_folder[:name], local: s.uids, remote: f.uids}
       end
     end
 
@@ -71,25 +84,42 @@ module Imap::Backup
     end
 
     def imap
-      return @imap unless @imap.nil?
+      @imap ||=
+        retry_on_error(errors: LOGIN_RETRY_CLASSES) do
+          options = provider_options
+          Imap::Backup.logger.debug(
+            "Creating IMAP instance: #{server}, options: #{options.inspect}"
+          )
+          imap = Net::IMAP.new(server, options)
+          if gmail? && Gmail::Authenticator.refresh_token?(password)
+            authenticator = Gmail::Authenticator.new(email: username, token: password)
+            credentials = authenticator.credentials
+            raise InvalidGmailOauth2RefreshToken if !credentials
+
+            Imap::Backup.logger.debug "Logging in with OAuth2 token: #{username}"
+            imap.authenticate("XOAUTH2", username, credentials.access_token)
+          else
+            Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
+            imap.login(username, password)
+          end
+          Imap::Backup.logger.debug "Login complete"
+          imap
+        end
+    end
 
-      options = provider_options
-      Imap::Backup.logger.debug(
-        "Creating IMAP instance: #{server}, options: #{options.inspect}"
-      )
-      @imap = Net::IMAP.new(server, options)
-      Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
-      @imap.login(username, password)
-      Imap::Backup.logger.debug "Login complete"
-      @imap
+    def server
+      return @server if @server
+      return nil if provider.nil?
+
+      @server = provider.host
     end
 
     private
 
     def each_folder
-      backup_folders.each do |folder_info|
-        folder = Account::Folder.new(self, folder_info[:name])
-        serializer = Serializer::Mbox.new(local_path, folder_info[:name])
+      backup_folders.each do |backup_folder|
+        folder = Account::Folder.new(self, backup_folder[:name])
+        serializer = Serializer::Mbox.new(local_path, backup_folder[:name])
         yield folder, serializer
       end
     end
@@ -133,10 +163,8 @@ module Imap::Backup
       password.gsub(/./, "x")
     end
 
-    def backup_folders
-      return @backup_folders if @backup_folders && !@backup_folders.empty?
-
-      (folders || []).map { |f| {name: f.name} }
+    def gmail?
+      server == Email::Provider::GMAIL_IMAP_SERVER
     end
 
     def local_folders
@@ -150,15 +178,19 @@ module Imap::Backup
       end
     end
 
-    def provider
-      @provider ||= Email::Provider.for_address(username)
+    def backup_folders
+      @backup_folders ||=
+        begin
+          if @config_folders&.any?
+            @config_folders
+          else
+            folders.map { |name| {name: name} }
+          end
+        end
     end
 
-    def server
-      return @server if @server
-      return nil if provider.nil?
-
-      @server = provider.host
+    def provider
+      @provider ||= Email::Provider.for_address(username)
     end
 
     def provider_options

data/lib/imap/backup/account/folder.rb

@@ -1,5 +1,7 @@
 require "forwardable"
 
+require "retry_on_error"
+
 module Imap::Backup
   module Account; end
 
@@ -7,8 +9,10 @@ module Imap::Backup
 
   class Account::Folder
     extend Forwardable
+    include RetryOnError
 
     REQUESTED_ATTRIBUTES = %w[RFC822 FLAGS INTERNALDATE].freeze
+    UID_FETCH_RETRY_CLASSES = [EOFError].freeze
 
     attr_reader :connection
     attr_reader :name
@@ -36,7 +40,7 @@ module Imap::Backup
     def create
       return if exist?
 
-      imap.create(name)
+      imap.create(utf7_encoded_name)
     end
 
     def uid_validity
@@ -66,7 +70,10 @@ module Imap::Backup
 
     def fetch(uid)
       examine
-      fetch_data_items = imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
+      fetch_data_items =
+        retry_on_error(errors: UID_FETCH_RETRY_CLASSES) do
+          imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
+        end
       return nil if fetch_data_items.nil?
 
       fetch_data_item = fetch_data_items[0]
@@ -81,22 +88,27 @@ module Imap::Backup
     def append(message)
       body = message.imap_body
       date = message.date&.to_time
-      response = imap.append(name, body, nil, date)
+      response = imap.append(utf7_encoded_name, body, nil, date)
       extract_uid(response)
     end
 
     private
 
     def examine
-      imap.examine(name)
+      imap.examine(utf7_encoded_name)
     rescue Net::IMAP::NoResponseError
-      Imap::Backup.logger.warn "Folder '#{name}' does not exist"
-      raise FolderNotFound, "Folder '#{name}' does not exist"
+      Imap::Backup.logger.warn "Folder '#{name}' does not exist on server"
+      raise FolderNotFound, "Folder '#{name}' does not exist on server"
     end
 
     def extract_uid(response)
       @uid_validity, uid = response.data.code.data.split(" ").map(&:to_i)
       uid
     end
+
+    def utf7_encoded_name
+      @utf7_encoded_name ||=
+        Net::IMAP.encode_utf7(name).force_encoding("ASCII-8BIT")
+    end
   end
 end