imap-backup 4.0.4 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69ed28d85dda7c3d30cd6c8d4a9888e9f477eedd6f8ff08741fcc7d27cf087f8
-  data.tar.gz: 1a99e7143052a1d0b1b2d58381c5f9da0db2b1e0e3882c24e56036cebead043f
+  metadata.gz: d6302ae17c5b96de2f99c6683c4a6403edbf80d2afc51cbe0f471918251cfaef
+  data.tar.gz: 349c0b68911a751e670176a91dfc98d4359a06a9cb8acae7c2cc5d5efa028f25
 SHA512:
-  metadata.gz: deb80ed5d629c81253574d96a7da0dcc6382eb6d5216c1f317b8083ca0f4dac80a3188cbc0b7f46ffbc01229dad9ab913858649558ca7b3a29bf7b81395bcce3
-  data.tar.gz: 2e6b2b8d2c67c6bc1e3ff5dcbb91c4eec92d0edb87ff33ad6e8a360b6635895c72cc7eb4cc68a7ff24bcfbad5a3533bda0a916e3c4d0c40ee67de70a010d4b2b
+  metadata.gz: 444432d3bf689fa12de1226cb84e9f8975a300f2c94cc2529254e1e3680fba6d7b0cfddfc3fff9001a866dd5d84d1afabc0e952e894ec5ae1a91557ea5538472
+  data.tar.gz: f4d156790a84308e08ee3d4348741e6d55b26f07fece75473a80f4fc0b7c0265c1bb62230cee178bf4c00941ff0de91a323ade1c0e0783a72a970c738c8823f0

data/bin/imap-backup

@@ -2,7 +2,10 @@
 
 $LOAD_PATH.unshift(File.expand_path("../lib/", __dir__))
 require "imap/backup/cli"
+require "imap/backup/logger"
 
-Imap::Backup::Configuration::List.new.setup_logging
+Imap::Backup::Logger.setup_logging
 
-Imap::Backup::CLI.start(ARGV)
+Imap::Backup::Logger.sanitize_stderr do
+  Imap::Backup::CLI.start(ARGV)
+end

data/lib/email/provider/apple_mail.rb

@@ -1,6 +1,6 @@
-require "email/provider/default"
+require "email/provider/base"
 
-class Email::Provider::AppleMail < Email::Provider::Default
+class Email::Provider::AppleMail < Email::Provider::Base
   def host
     "imap.mail.me.com"
   end

data/lib/email/provider/base.rb

@@ -0,0 +1,8 @@
+module Email; end
+class Email::Provider; end
+
+class Email::Provider::Base
+  def options
+    {port: 993, ssl: {ssl_version: :TLSv1_2}}
+  end
+end

data/lib/email/provider/fastmail.rb

@@ -1,6 +1,6 @@
-require "email/provider/default"
+require "email/provider/base"
 
-class Email::Provider::Fastmail < Email::Provider::Default
+class Email::Provider::Fastmail < Email::Provider::Base
   def host
     "imap.fastmail.com"
   end

data/lib/email/provider/gmail.rb

@@ -1,6 +1,6 @@
-require "email/provider/default"
+require "email/provider/base"
 
-class Email::Provider::GMail < Email::Provider::Default
+class Email::Provider::GMail < Email::Provider::Base
   def host
     "imap.gmail.com"
   end

data/lib/email/provider/{default.rb → unknown.rb}

@@ -1,7 +1,6 @@
-module Email; end
-class Email::Provider; end
+require "email/provider/base"
 
-class Email::Provider::Default
+class Email::Provider::Unknown < Email::Provider::Base
   # We don't know how to guess the IMAP server
   def host
   end

data/lib/email/provider.rb

@@ -1,7 +1,7 @@
-require "email/provider/default"
 require "email/provider/apple_mail"
 require "email/provider/fastmail"
 require "email/provider/gmail"
+require "email/provider/unknown"
 
 module Email; end
 
@@ -21,7 +21,7 @@ class Email::Provider
     when address.end_with?("@me.com")
       Email::Provider::AppleMail.new
     else
-      Email::Provider::Default.new
+      Email::Provider::Unknown.new
     end
   end
 end

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

@@ -4,63 +4,74 @@ require "imap/backup/client/default"
 require "retry_on_error"
 
 module Imap::Backup
-  module Account; end
+  class Account; end
 
   class Account::Connection
     include RetryOnError
 
     LOGIN_RETRY_CLASSES = [EOFError, Errno::ECONNRESET, SocketError].freeze
 
-    attr_reader :connection_options
-    attr_reader :local_path
-    attr_reader :password
-    attr_reader :username
-
-    def initialize(options)
-      @username = options[:username]
-      @password = options[:password]
-      @local_path = options[:local_path]
-      @config_folders = options[:folders]
-      @server = options[:server]
-      @connection_options = options[:connection_options] || {}
-      @folders = nil
+    attr_reader :account
+
+    def initialize(account)
+      @account = account
+      reset
       create_account_folder
     end
 
-    def folders
-      @folders ||=
+    # TODO: Make this private once the 'folders' command
+    # has been removed.
+    def folder_names
+      @folder_names ||=
         begin
-          folders = client.list
+          folder_names = client.list
 
-          if folders.empty?
-            message = "Unable to get folder list for account #{username}"
-            Imap::Backup.logger.info message
+          if folder_names.empty?
+            message = "Unable to get folder list for account #{account.username}"
+            Imap::Backup::Logger.logger.info message
             raise message
           end
 
-          folders
+          folder_names
+        end
+    end
+
+    def backup_folders
+      @backup_folders ||=
+        begin
+          names =
+            if account.folders&.any?
+              account.folders.map { |af| af[:name] }
+            else
+              folder_names
+            end
+
+          names.map do |name|
+            Account::Folder.new(self, name)
+          end
         end
     end
 
     def status
-      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}
+      backup_folders.map do |folder|
+        s = Serializer::Mbox.new(account.local_path, folder.name)
+        {name: folder.name, local: s.uids, remote: folder.uids}
       end
     end
 
     def run_backup
-      Imap::Backup.logger.debug "Running backup of account: #{username}"
+      Imap::Backup::Logger.logger.debug "Running backup of account: #{account.username}"
       # start the connection so we get logging messages in the right order
       client
       each_folder do |folder, serializer|
         next if !folder.exist?
 
-        Imap::Backup.logger.debug "[#{folder.name}] running backup"
+        Imap::Backup::Logger.logger.debug "[#{folder.name}] running backup"
         serializer.apply_uid_validity(folder.uid_validity)
         begin
-          Downloader.new(folder, serializer).run
+          Downloader.new(
+            folder, serializer, block_size: config.download_block_size
+          ).run
         rescue Net::IMAP::ByeResponseError
           reconnect
           retry
@@ -71,11 +82,11 @@ module Imap::Backup
     def local_folders
       return enum_for(:local_folders) if !block_given?
 
-      glob = File.join(local_path, "**", "*.imap")
-      base = Pathname.new(local_path)
+      glob = File.join(account.local_path, "**", "*.imap")
+      base = Pathname.new(account.local_path)
       Pathname.glob(glob) do |path|
         name = path.relative_path_from(base).to_s[0..-6]
-        serializer = Serializer::Mbox.new(local_path, name)
+        serializer = Serializer::Mbox.new(account.local_path, name)
         folder = Account::Folder.new(self, name)
         yield serializer, folder
       end
@@ -89,18 +100,27 @@ module Imap::Backup
 
     def disconnect
       client.disconnect if @client
+      reset
     end
 
     def reconnect
       disconnect
+    end
+
+    def reset
+      @backup_folders = nil
       @client = nil
+      @config = nil
+      @folder_names = nil
+      @provider = nil
+      @server = nil
     end
 
     def client
       @client ||=
         retry_on_error(errors: LOGIN_RETRY_CLASSES) do
           options = provider_options
-          Imap::Backup.logger.debug(
+          Imap::Backup::Logger.logger.debug(
             "Creating IMAP instance: #{server}, options: #{options.inspect}"
           )
           client =
@@ -109,23 +129,22 @@ module Imap::Backup
             else
               Client::Default.new(server, options)
             end
-          Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
-          client.login(username, password)
-          Imap::Backup.logger.debug "Login complete"
+          Imap::Backup::Logger.logger.debug "Logging in: #{account.username}/#{masked_password}"
+          client.login(account.username, account.password)
+          Imap::Backup::Logger.logger.debug "Login complete"
           client
         end
     end
 
     def server
-      @server ||= provider.host
+      @server ||= account.server || provider.host
     end
 
     private
 
     def each_folder
-      backup_folders.each do |backup_folder|
-        folder = Account::Folder.new(self, backup_folder[:name])
-        serializer = Serializer::Mbox.new(local_path, backup_folder[:name])
+      backup_folders.each do |folder|
+        serializer = Serializer::Mbox.new(account.local_path, folder.name)
         yield folder, serializer
       end
     end
@@ -133,16 +152,16 @@ module Imap::Backup
     def restore_folder(serializer, folder)
       existing_uids = folder.uids
       if existing_uids.any?
-        Imap::Backup.logger.debug(
+        Imap::Backup::Logger.logger.debug(
           "There's already a '#{folder.name}' folder with emails"
         )
         new_name = serializer.apply_uid_validity(folder.uid_validity)
         old_name = serializer.folder
         if new_name
-          Imap::Backup.logger.debug(
+          Imap::Backup::Logger.logger.debug(
             "Backup '#{old_name}' renamed and restored to '#{new_name}'"
           )
-          new_serializer = Serializer::Mbox.new(local_path, new_name)
+          new_serializer = Serializer::Mbox.new(account.local_path, new_name)
           new_folder = Account::Folder.new(self, new_name)
           new_folder.create
           new_serializer.force_uid_validity(new_folder.uid_validity)
@@ -159,33 +178,26 @@ module Imap::Backup
 
     def create_account_folder
       Utils.make_folder(
-        File.dirname(local_path),
-        File.basename(local_path),
+        File.dirname(account.local_path),
+        File.basename(account.local_path),
         Serializer::DIRECTORY_PERMISSIONS
       )
     end
 
     def masked_password
-      password.gsub(/./, "x")
-    end
-
-    def backup_folders
-      @backup_folders ||=
-        begin
-          if @config_folders&.any?
-            @config_folders
-          else
-            folders.map { |name| {name: name} }
-          end
-        end
+      account.password.gsub(/./, "x")
     end
 
     def provider
-      @provider ||= Email::Provider.for_address(username)
+      @provider ||= Email::Provider.for_address(account.username)
     end
 
     def provider_options
-      provider.options.merge(connection_options)
+      provider.options.merge(account.connection_options || {})
+    end
+
+    def config
+      @config ||= Configuration.new
     end
   end
 end

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

@@ -3,7 +3,7 @@ require "forwardable"
 require "retry_on_error"
 
 module Imap::Backup
-  module Account; end
+  class Account; end
 
   class FolderNotFound < StandardError; end
 
@@ -64,7 +64,7 @@ module Imap::Backup
         in `search_internal` in stdlib net/imap.rb.
         This is caused by `@responses["SEARCH"] being unset/undefined
       MESSAGE
-      Imap::Backup.logger.warn message
+      Imap::Backup::Logger.logger.warn message
       []
     end
 
@@ -84,6 +84,26 @@ module Imap::Backup
       nil
     end
 
+    def fetch_multi(uids)
+      examine
+      fetch_data_items =
+        retry_on_error(errors: UID_FETCH_RETRY_CLASSES) do
+          client.uid_fetch(uids, [BODY_ATTRIBUTE])
+        end
+      return nil if fetch_data_items.nil?
+
+      fetch_data_items.map do |item|
+        attributes = item.attr
+
+        {
+          uid: attributes["UID"],
+          body: attributes[BODY_ATTRIBUTE]
+        }
+      end
+    rescue FolderNotFound
+      nil
+    end
+
     def append(message)
       body = message.imap_body
       date = message.date&.to_time
@@ -96,7 +116,7 @@ module Imap::Backup
     def examine
       client.examine(utf7_encoded_name)
     rescue Net::IMAP::NoResponseError
-      Imap::Backup.logger.warn "Folder '#{name}' does not exist on server"
+      Imap::Backup::Logger.logger.warn "Folder '#{name}' does not exist on server"
       raise FolderNotFound, "Folder '#{name}' does not exist on server"
     end
 

data/lib/imap/backup/account.rb

@@ -0,0 +1,102 @@
+module Imap::Backup
+  class Account
+    attr_reader :username
+    attr_reader :password
+    attr_reader :local_path
+    attr_reader :folders
+    attr_reader :server
+    attr_reader :connection_options
+    attr_reader :changes
+    attr_reader :marked_for_deletion
+
+    def initialize(options)
+      @username = options[:username]
+      @password = options[:password]
+      @local_path = options[:local_path]
+      @folders = options[:folders]
+      @server = options[:server]
+      @connection_options = options[:connection_options]
+      @changes = {}
+      @marked_for_deletion = false
+    end
+
+    def connection
+      Account::Connection.new(self)
+    end
+
+    def valid?
+      username && password
+    end
+
+    def modified?
+      changes.any?
+    end
+
+    def clear_changes!
+      @changes = {}
+    end
+
+    def mark_for_deletion!
+      @marked_for_deletion = true
+    end
+
+    def marked_for_deletion?
+      @marked_for_deletion
+    end
+
+    def to_h
+      h = {
+        username: @username,
+        password: @password,
+      }
+      h[:local_path] = @local_path if @local_path
+      h[:folders] = @folders if @folders
+      h[:server] = @server if @server
+      h[:connection_options] = @connection_options if @connection_options
+      h
+    end
+
+    def username=(value)
+      update(:username, value)
+    end
+
+    def password=(value)
+      update(:password, value)
+    end
+
+    def local_path=(value)
+      update(:local_path, value)
+    end
+
+    def folders=(value)
+      raise "folders must be an Array" if !value.is_a?(Array)
+      update(:folders, value)
+    end
+
+    def server=(value)
+      update(:server, value)
+    end
+
+    def connection_options=(value)
+      parsed = JSON.parse(value)
+      update(:connection_options, parsed)
+    end
+
+    private
+
+    def update(field, value)
+      if changes[field]
+        change = changes[field]
+        changes.delete(field) if change[:from] == value
+      end
+      set_field!(field, value)
+    end
+
+    def set_field!(field, value)
+      key = :"@#{field}"
+      current = instance_variable_get(key)
+      changes[field] = {from: current, to: value}
+      instance_variable_set(key, value)
+    end
+  end
+end

data/lib/imap/backup/cli/accounts.rb

@@ -0,0 +1,43 @@
+module Imap::Backup
+  class CLI; end
+
+  class CLI::Accounts
+    include Enumerable
+
+    attr_reader :required_accounts
+
+    def initialize(required_accounts = [])
+      @required_accounts = required_accounts
+    end
+
+    def each(&block)
+      return enum_for(:each) if !block
+
+      accounts.each(&block)
+    end
+
+    private
+
+    def accounts
+      @accounts ||=
+        if required_accounts.empty?
+          config.accounts
+        else
+          config.accounts.select do |account|
+            required_accounts.include?(account.username)
+          end
+        end
+    end
+
+    def config
+      @config ||= begin
+        exists = Configuration.exist?
+        if !exists
+          path = Configuration.default_pathname
+          raise ConfigurationNotFound, "Configuration file '#{path}' not found"
+        end
+        Configuration.new
+      end
+    end
+  end
+end

data/lib/imap/backup/cli/folders.rb

@@ -14,7 +14,9 @@ module Imap::Backup
       def run
         each_connection(account_names) do |connection|
           puts connection.username
-          folders = connection.folders
+          # TODO: Make folder_names private once this command
+          # has been removed.
+          folders = connection.folder_names
           if folders.nil?
             warn "Unable to list account folders"
             return false

data/lib/imap/backup/cli/helpers.rb

@@ -1,4 +1,5 @@
 require "imap/backup"
+require "imap/backup/cli/accounts"
 
 module Imap::Backup::CLI::Helpers
   def symbolized(options)
@@ -6,8 +7,8 @@ module Imap::Backup::CLI::Helpers
   end
 
   def account(email)
-    connections = Imap::Backup::Configuration::List.new
-    account = connections.accounts.find { |a| a[:username] == email }
+    accounts = Imap::Backup::CLI::Accounts.new
+    account = accounts.find { |a| a.username == email }
     raise "#{email} is not a configured account" if !account
 
     account
@@ -20,14 +21,12 @@ module Imap::Backup::CLI::Helpers
   end
 
   def each_connection(names)
-    begin
-      connections = Imap::Backup::Configuration::List.new(names)
-    rescue Imap::Backup::ConfigurationNotFound
-      raise "imap-backup is not configured. Run `imap-backup setup`"
-    end
+    accounts = Imap::Backup::CLI::Accounts.new(names)
 
-    connections.each_connection do |connection|
-      yield connection
+    accounts.each do |account|
+      yield account.connection
     end
+  rescue Imap::Backup::ConfigurationNotFound
+    raise "imap-backup is not configured. Run `imap-backup setup`"
   end
 end

data/lib/imap/backup/cli/local.rb

@@ -1,3 +1,5 @@
+require "imap/backup/cli/accounts"
+
 module Imap::Backup
   class CLI::Local < Thor
     include Thor::Actions
@@ -5,8 +7,8 @@ module Imap::Backup
 
     desc "accounts", "List locally backed-up accounts"
     def accounts
-      connections = Imap::Backup::Configuration::List.new
-      connections.accounts.each { |a| Kernel.puts a[:username] }
+      accounts = CLI::Accounts.new
+      accounts.each { |a| Kernel.puts a.username }
     end
 
     desc "folders EMAIL", "List account folders"

data/lib/imap/backup/cli/setup.rb

@@ -7,7 +7,7 @@ class Imap::Backup::CLI::Setup < Thor
 
   no_commands do
     def run
-      Imap::Backup::Configuration::Setup.new.run
+      Imap::Backup::Setup.new.run
     end
   end
 end

data/lib/imap/backup/cli/utils.rb

@@ -11,9 +11,10 @@ module Imap::Backup
     def ignore_history(email)
       connection = connection(email)
 
-      connection.local_folders.each do |serializer, folder|
+      connection.backup_folders.each do |folder|
         next if !folder.exist?
 
+        serializer = Serializer::Mbox.new(connection.account.local_path, folder.name)
         do_ignore_folder_history(folder, serializer)
       end
     end
@@ -63,7 +64,7 @@ module Imap::Backup
     no_commands do
       def do_ignore_folder_history(folder, serializer)
         uids = folder.uids - serializer.uids
-        Imap::Backup.logger.info "Folder '#{folder.name}' - #{uids.length} messages"
+        Imap::Backup::Logger.logger.info "Folder '#{folder.name}' - #{uids.length} messages"
 
         serializer.apply_uid_validity(folder.uid_validity)