backup 3.0.19 → 3.0.20

data/lib/backup/model.rb

@@ -2,7 +2,7 @@
 
 module Backup
   class Model
-    include Backup::CLI
+    include Backup::CLI::Helpers
 
     ##
     # The trigger is used as an identifier for
@@ -41,6 +41,10 @@ module Backup
     # The syncers attribute holds an array of syncer objects
     attr_accessor :syncers
 
+    ##
+    # The chunk_size attribute holds the size of the chunks in megabytes
+    attr_accessor :chunk_size
+
     ##
     # The time when the backup initiated (in format: 2011.02.20.03.29.59)
     attr_accessor :time
@@ -63,6 +67,10 @@ module Backup
       # Use Backup::Model.current to retrieve the actual data of the model
       attr_accessor :current
 
+      ##
+      # Contains an array of chunk suffixes for a given file
+      attr_accessor :chunk_suffixes
+
       ##
       # Returns the full path to the current file (including the current extension).
       # To just return the filename and extension without the path, use File.basename(Backup::Model.file)
@@ -70,6 +78,12 @@ module Backup
         File.join(TMP_PATH, "#{ TIME }.#{ TRIGGER }.#{ Backup::Model.extension }")
       end
 
+      ##
+      # Returns the @chunk_suffixes variable, sets it to an emtpy array if nil
+      def chunk_suffixes
+        @chunk_suffixes ||= Array.new
+      end
+
       ##
       # Returns the temporary trigger path of the current model
       # e.g. /Users/Michael/tmp/backup/my_trigger
@@ -99,13 +113,9 @@ module Backup
       @label       = label
       @time        = TIME
 
-      @databases   = Array.new
-      @archives    = Array.new
-      @encryptors  = Array.new
-      @compressors = Array.new
-      @storages    = Array.new
-      @notifiers   = Array.new
-      @syncers     = Array.new
+      procedure_instance_variables.each do |variable|
+        instance_variable_set(variable, Array.new)
+      end
 
       instance_eval(&block)
       Backup::Model.all << self
@@ -157,10 +167,10 @@ module Backup
     ##
     # Adds a storage method to the array of storage
     # methods to use during the backup process
-    def store_with(storage, &block)
+    def store_with(storage, storage_id = nil, &block)
       @storages << Backup::Storage.const_get(
         last_constant(storage)
-      ).new(&block)
+      ).new(storage_id, &block)
     end
 
     ##
@@ -172,6 +182,20 @@ module Backup
       ).new(&block)
     end
 
+    ##
+    # Adds a method that allows the user to set the @chunk_size.
+    # The chunk_size (in megabytes) will later determine in how many chunks the
+    # backup needs to be split
+    def split_into_chunks_of(chunk_size = nil)
+      @chunk_size = chunk_size
+    end
+
+    ##
+    # Returns the path to the current file (including proper extension)
+    def file
+      Backup::Model.file
+    end
+
     ##
     # Performs the backup process
     ##
@@ -182,7 +206,7 @@ module Backup
     # Runs all (if any) archive objects to package all their
     # paths in to a single tar file and places it in the backup folder
     ##
-    # [Package]
+    # [Packaging]
     # After all the database dumps and archives are placed inside
     # the folder, it'll make a single .tar package (archive) out of it
     ##
@@ -192,6 +216,9 @@ module Backup
     # [Compression]
     # Optionally compresses the packaged file with one or more compressors
     ##
+    # [Splitting]
+    # Optionally splits the backup file in to multiple smaller chunks before transferring them
+    ##
     # [Storages]
     # Runs all (if any) storage objects to store the backups to remote locations
     # and (if configured) it'll cycle the files on the remote location to limit the
@@ -212,24 +239,49 @@ module Backup
     # breaks the process, it'll always ensure it removes the temporary files regardless
     # to avoid mass consumption of storage space on the machine
     def perform!
-      begin
-        if databases.any? or archives.any?
-          databases.each   { |d| d.perform! }
-          archives.each    { |a| a.perform! }
-          package!
-          compressors.each { |c| c.perform! }
-          encryptors.each  { |e| e.perform! }
-          storages.each    { |s| s.perform! }
-          clean!
+      if databases.any? or archives.any?
+        procedures.each do |procedure|
+          (procedure.call; next) if procedure.is_a?(Proc)
+          procedure.each(&:perform!)
         end
+      end
+
+      syncers.each(&:perform!)
+      notifiers.each { |n| n.perform!(self) }
+
+    rescue Exception => err
+      fatal = !err.is_a?(StandardError)
+
+      Logger.error Backup::Errors::ModelError.wrap(err, <<-EOS)
+        Backup for #{label} (#{trigger}) Failed!
+        An Error occured which has caused this Backup to abort before completion.
+        Please review the Log for this Backup to determine if steps need to be taken
+        to clean up, based on the point at which the failure occured.
+      EOS
+      Logger.error "\nBacktrace:\n" + err.backtrace.join("\n\s\s") + "\n\n"
+
+      if fatal
+        Logger.error Backup::Errors::ModelError.new(<<-EOS)
+          This Error was Fatal and Backup will now exit.
+          If you have other Backup jobs (triggers) configured to run,
+          they will not be processed.
+        EOS
+      else
+        Logger.message Backup::Errors::ModelError.new(<<-EOS)
+          If you have other Backup jobs (triggers) configured to run,
+          Backup will now attempt to continue...
+        EOS
+      end
 
-        syncers.each   { |s| s.perform!       }
-        notifiers.each { |n| n.perform!(self) }
-      rescue => exception
-        clean!
-        notifiers.each   { |n| n.perform!(self, exception) }
-        show_exception!(exception)
+      notifiers.each do |n|
+        begin
+          n.perform!(self, err)
+        rescue Exception; end
       end
+
+      exit(1) if fatal
+    ensure
+      clean!
     end
 
   private
@@ -239,35 +291,42 @@ module Backup
     # these files will be bundled in to a .tar archive (uncompressed) so it
     # becomes a single (transferrable) packaged file.
     def package!
-      Logger.message "Backup started packaging everything to a single archive file."
-      run(%|#{ utility(:tar) } -c -f '#{ File.join(TMP_PATH, "#{TIME}.#{TRIGGER}.tar") }' -C '#{ TMP_PATH }' '#{ TRIGGER }'|)
+      Backup::Packager.new(self).package!
+    end
+
+    ##
+    # Create a new instance of Backup::Splitter,
+    # passing it the current model instance and runs it.
+    def split!
+      Backup::Splitter.new(self).split!
     end
 
     ##
     # Cleans up the temporary files that were created after the backup process finishes
     def clean!
-      Logger.message "Backup started cleaning up the temporary files."
-      run("#{ utility(:rm) } -rf '#{ File.join(TMP_PATH, TRIGGER) }' '#{ File.join(TMP_PATH, "#{TIME}.#{TRIGGER}.#{Backup::Model.extension}") }'")
+      Backup::Cleaner.new(self).clean!
     end
 
     ##
-    # Returns the string representation of the last value of a nested constant
-    # example:
-    #  Backup::Model::MySQL
-    # becomes and returns:
-    #  "MySQL"
-    def last_constant(constant)
-      constant.to_s.split("::").last
+    # Returns an array of procedures
+    def procedures
+      Array.new([
+        databases, archives, lambda { package! }, compressors,
+        encryptors, lambda { split! }, storages
+      ])
+    end
+
+    ##
+    # Returns an Array of the names (String) of the procedure instance variables
+    def procedure_instance_variables
+      [:@databases, :@archives, :@encryptors, :@compressors, :@storages, :@notifiers, :@syncers]
     end
 
     ##
-    # Formats an exception
-    def show_exception!(exception)
-      Logger.normal "=" * 75 + "\nException that got raised:\n#{exception.class} - #{exception} \n" + "=" * 75 + "\n" + exception.backtrace.join("\n")
-      Logger.normal "=" * 75 + "\n\nYou are running Backup version \"#{Backup::Version.current}\" and Ruby version \"#{RUBY_VERSION} (patchlevel #{RUBY_PATCHLEVEL})\" on platform \"#{RUBY_PLATFORM}\".\n"
-      Logger.normal "If you've setup a \"Notification\" in your configuration file, the above error will have been sent."
-      #Notifies the shell an exception occured.
-      exit 1 
+    # Returns the string representation of the last value of a nested constant
+    # example: last_constant(Backup::Model::MySQL) becomes and returns "MySQL"
+    def last_constant(constant)
+      constant.to_s.split("::").last
     end
 
   end

data/lib/backup/notifier/base.rb

@@ -5,18 +5,68 @@ module Backup
     class Base
       include Backup::Configuration::Helpers
 
+      ##
+      # Container for the Model object
+      attr_accessor :model
+
+      ##
+      # Contains the Backup::Template object
+      attr_accessor :template
+
       ##
       # When set to true, the user will be notified by email
       # when a backup process ends without raising any exceptions
       attr_accessor :on_success
       alias :notify_on_success? :on_success
 
+      ##
+      # When set to true, the user will be notified by email
+      # when a backup process is successful, but has warnings
+      attr_accessor :on_warning
+      alias :notify_on_warning? :on_warning
+
       ##
       # When set to true, the user will be notified by email
       # when a backup process raises an exception before finishing
       attr_accessor :on_failure
       alias :notify_on_failure? :on_failure
 
+      ##
+      # Super method #initialize for all child classes
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        set_defaults!
+      end
+
+      ##
+      # Performs the notification
+      # Takes an exception object that might've been created if an exception occurred.
+      # If this is the case it'll invoke notify_failure!(exception), otherwise, if no
+      # error was raised, it'll go ahead and notify_success!
+      #
+      # If'll only perform these if on_success is true or on_failure is true
+      def perform!(model, exception = false)
+        @model     = model
+        @template  = Backup::Template.new({:model => model, :exception => exception})
+
+        action = false
+        if exception.eql?(false)
+          if notify_on_success? || (notify_on_warning? && Logger.has_warnings?)
+            action = Logger.has_warnings? ? :warning : :success
+          end
+        else
+          action = :failure if notify_on_failure?
+        end
+
+        if action
+          log!
+          notify!(action)
+        end
+      end
+
       ##
       # Logs a message to the console and log file to inform
       # the client that Backup is notifying about the process

data/lib/backup/notifier/campfire.rb

@@ -30,75 +30,55 @@ module Backup
       # Campfire account's room id
       attr_accessor :room_id
 
-      ##
-      # Container for the Model object
-      attr_accessor :model
-
-      ##
-      # Instantiates a new Backup::Notifier::Campfire object
-      def initialize(&block)
-        load_defaults!
-
-        instance_eval(&block) if block_given?
-
-        set_defaults!
-      end
-
       ##
       # Performs the notification
-      # Takes an exception object that might've been created if an exception occurred.
-      # If this is the case it'll invoke notify_failure!(exception), otherwise, if no
-      # error was raised, it'll go ahead and notify_success!
-      #
-      # If'll only perform these if on_success is true or on_failure is true
+      # Extends from super class. Must call super(model, exception).
+      # If any pre-configuration needs to be done, put it above the super(model, exception)
       def perform!(model, exception = false)
-        @model = model
-
-        if notify_on_success? and exception.eql?(false)
-          log!
-          notify_success!
-        elsif notify_on_failure? and not exception.eql?(false)
-          log!
-          notify_failure!(exception)
-        end
+        super(model, exception)
       end
 
     private
 
       ##
-      # Sends a message informing the user that the backup operation
-      # proceeded without any errors
-      def notify_success!
-        send_message("[Backup::Succeeded] #{model.label} (#{ File.basename(Backup::Model.file) })")
-      end
-
-      ##
-      # Sends a message informing the user that the backup operation
-      # raised an exception
-      def notify_failure!(exception)
-        send_message("[Backup::Failed] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      # Notify the user of the backup operation results.
+      # `status` indicates one of the following:
+      #
+      # `:success`
+      # : The backup completed successfully.
+      # : Notification will be sent if `on_success` was set to `true`
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged
+      # : Notification will be sent, including a copy of the current
+      # : backup log, if `on_warning` was set to `true`
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent, including the Exception which caused
+      # : the failure, the Exception's backtrace, a copy of the current
+      # : backup log and other information if `on_failure` was set to `true`
+      #
+      def notify!(status)
+        name = case status
+               when :success then 'Success'
+               when :warning then 'Warning'
+               when :failure then 'Failure'
+               end
+        message = "[Backup::%s] #{model.label} (#{model.trigger})" % name
+        send_message(message)
       end
 
       ##
-      # Setting up credentials
-      def set_defaults!
-        @campfire_client = {
-          :api_token => @api_token,
-          :subdomain => @subdomain,
-          :room_id   => @room_id
-        }
-      end
+      # nothing to do
+      def set_defaults!; end
 
       ##
       # Creates a new Campfire::Interface object and passes in the
       # campfire clients "room_id", "subdomain" and "api_token". Using this object
       # the provided "message" will be sent to the desired Campfire chat room
       def send_message(message)
-        room = Interface.room(
-          @campfire_client[:room_id],
-          @campfire_client[:subdomain],
-          @campfire_client[:api_token]
-        )
+        room = Interface.room(room_id, subdomain, api_token)
         room.message(message)
       end
 

data/lib/backup/notifier/hipchat.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+if RUBY_VERSION < '1.9.0'
+  Backup::Dependency.load('json')
+else
+  require 'json'
+end
+
+# Load HTTParty
+Backup::Dependency.load('hipchat')
+
+module Backup
+  module Notifier
+    class Hipchat < Base
+
+      ##
+      # The Hipchat API token
+      attr_accessor :token
+
+      ##
+      # Who the notification should appear from
+      attr_accessor :from
+
+      ##
+      # The rooms that should be notified
+      attr_accessor :rooms_notified
+
+      ##
+      # The background color of a success message. One of :yellow, :red, :green, :purple, or :random. (default: yellow)
+      attr_accessor :success_color
+
+      ##
+      # The background color of a warning message. One of :yellow, :red, :green, :purple, or :random. (default: yellow)
+      attr_accessor :warning_color
+
+      ##
+      # The background color of an error message. One of :yellow, :red, :green, :purple, or :random. (default: yellow)
+      attr_accessor :failure_color
+
+      ##
+      # Notify users in the room
+      attr_accessor :notify_users
+
+      ##
+      # Performs the notification
+      # Extends from super class. Must call super(model, exception).
+      # If any pre-configuration needs to be done, put it above the super(model, exception)
+      def perform!(model, exception = false)
+        @rooms_notified = [rooms_notified].flatten
+        super(model, exception)
+      end
+
+    private
+
+      def send_message(msg, color, notify)
+        client = HipChat::Client.new(token)
+        rooms_notified.each do |room|
+          client[room].send(from, msg, :color => color, :notify => notify)
+        end
+      end
+
+      ##
+      # Notify the user of the backup operation results.
+      # `status` indicates one of the following:
+      #
+      # `:success`
+      # : The backup completed successfully.
+      # : Notification will be sent if `on_success` was set to `true`
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged
+      # : Notification will be sent, including a copy of the current
+      # : backup log, if `on_warning` was set to `true`
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent, including the Exception which caused
+      # : the failure, the Exception's backtrace, a copy of the current
+      # : backup log and other information if `on_failure` was set to `true`
+      #
+      def notify!(status)
+        name, color = case status
+                      when :success then ['Success', success_color]
+                      when :warning then ['Warning', warning_color]
+                      when :failure then ['Failure', failure_color]
+                      end
+        message = "[Backup::%s] #{model.label} (#{model.trigger})" % name
+        send_message(message, color, notify_users)
+      end
+
+      def set_defaults!
+        @success_color ||= 'yellow'
+        @warning_color ||= 'yellow'
+        @failure_color ||= 'yellow'
+        @notify_users  ||= false
+      end
+    end
+  end
+end