backup 3.0.19 → 3.0.20

data/bin/backup

@@ -1,288 +1,11 @@
 #!/usr/bin/env ruby
+# encoding: utf-8
 
-##
-# Load RubyGems for Ruby <= 1.8.7
-require 'rubygems'
-require 'tempfile'
-require 'fileutils'
-
-##
-# Load Thor for the CLI and POpen4 for reading unix process status
-begin
-  require 'thor'
-  require 'popen4'
-rescue LoadError
-  puts "\nBackup requires Thor to load the CLI (Command Line Interface) and POpen4 to determine the status of unix processes."
-  puts "Please install both Thor and POpen4 first:\n\ngem install thor -v '~> 0.14.6'\ngem install popen4 -v '~> 0.1.2'"
-  exit 1
-end
-
-##
-# Load the Backup source
+# Load the Backup core library
 require File.expand_path("../../lib/backup", __FILE__)
 
-##
-# Build the Backup Command Line Interface using Thor
-class BackupCLI < Thor
-  include Thor::Actions
-
-  TEMPLATE_DIR = File.expand_path("../../lib/templates", __FILE__)
-
-  ##
-  # [Perform]
-  # Performs the backup process. The only required option is the --trigger [-t].
-  # If the other options (--config-file, --data-path, --cache--path, --tmp-path) aren't specified
-  # it'll fallback to the (good) defaults
-  method_option :trigger,     :type => :string,  :aliases => ['-t', '--triggers'], :required => true
-  method_option :config_file, :type => :string,  :aliases => '-c'
-  method_option :data_path,   :type => :string,  :aliases => '-d'
-  method_option :log_path,    :type => :string,  :aliases => '-l'
-  method_option :cache_path,  :type => :string
-  method_option :tmp_path,    :type => :string
-  method_option :quiet,       :type => :boolean, :aliases => '-q'
-  desc 'perform', "Performs the backup for the specified trigger.\n" +
-                  "You may perform multiple backups by providing multiple triggers, separated by commas.\n\n" +
-                  "Example:\n\s\s$ backup perform --triggers backup1,backup2,backup3,backup4\n\n" +
-                  "This will invoke 4 backups, and they will run in the order specified (not asynchronous)."
-  def perform
-
-    ##
-    # Overwrites the CONFIG_FILE location, if --config-file was specified
-    if options[:config_file]
-      Backup.send(:remove_const, :CONFIG_FILE)
-      Backup.send(:const_set, :CONFIG_FILE, options[:config_file])
-    end
-
-    ##
-    # Overwrites the DATA_PATH location, if --data-path was specified
-    if options[:data_path]
-      Backup.send(:remove_const, :DATA_PATH)
-      Backup.send(:const_set, :DATA_PATH, options[:data_path])
-    end
-
-    ##
-    # Overwrites the LOG_PATH location, if --log-path was specified
-    if options[:log_path]
-      Backup.send(:remove_const, :LOG_PATH)
-      Backup.send(:const_set, :LOG_PATH, options[:log_path])
-    end
-
-    ##
-    # Overwrites the CACHE_PATH location, if --cache-path was specified
-    if options[:cache_path]
-      Backup.send(:remove_const, :CACHE_PATH)
-      Backup.send(:const_set, :CACHE_PATH, options[:cache_path])
-    end
-
-    ##
-    # Overwrites the TMP_PATH location, if --tmp-path was specified
-    if options[:tmp_path]
-      Backup.send(:remove_const, :TMP_PATH)
-      Backup.send(:const_set, :TMP_PATH, options[:tmp_path])
-    end
-
-    ##
-    # Silence Backup::Logger from printing to STDOUT, if --quiet was specified
-    if options[:quiet]
-      Backup::Logger.send(:const_set, :QUIET, options[:quiet])
-    end
-
-    ##
-    # Ensure the CACHE_PATH, TMP_PATH and LOG_PATH are created if they do not yet exist
-    Array.new([Backup::CACHE_PATH, Backup::TMP_PATH, Backup::LOG_PATH]).each do |path|
-      FileUtils.mkdir_p(path)
-    end
-
-    ##
-    # Prepare all trigger names by splitting them by ','
-    # and finding trigger names matching wildcard
-    triggers = options[:trigger].split(",")
-    triggers.map!(&:strip).map!{ |t|
-      t.include?(Backup::Finder::WILDCARD) ?
-        Backup::Finder.new(t).matching : t
-    }.flatten!
-
-    #triggers.unique! # Uncomment if its undesirable to call triggers twice
-
-    ##
-    # Process each trigger
-    triggers.each do |trigger|
-
-      ##
-      # Defines the TRIGGER constant
-      Backup.send(:const_set, :TRIGGER, trigger)
-
-      ##
-      # Define the TIME constants
-      Backup.send(:const_set, :TIME, Time.now.strftime("%Y.%m.%d.%H.%M.%S"))
-
-      ##
-      # Ensure DATA_PATH and DATA_PATH/TRIGGER are created if they do not yet exist
-      FileUtils.mkdir_p(File.join(Backup::DATA_PATH, Backup::TRIGGER))
-
-      ##
-      # Parses the backup configuration file and returns the model instance by trigger
-      model = Backup::Finder.new(trigger).find
-
-      ##
-      # Runs the returned model
-      Backup::Logger.message "Performing backup for #{model.label}!"
-      model.perform!
-
-      ##
-      # Removes the TRIGGER constant
-      Backup.send(:remove_const, :TRIGGER) if defined? Backup::TRIGGER
-
-      ##
-      # Removes the TIME constant
-      Backup.send(:remove_const, :TIME) if defined? Backup::TIME
-
-      ##
-      # Reset the Backup::Model.current to nil for the next potential run
-      Backup::Model.current = nil
-
-      ##
-      # Reset the Backup::Model.all to an empty array since this will be
-      # re-filled during the next Backup::Finder.new(arg1, arg2).find
-      Backup::Model.all = Array.new
-
-      ##
-      # Reset the Backup::Model.extension to 'tar' so it's at it's
-      # initial state when the next Backup::Model initializes
-      Backup::Model.extension = 'tar'
-    end
-  end
-
-  ##
-  # [Generate]
-  # Generates a configuration file based on the arguments passed in.
-  # For example, running $ backup generate --databases='mongodb' will generate a pre-populated
-  # configuration file with a base MongoDB setup
-  desc 'generate', 'Generates configuration blocks based on the arguments you pass in'
-  method_option :path,        :type => :string
-  method_option :databases,   :type => :string
-  method_option :storages,    :type => :string
-  method_option :syncers,     :type => :string
-  method_option :encryptors,  :type => :string
-  method_option :compressors, :type => :string
-  method_option :notifiers,   :type => :string
-  method_option :archives,    :type => :boolean
-  def generate
-    temp_file = Tempfile.new('backup.rb')
-    temp_file << File.read( File.join(TEMPLATE_DIR, 'readme') )
-    temp_file << "Backup::Model.new(:my_backup, 'My Backup') do\n\n"
-
-    if options[:archives]
-      temp_file << File.read( File.join(TEMPLATE_DIR, 'archive') ) + "\n\n"
-    end
-
-    [:databases, :storages, :syncers, :encryptors, :compressors, :notifiers].each do |item|
-      if options[item]
-        options[item].split(',').map(&:strip).uniq.each do |entry|
-          if File.exist?( File.join(TEMPLATE_DIR, item.to_s[0..-2], entry) )
-            temp_file << File.read( File.join(TEMPLATE_DIR, item.to_s[0..-2], entry) ) + "\n\n"
-          end
-        end
-      end
-    end
-
-    temp_file << "end\n\n"
-    temp_file.close
-
-    path   = options[:path] || Backup::PATH
-    config = File.join(path, 'config.rb')
-
-    if overwrite?(config)
-      FileUtils.mkdir_p(path)
-      File.open(config, 'w') do |file|
-        file.write( File.read(temp_file.path) )
-        puts "Generated configuration file in '#{ config }'"
-      end
-    end
-    temp_file.unlink
-  end
-
-  ##
-  # [Decrypt]
-  # Shorthand for decrypting encrypted files
-  desc 'decrypt', 'Decrypts encrypted files'
-  method_option :encryptor, :type => :string,  :required => true
-  method_option :in,        :type => :string,  :required => true
-  method_option :out,       :type => :string,  :required => true
-  method_option :base64,    :type => :boolean, :default  => false
-  def decrypt
-    case options[:encryptor].downcase
-    when 'openssl'
-      base64 = options[:base64] ? '-base64' : ''
-      %x[openssl aes-256-cbc -d #{base64} -in '#{options[:in]}' -out '#{options[:out]}']
-    when 'gpg'
-      %x[gpg -o '#{options[:out]}' -d '#{options[:in]}']
-    else
-      puts "Unknown encryptor: #{options[:encryptor]}"
-      puts "Use either 'openssl' or 'gpg'"
-    end
-  end
-
-  ##
-  # [Dependencies]
-  # Returns a list of Backup's dependencies
-  desc 'dependencies', 'Display the list of dependencies for Backup, or install them through Backup.'
-  method_option :install, :type => :string
-  method_option :list,    :type => :boolean
-  def dependencies
-    unless options.any?
-      puts
-      puts "To display a list of available dependencies, run:\n\n"
-      puts "  backup dependencies --list"
-      puts
-      puts "To install one of these dependencies (with the correct version), run:\n\n"
-      puts "  backup dependencies --install <name>"
-      exit
-    end
-
-    if options[:list]
-      Backup::Dependency.all.each do |name, gemspec|
-        puts
-        puts name
-        puts "--------------------------------------------------"
-        puts "version:       #{gemspec[:version]}"
-        puts "lib required:  #{gemspec[:require]}"
-        puts "used for:      #{gemspec[:for]}"
-      end
-    end
-
-    if options[:install]
-      puts
-      puts "Installing \"#{options[:install]}\" version \"#{Backup::Dependency.all[options[:install]][:version]}\".."
-      puts "If this doesn't work, please issue the following command yourself:\n\n"
-      puts "  gem install #{options[:install]} -v '#{Backup::Dependency.all[options[:install]][:version]}'\n\n"
-      puts "Please wait..\n\n"
-      puts %x[gem install #{options[:install]} -v '#{Backup::Dependency.all[options[:install]][:version]}']
-    end
-  end
-
-  ##
-  # [Version]
-  # Returns the current version of the Backup gem
-  map '-v' => :version
-  desc 'version', 'Display installed Backup version'
-  def version
-    puts "Backup #{Backup::Version.current}"
-  end
-
-private
-
-  ##
-  # Helper method for asking the user if he/she wants to overwrite the file
-  def overwrite?(path)
-    if File.exist?(path)
-      return yes? "A configuration file already exists in #{ path }. Do you want to overwrite? [y/n]"
-    end
-    true
-  end
-
-end
+# Load the Backup command line interface utility
+require File.expand_path("../../lib/backup/cli/utility", __FILE__)
 
-##
-# Enable the CLI for the Backup binary
-BackupCLI.start
+# Initialize the Backup command line utility
+Backup::CLI::Utility.start

data/lib/backup.rb

@@ -1,9 +1,24 @@
 # encoding: utf-8
 
+# Load Ruby Core Libraries
+require 'rubygems'
 require 'fileutils'
+require 'tempfile'
 require 'yaml'
 require 'etc'
 
+# Attempt load to POpen4 and Thor Libraries
+begin
+  gem 'POpen4', '~> 0.1.4'
+  gem 'thor',   '~> 0.14.6'
+  require 'popen4'
+  require 'thor'
+rescue LoadError
+  puts "\nBackup requires Thor to load the CLI Utility (Command Line Interface Utility) and POpen4 to determine the status of the unix processes."
+  puts "Please install both the Thor and POpen4 libraries first:\n\ngem install thor -v '~> 0.14.6'\ngem install POpen4 -v '~> 0.1.4'"
+  exit 1
+end
+
 ##
 # The Backup Ruby Gem
 module Backup
@@ -17,97 +32,57 @@ module Backup
   #  database "MySQL" do |mysql|
   # You can do:
   #  database MySQL do |mysql|
-  DATABASES   = ['MySQL', 'PostgreSQL', 'MongoDB', 'Redis']
+  DATABASES   = ['MySQL', 'PostgreSQL', 'MongoDB', 'Redis', 'Riak']
   STORAGES    = ['S3', 'CloudFiles', 'Ninefold', 'Dropbox', 'FTP', 'SFTP', 'SCP', 'RSync', 'Local']
-  COMPRESSORS = ['Gzip', 'Bzip2', 'Lzma']
+  COMPRESSORS = ['Gzip', 'Bzip2', 'Pbzip2', 'Lzma']
   ENCRYPTORS  = ['OpenSSL', 'GPG']
   SYNCERS     = ['RSync', 'S3']
-  NOTIFIERS   = ['Mail', 'Twitter', 'Campfire', 'Presently']
+  NOTIFIERS   = ['Mail', 'Twitter', 'Campfire', 'Presently', 'Prowl', 'Hipchat']
 
   ##
   # Backup's internal paths
   LIBRARY_PATH       = File.join(File.dirname(__FILE__), 'backup')
-  CONFIGURATION_PATH = File.join(LIBRARY_PATH, 'configuration')
+  CLI_PATH           = File.join(LIBRARY_PATH, 'cli')
   STORAGE_PATH       = File.join(LIBRARY_PATH, 'storage')
   DATABASE_PATH      = File.join(LIBRARY_PATH, 'database')
   COMPRESSOR_PATH    = File.join(LIBRARY_PATH, 'compressor')
   ENCRYPTOR_PATH     = File.join(LIBRARY_PATH, 'encryptor')
   NOTIFIER_PATH      = File.join(LIBRARY_PATH, 'notifier')
   SYNCER_PATH        = File.join(LIBRARY_PATH, 'syncer')
-  EXCEPTION_PATH     = File.join(LIBRARY_PATH, 'exception')
+  CONFIGURATION_PATH = File.join(LIBRARY_PATH, 'configuration')
+  TEMPLATE_PATH      = File.expand_path('../../templates', __FILE__)
 
   ##
   # Backup's Environment paths
   USER        = ENV['USER'] || Etc.getpwuid.name
-  PATH        = File.join(ENV['HOME'], 'Backup')
-  DATA_PATH   = File.join(ENV['HOME'], 'Backup', 'data')
-  CONFIG_FILE = File.join(ENV['HOME'], 'Backup', 'config.rb')
-  LOG_PATH    = File.join(ENV['HOME'], 'Backup', 'log')
-  CACHE_PATH  = File.join(ENV['HOME'], 'Backup', '.cache')
-  TMP_PATH    = File.join(ENV['HOME'], 'Backup', '.tmp')
+  HOME        = File.expand_path(ENV['HOME'] || '')
+  PATH        = File.join(HOME, 'Backup')
+  CONFIG_FILE = File.join(PATH, 'config.rb')
+  DATA_PATH   = File.join(PATH, 'data')
+  LOG_PATH    = File.join(PATH, 'log')
+  CACHE_PATH  = File.join(PATH, '.cache')
+  TMP_PATH    = File.join(PATH, '.tmp')
 
   ##
   # Autoload Backup base files
   autoload :Model,      File.join(LIBRARY_PATH, 'model')
   autoload :Archive,    File.join(LIBRARY_PATH, 'archive')
-  autoload :CLI,        File.join(LIBRARY_PATH, 'cli')
+  autoload :Packager,   File.join(LIBRARY_PATH, 'packager')
+  autoload :Cleaner,    File.join(LIBRARY_PATH, 'cleaner')
+  autoload :Splitter,   File.join(LIBRARY_PATH, 'splitter')
   autoload :Finder,     File.join(LIBRARY_PATH, 'finder')
+  autoload :Binder,     File.join(LIBRARY_PATH, 'binder')
+  autoload :Template,   File.join(LIBRARY_PATH, 'template')
   autoload :Dependency, File.join(LIBRARY_PATH, 'dependency')
   autoload :Logger,     File.join(LIBRARY_PATH, 'logger')
   autoload :Version,    File.join(LIBRARY_PATH, 'version')
+  autoload :Errors,     File.join(LIBRARY_PATH, 'errors')
 
   ##
-  # Autoload Backup configuration files
-  module Configuration
-    autoload :Base,     File.join(CONFIGURATION_PATH, 'base')
-    autoload :Helpers,  File.join(CONFIGURATION_PATH, 'helpers')
-
-    module Notifier
-      autoload :Base,      File.join(CONFIGURATION_PATH, 'notifier', 'base')
-      autoload :Mail,      File.join(CONFIGURATION_PATH, 'notifier', 'mail')
-      autoload :Twitter,   File.join(CONFIGURATION_PATH, 'notifier', 'twitter')
-      autoload :Campfire,  File.join(CONFIGURATION_PATH, 'notifier', 'campfire')
-      autoload :Presently, File.join(CONFIGURATION_PATH, 'notifier', 'presently')
-    end
-
-    module Encryptor
-      autoload :Base,    File.join(CONFIGURATION_PATH, 'encryptor', 'base')
-      autoload :OpenSSL, File.join(CONFIGURATION_PATH, 'encryptor', 'open_ssl')
-      autoload :GPG,     File.join(CONFIGURATION_PATH, 'encryptor', 'gpg')
-    end
-
-    module Compressor
-      autoload :Base,  File.join(CONFIGURATION_PATH, 'compressor', 'base')
-      autoload :Gzip,  File.join(CONFIGURATION_PATH, 'compressor', 'gzip')
-      autoload :Bzip2, File.join(CONFIGURATION_PATH, 'compressor', 'bzip2')
-      autoload :Lzma,  File.join(CONFIGURATION_PATH, 'compressor', 'lzma')
-    end
-
-    module Storage
-      autoload :Base,       File.join(CONFIGURATION_PATH, 'storage', 'base')
-      autoload :S3,         File.join(CONFIGURATION_PATH, 'storage', 's3')
-      autoload :CloudFiles, File.join(CONFIGURATION_PATH, 'storage', 'cloudfiles')
-      autoload :Ninefold,   File.join(CONFIGURATION_PATH, 'storage', 'ninefold')
-      autoload :Dropbox,    File.join(CONFIGURATION_PATH, 'storage', 'dropbox')
-      autoload :FTP,        File.join(CONFIGURATION_PATH, 'storage', 'ftp')
-      autoload :SFTP,       File.join(CONFIGURATION_PATH, 'storage', 'sftp')
-      autoload :SCP,        File.join(CONFIGURATION_PATH, 'storage', 'scp')
-      autoload :RSync,      File.join(CONFIGURATION_PATH, 'storage', 'rsync')
-      autoload :Local,      File.join(CONFIGURATION_PATH, 'storage', 'local')
-    end
-
-    module Syncer
-      autoload :RSync, File.join(CONFIGURATION_PATH, 'syncer', 'rsync')
-      autoload :S3,    File.join(CONFIGURATION_PATH, 'syncer', 's3')
-    end
-
-    module Database
-      autoload :Base,       File.join(CONFIGURATION_PATH, 'database', 'base')
-      autoload :MySQL,      File.join(CONFIGURATION_PATH, 'database', 'mysql')
-      autoload :PostgreSQL, File.join(CONFIGURATION_PATH, 'database', 'postgresql')
-      autoload :MongoDB,    File.join(CONFIGURATION_PATH, 'database', 'mongodb')
-      autoload :Redis,      File.join(CONFIGURATION_PATH, 'database', 'redis')
-    end
+  # Autoload Backup CLI files
+  module CLI
+    autoload :Helpers, File.join(CLI_PATH, 'helpers')
+    autoload :Utility, File.join(CLI_PATH, 'utility')
   end
 
   ##
@@ -142,15 +117,17 @@ module Backup
     autoload :PostgreSQL, File.join(DATABASE_PATH, 'postgresql')
     autoload :MongoDB,    File.join(DATABASE_PATH, 'mongodb')
     autoload :Redis,      File.join(DATABASE_PATH, 'redis')
+    autoload :Riak,       File.join(DATABASE_PATH, 'riak')
   end
 
   ##
   # Autoload compressor files
   module Compressor
-    autoload :Base,  File.join(COMPRESSOR_PATH, 'base')
-    autoload :Gzip,  File.join(COMPRESSOR_PATH, 'gzip')
-    autoload :Bzip2, File.join(COMPRESSOR_PATH, 'bzip2')
-    autoload :Lzma,  File.join(COMPRESSOR_PATH, 'lzma')
+    autoload :Base,   File.join(COMPRESSOR_PATH, 'base')
+    autoload :Gzip,   File.join(COMPRESSOR_PATH, 'gzip')
+    autoload :Bzip2,  File.join(COMPRESSOR_PATH, 'bzip2')
+    autoload :Pbzip2, File.join(COMPRESSOR_PATH, 'pbzip2')
+    autoload :Lzma,   File.join(COMPRESSOR_PATH, 'lzma')
   end
 
   ##
@@ -170,13 +147,66 @@ module Backup
     autoload :Twitter,   File.join(NOTIFIER_PATH, 'twitter')
     autoload :Campfire,  File.join(NOTIFIER_PATH, 'campfire')
     autoload :Presently, File.join(NOTIFIER_PATH, 'presently')
+    autoload :Prowl,     File.join(NOTIFIER_PATH, 'prowl')
+    autoload :Hipchat,   File.join(NOTIFIER_PATH, 'hipchat')
   end
 
   ##
-  # Autoload exception classes
-  module Exception
-    autoload :CommandNotFound, File.join(EXCEPTION_PATH, 'command_not_found')
-    autoload :CommandFailed,   File.join(EXCEPTION_PATH, 'command_failed')
+  # Autoload Backup configuration files
+  module Configuration
+    autoload :Base,     File.join(CONFIGURATION_PATH, 'base')
+    autoload :Helpers,  File.join(CONFIGURATION_PATH, 'helpers')
+
+    module Notifier
+      autoload :Base,      File.join(CONFIGURATION_PATH, 'notifier', 'base')
+      autoload :Mail,      File.join(CONFIGURATION_PATH, 'notifier', 'mail')
+      autoload :Twitter,   File.join(CONFIGURATION_PATH, 'notifier', 'twitter')
+      autoload :Campfire,  File.join(CONFIGURATION_PATH, 'notifier', 'campfire')
+      autoload :Presently, File.join(CONFIGURATION_PATH, 'notifier', 'presently')
+      autoload :Prowl,     File.join(CONFIGURATION_PATH, 'notifier', 'prowl')
+      autoload :Hipchat,   File.join(CONFIGURATION_PATH, 'notifier', 'hipchat')
+    end
+
+    module Encryptor
+      autoload :Base,    File.join(CONFIGURATION_PATH, 'encryptor', 'base')
+      autoload :OpenSSL, File.join(CONFIGURATION_PATH, 'encryptor', 'open_ssl')
+      autoload :GPG,     File.join(CONFIGURATION_PATH, 'encryptor', 'gpg')
+    end
+
+    module Compressor
+      autoload :Base,   File.join(CONFIGURATION_PATH, 'compressor', 'base')
+      autoload :Gzip,   File.join(CONFIGURATION_PATH, 'compressor', 'gzip')
+      autoload :Bzip2,  File.join(CONFIGURATION_PATH, 'compressor', 'bzip2')
+      autoload :Pbzip2, File.join(CONFIGURATION_PATH, 'compressor', 'pbzip2')
+      autoload :Lzma,   File.join(CONFIGURATION_PATH, 'compressor', 'lzma')
+    end
+
+    module Storage
+      autoload :Base,       File.join(CONFIGURATION_PATH, 'storage', 'base')
+      autoload :S3,         File.join(CONFIGURATION_PATH, 'storage', 's3')
+      autoload :CloudFiles, File.join(CONFIGURATION_PATH, 'storage', 'cloudfiles')
+      autoload :Ninefold,   File.join(CONFIGURATION_PATH, 'storage', 'ninefold')
+      autoload :Dropbox,    File.join(CONFIGURATION_PATH, 'storage', 'dropbox')
+      autoload :FTP,        File.join(CONFIGURATION_PATH, 'storage', 'ftp')
+      autoload :SFTP,       File.join(CONFIGURATION_PATH, 'storage', 'sftp')
+      autoload :SCP,        File.join(CONFIGURATION_PATH, 'storage', 'scp')
+      autoload :RSync,      File.join(CONFIGURATION_PATH, 'storage', 'rsync')
+      autoload :Local,      File.join(CONFIGURATION_PATH, 'storage', 'local')
+    end
+
+    module Syncer
+      autoload :RSync, File.join(CONFIGURATION_PATH, 'syncer', 'rsync')
+      autoload :S3,    File.join(CONFIGURATION_PATH, 'syncer', 's3')
+    end
+
+    module Database
+      autoload :Base,       File.join(CONFIGURATION_PATH, 'database', 'base')
+      autoload :MySQL,      File.join(CONFIGURATION_PATH, 'database', 'mysql')
+      autoload :PostgreSQL, File.join(CONFIGURATION_PATH, 'database', 'postgresql')
+      autoload :MongoDB,    File.join(CONFIGURATION_PATH, 'database', 'mongodb')
+      autoload :Redis,      File.join(CONFIGURATION_PATH, 'database', 'redis')
+      autoload :Riak,       File.join(CONFIGURATION_PATH, 'database', 'riak')
+    end
   end
 
   ##
@@ -187,5 +217,4 @@ module Backup
       Backup::Finder.const_set(constant, Class.new)
     end
   end
-
 end