ext_backup 5.0.0.beta.2.1

data/lib/backup/encryptor/open_ssl.rb

@@ -0,0 +1,74 @@
+module Backup
+  module Encryptor
+    class OpenSSL < Base
+      ##
+      # The password that'll be used to encrypt the backup. This
+      # password will be required to decrypt the backup later on.
+      attr_accessor :password
+
+      ##
+      # The password file to use to encrypt the backup.
+      attr_accessor :password_file
+
+      ##
+      # Determines whether the 'base64' should be used or not
+      attr_accessor :base64
+
+      ##
+      # Determines whether the 'salt' flag should be used
+      attr_accessor :salt
+
+      ##
+      # Creates a new instance of Backup::Encryptor::OpenSSL and
+      # sets the password attribute to what was provided
+      def initialize(&block)
+        super
+
+        @base64        ||= false
+        @salt          ||= true
+        @password_file ||= nil
+
+        instance_eval(&block) if block_given?
+      end
+
+      ##
+      # This is called as part of the procedure run by the Packager.
+      # It sets up the needed options to pass to the openssl command,
+      # then yields the command to use as part of the packaging procedure.
+      # Once the packaging procedure is complete, it will return
+      # so that any clean-up may be performed after the yield.
+      def encrypt_with
+        log!
+        yield "#{utility(:openssl)} #{options}", ".enc"
+      end
+
+      private
+
+      ##
+      # Uses the 256bit AES encryption cipher, which is what the
+      # US Government uses to encrypt information at the "Top Secret" level.
+      #
+      # The -base64 option will make the encrypted output base64 encoded,
+      # this makes the encrypted file readable using text editors
+      #
+      # The -salt option adds strength to the encryption
+      #
+      # Always sets a password option, if even no password is given,
+      # but will prefer the password_file option if both are given.
+      def options
+        opts = ["aes-256-cbc"]
+        opts << "-base64" if @base64
+        opts << "-salt"   if @salt
+
+        opts <<
+          if @password_file.to_s.empty?
+            "-k #{Shellwords.escape(@password)}"
+          else
+            "-pass file:#{@password_file}"
+          end
+
+        opts.join(" ")
+      end
+    end
+  end
+end

data/lib/backup/errors.rb

@@ -0,0 +1,53 @@
+module Backup
+  # Provides cascading errors with formatted messages.
+  # See the specs for details.
+  module NestedExceptions
+    def self.included(klass)
+      klass.extend(Module.new do
+        def wrap(wrapped_exception, msg = nil)
+          new(msg, wrapped_exception)
+        end
+      end)
+    end
+
+    def initialize(obj = nil, wrapped_exception = nil)
+      @wrapped_exception = wrapped_exception
+      msg = (obj.respond_to?(:to_str) ? obj.to_str : obj.to_s)
+        .gsub(/^ */, "  ").strip
+      msg = clean_name(self.class.name) + (msg.empty? ? "" : ": #{msg}")
+
+      if wrapped_exception
+        msg << "\n--- Wrapped Exception ---\n"
+        class_name = clean_name(wrapped_exception.class.name)
+        msg << class_name + ": " unless
+            wrapped_exception.message.start_with? class_name
+        msg << wrapped_exception.message
+      end
+
+      super(msg)
+      set_backtrace(wrapped_exception.backtrace) if wrapped_exception
+    end
+
+    def exception(obj = nil)
+      return self if obj.nil? || equal?(obj)
+
+      ex = self.class.new(obj, @wrapped_exception)
+      ex.set_backtrace(backtrace) unless ex.backtrace
+      ex
+    end
+
+    private
+
+    def clean_name(name)
+      name.sub(/^Backup::/, "")
+    end
+  end
+
+  class Error < StandardError
+    include NestedExceptions
+  end
+
+  class FatalError < Exception
+    include NestedExceptions
+  end
+end

data/lib/backup/logger.rb

@@ -0,0 +1,197 @@
+require "backup/logger/console"
+require "backup/logger/logfile"
+require "backup/logger/syslog"
+require "backup/logger/fog_adapter"
+
+module Backup
+  class Logger
+    class Config
+      class Logger < Struct.new(:class, :options)
+        def enabled?
+          options.enabled?
+        end
+      end
+
+      class DSL < Struct.new(:ignores, :console, :logfile, :syslog)
+        def ignore_warning(str_or_regexp)
+          ignores << str_or_regexp
+        end
+      end
+
+      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(ignores, *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)
+      ##
+      # 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
+
+      def matches?(ignores)
+        text = lines.join("\n")
+        ignores.any? do |obj|
+          obj.is_a?(Regexp) ? text.match(obj) : text.include?(obj)
+        end
+      end
+    end
+
+    class << self
+      extend Forwardable
+      def_delegators :logger,
+        :start!, :abort!, :info, :warn, :error,
+        :messages, :has_warnings?, :has_errors?
+
+      ##
+      # 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
+      #
+      #     # 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.
+      # @see Console::Options
+      # @see Logfile::Options
+      # @see Syslog::Options
+      def configure(&block)
+        config.dsl.instance_eval(&block)
+      end
+
+      ##
+      # Called after each backup model/trigger has been performed.
+      def clear!
+        @logger = nil
+        logger.start!
+      end
+
+      private
+
+      def config
+        @config ||= Config.new
+      end
+
+      def logger
+        @logger ||= new(config)
+      end
+
+      def reset!
+        @config = @logger = nil
+      end
+    end
+
+    MUTEX = Mutex.new
+
+    ##
+    # 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
+
+    ##
+    # 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 do |obj|
+        MUTEX.synchronize { log(obj, level) }
+      end
+    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
+
+    ##
+    # 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
+
+    private
+
+    def log(obj, level)
+      message = Message.new(Time.now.utc, level, obj.to_s.split("\n"))
+
+      if message.level == :warn && message.matches?(@config.ignores)
+        message.level = :info
+      end
+      @has_warnings ||= message.level == :warn
+      @has_errors   ||= message.level == :error
+
+      messages << message
+      @loggers.each { |logger| logger.log(message) }
+    end
+  end
+end

data/lib/backup/logger/console.rb

@@ -0,0 +1,48 @@
+module Backup
+  class 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/fog_adapter.rb

@@ -0,0 +1,25 @@
+# require only the logger
+require "formatador"
+require "fog/core/logger"
+
+module Backup
+  class Logger
+    module FogAdapter
+      class << self
+        # Logged as :info so these won't generate warnings.
+        # This is mostly to keep STDOUT clean and to provide
+        # supplemental messages for our own warnings.
+        # These will generally occur during retry attempts.
+        def write(message)
+          Logger.info message.chomp
+        end
+
+        def tty?
+          false
+        end
+      end
+    end
+  end
+end
+
+Fog::Logger[:warning] = Backup::Logger::FogAdapter

data/lib/backup/logger/logfile.rb

@@ -0,0 +1,131 @@
+module Backup
+  class Logger
+    class Logfile
+      class Error < Backup::Error; end
+
+      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
+
+        ##
+        # Backup's logfile in which backup logs can be written
+        #
+        # As there is already a log_path, this can simply be just a file name
+        # that will be created (If not exists) on log_path directory
+        #
+        # This may also be set on the command line using +--log-file+.
+        # If set on the command line, any setting here will be ignored.
+        #
+        # @param [String]
+        # @return [String] Default: 'backup.log'
+        attr_reader :log_file
+
+        ##
+        # 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)
+        log_file = @options.log_file || "backup.log"
+        path = File.join(path, log_file)
+        if File.exist?(path) && !File.writable?(path)
+          raise Error, "Log File at '#{path}' is not writable"
+        end
+        path
+      end
+
+      ##
+      # Truncates the logfile to @options.max_bytes
+      def truncate!
+        return unless File.exist?(@logfile)
+
+        if File.stat(@logfile).size > @options.max_bytes
+          FileUtils.cp(@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