backup 3.0.19 → 3.0.20

data/lib/backup/database/mysql.rb

@@ -38,7 +38,6 @@ module Backup
         @additional_options ||= Array.new
 
         instance_eval(&block)
-        prepare!
       end
 
       ##
@@ -95,7 +94,8 @@ module Backup
       # Performs the mysqldump command and outputs the
       # data to the specified path based on the 'trigger'
       def perform!
-        log!
+        super
+
         run("#{mysqldump} > '#{File.join(dump_path, name)}.sql'")
       end
 

data/lib/backup/database/postgresql.rb

@@ -40,7 +40,6 @@ module Backup
         @additional_options ||= Array.new
 
         instance_eval(&block)
-        prepare!
         ENV['PGPASSWORD'] = password
       end
 
@@ -110,7 +109,8 @@ module Backup
       # data to the specified path based on the 'trigger'
       # and resets the 'PGPASSWORD' environment variable to nil
       def perform!
-        log!
+        super
+
         run("#{pgdump} > '#{File.join(dump_path, name)}.sql'")
         ENV['PGPASSWORD'] = nil
       end

data/lib/backup/database/redis.rb

@@ -34,7 +34,6 @@ module Backup
         @additional_options ||= Array.new
 
         instance_eval(&block)
-        prepare!
       end
 
       ##
@@ -73,7 +72,7 @@ module Backup
       # the Redis server to persist the current state to the dump file
       # before copying the dump to get the most recent updates in to the backup
       def perform!
-        log!
+        super
 
         invoke_save! if invoke_save
         copy!
@@ -83,10 +82,17 @@ module Backup
       # Tells Redis to persist the current state of the
       # in-memory database to the persisted dump file
       def invoke_save!
-        response = run("#{ utility('redis-cli') } #{ credential_options } #{ connectivity_options } #{ additional_options } SAVE")
+        response = run("#{ utility('redis-cli') } #{ credential_options } " +
+                       "#{ connectivity_options } #{ additional_options } SAVE")
         unless response =~ /OK/
-          Logger.error "Could not invoke the Redis SAVE command. The #{ database } file might not contain the most recent data."
-          Logger.error "Please check if the server is running, the credentials (if any) are correct, and the host/port/socket are correct."
+          raise Errors::Database::Redis::CommandError, <<-EOS
+            Could not invoke the Redis SAVE command.
+            The #{ database } file might not contain the most recent data.
+            Please check if the server is running, the credentials (if any) are correct,
+            and the host/port/socket are correct.
+
+            Redis CLI response: #{ response }
+          EOS
         end
       end
 
@@ -94,8 +100,10 @@ module Backup
       # Performs the copy command to copy over the Redis dump file to the Backup archive
       def copy!
         unless File.exist?(File.join(path, database))
-          Logger.error "Redis database dump not found in '#{ File.join(path, database) }'"
-          exit
+          raise Errors::Database::Redis::NotFoundError, <<-EOS
+            Redis database dump not found
+            File path was #{ File.join(path, database) }
+          EOS
         end
 
         # Temporarily remove a custom `utility_path` setting so that the system

data/lib/backup/database/riak.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Backup
+  module Database
+    class Riak < Base
+
+      ##
+      # Name is the name of the backup
+      attr_accessor :name
+
+      ##
+      # Node is the node from which to perform the backup.
+      attr_accessor :node
+
+      ##
+      # Cookie is the Erlang cookie/shared secret used to connect to the node.
+      attr_accessor :cookie
+
+      ##
+      # Creates a new instance of the Riak adapter object
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block)
+      end
+
+      ##
+      # Builds the full riak-admin string based on all attributes
+      def riakadmin
+        "riak-admin backup #{node} #{cookie}"
+      end
+
+      ##
+      # Performs the riak-admin command and outputs the
+      # data to the specified path based on the 'trigger'
+      def perform!
+        super
+        # have to make riak the owner since the riak-admin tool runs as the riak user in a default setup.
+        run("chown -R riak.riak #{dump_path}")
+        run("#{riakadmin} #{File.join(dump_path, name)} node")
+      end
+
+    end
+  end
+end

data/lib/backup/dependency.rb

@@ -48,7 +48,7 @@ module Backup
 
         'mail' => {
           :require => 'mail',
-          :version => '~> 2.3.0',
+          :version => '>= 2.2.15',
           :for     => 'Sending Emails (Mail Notifier)'
         },
 
@@ -69,6 +69,18 @@ module Backup
           :version => '~> 1.5.1',
           :for     => 'Parsing JSON for HTTParty'
         },
+
+        'prowler' => {
+          :require => 'prowler',
+          :version => '>= 1.3.1',
+          :for     => 'Sending iOS push notifications (Prowl Notifier)'
+        },
+
+        'hipchat' => {
+          :require => 'hipchat',
+          :version => '~> 0.4.1',
+          :for => 'Sending notifications to Hipchat'
+        }
       }
     end
 
@@ -81,12 +93,14 @@ module Backup
         gem(name, all[name][:version])
         require(all[name][:require])
       rescue LoadError
-        Backup::Logger.error("Dependency missing.")
-        puts "\nDependency required for:"
-        puts "\n\s\s#{all[name][:for]}"
-        puts "\nTo install the gem, issue the following command:"
-        puts "\n\s\sgem install #{name} -v '#{all[name][:version]}'"
-        puts "\nPlease try again after installing the missing dependency."
+        Logger.error Errors::Dependency::LoadError.new(<<-EOS)
+          Dependency missing
+          Dependency required for:
+          #{all[name][:for]}
+          To install the gem, issue the following command:
+          > gem install #{name} -v '#{all[name][:version]}'
+          Please try again after installing the missing dependency.
+        EOS
         exit
       end
     end

data/lib/backup/encryptor/base.rb

@@ -3,7 +3,7 @@
 module Backup
   module Encryptor
     class Base
-      include Backup::CLI
+      include Backup::CLI::Helpers
       include Backup::Configuration::Helpers
 
       ##

data/lib/backup/encryptor/open_ssl.rb

@@ -9,6 +9,10 @@ module Backup
       # 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_writer :base64
@@ -23,8 +27,9 @@ module Backup
       def initialize(&block)
         load_defaults!
 
-        @base64 ||= false
-        @salt   ||= false
+        @base64        ||= false
+        @salt          ||= false
+        @password_file ||= nil
 
         instance_eval(&block) if block_given?
       end
@@ -33,7 +38,7 @@ module Backup
       # Performs the encryption of the backup file
       def perform!
         log!
-        run("#{ utility(:openssl) } #{ options } -in '#{ Backup::Model.file }' -out '#{ Backup::Model.file }.enc' -k '#{ password }'")
+        run("#{ utility(:openssl) } #{ options } -in '#{ Backup::Model.file }' -out '#{ Backup::Model.file }.enc'")
         rm(Backup::Model.file)
         Backup::Model.extension += '.enc'
       end
@@ -44,11 +49,11 @@ module Backup
       # Backup::Encryptor::OpenSSL uses the 256bit AES encryption cipher.
       # 256bit AES is what the US Government uses to encrypt information at the "Top Secret" level.
       def options
-        (['aes-256-cbc'] + base64 + salt).join("\s")
+        (['aes-256-cbc'] + base64 + salt + pass).join("\s")
       end
 
       ##
-      # Returns '-a' if @base64 is set to 'true'.
+      # Returns '-base64' if @base64 is set to 'true'.
       # This option will make the encrypted output base64 encoded,
       # this makes the encrypted file readable using text editors
       def base64
@@ -62,6 +67,16 @@ module Backup
         return ['-salt'] if @salt; []
       end
 
+      ##
+      # Returns '-pass file:<password file>' when @password_file has been set.
+      def pass
+        if @password_file
+          ["-pass file:#{@password_file}"]
+        else
+          ["-k '#{@password}'"]
+        end
+      end
+
     end
   end
 end

data/lib/backup/errors.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Backup
+  ##
+  # - automatically defines module namespaces referenced under Backup::Errors
+  # - any constant name referenced that ends with 'Error' will be created
+  #   as a subclass of Backup::Errors::Error
+  # e.g.
+  #   err = Backup::Errors::Foo::Bar::FooError.new('error message')
+  #   err.message => "Foo::Bar::FooError: error message"
+  #
+  module ErrorsHelper
+    def const_missing(const)
+      if const.to_s.end_with?('Error')
+        module_eval("class #{const} < Backup::Errors::Error; end")
+      else
+        module_eval("module #{const}; extend Backup::ErrorsHelper; end")
+      end
+      const_get(const)
+    end
+  end
+
+  ##
+  # provides cascading errors with formatted messages
+  # see the specs for details
+  #
+  # e.g.
+  # module Backup
+  #   begin
+  #     begin
+  #       begin
+  #         raise Errors::ZoneAError, 'an error occurred in Zone A'
+  #       rescue => err
+  #         raise Errors::ZoneBError.wrap(err, <<-EOS)
+  #           an error occurred in Zone B
+  #
+  #           the following error should give a reason
+  #         EOS
+  #       end
+  #     rescue => err
+  #       raise Errors::ZoneCError.wrap(err)
+  #     end
+  #   rescue => err
+  #     puts Errors::ZoneDError.wrap(err, 'an error occurred in Zone D')
+  #   end
+  # end
+  #
+  # Outputs:
+  #   ZoneDError: an error occurred in Zone D
+  #     Reason: ZoneCError
+  #     ZoneBError: an error occurred in Zone B
+  #
+  #     the following error should give a reason
+  #     Reason: ZoneAError
+  #     an error occurred in Zone A
+  #
+  module Errors
+    extend ErrorsHelper
+
+    class Error < StandardError
+
+      def self.wrap(orig_err, msg = nil)
+        new(msg, orig_err)
+      end
+
+      def initialize(msg = nil, orig_err = nil)
+        super(msg)
+        set_backtrace(orig_err.backtrace) if @orig_err = orig_err
+      end
+
+      def to_s
+        return @to_s if @to_s
+        orig_to_s = super()
+
+        if orig_to_s == self.class.to_s
+          msg = orig_err_msg ?
+              "#{orig_err_class}: #{orig_err_msg}" : orig_err_class
+        else
+          msg = format_msg(orig_to_s)
+          msg << "\n  Reason: #{orig_err_class}" + (orig_err_msg ?
+              "\n  #{orig_err_msg}" : ' (no message given)') if @orig_err
+        end
+
+        @to_s = msg ? msg_prefix + msg : class_name
+      end
+
+      private
+
+      def msg_prefix
+        @msg_prefix ||= class_name + ': '
+      end
+
+      def orig_msg
+        @orig_msg ||= to_s.sub(msg_prefix, '')
+      end
+
+      def class_name
+        @class_name ||= self.class.to_s.sub('Backup::Errors::', '')
+      end
+
+      def orig_err_class
+        return unless @orig_err
+
+        @orig_err_class ||= @orig_err.is_a?(Errors::Error) ?
+            @orig_err.send(:class_name) : @orig_err.class.to_s
+      end
+
+      def orig_err_msg
+        return unless @orig_err
+        return @orig_err_msg unless @orig_err_msg.nil?
+
+        msg = @orig_err.is_a?(Errors::Error) ?
+            @orig_err.send(:orig_msg) : @orig_err.to_s
+        @orig_err_msg = (msg == orig_err_class) ?
+            false : format_msg(msg)
+      end
+
+      def format_msg(msg)
+        msg.gsub(/^ */, '  ').strip
+      end
+    end
+
+  end
+end

data/lib/backup/finder.rb

@@ -32,7 +32,8 @@ module Backup
         end
       end
 
-      puts "Could not find trigger '#{trigger}' in '#{config}'."; exit
+      raise Errors::Finder::MissingTriggerError,
+          "Could not find trigger '#{trigger}' in '#{config}'."
     end
 
     ##
@@ -68,12 +69,19 @@ module Backup
     # Tries to find and load the configuration file
     def load_config!
       unless File.exist?(config)
-        puts "Could not find a configuration file in '#{config}'."; exit
+        raise Errors::Finder::MissingConfigError,
+            "Could not find configuration file: '#{config}'."
       end
 
+      ##
+      # Reset the Backup::Model.all to an empty array since this will be
+      # re-filled during the next Backup::Finder.new(arg1, arg2).find
+      # or Backup::Finder.new(arg).matching call
+      Backup::Model.all = Array.new
+
       ##
       # Loads the backup configuration file
-      instance_eval(File.read(config))
+      Backup.module_eval(File.read(config), config, 1)
     end
   end
 end

data/lib/backup/logger.rb

@@ -1,102 +1,141 @@
 # encoding: utf-8
 
 module Backup
-  class Logger
+  module Logger
+    class << self
 
-    ##
-    # Outputs a messages to the console and writes it to the backup.log
-    def self.message(string)
-      puts    loggify(:message, string, :green) unless quiet?
-      to_file loggify(:message, string)
-    end
+      ##
+      # 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)
+      end
 
-    ##
-    # Outputs an error to the console and writes it to the backup.log
-    def self.error(string)
-      puts    loggify(:error, string, :red) unless quiet?
-      to_file loggify(:error, string)
-    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
 
-    ##
-    # Outputs a notice to the console and writes it to the backup.log
-    def self.warn(string)
-      puts    loggify(:warning, string, :yellow) unless quiet?
-      to_file loggify(:warning, string)
-    end
+      ##
+      # 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
 
-    ##
-    # Outputs the data as if it were a regular 'puts' command,
-    # but also logs it to the backup.log
-    def self.normal(string)
-      puts    string unless quiet?
-      to_file string
-    end
+      # 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)
+      end
 
-    ##
-    # Silently logs data to the log file
-    def self.silent(string)
-      to_file loggify(:silent, string)
-    end
+      ##
+      # Silently logs data to the log file
+      def silent(string)
+        to_file     loggify(string, :silent)
+      end
 
-    ##
-    # Returns the time in [YYYY/MM/DD HH:MM:SS] format
-    def self.time
-      Time.now.strftime("%Y/%m/%d %H:%M:%S")
-    end
+      ##
+      # Returns an Array of all messages written to the log file for this session
+      def messages
+        @messages ||= []
+      end
 
-    ##
-    # Builds the string in a log format with the date/time, the type (colorized)
-    # based on whether it's a message, notice or error, and the message itself.
-    # ANSI color codes are only used in the console, and are not written to the log
-    # since it doesn't do anything and just adds more unnecessary bloat to the log file
-    def self.loggify(type, string, color = false)
-      return "[#{time}][#{type}] #{string}" unless color
-      "[#{time}][#{send(color, type)}] #{string}"
-    end
+      ##
+      # Returns true if any warnings have been issued
+      def has_warnings?
+        @has_warnings ||= false
+      end
 
-    ##
-    # Writes (appends) a string to the backup.log file
-    def self.to_file(string)
-      File.open(File.join(LOG_PATH, 'backup.log'), 'a') do |file|
-        file.write("#{string}\n")
+      def clear!
+        messages.clear
+        @has_warnings = false
       end
-    end
 
-    ##
-    # Invokes the #colorize method with the provided string
-    # and the color code "32" (for green)
-    def self.green(string)
-      colorize(string, 32)
-    end
+      private
 
-    ##
-    # Invokes the #colorize method with the provided string
-    # and the color code "33" (for yellow)
-    def self.yellow(string)
-      colorize(string, 33)
-    end
+      ##
+      # Returns the time in [YYYY/MM/DD HH:MM:SS] format
+      def time
+        Time.now.strftime("%Y/%m/%d %H:%M:%S")
+      end
 
-    ##
-    # Invokes the #colorize method the with provided string
-    # and the color code "31" (for red)
-    def self.red(string)
-      colorize(string, 31)
-    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
+      end
 
-    ##
-    # Wraps the provided string in colorizing tags to provide
-    # easier to view output to the client
-    def self.colorize(string, code)
-      "\e[#{code}m#{string}\e[0m"
-    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) }
+      end
 
-    ##
-    # Returns 'true' (boolean) if the QUIET constant is defined
-    # By default it isn't defined, only when initializing Backup using
-    # the '--quite' (or '-q') option in the CLI (e.g. backup perform -t my_backup --quiet)
-    def self.quiet?
-      const_defined?(:QUIET) && QUIET
-    end
+      ##
+      # Receives an Array of Strings to be written to the log file.
+      def to_file(lines)
+        File.open(File.join(LOG_PATH, 'backup.log'), 'a') do |file|
+          lines.each {|line| file.puts line }
+        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)
+      end
 
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "33" (for yellow)
+      def yellow(string)
+        colorize(string, 33)
+      end
+
+      ##
+      # Invokes the #colorize method the with provided string
+      # and the color code "31" (for red)
+      def red(string)
+        colorize(string, 31)
+      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"
+      end
+
+      ##
+      # Returns 'true' (boolean) if the QUIET constant is defined
+      # By default it isn't defined, only when initializing Backup using
+      # the '--quiet' (or '-q') option in the CLI
+      # (e.g. backup perform -t my_backup --quiet)
+      def quiet?
+        const_defined?(:QUIET) && QUIET
+      end
+
+    end
   end
 end