backup 3.0.27 → 3.1.0

data/lib/backup/encryptor/base.rb

@@ -3,7 +3,7 @@
 module Backup
   module Encryptor
     class Base
-      include Backup::CLI::Helpers
+      include Backup::Utilities::Helpers
       include Backup::Configuration::Helpers
 
       def initialize
@@ -22,7 +22,7 @@ module Backup
       # Logs a message to the console and log file to inform
       # the client that Backup is encrypting the archive
       def log!
-        Logger.message "Using #{ encryptor_name } to encrypt the archive."
+        Logger.info "Using #{ encryptor_name } to encrypt the archive."
       end
     end
   end

data/lib/backup/logger.rb

@@ -1,152 +1,150 @@
 # encoding: utf-8
 
+require 'backup/logger/console'
+require 'backup/logger/logfile'
+require 'backup/logger/syslog'
+
 module Backup
   module Logger
-    class << self
-
-      attr_accessor :quiet
 
-      ##
-      # Outputs a messages to the console and writes it to the backup.log
-      def message(string)
-        to_console  loggify(string, :message, :green)
-        to_file     loggify(string, :message)
+    class Config
+      class Logger < Struct.new(:class, :options)
+        def enabled?
+          options.enabled?
+        end
       end
 
-      ##
-      # Outputs an error to the console and writes it to the backup.log
-      # Called when an Exception has caused the backup process to abort.
-      def error(string)
-        to_console  loggify(string, :error,   :red), true
-        to_file     loggify(string, :error)
-      end
+      DSL = Struct.new(:console, :logfile, :syslog)
 
-      ##
-      # Outputs a notice to the console and writes it to the backup.log
-      # Sets #has_warnings? true so :on_warning notifications will be sent
-      def warn(string)
-        @has_warnings = true
-        to_console  loggify(string, :warning, :yellow), true
-        to_file     loggify(string, :warning)
-      end
+      attr_reader :loggers, :dsl
 
-      # Outputs the data as if it were a regular 'puts' command,
-      # but also logs it to the backup.log
-      def normal(string)
-        to_console  loggify(string)
-        to_file     loggify(string)
+      def initialize
+        @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))
       end
+    end
 
+    ##
+    # All messages sent to the Logger are stored in Logger.messages
+    # and sent to all enabled logger's #log method as Message objects.
+    class Message < Struct.new(:time, :level, :lines)
       ##
-      # Silently logs data to the log file
-      def silent(string)
-        to_file     loggify(string, :silent)
+      # Returns an Array of the message lines in the following format:
+      #
+      #   [YYYY/MM/DD HH:MM:SS][level] message line text
+      def formatted_lines
+        timestamp = time.strftime("%Y/%m/%d %H:%M:%S")
+        lines.map {|line| "[#{ timestamp }][#{ level }] #{ line }" }
       end
+    end
 
+    class << self
       ##
-      # Returns an Array of all messages written to the log file for this session
-      def messages
-        @messages ||= []
-      end
+      # Returns an Array of Message objects for all logged messages received.
+      # These are used to attach log files to Mail notifications.
+      attr_reader :messages
 
       ##
-      # Returns true if any warnings have been issued
-      def has_warnings?
-        @has_warnings ||= false
-      end
-
-      def clear!
-        messages.clear
-        @has_warnings = false
-      end
-
-      def truncate!(max_bytes = 500_000)
-        log_file = File.join(Config.log_path, 'backup.log')
-        return unless File.exist?(log_file)
-
-        if File.stat(log_file).size > max_bytes
-          FileUtils.mv(log_file, log_file + '~')
-          File.open(log_file + '~', 'r') do |io_in|
-            File.open(log_file, 'w') do |io_out|
-              io_in.seek(-max_bytes, IO::SEEK_END) && io_in.gets
-              while line = io_in.gets
-                io_out.puts line
-              end
-            end
-          end
-          FileUtils.rm_f(log_file + '~')
-        end
-      end
-
-      private
-
-      ##
-      # Returns the time in [YYYY/MM/DD HH:MM:SS] format
-      def time
-        Time.now.strftime("%Y/%m/%d %H:%M:%S")
+      # Allows the Logger to be configured.
+      #
+      #   # shown with their default values
+      #   Backup::Logger.configure do
+      #     # Console options:
+      #     console.quiet = false
+      #
+      #     # Logfile options:
+      #     logfile.enabled   = true
+      #     logfile.log_path  = 'log'
+      #     logfile.max_bytes = 500_000
+      #
+      #     # Syslog options:
+      #     syslog.enabled  = false
+      #     syslog.ident    = 'backup'
+      #     syslog.options  = Syslog::LOG_PID
+      #     syslog.facility = Syslog::LOG_LOCAL0
+      #     syslog.info     = Syslog::LOG_INFO
+      #     syslog.warn     = Syslog::LOG_WARNING
+      #     syslog.error    = Syslog::LOG_ERR
+      #   end
+      #
+      # See each Logger's Option class for details.
+      # @see Console::Options
+      # @see Logfile::Options
+      # @see Syslog::Options
+      def configure(&block)
+        @config.dsl.instance_eval(&block)
       end
 
       ##
-      # Receives a String, or an Object that responds to #to_s (e.g. an
-      # Exception), from one of the messaging methods and converts it into an
-      # Array of Strings, split on newline separators. Each line is then
-      # formatted into a log format based on the given options, and the Array
-      # returned to be passed to to_console() and/or to_file().
-      def loggify(string, type = false, color = false)
-        lines = string.to_s.split("\n")
-        if type
-          type = send(color, type) if color
-          time_now = time
-          lines.map {|line| "[#{time_now}][#{type}] #{line}" }
-        else
-          lines
-        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
 
       ##
-      # Receives an Array of Strings to be written to the console.
-      def to_console(lines, stderr = false)
-        return if quiet
-        lines.each {|line| stderr ? Kernel.warn(line) : puts(line) }
+      # Returns true if any +:warn+ level messages have been received.
+      def has_warnings?
+        @has_warnings
       end
 
       ##
-      # Receives an Array of Strings to be written to the log file.
-      def to_file(lines)
-        File.open(File.join(Config.log_path, 'backup.log'), 'a') do |file|
-          lines.each {|line| file.puts line }
+      # 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
-        messages.push(*lines)
       end
 
       ##
-      # Invokes the #colorize method with the provided string
-      # and the color code "32" (for green)
-      def green(string)
-        colorize(string, 32)
+      # Called after each backup model/trigger has been performed.
+      def clear!
+        messages.clear
+        @has_warnings = false
       end
 
       ##
-      # Invokes the #colorize method with the provided string
-      # and the color code "33" (for yellow)
-      def yellow(string)
-        colorize(string, 33)
+      # 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
 
-      ##
-      # Invokes the #colorize method the with provided string
-      # and the color code "31" (for red)
-      def red(string)
-        colorize(string, 31)
+      private
+
+      def initialize!
+        @messages = []
+        @loggers = []
+        @config = Config.new
+        @has_warnings = false
       end
 
-      ##
-      # Wraps the provided string in colorizing tags to provide
-      # easier to view output to the client
-      def colorize(string, code)
-        "\e[#{code}m#{string}\e[0m"
+      def log(obj, level)
+        @has_warnings ||= level == :warn
+        message = Message.new(Time.now, level, obj.to_s.split("\n"))
+        @messages << message
+        @loggers.each {|logger| logger.log(message) }
       end
 
     end
+
+    initialize!
   end
 end

data/lib/backup/logger/console.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Backup
+  module Logger
+    class Console
+      class Options
+        ##
+        # Disables all console output.
+        #
+        # This may also be set on the command line using +--quiet+.
+        #
+        # If +--no-quiet+ is used on the command line, console output
+        # will be enabled and any setting here will be ignored.
+        #
+        # @param [Boolean, nil]
+        # @return [Boolean, nil] Default: +false+
+        attr_reader :quiet
+
+        def initialize
+          @quiet = false
+        end
+
+        def enabled?
+          !quiet
+        end
+
+        def quiet=(val)
+          @quiet = val unless quiet.nil?
+        end
+      end
+
+      COLORS = {
+        :info   => "\e[32m%s\e[0m", # green
+        :warn   => "\e[33m%s\e[0m", # yellow
+        :error  => "\e[31m%s\e[0m"  # red
+      }
+
+      def initialize(options = nil)
+        $stdout.sync = $stderr.sync = true
+      end
+
+      def log(message)
+        io = message.level == :info ? $stdout : $stderr
+        lines = message.formatted_lines
+        lines.map! {|line| COLORS[message.level] % line } if io.tty?
+        io.puts lines
+      end
+
+    end
+  end
+end

data/lib/backup/logger/logfile.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module Backup
+  module Logger
+    class Logfile
+      class Options
+        ##
+        # Enable the use of Backup's log file.
+        #
+        # While not necessary, as this is +true+ by default,
+        # this may also be set on the command line using +--logfile+.
+        #
+        # The use of Backup's log file may be disabled using the
+        # command line option +--no-logfile+.
+        #
+        # If +--no--logfile+ is used on the command line, then the
+        # log file will be disabled and any setting here will be ignored.
+        #
+        # @param [Boolean, nil]
+        # @return [Boolean, nil] Default: +true+
+        attr_reader :enabled
+
+        ##
+        # Path to directory where Backup's logfile will be written.
+        #
+        # This may be given as an absolute path, or a path relative
+        # to Backup's +--root-path+ (which defaults to +~/Backup+).
+        #
+        # This may also be set on the command line using +--log-path+.
+        # If set on the command line, any setting here will be ignored.
+        #
+        # @param [String]
+        # @return [String] Default: 'log'
+        attr_reader :log_path
+
+        ##
+        # Size in bytes to truncate logfile to before backup jobs are run.
+        #
+        # This is done once before all +triggers+, so the maximum logfile size
+        # would be this value plus whatever the jobs produce.
+        #
+        # @param [Integer]
+        # @return [Integer] Default: +500_000+
+        attr_accessor :max_bytes
+
+        def initialize
+          @enabled = true
+          @log_path = ''
+          @max_bytes = 500_000
+        end
+
+        def enabled?
+          !!enabled
+        end
+
+        def enabled=(val)
+          @enabled = val unless enabled.nil?
+        end
+
+        def log_path=(val)
+          @log_path = val.to_s.strip if log_path.empty?
+        end
+      end
+
+      def initialize(options)
+        @options = options
+        @logfile = setup_logfile
+        truncate!
+      end
+
+      def log(message)
+        File.open(@logfile, 'a') {|f| f.puts message.formatted_lines }
+      end
+
+      private
+
+      ##
+      # Returns the full path to the log file, based on the configured
+      # @options.log_path, and ensures the path to the log file exists.
+      def setup_logfile
+        # strip any trailing '/' in case the user supplied this as part of
+        # an absolute path, so we can match it against File.expand_path()
+        path = @options.log_path.chomp('/')
+        if path.empty?
+          path = File.join(Backup::Config.root_path, 'log')
+        elsif path != File.expand_path(path)
+          path = File.join(Backup::Config.root_path, path)
+        end
+        FileUtils.mkdir_p(path)
+        File.join(path, 'backup.log')
+      end
+
+      ##
+      # Truncates the logfile to @options.max_bytes
+      def truncate!
+        return unless File.exist?(@logfile)
+
+        if File.stat(@logfile).size > @options.max_bytes
+          FileUtils.mv(@logfile, @logfile + '~')
+          File.open(@logfile + '~', 'r') do |io_in|
+            File.open(@logfile, 'w') do |io_out|
+              io_in.seek(-@options.max_bytes, IO::SEEK_END) && io_in.gets
+              while line = io_in.gets
+                io_out.puts line
+              end
+            end
+          end
+          FileUtils.rm_f(@logfile + '~')
+        end
+      end
+    end
+  end
+end

data/lib/backup/logger/syslog.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Backup
+  module Logger
+    class Syslog
+      class Options
+        ##
+        # Enables logging to the system's Syslog compatible logger.
+        #
+        # This may also be enabled using +--syslog+ on the command line.
+        #
+        # If +--no-syslog+ is used on the command line, this will be
+        # disabled and any settings here will be ignored.
+        #
+        # @param [Boolean, nil]
+        # @return [Boolean, nil] Default: +false+
+        attr_reader :enabled
+
+        ##
+        # Specify the identification string to be used with Syslog.
+        #
+        # @param [String]
+        # @return [String] Default: 'backup'
+        attr_accessor :ident
+
+        ##
+        # Specify the options to be used with Syslog.
+        #
+        # See the Ruby Standard Library documentation for +Syslog+ for more info.
+        # http://rdoc.info/stdlib/syslog/Syslog.open
+        #
+        # Note that setting this to +nil+ will cause this to default
+        # to a setting of +Syslog::LOG_PID | Syslog::LOG_CONS+
+        #
+        # @param [Integer]
+        # @return [Integer] Default: +Syslog::LOG_PID+
+        attr_accessor :options
+
+        ##
+        # Specify the facility to be used with Syslog.
+        #
+        # See the Ruby Standard Library documentation for +Syslog+ for more info.
+        # http://rdoc.info/stdlib/syslog/Syslog.open
+        #
+        # Note that setting this to +nil+ will cause this to default
+        # to a setting of +Syslog::LOG_USER+
+        #
+        # @param [Integer]
+        # @return [Integer] Default: +Syslog::LOG_LOCAL0+
+        attr_accessor :facility
+
+        ##
+        # Specify the priority level to be used for +:info+ messages.
+        #
+        # See the Ruby Standard Library documentation for +Syslog+ for more info.
+        # http://rdoc.info/stdlib/syslog/Syslog.log
+        #
+        # @param [Integer]
+        # @return [Integer] Default: +Syslog::LOG_INFO+
+        attr_accessor :info
+
+        ##
+        # Specify the priority level to be used for +:warn+ messages.
+        #
+        # See the Ruby Standard Library documentation for +Syslog+ for more info.
+        # http://rdoc.info/stdlib/syslog/Syslog.log
+        #
+        # @param [Integer]
+        # @return [Integer] Default: +Syslog::LOG_WARNING+
+        attr_accessor :warn
+
+        ##
+        # Specify the priority level to be used for +:error+ messages.
+        #
+        # See the Ruby Standard Library documentation for +Syslog+ for more info.
+        # http://rdoc.info/stdlib/syslog/Syslog.log
+        #
+        # @param [Integer]
+        # @return [Integer] Default: +Syslog::LOG_ERR+
+        attr_accessor :error
+
+        def initialize
+          @enabled = false
+          @ident = 'backup'
+          @options = ::Syslog::LOG_PID
+          @facility = ::Syslog::LOG_LOCAL0
+          @info = ::Syslog::LOG_INFO
+          @warn = ::Syslog::LOG_WARNING
+          @error = ::Syslog::LOG_ERR
+        end
+
+        def enabled?
+          !!enabled
+        end
+
+        def enabled=(val)
+          @enabled = val unless enabled.nil?
+        end
+      end
+
+      def initialize(options)
+        @options = options
+      end
+
+      ##
+      # Message lines are sent without formatting (timestamp, level),
+      # since Syslog will provide it's own timestamp and priority.
+      def log(message)
+        level = @options.send(message.level)
+        ::Syslog.open(@options.ident, @options.options, @options.facility) do |s|
+          message.lines.each {|line| s.log(level, line) }
+        end
+      end
+    end
+  end
+end