backup_checksum 3.0.23

data/lib/backup/checksum/shasum.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Backup
+  module Checksum
+    class Shasum < Base
+
+
+      def checksum_with(outfile)
+        log!
+        yield "shasum '#{outfile}' >> '#{outfile}.sum'"
+      end
+
+
+    end
+  end
+end

data/lib/backup/cleaner.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module Backup
+  module Cleaner
+    class << self
+
+      ##
+      # Logs warnings if any temporary files still exist
+      # from the last time this model/trigger was run,
+      # then removes the files.
+      def prepare(model)
+        @model = model
+
+        messages = []
+        if packaging_folder_dirty?
+          messages << <<-EOS
+            The temporary backup folder still contains files!
+            '#{ File.join(Config.tmp_path, @model.trigger) }'
+            These files will now be removed.
+          EOS
+          FileUtils.rm_rf(File.join(Config.tmp_path, @model.trigger))
+        end
+
+        package_files = tmp_path_package_files
+        unless package_files.empty?
+          # the chances that tmp_path would be dirty
+          # AND package files exist are practically nil
+          messages << ('-' * 74) unless messages.empty?
+
+          messages << <<-EOS
+            The temporary backup folder '#{ Config.tmp_path }'
+            appears to contain the package files from the previous backup!
+            #{ package_files.join("\n") }
+            These files will now be removed.
+          EOS
+          package_files.each {|file| FileUtils.rm_f(file) }
+        end
+
+        unless messages.empty?
+          Logger.warn Errors::CleanerError.new(<<-EOS)
+            Cleanup Warning
+            #{ messages.join("\n") }
+            Please check the log for messages and/or your notifications
+            concerning this backup: '#{ @model.label } (#{ @model.trigger })'
+            The temporary files which had to be removed should not have existed.
+          EOS
+        end
+      end
+
+      ##
+      # Remove the temporary folder used during packaging
+      def remove_packaging(model)
+        Logger.message "Cleaning up the temporary files..."
+        FileUtils.rm_rf(File.join(Config.tmp_path, model.trigger))
+      end
+
+      ##
+      # Remove the final package files from tmp_path
+      # Note: 'force' is used, since a Local Storage may *move* these files.
+      def remove_package(package)
+        Logger.message "Cleaning up the package files..."
+        package.filenames.each do |file|
+          FileUtils.rm_f(File.join(Config.tmp_path, file))
+        end
+      end
+
+      ##
+      # Logs warnings if any temporary files still exist
+      # when errors occur during the backup
+      def warnings(model)
+        @model = model
+
+        messages = []
+        if packaging_folder_dirty?
+          messages << <<-EOS
+            The temporary backup folder still contains files!
+            '#{ File.join(Config.tmp_path, @model.trigger) }'
+            This folder may contain completed Archives and/or Database backups.
+          EOS
+        end
+
+        package_files = tmp_path_package_files
+        unless package_files.empty?
+          # the chances that tmp_path would be dirty
+          # AND package files exist are practically nil
+          messages << ('-' * 74) unless messages.empty?
+
+          messages << <<-EOS
+            The temporary backup folder '#{ Config.tmp_path }'
+            appears to contain the backup files which were to be stored:
+            #{ package_files.join("\n") }
+          EOS
+        end
+
+        unless messages.empty?
+          Logger.warn Errors::CleanerError.new(<<-EOS)
+            Cleanup Warning
+            #{ messages.join("\n") }
+            Make sure you check these files before the next scheduled backup for
+            '#{ @model.label } (#{ @model.trigger })'
+            These files will be removed at that time!
+          EOS
+        end
+      end
+
+      private
+
+      def packaging_folder_dirty?
+        !Dir[File.join(Config.tmp_path, @model.trigger, '*')].empty?
+      end
+
+      def tmp_path_package_files
+        Dir[File.join(
+          Config.tmp_path,
+          "????.??.??.??.??.??.#{ @model.trigger }.tar{,[.-]*}"
+        )]
+      end
+
+    end
+  end
+end

data/lib/backup/cli/helpers.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module Backup
+  module CLI
+    module Helpers
+      UTILITY = {}
+
+      ##
+      # 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
+
+      ##
+      # Returns the full path to the specified utility.
+      # Raises an error if utility can not be found in the system's $PATH
+      def utility(name)
+        path = UTILITY[name] || %x[which #{name} 2>/dev/null].chomp
+        if path.empty?
+          raise Errors::CLI::UtilityNotFoundError, <<-EOS
+            Path to '#{ name }' could not be found.
+            Make sure the specified utility is installed
+            and available in your system's $PATH.
+            If this is a database utility, you may need to specify the full path
+            using the Database's '<utility_name>_utility' configuration setting.
+          EOS
+        end
+        UTILITY[name] = path
+      end
+
+      ##
+      # Returns the name of the command name from the given command line
+      def command_name(command)
+        i = command =~ /\s/
+        command = command.slice(0, i) if i
+        command.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,247 @@
+# 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 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
+        ##
+        # Silence Backup::Logger from printing to STDOUT, if --quiet was specified
+        Logger.quiet = options[:quiet]
+
+        ##
+        # Update Config variables based on the given options
+        Config.update(options)
+
+        ##
+        # Load the configuration file
+        Config.load_config!
+
+        ##
+        # Ensure the :log_path, :cache_path and :tmp_path are created
+        # if they do not yet exist
+        [Config.log_path, Config.cache_path, Config.tmp_path].each do |path|
+          FileUtils.mkdir_p(path)
+        end
+
+        ##
+        # Truncate log file if needed
+        Logger.truncate!
+
+        ##
+        # 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?('*') ? Model.find_matching(t) : t
+        }.flatten!
+
+        ##
+        # Process each trigger
+        triggers.each do |trigger|
+          ##
+          # Find the model for this trigger
+          # Will raise an error if not found
+          model = Model.find(trigger)
+
+          ##
+          # Prepare and Perform the backup
+          model.prepare!
+          model.perform!
+
+          ##
+          # Clear the Log Messages for the next potential run
+          Logger.clear!
+        end
+
+      rescue => err
+        Logger.error 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
+      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: #{Config.root_path}\n"
+
+      method_option :trigger,     :type => :string, :required => true
+      method_option :config_path, :type => :string,
+                    :desc => 'Path to your Backup configuration directory'
+
+      # 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] || Config.root_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: '#{ 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: '#{ config }'."
+        end
+      end
+
+      ##
+      # [Generate:Config]
+      # Generates the main configuration file
+      desc 'generate:config', 'Generates the main Backup bootstrap/configuration file'
+      method_option :config_path, :type => :string,
+                    :desc => 'Path to your Backup configuration directory'
+      define_method 'generate:config' do
+        config_path = options[:config_path] ?
+            File.expand_path(options[:config_path]) : Config.root_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: '#{ 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
+
+      ##
+      # 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