backup 3.0.20 → 3.0.21

data/lib/backup/storage/ftp.rb

@@ -25,47 +25,30 @@ module Backup
       attr_accessor :passive_mode
 
       ##
-      # This is the remote path to where the backup files will be stored
-      def remote_path
-        File.join(path, TRIGGER, @time)
-      end
-
-      ##
-      # Performs the backup transfer
-      def perform!
-        super
-        transfer!
-        cycle!
-      end
-
-    private
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
 
-      ##
-      # Set configuration defaults before evaluating configuration block,
-      # after setting defaults from Storage::Base
-      def pre_configure
-        super
         @port         ||= 21
         @path         ||= 'backups'
         @passive_mode ||= false
-      end
 
-      ##
-      # Adjust configuration after evaluating configuration block,
-      # after adjustments from Storage::Base
-      def post_configure
-        super
+        instance_eval(&block) if block_given?
+
         @path = path.sub(/^\~\//, '')
       end
 
+      private
+
       ##
-      # Establishes a connection to the remote server and returns the Net::FTP object.
+      # Establishes a connection to the remote server
       #
-      # Note *
-      # Since the FTP port is defined as a constant in the Net::FTP class, and might be required
-      # to change by the user, we dynamically remove and re-add the constant with the provided port value
+      # Note:
+      # Since the FTP port is defined as a constant in the Net::FTP class, and
+      # might be required to change by the user, we dynamically remove and
+      # re-add the constant with the provided port value
       def connection
-        if defined? Net::FTP::FTP_PORT
+        if Net::FTP.const_defined?(:FTP_PORT)
           Net::FTP.send(:remove_const, :FTP_PORT)
         end; Net::FTP.send(:const_set, :FTP_PORT, port)
 
@@ -78,10 +61,12 @@ module Backup
       ##
       # Transfers the archived file to the specified remote server
       def transfer!
+        remote_path = remote_path_for(@package)
+
         connection do |ftp|
-          create_remote_directories(ftp)
+          create_remote_path(remote_path, ftp)
 
-          files_to_transfer do |local_file, remote_file|
+          files_to_transfer_for(@package) do |local_file, remote_file|
             Logger.message "#{storage_name} started transferring " +
                 "'#{ local_file }' to '#{ ip }'."
             ftp.put(
@@ -93,10 +78,14 @@ module Backup
       end
 
       ##
-      # Removes the transferred archive file from the server
-      def remove!
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
         connection do |ftp|
-          transferred_files do |local_file, remote_file|
+          transferred_files_for(package) do |local_file, remote_file|
             Logger.message "#{storage_name} started removing " +
                 "'#{ local_file }' from '#{ ip }'."
 
@@ -110,11 +99,12 @@ module Backup
       ##
       # Creates (if they don't exist yet) all the directories on the remote
       # server in order to upload the backup file. Net::FTP does not support
-      # paths to directories that don't yet exist when creating new directories.
-      # Instead, we split the parts up in to an array (for each '/') and loop through
-      # that to create the directories one by one. Net::FTP raises an exception when
-      # the directory it's trying to create already exists, so we have rescue it
-      def create_remote_directories(ftp)
+      # paths to directories that don't yet exist when creating new
+      # directories. Instead, we split the parts up in to an array (for each
+      # '/') and loop through that to create the directories one by one.
+      # Net::FTP raises an exception when the directory it's trying to create
+      # already exists, so we have rescue it
+      def create_remote_path(remote_path, ftp)
         path_parts = Array.new
         remote_path.split('/').each do |path_part|
           path_parts << path_part

data/lib/backup/storage/local.rb

@@ -1,70 +1,54 @@
 # encoding: utf-8
 
-##
-# Load the Ruby FileUtils library
-require 'fileutils'
-
 module Backup
   module Storage
     class Local < Base
 
       ##
-      # Path to store backups to
+      # Path where the backup will be stored.
       attr_accessor :path
 
       ##
-      # This is the remote path to where the backup files will be stored.
-      # Eventhough it says "remote", it's actually the "local" path, but
-      # the naming is necessary for compatibility reasons
-      def remote_path
-        File.join(path, TRIGGER, @time)
-      end
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
 
-      ##
-      # Performs the backup transfer
-      def perform!
-        super
-        transfer!
-        cycle!
-      end
+        @path ||= File.join(
+          File.expand_path(ENV['HOME'] || ''),
+          'backups'
+        )
 
-    private
+        instance_eval(&block) if block_given?
 
-      ##
-      # Set configuration defaults before evaluating configuration block,
-      # after setting defaults from Storage::Base
-      def pre_configure
-        super
-        @path ||= "#{ENV['HOME']}/backups"
+        @path = File.expand_path(@path)
       end
 
-      ##
-      # Adjust configuration after evaluating configuration block,
-      # after adjustments from Storage::Base
-      def post_configure
-        super
-        @path = File.expand_path(path)
-      end
+      private
 
       ##
-      # Transfers the archived file to the specified local path
+      # Transfers the archived file to the specified path
       def transfer!
-        create_local_directories!
+        remote_path = remote_path_for(@package)
+        FileUtils.mkdir_p(remote_path)
 
-        files_to_transfer do |local_file, remote_file|
+        files_to_transfer_for(@package) do |local_file, remote_file|
           Logger.message "#{storage_name} started transferring '#{ local_file }'."
-          FileUtils.cp(
-            File.join(local_path, local_file),
-            File.join(remote_path, remote_file)
-          )
+
+          src_path = File.join(local_path, local_file)
+          dst_path = File.join(remote_path, remote_file)
+          FileUtils.send(transfer_method, src_path, dst_path)
         end
       end
 
       ##
-      # Removes the transferred archive file from the local path
-      def remove!
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
         messages = []
-        transferred_files do |local_file, remote_file|
+        transferred_files_for(package) do |local_file, remote_file|
           messages << "#{storage_name} started removing '#{ local_file }'."
         end
         Logger.message messages.join("\n")
@@ -73,9 +57,24 @@ module Backup
       end
 
       ##
-      # Creates the path to where the backups are stored if it doesn't exist yet
-      def create_local_directories!
-        FileUtils.mkdir_p(remote_path)
+      # Set and return the transfer method.
+      # If this Local Storage is not the last Storage for the Model,
+      # force the transfer to use a *copy* operation and issue a warning.
+      def transfer_method
+        return @transfer_method if @transfer_method
+
+        if self == @model.storages.last
+          @transfer_method = :mv
+        else
+          Logger.warn Errors::Storage::Local::TransferError.new(<<-EOS)
+            Local File Copy Warning!
+            The final backup file(s) for '#{@model.label}' (#{@model.trigger})
+            will be *copied* to '#{remote_path_for(@package)}'
+            To avoid this, when using more than one Storage, the 'Local' Storage
+            should be added *last* so the files may be *moved* to their destination.
+          EOS
+          @transfer_method = :cp
+        end
       end
 
     end

data/lib/backup/storage/ninefold.rb

@@ -17,48 +17,26 @@ module Backup
       attr_accessor :path
 
       ##
-      # This is the remote path to where the backup files will be stored
-      def remote_path
-        File.join(path, TRIGGER, @time).sub(/^\//, '')
-      end
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
 
-      ##
-      # This is the provider that Fog uses for the Ninefold storage
-      def provider
-        'Ninefold'
-      end
+        @path ||= 'backups'
 
-      ##
-      # Performs the backup transfer
-      def perform!
-        super
-        transfer!
-        cycle!
+        instance_eval(&block) if block_given?
       end
 
-    private
 
-      ##
-      # Set configuration defaults before evaluating configuration block,
-      # after setting defaults from Storage::Base
-      def pre_configure
-        super
-        @path ||= 'backups'
-      end
+      private
 
       ##
-      # Adjust configuration after evaluating configuration block,
-      # after adjustments from Storage::Base
-      def post_configure
-        super
+      # This is the provider that Fog uses for the Ninefold storage
+      def provider
+        'Ninefold'
       end
 
       ##
-      # Establishes a connection to Amazon S3 and returns the Fog object.
-      # Not doing any instance variable caching because this object gets persisted in YAML
-      # format to a file and will issues. This, however has no impact on performance since it only
-      # gets invoked once per object for a #transfer! and once for a remove! Backups run in the
-      # background anyway so even if it were a bit slower it shouldn't matter.
+      # Establishes a connection to Amazon S3
       def connection
         @connection ||= Fog::Storage.new(
           :provider                => provider,
@@ -67,41 +45,69 @@ module Backup
         )
       end
 
+      ##
+      # Queries the connection for the directory for the given +remote_path+
+      # Returns nil if not found, or creates the directory if +create+ is true.
+      def directory_for(remote_path, create = false)
+        directory = connection.directories.get(remote_path)
+        if directory.nil? && create
+          directory = connection.directories.create(:key => remote_path)
+        end
+        directory
+      end
+
+      def remote_path_for(package)
+        super(package).sub(/^\//, '')
+      end
+
       ##
       # Transfers the archived file to the specified directory
       def transfer!
-        files_to_transfer do |local_file, remote_file|
+        remote_path = remote_path_for(@package)
+
+        directory = directory_for(remote_path, true)
+
+        files_to_transfer_for(@package) do |local_file, remote_file|
           Logger.message "#{storage_name} started transferring '#{ local_file }'."
-          directory   = connection.directories.get(remote_path)
-          directory ||= connection.directories.create(:key => remote_path)
-          directory.files.create(
-            :key  => remote_file,
-            :body => File.open(File.join(local_path, local_file))
-          )
+
+          File.open(File.join(local_path, local_file), 'r') do |file|
+            directory.files.create(:key => remote_file, :body => file)
+          end
         end
       end
 
       ##
-      # Removes the transferred archive file from the Amazon S3 bucket
-      def remove!
-        if directory = connection.directories.get(remote_path)
-          transferred_files do |local_file, remote_file|
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        if directory = directory_for(remote_path)
+          not_found = []
+
+          transferred_files_for(package) do |local_file, remote_file|
             Logger.message "#{storage_name} started removing " +
-                "'#{ local_file }' from Ninefold.'"
+                "'#{ local_file }' from Ninefold."
 
             if file = directory.files.get(remote_file)
               file.destroy
             else
-              # Note: Fog-0.11.0 will return nil if remote_file is not found
-              raise Errors::Storage::Ninefold::NotFoundError,
-                  "'#{remote_file}' not found in '#{remote_path}'", caller(1)
+              not_found << remote_file
             end
           end
+
           directory.destroy
+
+          unless not_found.empty?
+            raise Errors::Storage::Ninefold::NotFoundError, <<-EOS
+                The following file(s) were not found in '#{ remote_path }'
+                #{ not_found.join("\n") }
+            EOS
+          end
         else
-          # Note: Fog-0.11.0 will return nil if remote_path is not found
           raise Errors::Storage::Ninefold::NotFoundError,
-              "Directory at '#{remote_path}' not found", caller(1)
+              "Directory at '#{remote_path}' not found"
         end
       end
 

data/lib/backup/storage/rsync.rb

@@ -1,9 +1,5 @@
 # encoding: utf-8
 
-##
-# Require the tempfile Ruby library when Backup::Storage::RSync is loaded
-require 'tempfile'
-
 ##
 # Only load the Net::SSH library when the Backup::Storage::RSync class is loaded
 Backup::Dependency.load('net-ssh')
@@ -30,83 +26,79 @@ module Backup
       attr_accessor :local
 
       ##
-      # This is the remote path to where the backup files will be stored
-      def remote_path
-        File.join(path, TRIGGER)
-      end
-
-      ##
-      # Performs the backup transfer
-      def perform!
-        super
-        write_password_file!
-        transfer!
-      ensure
-        remove_password_file!
-      end
-
-    private
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
 
-      ##
-      # Set configuration defaults before evaluating configuration block,
-      # after setting defaults from Storage::Base
-      def pre_configure
-        super
         @port   ||= 22
         @path   ||= 'backups'
         @local  ||= false
+
+        instance_eval(&block) if block_given?
+
+        @path = path.sub(/^\~\//, '')
       end
 
+      private
+
       ##
-      # Adjust configuration after evaluating configuration block,
-      # after adjustments from Storage::Base
-      def post_configure
-        super
-        @path = path.sub(/^\~\//, '')
+      # This is the remote path to where the backup files will be stored
+      #
+      # Note: This overrides the superclass' method
+      def remote_path_for(package)
+        File.join(path, package.trigger)
       end
 
       ##
-      # Establishes a connection to the remote server and returns the Net::SSH object.
+      # Establishes a connection to the remote server
       def connection
-        Net::SSH.start(ip, username, :password => password, :port => port) do |ssh|
-          yield ssh
-        end
+        Net::SSH.start(
+          ip, username, :password => password, :port => port
+        ) {|ssh| yield ssh }
       end
 
       ##
       # Transfers the archived file to the specified remote server
       def transfer!
-        create_remote_directories!
-
-        Logger.message "#{storage_name} started transferring " +
-            "'#{ filename }' to '#{ ip }'."
-
-        if local
-          run(
-            "#{ utility(:rsync) } '#{ File.join(local_path, filename) }' " +
-            "'#{ File.join(remote_path, filename[20..-1]) }'"
-          )
-        else
-          run(
-            "#{ utility(:rsync) } #{ rsync_options } #{ rsync_port } " +
-            "#{ rsync_password_file } '#{ File.join(local_path, filename) }' " +
-            "'#{ username }@#{ ip }:#{ File.join(remote_path, filename[20..-1]) }'"
-          )
+        write_password_file! unless local
+
+        remote_path = remote_path_for(@package)
+
+        create_remote_path!(remote_path)
+
+        files_to_transfer_for(@package) do |local_file, remote_file|
+          if local
+            Logger.message "#{storage_name} started transferring " +
+                "'#{ local_file }' to '#{ remote_path }'."
+            run(
+              "#{ utility(:rsync) } '#{ File.join(local_path, local_file) }' " +
+              "'#{ File.join(remote_path, remote_file) }'"
+            )
+          else
+            Logger.message "#{storage_name} started transferring " +
+                "'#{ local_file }' to '#{ ip }'."
+            run(
+              "#{ utility(:rsync) } #{ rsync_options } #{ rsync_port } " +
+              "#{ rsync_password_file } '#{ File.join(local_path, local_file) }' " +
+              "'#{ username }@#{ ip }:#{ File.join(remote_path, remote_file) }'"
+            )
+          end
         end
+
+      ensure
+        remove_password_file! unless local
       end
 
       ##
-      # Note: RSync::Storage doesn't cycle
-      def remove!
-        nil
-      end
+      # Note: Storage::RSync doesn't cycle
+      def remove!; end
 
       ##
       # Creates (if they don't exist yet) all the directories on the remote
       # server in order to upload the backup file.
-      def create_remote_directories!
+      def create_remote_path!(remote_path)
         if @local
-          mkdir(remote_path)
+          FileUtils.mkdir_p(remote_path)
         else
           connection do |ssh|
             ssh.exec!("mkdir -p '#{ remote_path }'")
@@ -130,6 +122,7 @@ module Backup
       # (temporary file containing the password)
       def remove_password_file!
         @password_file.delete if @password_file
+        @password_file = nil
       end
 
       ##