backup 3.0.20 → 3.0.21

data/lib/backup/cleaner.rb

@@ -1,36 +1,121 @@
 # encoding: utf-8
 
 module Backup
-  class Cleaner
-    include Backup::CLI::Helpers
+  module Cleaner
+    class << self
 
-    ##
-    # Holds an instance of the current Backup model
-    attr_accessor :model
+      ##
+      # 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
 
-    ##
-    # Creates a new instance of Backup::Cleaner
-    def initialize(model)
-      @model = model
-    end
+        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
 
-    ##
-    # 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
+        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
 
-  private
+      def tmp_path_package_files
+        Dir[File.join(
+          Config.tmp_path,
+          "????.??.??.??.??.??.#{ @model.trigger }.tar{,[.-]*}"
+        )]
+      end
 
-    ##
-    # 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

@@ -3,6 +3,7 @@
 module Backup
   module CLI
     module Helpers
+      UTILITY = {}
 
       ##
       # Runs a given command in an isolated (sub) process using POpen4.
@@ -33,44 +34,28 @@ module Backup
       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
+      # 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)
-        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
+        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
-        name
+        UTILITY[name] = path
       end
 
       ##
-      # Returns the name of the command
+      # Returns the name of the command name from the given command line
       def command_name(command)
-        command.slice(0, command.index(/\s/)).split('/')[-1]
+        i = command =~ /\s/
+        command = command.slice(0, i) if i
+        command.split('/')[-1]
       end
 
       ##

data/lib/backup/cli/utility.rb

@@ -13,7 +13,7 @@ module Backup
       # 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,
+      # 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']
@@ -30,71 +30,56 @@ module Backup
                       "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.quiet = options[:quiet]
 
         ##
-        # Silence Backup::Logger from printing to STDOUT, if --quiet was specified
-        Logger.send(:const_set, :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?(Backup::Finder::WILDCARD) ?
-            Backup::Finder.new(t).matching : t
+        triggers.map!(&:strip).map! {|t|
+          t.include?('*') ? Model.find_matching(t) : 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"))
+          # Find the model for this trigger
+          # Will raise an error if not found
+          model = Model.find(trigger)
 
           ##
-          # 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}!"
+          # Prepare and Perform the backup
+          model.prepare!
           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)
+        Logger.error Errors::CLIError.wrap(err)
         exit(1)
       end
 
@@ -104,14 +89,15 @@ module Backup
       # 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"
+          "\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
@@ -127,10 +113,11 @@ module Backup
 
       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
+          :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
+        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")
@@ -141,14 +128,14 @@ module Backup
             file.write(Backup::Template.new({:options => opts}).
                        result("cli/utility/model.erb"))
           end
-          puts "Generated model file in '#{ model }'."
+          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 in '#{ config }'."
+          puts "Generated configuration file: '#{ config }'."
         end
       end
 
@@ -156,18 +143,19 @@ module Backup
       # [Generate:Config]
       # Generates the main configuration file
       desc 'generate:config', 'Generates the main Backup bootstrap/configuration file'
-      method_option :path, :type => :string
+      method_option :config_path, :type => :string,
+                    :desc => 'Path to your Backup configuration directory'
       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")
+        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 in '#{ config }'"
+          puts "Generated configuration file: '#{ config }'."
         end
       end
 
@@ -192,7 +180,7 @@ module Backup
           %x[gpg -o '#{options[:out]}' -d '#{options[:in]}']
         else
           puts "Unknown encryptor: #{options[:encryptor]}"
-          puts "Use either 'openssl' or 'gpg'"
+          puts "Use either 'openssl' or 'gpg'."
         end
       end
 
@@ -245,55 +233,6 @@ module Backup
 
       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)