interu-backup 3.0.16

data/backup.gemspec

@@ -0,0 +1,31 @@
+# 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.current
+  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, written for Linux and Mac OSX, that allows you to easily perform backup operations on both your remote, as well as your local environment. It provides you with an elegant DSL in Ruby for modeling (configuring) your backups. Backup has built-in support for various databases, storage protocols/services, syncers, compressors, encryptors and notifiers which you can mix and match. It was built with modularity, extensibility and simplicity in mind.'
+
+  ##
+  # 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']
+
+end

data/bin/backup

@@ -0,0 +1,267 @@
+#! /usr/bin/env ruby
+
+##
+# Load RubyGems for Ruby <= 1.8.7
+require 'rubygems'
+require 'tempfile'
+require 'fileutils'
+
+##
+# 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
+  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, --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 :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 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 and LOG_PATH are created if they do not yet exist
+    Array.new([Backup::TMP_PATH, Backup::LOG_PATH]).each do |path|
+      FileUtils.mkdir_p(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
+
+    ##
+    # Process each trigger
+    options[:trigger].split(",").map(&:strip).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, Backup::CONFIG_FILE).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
+
+##
+# Enable the CLI for the Backup binary
+BackupCLI.start

data/lib/backup.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'yaml'
+
+##
+# The Backup Ruby Gem
+module Backup
+
+  ##
+  # 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', 'Bzip2']
+  ENCRYPTORS  = ['OpenSSL', 'GPG']
+  SYNCERS     = ['RSync', 'S3']
+  NOTIFIERS   = ['Mail', 'Twitter', 'Campfire', 'Presently']
+
+  ##
+  # 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')
+  SYNCER_PATH        = File.join(LIBRARY_PATH, 'syncer')
+  EXCEPTION_PATH     = File.join(LIBRARY_PATH, 'exception')
+
+  ##
+  # 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 :Dependency, File.join(LIBRARY_PATH, 'dependency')
+  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')
+      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')
+    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 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
+  end
+
+  ##
+  # Autoload Backup storage files
+  module Storage
+    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
+
+  ##
+  # Autoload Backup syncer files
+  module Syncer
+    autoload :Base,  File.join(SYNCER_PATH, 'base')
+    autoload :RSync, File.join(SYNCER_PATH, 'rsync')
+    autoload :S3,    File.join(SYNCER_PATH, 's3')
+  end
+
+  ##
+  # 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
+
+  ##
+  # 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')
+  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')
+    autoload :Twitter,  File.join(NOTIFIER_PATH, 'twitter')
+    autoload :Campfire, File.join(NOTIFIER_PATH, 'campfire')
+    autoload :Presently, File.join(NOTIFIER_PATH, 'presently')
+  end
+
+  ##
+  # Autoload exception classes
+  module Exception
+    autoload :CommandNotFound, File.join(EXCEPTION_PATH, 'command_not_found')
+  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 + SYNCERS).each do |constant|
+    unless Backup::Finder.const_defined?(constant)
+      Backup::Finder.const_set(constant, Class.new)
+    end
+  end
+
+end