alg-backup 3.0.10

data/bin/backup

@@ -0,0 +1,260 @@
+#! /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
+  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
+
+    ##
+    # Process each trigger
+    options[:trigger].split(",").map { |t| t.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 { |i| i.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,168 @@
+# 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']
+  ENCRYPTORS  = ['OpenSSL', 'GPG']
+  SYNCERS     = ['RSync', 'S3']
+  NOTIFIERS   = ['Mail', 'Twitter']
+
+  ##
+  # 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')
+
+  ##
+  # 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')
+    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 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')
+  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')
+  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

data/lib/backup/archive.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Backup
+  class Archive
+    include Backup::CLI
+
+    ##
+    # Stores the name of the archive
+    attr_accessor :name
+
+    ##
+    # Stores an array of different paths/files to store
+    attr_accessor :paths
+
+    ##
+    # Stores an array of different paths/files to exclude
+    attr_accessor :excludes
+
+    ##
+    # Stores the path to the archive directory
+    attr_accessor :archive_path
+
+    ##
+    # Takes the name of the archive and the configuration block
+    def initialize(name, &block)
+      @name         = name.to_sym
+      @paths        = Array.new
+      @excludes     = Array.new
+      @archive_path = File.join(TMP_PATH, TRIGGER, 'archive')
+
+      instance_eval(&block)
+    end
+
+    ##
+    # Adds new paths to the @paths instance variable array
+    def add(path)
+      @paths << path
+    end
+
+    ##
+    # Adds new paths to the @excludes instance variable array
+    def exclude(path)
+      @excludes << path
+    end
+
+    ##
+    # Archives all the provided paths in to a single .tar file
+    # and places that .tar file in the folder which later will be packaged
+    def perform!
+      mkdir(archive_path)
+      Logger.message("#{ self.class } started packaging and archiving #{ paths.map { |path| "\"#{path}\""}.join(", ") }.")
+      run("#{ utility(:tar) } -c #{ paths_to_exclude } #{ paths_to_package } 1> '#{ File.join(archive_path, "#{name}.tar") }' 2> /dev/null")
+    end
+
+  private
+
+    ##
+    # Returns a "tar-ready" string of all the specified paths combined
+    def paths_to_package
+      paths.map do |path|
+        "'#{path}'"
+      end.join("\s")
+    end
+
+    ##
+    # Returns a "tar-ready" string of all the specified excludes combined
+    def paths_to_exclude
+      if excludes.any?
+        "--exclude={" + excludes.map{ |e| "'#{e}'" }.join(",") + "}"
+      end
+    end
+  end
+end