backup 3.1.3 → 3.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MDQwZGQzZjE1OWQ2MDAwZjBjMjBkODZiYzRlMTdmZTc0Njc4NzUzOQ==
-  data.tar.gz: !binary |-
-    ZDQ1MjVkYjIyNThmZWJkNWFkZjI1MDJiZTAyNTA0MTg1NGZhNzc3Yg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NzQwNGViMWM5ZjliYzFhNzVmNGI5NzhhZmFiNDMwYWM5ZTM0NmQ3MmE2NmJm
-    YTM5MTUwM2QyN2NlMTMxOWM5MWJhMzAwN2M4ZTExYjFkNTdlZjc4MDc2ODVl
-    NTI1ZGI4OTYzYTVkMTk3ZDFlYjhiNWVkMTZiMzJmZDU5ZTg5M2E=
-  data.tar.gz: !binary |-
-    ODUwM2U2MGFkYjQ5MTkwOTQ1Yzg0MWIzNWEwMzdmMDQwYzdhZGNkMmI3NWM5
-    YzY0MWJiMDA1ZmViZTQxMDVmZTU1ZDAwYmRhZjFhY2ZjZGEzZGFkYWU0ZmQ1
-    MDEwMWZkOGM3ZGJlY2Q3OWMwOTZhOTNmYzY1NTNjYWViZjU1MTA=
+SHA1:
+  metadata.gz: 97b183cb0d0c210153909788775e95a6a686a4cc
+  data.tar.gz: 4eb3b105dcdea08f667c8e94625ec9bdf174dc49
+SHA512:
+  metadata.gz: d5c1cd997c5e0823022b323b639c7977b7d3f573468c860f0fab496ed619b3b44baae8c56ab8dbe13e9ab0643844dac72be9ac6e79c19ef5859faf2fd05760c5
+  data.tar.gz: 07af01b103adf78549d1296145403dded6e8e6d4cea9dbd5b750839ca26f585c32e0c42a0359f46f9ac0bcc57a412e6b6fdb3e8ab5b8b0936f8496109af7ce09

data/lib/backup.rb

@@ -7,6 +7,7 @@ require 'tempfile'
 require 'syslog'
 require 'yaml'
 require 'etc'
+require 'forwardable'
 
 require 'open4'
 require 'thor'

data/lib/backup/archive.rb

@@ -3,121 +3,148 @@
 module Backup
   class Archive
     include Backup::Utilities::Helpers
+    attr_reader :name, :options
 
     ##
-    # Stores the name of the archive
-    attr_reader :name
-
-    ##
-    # Stores an array of different paths/files to store
-    attr_reader :paths
-
-    ##
-    # Stores an array of different paths/files to exclude
-    attr_reader :excludes
-
-    ##
-    # String of additional arguments for the `tar` command
-    attr_reader :tar_args
-
-    ##
-    # Takes the name of the archive and the configuration block
+    # Adds a new Archive to a Backup Model.
+    #
+    #     Backup::Model.new(:my_backup, 'My Backup') do
+    #       archive :my_archive do |archive|
+    #         archive.add 'path/to/archive'
+    #         archive.add '/another/path/to/archive'
+    #         archive.exclude 'path/to/exclude'
+    #         archive.exclude '/another/path/to/exclude'
+    #       end
+    #     end
+    #
+    # All paths added using `add` or `exclude` will be expanded to their
+    # full paths from the root of the filesystem. Files will be added to
+    # the tar archive using these full paths, and their leading `/` will
+    # be preserved (using tar's `-P` option).
+    #
+    #     /path/to/pwd/path/to/archive/...
+    #     /another/path/to/archive/...
+    #
+    # When a `root` path is given, paths to add/exclude are taken as
+    # relative to the `root` path, unless given as absolute paths.
+    #
+    #     Backup::Model.new(:my_backup, 'My Backup') do
+    #       archive :my_archive do |archive|
+    #         archive.root '~/my_data'
+    #         archive.add 'path/to/archive'
+    #         archive.add '/another/path/to/archive'
+    #         archive.exclude 'path/to/exclude'
+    #         archive.exclude '/another/path/to/exclude'
+    #       end
+    #     end
+    #
+    # This directs `tar` to change directories to the `root` path to create
+    # the archive. Unless paths were given as absolute, the paths within the
+    # archive will be relative to the `root` path.
+    #
+    #     path/to/archive/...
+    #     /another/path/to/archive/...
+    #
+    # For absolute paths added to this archive, the leading `/` will be
+    # preserved. Take note that when archives are extracted, leading `/` are
+    # stripped by default, so care must be taken when extracting archives with
+    # mixed relative/absolute paths.
     def initialize(model, name, &block)
-      @model    = model
-      @name     = name.to_s
-      @paths    = Array.new
-      @excludes = Array.new
-      @tar_args = ''
-
-      instance_eval(&block) if block_given?
-    end
-
-    ##
-    # Adds new paths to the @paths instance variable array
-    def add(path)
-      @paths << File.expand_path(path)
-    end
-
-    ##
-    # Adds new paths to the @excludes instance variable array
-    def exclude(path)
-      @excludes << File.expand_path(path)
+      @model   = model
+      @name    = name.to_s
+      @options = {
+        :root        => false,
+        :paths       => [],
+        :excludes    => [],
+        :tar_options => ''
+      }
+      DSL.new(@options).instance_eval(&block)
     end
 
-    ##
-    # Adds the given String of +options+ to the `tar` command.
-    # e.g. '-h --xattrs'
-    def tar_options(options)
-      @tar_args = 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
-    # If the model is configured with a Compressor, the tar command output
-    # will be piped through the Compressor command and the file extension
-    # will be adjusted to indicate the type of compression used.
     def perform!
-      Logger.info "#{ self.class } has started archiving:\n" +
-          paths.map {|path| "  #{path}" }.join("\n")
+      Logger.info "Creating Archive '#{ name }'..."
 
-      archive_path = File.join(Config.tmp_path, @model.trigger, 'archives')
-      FileUtils.mkdir_p(archive_path)
+      path = File.join(Config.tmp_path, @model.trigger, 'archives')
+      FileUtils.mkdir_p(path)
 
-      archive_ext = 'tar'
       pipeline = Pipeline.new
-
       pipeline.add(
-        "#{ utility(:tar) } #{ tar_arguments } -cPf - " +
+        "#{ utility(:tar) } #{ tar_options } -cPf -#{ tar_root } " +
         "#{ paths_to_exclude } #{ paths_to_package }",
         tar_success_codes
       )
 
-      if @model.compressor
-        @model.compressor.compress_with do |command, ext|
-          pipeline << command
-          archive_ext << ext
-        end
-      end
+      extension = 'tar'
+      @model.compressor.compress_with do |command, ext|
+        pipeline << command
+        extension << ext
+      end if @model.compressor
 
       pipeline << "#{ utility(:cat) } > " +
-          "'#{ File.join(archive_path, "#{name}.#{archive_ext}") }'"
+          "'#{ File.join(path, "#{ name }.#{ extension }") }'"
       pipeline.run
+
       if pipeline.success?
-        Logger.info "#{ self.class } Complete!"
+        Logger.info "Archive '#{ name }' Complete!"
       else
         raise Errors::Archive::PipelineError,
-            "Failed to Create Backup Archive\n" +
+            "Failed to Create Archive '#{ name }'\n" +
             pipeline.error_messages
       end
     end
 
     private
 
-    ##
-    # Returns a "tar-ready" string of all the specified paths combined
+    def tar_root
+      options[:root] ? " -C '#{ File.expand_path(options[:root]) }'" : ''
+    end
+
     def paths_to_package
-      paths.map {|path| "'#{path}'" }.join(' ')
+      options[:paths].map {|path|
+        "'#{ prepare_path(path) }'"
+      }.join(' ')
     end
 
-    ##
-    # Returns a "tar-ready" string of all the specified excludes combined
     def paths_to_exclude
-      if excludes.any?
-        excludes.map {|path| "--exclude='#{path}'" }.join(' ')
-      end
+      options[:excludes].map {|path|
+        "--exclude='#{ prepare_path(path) }'"
+      }.join(' ')
     end
 
-    ##
-    # Returns arguments for GNU or BSD tar.
-    def tar_arguments
-      gnu_tar? ? "--ignore-failed-read #{ tar_args }".strip : tar_args
+    def prepare_path(path)
+      options[:root] ? path : File.expand_path(path)
+    end
+
+    def tar_options
+      args = options[:tar_options]
+      gnu_tar? ? "--ignore-failed-read #{ args }".strip : args
     end
 
-    ##
-    # Returns successful GNU or BSD tar exit codes.
     def tar_success_codes
       gnu_tar? ? [0, 1] : [0]
     end
+
+    class DSL
+      def initialize(options)
+        @options = options
+      end
+
+      def root(path)
+        @options[:root] = path
+      end
+
+      def add(path)
+        @options[:paths] << path
+      end
+
+      def exclude(path)
+        @options[:excludes] << path
+      end
+
+      def tar_options(opts)
+        @options[:tar_options] = opts
+      end
+    end
+
   end
 end

data/lib/backup/cli.rb

@@ -9,12 +9,27 @@ module Backup
     ##
     # [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 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".
+    #
+    # If the --check option is given, the config.rb and all model files will be
+    # loaded, but no triggers will be run. If the check fails, errors will be
+    # reported to the console. If the check passes, a success message will be
+    # reported to the console unless --quiet is set. Use --no-quiet to ensure
+    # these messages are output. The command will exit with status 0 if
+    # successful, or status 1 if there were problems.
+    #
+    # This command will exit with one of the following status codes:
+    #
+    #   0: All triggers were successful and no warnings were issued.
+    #   1: All triggers were successful, but some had warnings.
+    #   2: All triggers were processed, but some failed.
+    #   3: A fatal error caused Backup to exit.
+    #      Some triggers may not have been processed.
     desc 'perform', "Performs the backup for the specified trigger(s)."
     long_desc "Performs the backup for the specified trigger(s).\n\n" +
               "You may perform multiple backups by providing multiple triggers, separated by commas.\n\n" +
@@ -110,13 +125,13 @@ module Backup
         # Finalize Logger configuration and begin real-time logging.
         Logger.start!
 
-      rescue => err
+      rescue Exception => err
         Logger.error Errors::CLIError.wrap(err)
         Logger.error 'Configuration Check Failed.' if options[:check]
         # Logger configuration will be ignored
         # and messages will be output to the console only.
         Logger.abort!
-        exit(1)
+        exit(options[:check] ? 1 : 3)
       end
 
       if options[:check]
@@ -128,10 +143,14 @@ module Backup
         #
         # Model#perform! handles all exceptions from this point,
         # as each model may fail and return here to allow others to run.
+        warnings = errors = false
         models.each do |model|
           model.perform!
+          warnings ||= Logger.has_warnings?
+          errors   ||= Logger.has_errors?
           Logger.clear!
         end
+        exit(errors ? 2 : 1) if errors || warnings
       end
     end
 

data/lib/backup/logger.rb

@@ -5,7 +5,7 @@ require 'backup/logger/logfile'
 require 'backup/logger/syslog'
 
 module Backup
-  module Logger
+  class Logger
 
     class Config
       class Logger < Struct.new(:class, :options)
@@ -14,17 +14,22 @@ module Backup
         end
       end
 
-      DSL = Struct.new(:console, :logfile, :syslog)
+      class DSL < Struct.new(:ignores, :console, :logfile, :syslog)
+        def ignore_warning(str_or_regexp)
+          ignores << str_or_regexp
+        end
+      end
 
-      attr_reader :loggers, :dsl
+      attr_reader :ignores, :loggers, :dsl
 
       def initialize
+        @ignores = []
         @loggers = [
           Logger.new(Console, Console::Options.new),
           Logger.new(Logfile, Logfile::Options.new),
           Logger.new(Syslog, Syslog::Options.new)
         ]
-        @dsl = DSL.new(*@loggers.map(&:options))
+        @dsl = DSL.new(ignores, *loggers.map(&:options))
       end
     end
 
@@ -40,13 +45,20 @@ module Backup
         timestamp = time.strftime("%Y/%m/%d %H:%M:%S")
         lines.map {|line| "[#{ timestamp }][#{ level }] #{ line }" }
       end
+
+      def matches?(ignores)
+        text = lines.join("\n")
+        ignores.any? {|obj|
+          obj.is_a?(Regexp) ? text.match(obj) : text.include?(obj)
+        }
+      end
     end
 
     class << self
-      ##
-      # Returns an Array of Message objects for all logged messages received.
-      # These are used to attach log files to Mail notifications.
-      attr_reader :messages
+      extend Forwardable
+      def_delegators :logger,
+          :start!, :abort!, :info, :warn, :error,
+          :messages, :has_warnings?, :has_errors?
 
       ##
       # Allows the Logger to be configured.
@@ -69,6 +81,11 @@ module Backup
       #     syslog.info     = Syslog::LOG_INFO
       #     syslog.warn     = Syslog::LOG_WARNING
       #     syslog.error    = Syslog::LOG_ERR
+      #
+      #     # Ignore Warnings:
+      #     # Converts :warn level messages to level :info
+      #     ignore_warning 'that contains this string'
+      #     ignore_warning /that matches this regexp/
       #   end
       #
       # See each Logger's Option class for details.
@@ -76,75 +93,102 @@ module Backup
       # @see Logfile::Options
       # @see Syslog::Options
       def configure(&block)
-        @config.dsl.instance_eval(&block)
+        config.dsl.instance_eval(&block)
       end
 
       ##
-      # Sends a message to the Logger using the specified log level.
-      # +obj+ may be any Object that responds to #to_s (i.e. an Exception)
-      [:info, :warn, :error].each do |level|
-        define_method level, lambda {|obj| log(obj, level) }
+      # Called after each backup model/trigger has been performed.
+      def clear!
+        @logger = nil
+        logger.start!
       end
 
-      ##
-      # Returns true if any +:warn+ level messages have been received.
-      def has_warnings?
-        @has_warnings
-      end
+      private
 
-      ##
-      # The Logger is available as soon as Backup is loaded, and stores all
-      # messages it receives. Since the Logger may be configured via the
-      # command line and/or the user's +config.rb+, no messages are sent
-      # until configuration can be completed. (see CLI#perform)
-      #
-      # Once configuration is completed, this method is called to activate
-      # all enabled loggers and send them any messages that have been received
-      # up to this point. From this point onward, these loggers will be sent
-      # all messages as soon as they're received.
-      def start!
-        @config.loggers.each do |logger|
-          @loggers << logger.class.new(logger.options) if logger.enabled?
-        end
-        @messages.each do |message|
-          @loggers.each {|logger| logger.log(message) }
-        end
+      def config
+        @config ||= Config.new
       end
 
-      ##
-      # Called after each backup model/trigger has been performed.
-      def clear!
-        messages.clear
-        @has_warnings = false
+      def logger
+        @logger ||= new(config)
       end
 
-      ##
-      # If errors are encountered by Backup::CLI while preparing to perform
-      # the backup jobs, this method is called to dump all messages to the
-      # console before Backup exits.
-      def abort!
-        console = Console.new
-        console.log(@messages.shift) until @messages.empty?
+      def reset!
+        @config = @logger = nil
       end
+    end
 
-      private
+    ##
+    # Returns an Array of Message objects for all logged messages received.
+    # These are used to attach log files to Mail notifications.
+    attr_reader :messages
+
+    def initialize(config)
+      @config = config
+      @messages = []
+      @loggers = []
+      @has_warnings = @has_errors = false
+    end
 
-      def initialize!
-        @messages = []
-        @loggers = []
-        @config = Config.new
-        @has_warnings = false
-      end
+    ##
+    # Sends a message to the Logger using the specified log level.
+    # +obj+ may be any Object that responds to #to_s (i.e. an Exception)
+    [:info, :warn, :error].each do |level|
+      define_method level, lambda {|obj| log(obj, level) }
+    end
+
+    ##
+    # Returns true if any +:warn+ level messages have been received.
+    def has_warnings?
+      @has_warnings
+    end
+
+    ##
+    # Returns true if any +:error+ level messages have been received.
+    def has_errors?
+      @has_errors
+    end
 
-      def log(obj, level)
-        @has_warnings ||= level == :warn
-        message = Message.new(Time.now, level, obj.to_s.split("\n"))
-        @messages << message
+    ##
+    # The Logger is available as soon as Backup is loaded, and stores all
+    # messages it receives. Since the Logger may be configured via the
+    # command line and/or the user's +config.rb+, no messages are sent
+    # until configuration can be completed. (see CLI#perform)
+    #
+    # Once configuration is completed, this method is called to activate
+    # all enabled loggers and send them any messages that have been received
+    # up to this point. From this point onward, these loggers will be sent
+    # all messages as soon as they're received.
+    def start!
+      @config.loggers.each do |logger|
+        @loggers << logger.class.new(logger.options) if logger.enabled?
+      end
+      messages.each do |message|
         @loggers.each {|logger| logger.log(message) }
       end
+    end
 
+    ##
+    # If errors are encountered by Backup::CLI while preparing to perform
+    # the backup jobs, this method is called to dump all messages to the
+    # console before Backup exits.
+    def abort!
+      console = Console.new
+      console.log(messages.shift) until messages.empty?
     end
 
-    initialize!
+    private
+
+    def log(obj, level)
+      message = Message.new(Time.now, level, obj.to_s.split("\n"))
+
+      message.level = :info if message.level == :warn &&
+          message.matches?(@config.ignores)
+      @has_warnings ||= message.level == :warn
+      @has_errors   ||= message.level == :error
+
+      messages << message
+      @loggers.each {|logger| logger.log(message) }
+    end
   end
 end