backup 3.0.20 → 3.0.21

data/lib/backup/dependency.rb

@@ -9,7 +9,6 @@ module Backup
   # has not been installed, or when the gem's version is incorrect, and provide the
   # command to install the gem. These dependencies are dynamically loaded in the Gemfile
   class Dependency
-    extend Backup::CLI
 
     ##
     # Returns a hash of dependencies that Backup requires
@@ -22,9 +21,9 @@ module Backup
           :for     => 'Amazon S3, Rackspace Cloud Files (S3, CloudFiles Storages)'
         },
 
-        'dropbox' => {
-          :require => 'dropbox',
-          :version => '~> 1.3.0',
+        'dropbox-sdk' => {
+          :require => 'dropbox_sdk',
+          :version => '~> 1.1.0',
           :for     => 'Dropbox Web Service (Dropbox Storage)'
         },
 
@@ -101,7 +100,7 @@ module Backup
           > gem install #{name} -v '#{all[name][:version]}'
           Please try again after installing the missing dependency.
         EOS
-        exit
+        exit 1
       end
     end
 

data/lib/backup/encryptor/base.rb

@@ -6,11 +6,23 @@ module Backup
       include Backup::CLI::Helpers
       include Backup::Configuration::Helpers
 
+      def initialize
+        load_defaults!
+      end
+
+      private
+
+      ##
+      # Return the encryptor name, with Backup namespace removed
+      def encryptor_name
+        self.class.to_s.sub('Backup::', '')
+      end
+
       ##
       # Logs a message to the console and log file to inform
       # the client that Backup is encrypting the archive
       def log!
-        Logger.message "#{ self.class } started encrypting the archive."
+        Logger.message "Using #{ encryptor_name } to encrypt the archive."
       end
     end
   end

data/lib/backup/encryptor/gpg.rb

@@ -1,9 +1,5 @@
 # encoding: utf-8
 
-##
-# Require the tempfile Ruby library when Backup::Encryptor::GPG is loaded
-require 'tempfile'
-
 module Backup
   module Encryptor
     class GPG < Base
@@ -12,67 +8,71 @@ module Backup
       # The GPG Public key that'll be used to encrypt the backup
       attr_accessor :key
 
-      ##
-      # Contains the GPG encryption key id which'll be extracted from the public key file
-      attr_accessor :encryption_key_id
-
-      ##
-      # Contains the temporary file with the public key
-      attr_accessor :tmp_file
-
       ##
       # Creates a new instance of Backup::Encryptor::GPG and
       # sets the key to the provided GPG key. To enhance the DSL
       # the user may use tabs and spaces to indent the multi-line key string
       # since we gsub() every preceding 'space' and 'tab' on each line
       def initialize(&block)
-        load_defaults!
+        super
 
         instance_eval(&block) if block_given?
-
-        @key = key.gsub(/^[[:blank:]]+/, '')
       end
 
       ##
-      # Performs the encrypting of the backup file and will
-      # remove the unencrypted backup file, as well as the temp file
-      def perform!
+      # This is called as part of the procedure run by the Packager.
+      # It sets up the needed encryption_key_email to pass to the gpg command,
+      # then yields the command to use as part of the packaging procedure.
+      # Once the packaging procedure is complete, it will return
+      # so that any clean-up may be performed after the yield.
+      def encrypt_with
         log!
-        write_tmp_file!
-        extract_encryption_key_id!
+        extract_encryption_key_email!
 
-        run("#{ utility(:gpg) } #{ options } -o '#{ Backup::Model.file }.gpg' '#{ Backup::Model.file }'")
+        yield "#{ utility(:gpg) } #{ options }", '.gpg'
+      end
 
-        rm(Backup::Model.file)
-        tmp_file.unlink
+      private
 
-        Backup::Model.extension += '.gpg'
+      ##
+      # Imports the given encryption key to ensure it's available for use,
+      # and extracts the email address used to create the key.
+      # This is stored in '@encryption_key_email', to be used to specify
+      # the --recipient when performing encryption so this key is used.
+      def extract_encryption_key_email!
+        if @encryption_key_email.to_s.empty?
+          with_tmp_key_file do |tmp_file|
+            @encryption_key_email = run(
+              "#{ utility(:gpg) } --import '#{tmp_file}' 2>&1"
+            ).match(/<(.+)>/)[1]
+          end
+        end
       end
 
-    private
-
       ##
       # GPG options
-      # Sets the gpg mode to 'encrypt' and passes in the encryption_key_id
+      # Sets the gpg mode to 'encrypt' and passes in the encryption_key_email
       def options
-        "-e --trust-model always -r '#{ encryption_key_id }'"
+        "-e --trust-model always -r '#{ @encryption_key_email }'"
       end
 
       ##
-      # Creates a new temp file and writes the provided public gpg key to it
-      def write_tmp_file!
-        @tmp_file = Tempfile.new('backup.pub')
-        FileUtils.chown(USER, nil, @tmp_file.path)
-        FileUtils.chmod(0600, @tmp_file.path)
-        @tmp_file.write(key)
-        @tmp_file.close
+      # Writes the provided public gpg key to a temp file,
+      # yields the path, then deletes the file when the block returns.
+      def with_tmp_key_file
+        tmp_file = Tempfile.new('backup.pub')
+        FileUtils.chown(Config.user, nil, tmp_file.path)
+        FileUtils.chmod(0600, tmp_file.path)
+        tmp_file.write(encryption_key)
+        tmp_file.close
+        yield tmp_file.path
+        tmp_file.delete
       end
 
       ##
-      # Extracts the 'encryption key id' from the '@tmp_file'
-      # and stores it in '@encryption_key_id'
-      def extract_encryption_key_id!
-        @encryption_key_id = run("#{ utility(:gpg) } --import '#{tmp_file.path}' 2>&1").match(/<(.+)>/)[1]
+      # Returns the encryption key with preceding spaces and tabs removed
+      def encryption_key
+        key.gsub(/^[[:blank:]]+/, '')
       end
 
     end

data/lib/backup/encryptor/open_ssl.rb

@@ -15,66 +15,56 @@ module Backup
 
       ##
       # Determines whether the 'base64' should be used or not
-      attr_writer :base64
+      attr_accessor :base64
 
       ##
       # Determines whether the 'salt' flag should be used
-      attr_writer :salt
+      attr_accessor :salt
 
       ##
       # Creates a new instance of Backup::Encryptor::OpenSSL and
       # sets the password attribute to what was provided
       def initialize(&block)
-        load_defaults!
+        super
 
         @base64        ||= false
-        @salt          ||= false
+        @salt          ||= true
         @password_file ||= nil
 
         instance_eval(&block) if block_given?
       end
 
       ##
-      # Performs the encryption of the backup file
-      def perform!
+      # This is called as part of the procedure run by the Packager.
+      # It sets up the needed options to pass to the openssl command,
+      # then yields the command to use as part of the packaging procedure.
+      # Once the packaging procedure is complete, it will return
+      # so that any clean-up may be performed after the yield.
+      def encrypt_with
         log!
-        run("#{ utility(:openssl) } #{ options } -in '#{ Backup::Model.file }' -out '#{ Backup::Model.file }.enc'")
-        rm(Backup::Model.file)
-        Backup::Model.extension += '.enc'
+        yield "#{ utility(:openssl) } #{ options }", '.enc'
       end
 
-    private
+      private
 
       ##
-      # Backup::Encryptor::OpenSSL uses the 256bit AES encryption cipher.
-      # 256bit AES is what the US Government uses to encrypt information at the "Top Secret" level.
-      def options
-        (['aes-256-cbc'] + base64 + salt + pass).join("\s")
-      end
-
-      ##
-      # Returns '-base64' if @base64 is set to 'true'.
-      # This option will make the encrypted output base64 encoded,
+      # Uses the 256bit AES encryption cipher, which is what the
+      # US Government uses to encrypt information at the "Top Secret" level.
+      #
+      # The -base64 option will make the encrypted output base64 encoded,
       # this makes the encrypted file readable using text editors
-      def base64
-        return ['-base64'] if @base64; []
-      end
-
-      ##
-      # Returns '-salt' if @salt is set to 'true'.
-      # This options adds strength to the encryption
-      def salt
-        return ['-salt'] if @salt; []
-      end
-
-      ##
-      # Returns '-pass file:<password file>' when @password_file has been set.
-      def pass
-        if @password_file
-          ["-pass file:#{@password_file}"]
-        else
-          ["-k '#{@password}'"]
-        end
+      #
+      # The -salt option adds strength to the encryption
+      #
+      # Always sets a password option, if even no password is given,
+      # but will prefer the password_file option if both are given.
+      def options
+        opts = ['aes-256-cbc']
+        opts << '-base64' if @base64
+        opts << '-salt'   if @salt
+        opts << ( @password_file.to_s.empty? ?
+                "-k '#{@password}'" : "-pass file:#{@password_file}" )
+        opts.join(' ')
       end
 
     end

data/lib/backup/logger.rb

@@ -4,6 +4,8 @@ module Backup
   module Logger
     class << self
 
+      attr_accessor :quiet
+
       ##
       # Outputs a messages to the console and writes it to the backup.log
       def message(string)
@@ -58,6 +60,22 @@ module Backup
         @has_warnings = false
       end
 
+      def truncate!(max_bytes = 500_000)
+        log_file = File.join(Config.log_path, 'backup.log')
+        if File.stat(log_file).size > max_bytes
+          FileUtils.mv(log_file, log_file + '~')
+          File.open(log_file + '~', 'r') do |io_in|
+            File.open(log_file, 'w') do |io_out|
+              io_in.seek(-max_bytes, IO::SEEK_END) && io_in.gets
+              while line = io_in.gets
+                io_out.puts line
+              end
+            end
+          end
+          FileUtils.rm_f(log_file + '~')
+        end
+      end
+
       private
 
       ##
@@ -86,14 +104,14 @@ module Backup
       ##
       # Receives an Array of Strings to be written to the console.
       def to_console(lines, stderr = false)
-        return if quiet?
+        return if quiet
         lines.each {|line| stderr ? Kernel.warn(line) : puts(line) }
       end
 
       ##
       # Receives an Array of Strings to be written to the log file.
       def to_file(lines)
-        File.open(File.join(LOG_PATH, 'backup.log'), 'a') do |file|
+        File.open(File.join(Config.log_path, 'backup.log'), 'a') do |file|
           lines.each {|line| file.puts line }
         end
         messages.push(*lines)
@@ -127,15 +145,6 @@ module Backup
         "\e[#{code}m#{string}\e[0m"
       end
 
-      ##
-      # Returns 'true' (boolean) if the QUIET constant is defined
-      # By default it isn't defined, only when initializing Backup using
-      # the '--quiet' (or '-q') option in the CLI
-      # (e.g. backup perform -t my_backup --quiet)
-      def quiet?
-        const_defined?(:QUIET) && QUIET
-      end
-
     end
   end
 end

data/lib/backup/model.rb

@@ -4,196 +4,186 @@ module Backup
   class Model
     include Backup::CLI::Helpers
 
-    ##
-    # The trigger is used as an identifier for
-    # initializing the backup process
-    attr_accessor :trigger
+    class << self
+      ##
+      # The Backup::Model.all class method keeps track of all the models
+      # that have been instantiated. It returns the @all class variable,
+      # which contains an array of all the models
+      def all
+        @all ||= []
+      end
 
-    ##
-    # The label is used for a more friendly user output
-    attr_accessor :label
+      ##
+      # Return the first model matching +trigger+.
+      # Raises Errors::MissingTriggerError if no matches are found.
+      def find(trigger)
+        trigger = trigger.to_s
+        all.each do |model|
+          return model if model.trigger == trigger
+        end
+        raise Errors::Model::MissingTriggerError,
+            "Could not find trigger '#{trigger}'."
+      end
+
+      ##
+      # Find and return an Array of all models matching +trigger+
+      # Used to match triggers using a wildcard (*)
+      def find_matching(trigger)
+        regex = /^#{ trigger.to_s.gsub('*', '(.*)') }$/
+        all.select {|model| regex =~ model.trigger }
+      end
+    end
 
     ##
-    # The databases attribute holds an array of database objects
-    attr_accessor :databases
+    # The trigger (stored as a String) is used as an identifier
+    # for initializing the backup process
+    attr_reader :trigger
 
     ##
-    # The archives attr_accessor holds an array of archive objects
-    attr_accessor :archives
+    # The label (stored as a String) is used for a more friendly user output
+    attr_reader :label
 
     ##
-    # The encryptors attr_accessor holds an array of encryptor objects
-    attr_accessor :encryptors
+    # The databases attribute holds an array of database objects
+    attr_reader :databases
 
     ##
-    # The compressors attr_accessor holds an array of compressor objects
-    attr_accessor :compressors
+    # The archives attr_accessor holds an array of archive objects
+    attr_reader :archives
 
     ##
     # The notifiers attr_accessor holds an array of notifier objects
-    attr_accessor :notifiers
+    attr_reader :notifiers
 
     ##
     # The storages attribute holds an array of storage objects
-    attr_accessor :storages
+    attr_reader :storages
 
     ##
     # The syncers attribute holds an array of syncer objects
-    attr_accessor :syncers
+    attr_reader :syncers
 
     ##
-    # The chunk_size attribute holds the size of the chunks in megabytes
-    attr_accessor :chunk_size
+    # Holds the configured Compressor
+    attr_reader :compressor
 
     ##
-    # The time when the backup initiated (in format: 2011.02.20.03.29.59)
-    attr_accessor :time
-
-    class << self
-      ##
-      # The Backup::Model.all class method keeps track of all the models
-      # that have been instantiated. It returns the @all class variable,
-      # which contains an array of all the models
-      attr_accessor :all
-
-      ##
-      # Contains the current file extension (this changes from time to time after a file
-      # gets compressed or encrypted so we can keep track of the correct file when new
-      # extensions get appended to the current file name)
-      attr_accessor :extension
-
-      ##
-      # Contains the currently-in-use model. This attribute should get set by Backup::Finder.
-      # Use Backup::Model.current to retrieve the actual data of the model
-      attr_accessor :current
-
-      ##
-      # Contains an array of chunk suffixes for a given file
-      attr_accessor :chunk_suffixes
-
-      ##
-      # Returns the full path to the current file (including the current extension).
-      # To just return the filename and extension without the path, use File.basename(Backup::Model.file)
-      def file
-        File.join(TMP_PATH, "#{ TIME }.#{ TRIGGER }.#{ Backup::Model.extension }")
-      end
-
-      ##
-      # Returns the @chunk_suffixes variable, sets it to an emtpy array if nil
-      def chunk_suffixes
-        @chunk_suffixes ||= Array.new
-      end
+    # Holds the configured Encryptor
+    attr_reader :encryptor
 
-      ##
-      # Returns the temporary trigger path of the current model
-      # e.g. /Users/Michael/tmp/backup/my_trigger
-      def tmp_path
-        File.join(TMP_PATH, TRIGGER)
-      end
-    end
+    ##
+    # Holds the configured Splitter
+    attr_reader :splitter
 
     ##
-    # Accessible through "Backup::Model.all", it stores an array of Backup::Model instances.
-    # Everytime a new Backup::Model gets instantiated it gets pushed into this array
-    @all = Array.new
+    # The final backup Package this model will create.
+    attr_reader :package
 
     ##
-    # Contains the current file extension (should change after each compression or encryption)
-    @extension = 'tar'
+    # The time when the backup initiated (in format: 2011.02.20.03.29.59)
+    attr_reader :time
 
     ##
-    # Takes a trigger, label and the configuration block and instantiates the model.
-    # The TIME (time of execution) gets stored in the @time attribute.
-    # After the instance has evaluated the configuration block and properly set the
-    # configuration for the model, it will append the newly created "model" instance
-    # to the @all class variable (Array) so it can be accessed by Backup::Finder
-    # and any other location
+    # Takes a trigger, label and the configuration block.
+    # After the instance has evaluated the configuration block
+    # to configure the model, it will be appended to Model.all
     def initialize(trigger, label, &block)
-      @trigger     = trigger
-      @label       = label
-      @time        = TIME
+      @trigger = trigger.to_s
+      @label   = label.to_s
 
       procedure_instance_variables.each do |variable|
         instance_variable_set(variable, Array.new)
       end
 
-      instance_eval(&block)
-      Backup::Model.all << self
-    end
-
-    ##
-    # Adds a database to the array of databases
-    # to dump during the backup process
-    def database(database, &block)
-      @databases << Backup::Database.const_get(
-        last_constant(database)
-      ).new(&block)
+      instance_eval(&block) if block_given?
+      Model.all << self
     end
 
     ##
     # Adds an archive to the array of archives
     # to store during the backup process
     def archive(name, &block)
-      @archives << Backup::Archive.new(name, &block)
+      @archives << Archive.new(self, name, &block)
     end
 
     ##
-    # Adds an encryptor to the array of encryptors
-    # to use during the backup process
-    def encrypt_with(name, &block)
-      @encryptors << Backup::Encryptor.const_get(
-        last_constant(name)
-      ).new(&block)
+    # Adds a database to the array of databases
+    # to dump during the backup process
+    def database(name, &block)
+      @databases << get_class_from_scope(Database, name).new(self, &block)
     end
 
     ##
-    # Adds a compressor to the array of compressors
-    # to use during the backup process
-    def compress_with(name, &block)
-      @compressors << Backup::Compressor.const_get(
-        last_constant(name)
-      ).new(&block)
+    # Adds a storage method to the array of storage
+    # methods to use during the backup process
+    def store_with(name, storage_id = nil, &block)
+      @storages << get_class_from_scope(Storage, name).new(self, storage_id, &block)
+    end
+
+    ##
+    # Adds a syncer method to the array of syncer
+    # methods to use during the backup process
+    def sync_with(name, &block)
+      ##
+      # Warn user of DSL change from 'RSync' to 'RSync::Local'
+      if name.to_s == 'Backup::Config::RSync'
+        Logger.warn Errors::ConfigError.new(<<-EOS)
+          Configuration Update Needed for Syncer::RSync
+          The RSync Syncer has been split into three separate modules:
+          RSync::Local, RSync::Push and RSync::Pull
+          Please update your configuration for your local RSync Syncer
+          from 'sync_with RSync do ...' to 'sync_with RSync::Local do ...'
+        EOS
+        name = Backup::Config::RSync::Local
+      end
+      @syncers << get_class_from_scope(Syncer, name).new(&block)
     end
 
     ##
     # Adds a notifier to the array of notifiers
     # to use during the backup process
     def notify_by(name, &block)
-      @notifiers << Backup::Notifier.const_get(
-        last_constant(name)
-      ).new(&block)
+      @notifiers << get_class_from_scope(Notifier, name).new(self, &block)
     end
 
     ##
-    # Adds a storage method to the array of storage
-    # methods to use during the backup process
-    def store_with(storage, storage_id = nil, &block)
-      @storages << Backup::Storage.const_get(
-        last_constant(storage)
-      ).new(storage_id, &block)
+    # Adds an encryptor to use during the backup process
+    def encrypt_with(name, &block)
+      @encryptor = get_class_from_scope(Encryptor, name).new(&block)
     end
 
     ##
-    # Adds a syncer method to the array of syncer
-    # methods to use during the backup process
-    def sync_with(syncer, &block)
-      @syncers << Backup::Syncer.const_get(
-        last_constant(syncer)
-      ).new(&block)
+    # Adds a compressor to use during the backup process
+    def compress_with(name, &block)
+      @compressor = get_class_from_scope(Compressor, name).new(&block)
     end
 
     ##
-    # Adds a method that allows the user to set the @chunk_size.
-    # The chunk_size (in megabytes) will later determine in how many chunks the
-    # backup needs to be split
-    def split_into_chunks_of(chunk_size = nil)
-      @chunk_size = chunk_size
+    # Adds a method that allows the user to configure this backup model
+    # to use a Splitter, with the given +chunk_size+
+    # The +chunk_size+ (in megabytes) will later determine
+    # in how many chunks the backup needs to be split into
+    def split_into_chunks_of(chunk_size)
+      if chunk_size.is_a?(Integer)
+        @splitter = Splitter.new(self, chunk_size)
+      else
+        raise Errors::Model::ConfigurationError, <<-EOS
+          Invalid Chunk Size for Splitter
+          Argument to #split_into_chunks_of() must be an Integer
+        EOS
+      end
     end
 
     ##
-    # Returns the path to the current file (including proper extension)
-    def file
-      Backup::Model.file
+    # Ensure DATA_PATH and DATA_PATH/TRIGGER are created
+    # if they do not yet exist
+    #
+    # Clean any temporary files and/or package files left over
+    # from the last time this model/trigger was performed.
+    # Logs warnings if files exist and are cleaned.
+    def prepare!
+      FileUtils.mkdir_p(File.join(Config.data_path, trigger))
+      Cleaner.prepare(self)
     end
 
     ##
@@ -211,10 +201,10 @@ module Backup
     # the folder, it'll make a single .tar package (archive) out of it
     ##
     # [Encryption]
-    # Optionally encrypts the packaged file with one or more encryptors
+    # Optionally encrypts the packaged file with the configured encryptor
     ##
     # [Compression]
-    # Optionally compresses the packaged file with one or more compressors
+    # Optionally compresses the each Archive and Database dump with the configured compressor
     ##
     # [Splitting]
     # Optionally splits the backup file in to multiple smaller chunks before transferring them
@@ -234,11 +224,21 @@ module Backup
     # any errors.
     ##
     # [Cleaning]
-    # After the whole backup process finishes, it'll go ahead and remove any temporary
-    # file that it produced. If an exception(error) is raised during this process which
-    # breaks the process, it'll always ensure it removes the temporary files regardless
-    # to avoid mass consumption of storage space on the machine
+    # Once the final Packaging is complete, the temporary folder used will be removed.
+    # Then, once all Storages have run, the final packaged files will be removed.
+    # If any errors occur during the backup process, all temporary files will be left in place.
+    # If the error occurs before Packaging, then the temporary folder (tmp_path/trigger)
+    # will remain and may contain all or some of the configured Archives and/or Database dumps.
+    # If the error occurs after Packaging, but before the Storages complete, then the final
+    # packaged files (located in the root of tmp_path) will remain.
+    # *** Important *** If an error occurs and any of the above mentioned temporary files remain,
+    # those files *** will be removed *** before the next scheduled backup for the same trigger.
+    #
     def perform!
+      @started_at = Time.now
+      @time = @started_at.strftime("%Y.%m.%d.%H.%M.%S")
+      log!(:started)
+
       if databases.any? or archives.any?
         procedures.each do |procedure|
           (procedure.call; next) if procedure.is_a?(Proc)
@@ -247,27 +247,29 @@ module Backup
       end
 
       syncers.each(&:perform!)
-      notifiers.each { |n| n.perform!(self) }
+      notifiers.each(&:perform!)
+      log!(:finished)
 
     rescue Exception => err
       fatal = !err.is_a?(StandardError)
 
-      Logger.error Backup::Errors::ModelError.wrap(err, <<-EOS)
+      err = Errors::ModelError.wrap(err, <<-EOS)
         Backup for #{label} (#{trigger}) Failed!
         An Error occured which has caused this Backup to abort before completion.
-        Please review the Log for this Backup to determine if steps need to be taken
-        to clean up, based on the point at which the failure occured.
       EOS
-      Logger.error "\nBacktrace:\n" + err.backtrace.join("\n\s\s") + "\n\n"
+      Logger.error err
+      Logger.error "\nBacktrace:\n\s\s" + err.backtrace.join("\n\s\s") + "\n\n"
+
+      Cleaner.warnings(self)
 
       if fatal
-        Logger.error Backup::Errors::ModelError.new(<<-EOS)
+        Logger.error Errors::ModelError.new(<<-EOS)
           This Error was Fatal and Backup will now exit.
           If you have other Backup jobs (triggers) configured to run,
           they will not be processed.
         EOS
       else
-        Logger.message Backup::Errors::ModelError.new(<<-EOS)
+        Logger.message Errors::ModelError.new(<<-EOS)
           If you have other Backup jobs (triggers) configured to run,
           Backup will now attempt to continue...
         EOS
@@ -275,58 +277,99 @@ module Backup
 
       notifiers.each do |n|
         begin
-          n.perform!(self, err)
+          n.perform!(true)
         rescue Exception; end
       end
 
       exit(1) if fatal
-    ensure
-      clean!
     end
 
-  private
+    private
 
     ##
     # After all the databases and archives have been dumped and sorted,
-    # these files will be bundled in to a .tar archive (uncompressed) so it
-    # becomes a single (transferrable) packaged file.
+    # these files will be bundled in to a .tar archive (uncompressed),
+    # which may be optionally Encrypted and/or Split into multiple "chunks".
+    # All information about this final archive is stored in the @package.
+    # Once complete, the temporary folder used during packaging is removed.
     def package!
-      Backup::Packager.new(self).package!
+      @package = Package.new(self)
+      Packager.package!(self)
+      Cleaner.remove_packaging(self)
     end
 
     ##
-    # Create a new instance of Backup::Splitter,
-    # passing it the current model instance and runs it.
-    def split!
-      Backup::Splitter.new(self).split!
-    end
-
-    ##
-    # Cleans up the temporary files that were created after the backup process finishes
+    # Removes the final package file(s) once all configured Storages have run.
     def clean!
-      Backup::Cleaner.new(self).clean!
+      Cleaner.remove_package(@package)
     end
 
     ##
     # Returns an array of procedures
     def procedures
-      Array.new([
-        databases, archives, lambda { package! }, compressors,
-        encryptors, lambda { split! }, storages
-      ])
+      [databases, archives, lambda { package! }, storages, lambda { clean! }]
     end
 
     ##
     # Returns an Array of the names (String) of the procedure instance variables
     def procedure_instance_variables
-      [:@databases, :@archives, :@encryptors, :@compressors, :@storages, :@notifiers, :@syncers]
+      [:@databases, :@archives, :@storages, :@notifiers, :@syncers]
+    end
+
+    ##
+    # Returns the class/model specified by +name+ inside of +scope+.
+    # +scope+ should be a Class/Module.
+    # +name+ may be Class/Module or String representation
+    # of any namespace which exists under +scope+.
+    #
+    # The 'Backup::Config::' namespace is stripped from +name+,
+    # since this is the namespace where we define module namespaces
+    # for use with Model's DSL methods.
+    #
+    # Examples:
+    #   get_class_from_scope(Backup::Database, 'MySQL')
+    #     returns the class Backup::Database::MySQL
+    #
+    #   get_class_from_scope(Backup::Syncer, Backup::Config::RSync::Local)
+    #     returns the class Backup::Syncer::RSync::Local
+    #
+    def get_class_from_scope(scope, name)
+      klass = scope
+      name = name.to_s.sub(/^Backup::Config::/, '')
+      name.split('::').each do |chunk|
+        klass = klass.const_get(chunk)
+      end
+      klass
+    end
+
+    ##
+    # Logs messages when the backup starts and finishes
+    def log!(action)
+      case action
+      when :started
+        Logger.message "Performing Backup for '#{label} (#{trigger})'!\n" +
+            "[ backup #{ Version.current } : #{ RUBY_DESCRIPTION } ]"
+
+      when :finished
+        msg = "Backup for '#{ label } (#{ trigger })' " +
+              "Completed %s in #{ elapsed_time }"
+        if Logger.has_warnings?
+          Logger.warn msg % 'Successfully (with Warnings)'
+        else
+          Logger.message msg % 'Successfully'
+        end
+      end
     end
 
     ##
-    # Returns the string representation of the last value of a nested constant
-    # example: last_constant(Backup::Model::MySQL) becomes and returns "MySQL"
-    def last_constant(constant)
-      constant.to_s.split("::").last
+    # Returns a string representing the elapsed time since the backup started.
+    def elapsed_time
+      duration  = Time.now.to_i - @started_at.to_i
+      hours     = duration / 3600
+      remainder = duration - (hours * 3600)
+      minutes   = remainder / 60
+      seconds   = remainder - (minutes * 60)
+      '%02d:%02d:%02d' % [hours, minutes, seconds]
     end
 
   end