backup 2.4.5.1 → 3.0.0.build.0

data/backup.gemspec

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/lib/backup')
+
+Gem::Specification.new do |gem|
+
+  ##
+  # General configuration / information
+  gem.name        = 'backup'
+  gem.version     = Backup::Version.gemspec
+  gem.platform    = Gem::Platform::RUBY
+  gem.authors     = 'Michael van Rooijen'
+  gem.email       = 'meskyanichi@gmail.com'
+  gem.homepage    = 'http://rubygems.org/gems/backup'
+  gem.summary     = 'Backup is a RubyGem (for UNIX-like operating systems: Linux, Mac OSX) that allows you to configure and perform backups in a simple manner using an elegant Ruby DSL.'
+  gem.description = 'Backup is a RubyGem (for UNIX-like operating systems: Linux, Mac OSX) that allows you to configure and perform backups in a simple manner using an elegant Ruby DSL.
+                    It supports various various databases (MySQL, PostgreSQL, MongoDB and Redis), it supports various storage locations
+                    (Amazon S3, Rackspace Cloud Files, Dropbox, any remote server through FTP, SFTP, SCP and RSync), it can archive files and folders,
+                    it can cycle backups, it can do incremental backups, it can compress backups, it can encrypt backups (OpenSSL or GPG),
+                    it can notify you about successful and/or failed backups. It is very extensible and easy to add new functionality to. It\'s easy to use.'
+
+  ##
+  # Files and folder that need to be compiled in to the Ruby Gem
+  gem.files         = %x[git ls-files].split("\n")
+  gem.test_files    = %x[git ls-files -- {spec}/*].split("\n")
+  gem.require_path  = 'lib'
+
+  ##
+  # The Backup CLI executable
+  gem.executables   = ['backup']
+
+  ##
+  # Production gem dependencies
+  gem.add_dependency 'thor',     ['~> 0.14.6'] # CLI
+  gem.add_dependency 'fog',      ['~> 0.5.3' ] # Amazon S3, Rackspace Cloud Files
+  gem.add_dependency 'dropbox',  ['~> 1.2.3' ] # Dropbox
+  gem.add_dependency 'mail',     ['~> 2.2.15'] # Mail
+  gem.add_dependency 'net-sftp', ['~> 2.0.5' ] # SFTP Protocol
+  gem.add_dependency 'net-scp',  ['~> 1.0.4' ] # SCP Protocol
+
+end

data/bin/backup

@@ -1,108 +1,179 @@
-#!/usr/bin/env ruby
+#! /usr/bin/env ruby
 
-require 'optparse'
-require 'backup'
+##
+# Load RubyGems for Ruby <= 1.8.7
+require 'rubygems'
+require 'tempfile'
+require 'fileutils'
 
-Backup::System.boot!
+##
+# Load Thor for the Command Line Interface
+begin
+  require 'thor'
+rescue LoadError
+  puts 'Backup uses Thor as CLI (Command Line Interface).'
+  puts 'Please install Thor first: `gem install thor`'
+end
+
+##
+# Load the Backup source
+require File.expand_path("../../lib/backup", __FILE__)
+
+##
+# Build the Backup Command Line Interface using Thor
+class BackupCLI < Thor
+
+  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, --tmp_path) aren't specified
+  # it'll fallback to the (good) defaults
+  method_option :trigger,     :type => :string, :aliases => '-t', :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 :tmp_path,    :type => :string
+  desc 'perform', 'Performs the backup for the specified trigger'
+  def perform
+
+    ##
+    # Defines the TRIGGER and TIME constants
+    Backup.send(:const_set, :TRIGGER, options[:trigger])
+    Backup.send(:const_set, :TIME, Time.now.strftime("%Y.%m.%d.%H.%M.%S"))
+
+    ##
+    # 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
 
-include Backup::Environment::UnixConfiguration::Commands
-include Backup::Environment::UnixConfiguration::Helpers
+    ##
+    # 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
 
-options = {}
+    ##
+    # 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
 
-optparse = OptionParser.new do |opts|
-  
-  opts.banner = "\nUsage: backup [options]\n "
-  
-  opts.on('-r', '--run [trigger]', "Runs backup process by trigger") do |trigger|
-    confirm_configuration_file_existence
-    puts "Running: #{trigger}."
-    Backup::Setup.new(trigger, @backup_procedures).initialize_adapter
+    ##
+    # 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
+
+    ##
+    # Ensure the TMP_PATH, LOG_PATH, DATA_PATH and DATA_PATH/TRIGGER
+    # are created if they do not yet exist
+    Array.new([
+      Backup::TMP_PATH,
+      Backup::LOG_PATH,
+      File.join(Backup::DATA_PATH, Backup::TRIGGER)
+    ]).each do |path|
+      FileUtils.mkdir_p(path)
+    end
+
+    ##
+    # Parses the backup configuration file and returns the model instance by trigger
+    model = Backup::Finder.new(Backup::TRIGGER, Backup::CONFIG_FILE).find
+
+    ##
+    # Runs the returned model
+    Backup::Logger.message "Performing backup for #{model.label}!"
+    model.perform!
   end
-  
-  opts.on('-f', '--find [trigger]', "Finds backup records by trigger") do |trigger|
-    confirm_configuration_file_existence
-    puts "Finding backup records with trigger: #{trigger}."
-    backup = Backup::Setup.new(trigger, @backup_procedures)
-    records = backup.procedure.record_class.all( :conditions => {:trigger => trigger} )
-
-    if options[:table]
-      puts Hirb::Helpers::AutoTable.render(records)
+
+  ##
+  # [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 :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, :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
+    if options[:path]
+      FileUtils.mkdir_p(options[:path])
+      File.open(File.join(options[:path], 'config.rb'), 'w') do |file|
+        file.write( File.read(temp_file.path) )
+        puts "Generated configuration file in '#{File.join(options[:path], 'config.rb')}'"
+      end
     else
-      records.each do |record|
-        puts record.to_yaml
+      FileUtils.mkdir_p(Backup::PATH)
+      File.open(File.join(Backup::PATH, 'config.rb'), 'w') do |file|
+        file.write( File.read(temp_file.path) )
+        puts "Generated configuration file in '#{File.join(Backup::PATH, 'config.rb')}'"
       end
     end
-  end
-  
-  opts.on('-t', '--truncate [trigger]', "Truncates backup records for specified trigger") do |trigger|
-    puts "Truncating backup records with trigger: #{trigger}."
-    Backup::Record::Base.destroy_all :trigger => trigger
-  end
-  
-  opts.on('-d', '--destroy [trigger]', "Destroys backup records and files for specified trigger") do |trigger|
-    confirm_configuration_file_existence
-    puts "Destroying backup records with trigger: #{trigger}."
-    backup = Backup::Setup.new(trigger, @backup_procedures)
-    backup.procedure.record_class.destroy_all_backups( backup.procedure, trigger )
-  end
-  
-  opts.on('--truncate-all', "Truncates all backup records") do
-    puts "Truncating all backup records."
-    Backup::Record::Base.destroy_all
+    temp_file.unlink
   end
 
-  opts.on('--destroy-all', "Destroys all backup records and files") do
-    confirm_configuration_file_existence
-    puts "Destroying all backup records."
-    backup = Backup::Setup.new(false, @backup_procedures)
-    backup.procedures.each do |backup_procedure|
-      backup_procedure.record_class.destroy_all_backups( backup_procedure, backup_procedure.trigger )
+  ##
+  # [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
 
-  opts.on('--decrypt [file]', "Decrypts a \"Backup\" encrypted file") do |file|
-    puts "Attempting to decrypt: #{file}."
-    %x{ openssl enc -des-cbc -d -in #{file} -out #{file.gsub('.enc', '')} }
-  end
-  
-  options[:table] = false
-  opts.on('--table', "Shows records in table format") do |format|
-    options[:table] = true
+  ##
+  # [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
 
-  opts.on('--setup', "Sets up Backup") do
-    setup
-  end
-  
-  opts.on('--reset', "Reinstalls Backup (This will remove ALL current settings!)") do
-    reset
-  end
-  
-  opts.on('--remove', "Removes Backup (This will remove ALL current settings!)") do
-    remove
-  end
-  
-  opts.on('-v', '--version', 'Displays installed Backup version') do
-    File.open(File.join(File.dirname(__FILE__), '..', 'VERSION')) do |file|
-      puts "Backup version #{file.read}"
-    end
-    exit
-  end  
-
-  opts.on('-h', '--help', 'Display help screen') do
-    puts opts
-    puts "\n "
-    exit
-  end  
-  
 end
 
-begin
-  optparse.parse!
-rescue OptionParser::InvalidOption
-  puts "\nInvalid Option. See the list of available options below.\n"
-  puts optparse
-  puts "\n "
-  exit
-end
+##
+# Enable the CLI for the Backup binary
+BackupCLI.start

data/lib/backup.rb

@@ -1,132 +1,148 @@
-BACKUP_SYSTEM = Proc.new do
-  # Load Gems
-  require 'hirb'
-
-  # Load Extensions
-  require 'backup/core_ext/object'
-
-  # Load Environments
-  require 'backup/environment/base'
-  require 'backup/environment/unix_configuration'
-  require 'backup/environment/rails_configuration'
-
-  # Load Configuration
-  require 'backup/configuration/attributes'
-  require 'backup/configuration/base'
-  require 'backup/configuration/adapter'
-  require 'backup/configuration/adapter_options'
-  require 'backup/configuration/storage'
-  require 'backup/configuration/mail'
-  require 'backup/configuration/smtp'
-  require 'backup/configuration/helpers'
-
-  require 'backup/command_helper'
-
-  # Include the Configuration and Environment Helpers
-  include Backup::Configuration::Helpers
-  include Backup::Environment::Base
-
-  # Load either UNIX or RAILS environment configuration
-  case current_environment
-    when :unix  then include Backup::Environment::UnixConfiguration
-    when :rails then include Backup::Environment::RailsConfiguration
-  end
+# encoding: utf-8
 
-  # Load configuration
-  if File.exist?(File.join(BACKUP_PATH, 'config', 'backup.rb'))
-    require File.join(BACKUP_PATH, 'config', 'backup.rb')
-  end
+require 'fileutils'
+require 'yaml'
 
-  # Load Mail Notifier
-  require 'backup/mail/base'
+##
+# The Backup Ruby Gem
+module Backup
 
-  # Set Mail Configuration (extracted from the backup.rb configuration file) inside the Mail Class
-  Backup::Mail::Base.setup(@mail_configuration)
-end
+  ##
+  # List the available database, storage, compressor, encryptor and notifier constants.
+  # These are used to dynamically define these constants as classes inside Backup::Finder
+  # to provide a nicer configuration file DSL syntax to the users. Adding existing constants
+  # to the arrays below will enable the user to use a constant instead of a string.
+  # Example, instead of:
+  #  database "MySQL" do |mysql|
+  # You can do:
+  #  database MySQL do |mysql|
+  DATABASES   = ['MySQL', 'PostgreSQL', 'MongoDB', 'Redis']
+  STORAGES    = ['S3', 'CloudFiles', 'Dropbox', 'FTP', 'SFTP', 'SCP', 'RSync']
+  COMPRESSORS = ['Gzip']
+  ENCRYPTORS  = ['OpenSSL', 'GPG']
+  NOTIFIERS   = ['Mail']
 
-# Backup Module
-module Backup
-  
-  class System
-    def self.boot!
-      BACKUP_SYSTEM.call
-      true
+  ##
+  # Backup's internal paths
+  LIBRARY_PATH       = File.join(File.dirname(__FILE__), 'backup')
+  CONFIGURATION_PATH = File.join(LIBRARY_PATH, 'configuration')
+  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')
+
+  ##
+  # Backup's Environment paths
+  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')
+  TMP_PATH           = File.join(ENV['HOME'], 'Backup', '.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 :Finder,  File.join(LIBRARY_PATH, 'finder')
+  autoload :Logger,  File.join(LIBRARY_PATH, 'logger')
+  autoload :Version, File.join(LIBRARY_PATH, 'version')
+
+  ##
+  # 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')
+    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')
+    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 :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')
+    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
-  end
-  
-  module Adapters
-    autoload :Base,       'backup/adapters/base'
-    autoload :MySQL,      'backup/adapters/mysql'
-    autoload :MongoDB,     'backup/adapters/mongo_db'
-    autoload :SQLite,     'backup/adapters/sqlite'
-    autoload :PostgreSQL, 'backup/adapters/postgresql'
-    autoload :Archive,    'backup/adapters/archive'
-    autoload :Custom,     'backup/adapters/custom'
   end
 
+  ##
+  # Autoload Backup storage files
   module Storage
-    autoload :Base,       'backup/storage/base'
-    autoload :CloudFiles, 'backup/storage/cloudfiles'
-    autoload :S3,         'backup/storage/s3'
-    autoload :SCP,        'backup/storage/scp'
-    autoload :FTP,        'backup/storage/ftp'
-    autoload :SFTP,       'backup/storage/sftp'
-    autoload :Local,      'backup/storage/local'
-    autoload :Dropbox,    'backup/storage/dropbox'
+    autoload :Base,       File.join(STORAGE_PATH, 'base')
+    autoload :Object,     File.join(STORAGE_PATH, 'object')
+    autoload :S3,         File.join(STORAGE_PATH, 's3')
+    autoload :CloudFiles, File.join(STORAGE_PATH, 'cloudfiles')
+    autoload :Dropbox,    File.join(STORAGE_PATH, 'dropbox')
+    autoload :FTP,        File.join(STORAGE_PATH, 'ftp')
+    autoload :SFTP,       File.join(STORAGE_PATH, 'sftp')
+    autoload :SCP,        File.join(STORAGE_PATH, 'scp')
+    autoload :RSync,      File.join(STORAGE_PATH, 'rsync')
   end
 
-  module Record
-    autoload :Base,       'backup/record/base'
-    autoload :CloudFiles, 'backup/record/cloudfiles'
-    autoload :S3,         'backup/record/s3'
-    autoload :SCP,        'backup/record/scp'
-    autoload :FTP,        'backup/record/ftp'
-    autoload :SFTP,       'backup/record/sftp'
-    autoload :Local,      'backup/record/local'
-    autoload :Dropbox,    'backup/record/dropbox'
+  ##
+  # Autoload Backup database files
+  module Database
+    autoload :Base,       File.join(DATABASE_PATH, 'base')
+    autoload :MySQL,      File.join(DATABASE_PATH, 'mysql')
+    autoload :PostgreSQL, File.join(DATABASE_PATH, 'postgresql')
+    autoload :MongoDB,    File.join(DATABASE_PATH, 'mongodb')
+    autoload :Redis,      File.join(DATABASE_PATH, 'redis')
   end
 
-  class Setup
-  
-    attr_accessor :trigger, :procedures, :procedure
-    
-    # Sets the Trigger and All Available Procedures.
-    # Will not find a specific procedure if the "trigger" argument is set to false.
-    def initialize(trigger, procedures)
-      self.trigger    = trigger
-      self.procedures = procedures
-      self.procedure  = find_triggered_procedure unless trigger.eql?(false)
-    end
-    
-    # Initializes one of the few adapters and start the backup process
-    def initialize_adapter
-      case procedure.adapter_name.to_sym
-        when :mongo       then Backup::Adapters::MongoDB.new    trigger, procedure
-        when :mysql       then Backup::Adapters::MySQL.new      trigger, procedure
-        when :sqlite      then Backup::Adapters::SQLite.new     trigger, procedure
-        when :postgresql  then Backup::Adapters::PostgreSQL.new trigger, procedure
-        when :archive     then Backup::Adapters::Archive.new    trigger, procedure
-        when :custom      then Backup::Adapters::Custom.new     trigger, procedure
-        else
-          puts "Unknown Adapter: \"#{procedure.adapter_name}\"."
-          exit
-      end
-    end
-    
-    # Scans through all the backup settings and returns the backup setting
-    # that was specified in the "trigger" argument.
-    # If an non-existing trigger is specified, it will raise an error and display
-    # all the available triggers.
-    def find_triggered_procedure
-      procedures.each do |procedure|
-        if procedure.trigger.eql?(trigger)
-          return procedure
-        end
-      end
-      available_triggers = procedures.map {|procedure| "- #{procedure.trigger}\n" }
-      puts "Could not find a backup procedure with the trigger \"#{trigger}\". \nHere's a list of available triggers:\n#{available_triggers}"
-      exit
-    end
+  ##
+  # Autoload compressor files
+  module Compressor
+    autoload :Base, File.join(COMPRESSOR_PATH, 'base')
+    autoload :Gzip, File.join(COMPRESSOR_PATH, 'gzip')
+  end
+
+  ##
+  # Autoload encryptor files
+  module Encryptor
+    autoload :Base,    File.join(ENCRYPTOR_PATH, 'base')
+    autoload :OpenSSL, File.join(ENCRYPTOR_PATH, 'open_ssl')
+    autoload :GPG,     File.join(ENCRYPTOR_PATH, 'gpg')
+  end
 
+  ##
+  # Autoload notification files
+  module Notifier
+    autoload :Base,   File.join(NOTIFIER_PATH, 'base')
+    autoload :Binder, File.join(NOTIFIER_PATH, 'binder')
+    autoload :Mail,   File.join(NOTIFIER_PATH, 'mail')
   end
+
+  ##
+  # Dynamically defines all the available database, storage, compressor, encryptor and notifier
+  # classes inside Backup::Finder to improve the DSL for the configuration file
+  (DATABASES + STORAGES + COMPRESSORS + ENCRYPTORS + NOTIFIERS).each do |constant|
+    Backup::Finder.const_set(constant, Class.new)
+  end
+
 end