backup 3.0.19 → 3.0.20

data/lib/backup/archive.rb

@@ -2,7 +2,7 @@
 
 module Backup
   class Archive
-    include Backup::CLI
+    include Backup::CLI::Helpers
 
     ##
     # Stores the name of the archive
@@ -23,10 +23,10 @@ module Backup
     ##
     # 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')
+      @name     = name.to_sym
+      @paths    = Array.new
+      @excludes = Array.new
+      @tar_options = ''
 
       instance_eval(&block)
     end
@@ -34,22 +34,34 @@ module Backup
     ##
     # Adds new paths to the @paths instance variable array
     def add(path)
-      @paths << path
+      @paths << File.expand_path(path)
     end
 
     ##
     # Adds new paths to the @excludes instance variable array
     def exclude(path)
-      @excludes << path
+      @excludes << File.expand_path(path)
+    end
+
+    ##
+    # Adds the given String of +options+ to the `tar` command.
+    # e.g. '-h --xattrs'
+    def tar_options(options)
+      @tar_options = options
     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!
+      @archive_path = File.join(TMP_PATH, TRIGGER, 'archive')
       mkdir(archive_path)
-      Logger.message("#{ self.class } started packaging and archiving #{ paths.map { |path| "\"#{path}\""}.join(", ") }.")
-      run("#{ utility(:tar) } -c -f '#{ File.join(archive_path, "#{name}.tar") }' #{ paths_to_exclude } #{ paths_to_package } 2> /dev/null")
+
+      Logger.message "#{ self.class } started packaging and archiving:\n" +
+          paths.map {|path| "  #{path}" }.join("\n")
+
+      run("#{ utility(:tar) } #{ @tar_options } -cf '#{ File.join(archive_path, "#{name}.tar") }' " +
+          "#{ paths_to_exclude } #{ paths_to_package }", :ignore_exit_codes => [1])
     end
 
   private

data/lib/backup/binder.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Backup
+  class Binder
+
+    ##
+    # Creates a new Backup::Notifier::Binder instance. Loops through the provided
+    # Hash to set instance variables
+    def initialize(key_and_values)
+      key_and_values.each do |key, value|
+        instance_variable_set("@#{ key }", value)
+      end
+    end
+
+    ##
+    # Returns the binding (needs a wrapper method because #binding is a private method)
+    def get_binding
+      binding
+    end
+
+  end
+end

data/lib/backup/cleaner.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Backup
+  class Cleaner
+    include Backup::CLI::Helpers
+
+    ##
+    # Holds an instance of the current Backup model
+    attr_accessor :model
+
+    ##
+    # Creates a new instance of Backup::Cleaner
+    def initialize(model)
+      @model = model
+    end
+
+    ##
+    # Runs the cleaner object which removes all the tmp files generated by Backup
+    def clean!
+      Logger.message "#{self.class} started cleaning up the temporary files."
+      run("#{ utility(:rm) } -rf #{ paths.map { |path| "'#{ path }'" }.join(" ") }")
+    end
+
+  private
+
+    ##
+    # Returns an Array of paths to temporary files generated by Backup that need to be removed
+    def paths
+      Array.new([
+        File.join(TMP_PATH, TRIGGER),
+        Backup::Model.file,
+        Backup::Model.chunk_suffixes.map { |chunk_suffix| "#{Backup::Model.file}-#{chunk_suffix}" }
+      ]).flatten
+    end
+  end
+end

data/lib/backup/cli/helpers.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module Backup
+  module CLI
+    module Helpers
+
+      ##
+      # Runs a given command in an isolated (sub) process using POpen4.
+      # The STDOUT, STDERR and the returned exit code of the utility will be stored in the process_data Hash.
+      #
+      # If a command returns an exit code other than 0, an exception will raise and the backup process will abort.
+      # Some utilities return exit codes other than 0 which aren't an issue in Backup's context. If this is the case,
+      # you can pass in an array of exit codes to ignore (whitelist), for example:
+      #
+      #   run("tar -cf /output.tar /some/folder", :ignore_exit_codes => [1])
+      #
+      # So if the `tar` utility returns in this case 1, Backup will consider it an acceptable return code.
+      #
+      # Note: Exit code 0 is always automatically added to the :ignore_exit_codes array, regardless of whether you specify an
+      #       array to ignore or not.
+      def run(command, options = {})
+        command.gsub!(/^\s+/, "")
+
+        process_data                     = Hash.new
+        pid, stdin, stdout, stderr       = Open4::popen4(command)
+        ignored, process_data[:status]   = Process::waitpid2(pid)
+        process_data[:stdout]            = stdout.read
+        process_data[:stderr]            = stderr.read
+        process_data[:ignore_exit_codes] = ((options[:ignore_exit_codes] || Array.new) << 0).uniq
+
+        raise_if_command_failed!(command_name(command), process_data)
+        process_data[:stdout]
+      end
+
+      ##
+      # Wrapper method for FileUtils.mkdir_p to create directories
+      # through a ruby method. This helps with test coverage and
+      # improves readability
+      def mkdir(path)
+        FileUtils.mkdir_p(path)
+      end
+
+      ##
+      # Wrapper for the FileUtils.rm_rf to remove files and folders
+      # through a ruby method. This helps with test coverage and
+      # improves readability
+      def rm(path)
+        FileUtils.rm_rf(path)
+      end
+
+      ##
+      # Tries to find the full path of the specified utility. If the full
+      # path is found, it'll return that. Otherwise it'll just return the
+      # name of the utility. If the 'utility_path' is defined, it'll check
+      # to see if it isn't an empty string, and if it isn't, it'll go ahead and
+      # always use that path rather than auto-detecting it
+      def utility(name)
+        if respond_to?(:utility_path)
+          if utility_path.is_a?(String) and not utility_path.empty?
+            return utility_path
+          end
+        end
+
+        if path = %x[which #{name} 2>/dev/null].chomp and not path.empty?
+          return path
+        end
+        name
+      end
+
+      ##
+      # Returns the name of the command
+      def command_name(command)
+        command.slice(0, command.index(/\s/)).split('/')[-1]
+      end
+
+      ##
+      # Inspects the exit code returned from the POpen4 child process. If the exit code isn't listed
+      # in the process_data[:ignore_exit_codes] array, an exception will be raised, aborting the backup process.
+      #
+      # Information regarding the error ( EXIT CODE and STDERR ) will be returned to the shell so the user can
+      # investigate the issue.
+      #
+      # raises Backup::Errors::CLI::SystemCallError
+      def raise_if_command_failed!(utility, process_data)
+        unless process_data[:ignore_exit_codes].include?(process_data[:status].to_i)
+
+          stderr = process_data[:stderr].empty? ?
+              nil : "STDERR:\n#{process_data[:stderr]}\n"
+          stdout = process_data[:stdout].empty? ?
+              nil : "STDOUT:\n#{process_data[:stdout]}\n"
+
+          raise Errors::CLI::SystemCallError, <<-EOS
+            Failed to run #{utility} on #{RUBY_PLATFORM}
+            The following information should help to determine the problem:
+            Exit Code: #{process_data[:status]}
+            #{stderr}#{stdout}
+          EOS
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/cli/utility.rb

@@ -0,0 +1,308 @@
+# encoding: utf-8
+
+##
+# Build the Backup Command Line Interface using Thor
+module Backup
+  module CLI
+    class Utility < Thor
+      include Thor::Actions
+
+      ##
+      # [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
+      # they will fallback to the (good) defaults
+      #
+      # If --root-path is given, it will be used as the base (Backup::PATH) for our defaults,
+      # as well as the base path for any option specified as a relative path.
+      # Any option given as an absolute path will be used "as-is".
+      method_option :trigger,         :type => :string,  :required => true, :aliases => ['-t', '--triggers']
+      method_option :config_file,     :type => :string,  :default => '',    :aliases => '-c'
+      method_option :root_path,       :type => :string,  :default => '',    :aliases => '-r'
+      method_option :data_path,       :type => :string,  :default => '',    :aliases => '-d'
+      method_option :log_path,        :type => :string,  :default => '',    :aliases => '-l'
+      method_option :cache_path,      :type => :string,  :default => ''
+      method_option :tmp_path,        :type => :string,  :default => ''
+      method_option :quiet,           :type => :boolean, :default => false, :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
+        ##
+        # Setup required paths based on the given options
+        setup_paths(options)
+
+        ##
+        # Silence Backup::Logger from printing to STDOUT, if --quiet was specified
+        Logger.send(:const_set, :QUIET, options[:quiet])
+
+        ##
+        # 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!
+
+        ##
+        # 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
+          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
+
+          ##
+          # Clear the Log Messages for the next potential run
+          Logger.clear!
+
+          ##
+          # Reset the Backup::Model.extension to 'tar' so it's at its
+          # initial state when the next Backup::Model initializes
+          Backup::Model.extension = 'tar'
+        end
+
+      rescue => err
+        Logger.error Backup::Errors::CLIError.wrap(err)
+        exit(1)
+      end
+
+      ##
+      # [Generate:Model]
+      # Generates a model configuration file based on the arguments passed in.
+      # For example:
+      #   $ backup generate:model --trigger my_backup --databases='mongodb'
+      # will generate a pre-populated model with a base MongoDB setup
+      method_option :trigger,     :type => :string, :required => true
+      method_option :config_path, :type => :string,
+                    :desc => 'Path to your Backup configuration directory'
+      desc 'generate:model', "Generates a Backup model file\n\n" +
+          "Note:\n" +
+          "\s\s'--config-path' is the path to the directory where 'config.rb' is located.\n" +
+          "\s\sThe model file will be created as '<config_path>/models/<trigger>.rb'\n" +
+          "\s\sDefault: #{Backup::PATH}\n"
+
+      # options with their available values
+      %w{ databases storages syncers
+          encryptors compressors notifiers }.map(&:to_sym).each do |name|
+        path = File.join(Backup::TEMPLATE_PATH, 'cli', 'utility', name.to_s[0..-2])
+        method_option name, :type => :string, :desc =>
+            "(#{Dir[path + '/*'].sort.map {|p| File.basename(p) }.join(', ')})"
+      end
+
+      method_option :archives,    :type => :boolean
+      method_option :splitter,    :type => :boolean, :default => true,
+                    :desc => "use `--no-splitter` to disable"
+
+      define_method "generate:model" do
+        opts = options.merge(
+          :trigger      => options[:trigger].gsub(/[\W\s]/, '_'),
+          :config_path  => options[:config_path] ? File.expand_path(options[:config_path]) : nil
+        )
+        config_path    = opts[:config_path] || Backup::PATH
+        models_path    = File.join(config_path, "models")
+        config         = File.join(config_path, "config.rb")
+        model          = File.join(models_path, "#{opts[:trigger]}.rb")
+
+        FileUtils.mkdir_p(models_path)
+        if overwrite?(model)
+          File.open(model, 'w') do |file|
+            file.write(Backup::Template.new({:options => opts}).
+                       result("cli/utility/model.erb"))
+          end
+          puts "Generated model file in '#{ model }'."
+        end
+
+        if not File.exist?(config)
+          File.open(config, "w") do |file|
+            file.write(Backup::Template.new.result("cli/utility/config"))
+          end
+          puts "Generated configuration file in '#{ config }'."
+        end
+      end
+
+      ##
+      # [Generate:Config]
+      # Generates the main configuration file
+      desc 'generate:config', 'Generates the main Backup bootstrap/configuration file'
+      method_option :path, :type => :string
+      define_method 'generate:config' do
+        path = options[:path] ? File.expand_path(options[:path]) : nil
+        config_path = path || Backup::PATH
+        config      = File.join(config_path, "config.rb")
+
+        FileUtils.mkdir_p(config_path)
+        if overwrite?(config)
+          File.open(config, "w") do |file|
+            file.write(Backup::Template.new.result("cli/utility/config"))
+          end
+          puts "Generated configuration file in '#{ config }'"
+        end
+      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
+      method_option :password_file, :type => :string,  :default  => ''
+      method_option :salt,          :type => :boolean, :default  => false
+      def decrypt
+        case options[:encryptor].downcase
+        when 'openssl'
+          base64   = options[:base64] ? '-base64' : ''
+          password = options[:password_file] ? "-pass file:#{options[:password_file]}" : ''
+          salt     = options[:salt] ? '-salt' : ''
+          %x[openssl aes-256-cbc -d #{base64} #{password} #{salt} -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
+
+      ##
+      # Setup required paths based on the given options
+      #
+      def setup_paths(options)
+        ##
+        # Set PATH if --root-path is given and the directory exists
+        root_path = false
+        root_given = options[:root_path].strip
+        if !root_given.empty? && File.directory?(root_given)
+          root_path = File.expand_path(root_given)
+          Backup.send(:remove_const, :PATH)
+          Backup.send(:const_set, :PATH, root_path)
+        end
+
+        ##
+        # Update all defaults and given paths to use root_path (if given).
+        # Paths given as an absolute path will be used 'as-is'
+        { :config_file  => 'config.rb',
+          :data_path    => 'data',
+          :log_path     => 'log',
+          :cache_path   => '.cache',
+          :tmp_path     => '.tmp' }.each do |key, name|
+          # strip any trailing '/' in case the user supplied this as part of
+          # an absolute path, so we can match it against File.expand_path()
+          given = options[key].sub(/\/\s*$/, '').lstrip
+          path = false
+          if given.empty?
+            path = File.join(root_path, name) if root_path
+          else
+            path = File.expand_path(given)
+            unless given == path
+              path = File.join(root_path, given) if root_path
+            end
+          end
+
+          const = key.to_s.upcase
+          if path
+            Backup.send(:remove_const, const)
+            Backup.send(:const_set, const, path)
+          else
+            path = Backup.const_get(const)
+          end
+
+          ##
+          # Ensure the LOG_PATH, CACHE_PATH and TMP_PATH are created if they do not yet exist
+          FileUtils.mkdir_p(path) if [:log_path, :cache_path, :tmp_path].include?(key)
+        end
+      end
+
+      ##
+      # Helper method for asking the user if he/she wants to overwrite the file
+      def overwrite?(path)
+        if File.exist?(path)
+          return yes? "A file already exists at '#{ path }'. Do you want to overwrite? [y/n]"
+        end
+        true
+      end
+
+    end
+  end
+end