backup-agoddard 3.0.27

data/lib/backup/notifier/prowl.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+##
+# Only load the Prowler gem when using Prowler notifications
+Backup::Dependency.load('prowler')
+
+module Backup
+  module Notifier
+    class Prowl < Base
+
+      ##
+      # Application name
+      # Tell something like your server name. Example: "Server1 Backup"
+      attr_accessor :application
+
+      ##
+      # API-Key
+      # Create a Prowl account and request an API key on prowlapp.com.
+      attr_accessor :api_key
+
+      def initialize(model, &block)
+        super(model)
+
+        instance_eval(&block) if block_given?
+      end
+
+      private
+
+      ##
+      # 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]' % name
+        send_message(message)
+      end
+
+      def send_message(message)
+        client = Prowler.new(:application => application, :api_key => api_key)
+        client.notify(message, "#{@model.label} (#{@model.trigger})")
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/pushover.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'net/https'
+
+module Backup
+  module Notifier
+    class Pushover < Base
+
+      ##
+      # The API User Token
+      attr_accessor :user
+
+      ##
+      # The API Application Token
+      attr_accessor :token
+
+      ##
+      # The user's device identifier to sent he message directly to that device rather than all of the user's devices
+      attr_accessor :device
+
+      ##
+      # The message title
+      attr_accessor :title
+
+      ##
+      # The priority of the notification
+      attr_accessor :priority
+
+      def initialize(model, &block)
+        super(model)
+
+        instance_eval(&block) if block_given?
+      end
+
+      private
+
+      ##
+      # 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 :failure then 'Failure'
+               when :warning then 'Warning'
+               end
+        message = "[Backup::%s] #{@model.label} (#{@model.trigger})" % name
+
+        send_message(message)
+      end
+
+      # Push a message via the Pushover API
+      def send_message(message)
+        url = URI.parse("https://api.pushover.net/1/messages.json")
+
+        request = Net::HTTP::Post.new(url.path)
+        request.set_form_data(parameters.merge ({:message => message}))
+        response = Net::HTTP.new(url.host, url.port)
+
+        response.use_ssl = true
+        response.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        response.start {|http| http.request(request) }
+      end
+
+      # List available parameters
+      def parameters
+        @values = {}
+        [:token, :user, :message, :title, :priority, :device].each { |k| @values.merge! k => self.instance_variable_get("@#{k}") }
+        @values
+      end
+    end
+  end
+end

data/lib/backup/notifier/twitter.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+##
+# Only load the Twitter gem when using Twitter notifications
+Backup::Dependency.load('twitter')
+
+module Backup
+  module Notifier
+    class Twitter < Base
+
+      ##
+      # Twitter consumer key credentials
+      attr_accessor :consumer_key, :consumer_secret
+
+      ##
+      # OAuth credentials
+      attr_accessor :oauth_token, :oauth_token_secret
+
+      def initialize(model, &block)
+        super(model)
+
+        instance_eval(&block) if block_given?
+      end
+
+      private
+
+      ##
+      # 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}) (@ #{@model.time})" % name
+        send_message(message)
+      end
+
+      def send_message(message)
+        ::Twitter.configure do |config|
+          config.consumer_key       = @consumer_key
+          config.consumer_secret    = @consumer_secret
+          config.oauth_token        = @oauth_token
+          config.oauth_token_secret = @oauth_token_secret
+        end
+
+        client = ::Twitter::Client.new
+        client.update(message)
+      end
+
+    end
+  end
+end

data/lib/backup/package.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Backup
+  class Package
+
+    ##
+    # The time when the backup initiated (in format: 2011.02.20.03.29.59)
+    attr_reader :time
+
+    ##
+    # The trigger which initiated the backup process
+    attr_reader :trigger
+
+    ##
+    # Extension for the final archive file(s)
+    attr_accessor :extension
+
+    ##
+    # Set by the Splitter if the final archive was "chunked"
+    attr_accessor :chunk_suffixes
+
+    ##
+    # The version of Backup used to create the package
+    attr_reader :version
+
+    def initialize(model)
+      @time = model.time
+      @trigger = model.trigger
+      @extension = 'tar'
+      @chunk_suffixes = Array.new
+      @version = Backup::Version.current
+    end
+
+    def filenames
+      if chunk_suffixes.empty?
+        [basename]
+      else
+        chunk_suffixes.map {|suffix| "#{ basename }-#{ suffix }" }
+      end
+    end
+
+    def basename
+      "#{ time }.#{ trigger }.#{ extension }"
+    end
+
+  end
+end

data/lib/backup/packager.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+module Backup
+  module Packager
+    class << self
+      include Backup::CLI::Helpers
+
+      ##
+      # Build the final package for the backup model.
+      def package!(model)
+        @package   = model.package
+        @encryptor = model.encryptor
+        @splitter  = model.splitter
+        @pipeline  = Pipeline.new
+
+        Logger.message "Packaging the backup files..."
+        procedure.call
+
+        if @pipeline.success?
+          Logger.message "Packaging Complete!"
+        else
+          raise Errors::Packager::PipelineError,
+              "Failed to Create Backup Package\n" +
+              @pipeline.error_messages
+        end
+      end
+
+      private
+
+      ##
+      # Builds a chain of nested Procs which adds each command to a Pipeline
+      # needed to package the final command to package the backup.
+      # This is done so that the Encryptor and Splitter have the ability
+      # to perform actions before and after the final command is executed.
+      # No Encryptors currently utilize this, however the Splitter does.
+      def procedure
+        stack = []
+
+        ##
+        # Initial `tar` command to package the temporary backup folder.
+        # The command's output will then be either piped to the Encryptor
+        # or the Splitter (if no Encryptor), or through `cat` into the final
+        # output file if neither are configured.
+        @pipeline << "#{ utility(:tar) } -cf - " +
+            "-C '#{ Config.tmp_path }' '#{ @package.trigger }'"
+
+        ##
+        # If an Encryptor was configured, it will be called first
+        # to add the encryption utility command to be piped through,
+        # and amend the final package extension.
+        # It's output will then be either piped into a Splitter,
+        # or through `cat` into the final output file.
+        if @encryptor
+          stack << lambda do
+            @encryptor.encrypt_with do |command, ext|
+              @pipeline << command
+              @package.extension << ext
+              stack.shift.call
+            end
+          end
+        end
+
+        ##
+        # If a Splitter was configured, the `split` utility command will be
+        # added to the Pipeline to split the final output into multiple files.
+        # Once the Proc executing the Pipeline has completed and returns back
+        # to the Splitter, it will check the final output files to determine
+        # if the backup was indeed split.
+        # If so, it will set the package's chunk_suffixes. If not, it will
+        # remove the '-aa' suffix from the only file created by `split`.
+        #
+        # If no Splitter was configured, the final file output will be
+        # piped through `cat` into the final output file.
+        if @splitter
+          stack << lambda do
+            @splitter.split_with do |command|
+              @pipeline << command
+              stack.shift.call
+            end
+          end
+        else
+          stack << lambda do
+            outfile = File.join(Config.tmp_path, @package.basename)
+            @pipeline << "cat > #{ outfile }"
+            stack.shift.call
+          end
+        end
+
+        ##
+        # Last Proc to be called runs the Pipeline the procedure built.
+        # Once complete, the call stack will unwind back through the
+        # preceeding Procs in the stack (if any)
+        stack << lambda { @pipeline.run }
+
+        stack.shift
+      end
+
+    end
+  end
+end

data/lib/backup/pipeline.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+module Backup
+  class Pipeline
+    include Backup::CLI::Helpers
+
+    attr_reader :stderr, :errors
+
+    def initialize
+      @commands = []
+      @errors = []
+      @stderr = ''
+    end
+
+    ##
+    # Adds a command to be executed in the pipeline.
+    # Each command will be run in the order in which it was added,
+    # with it's output being piped to the next command.
+    def <<(command)
+      @commands << command
+    end
+
+    ##
+    # Runs the command line from `#pipeline` and collects STDOUT/STDERR.
+    # STDOUT is then parsed to determine the exit status of each command.
+    # For each command with a non-zero exit status, a SystemCallError is
+    # created and added to @errors. All STDERR output is set in @stderr.
+    #
+    # Note that there is no accumulated STDOUT from the commands themselves.
+    # Also, the last command should not attempt to write to STDOUT.
+    # Any output on STDOUT from the final command will be sent to STDERR.
+    # This in itself will not cause #run to fail, but will log warnings
+    # when all commands exit with non-zero status.
+    #
+    # Use `#success?` to determine if all commands in the pipeline succeeded.
+    # If `#success?` returns `false`, use `#error_messages` to get an error report.
+    def run
+      Open4.popen4(pipeline) do |pid, stdin, stdout, stderr|
+        pipestatus = stdout.read.gsub("\n", '').split(':').sort
+        pipestatus.each do |status|
+          index, exitstatus = status.split('|').map(&:to_i)
+          if exitstatus > 0
+            command = command_name(@commands[index])
+            @errors << SystemCallError.new(
+              "'#{ command }' returned exit code: #{ exitstatus }", exitstatus
+            )
+          end
+        end
+        @stderr = stderr.read.strip
+      end
+      Logger.warn(stderr_messages) if success? && stderr_messages
+    rescue Exception => e
+      raise Errors::Pipeline::ExecutionError.wrap(e)
+    end
+
+    def success?
+      @errors.empty?
+    end
+
+    ##
+    # Returns a multi-line String, reporting all STDERR messages received
+    # from the commands in the pipeline (if any), along with the SystemCallError
+    # (Errno) message for each command which had a non-zero exit status.
+    #
+    # Each error is wrapped by Backup::Errors to provide formatting.
+    def error_messages
+      @error_messages ||= (stderr_messages || '') +
+          "The following system errors were returned:\n" +
+          @errors.map {|err| Errors::Error.wrap(err).message }.join("\n")
+    end
+
+    private
+
+    ##
+    # Each command is added as part of the pipeline, grouped with an `echo`
+    # command to pass along the command's index in @commands and it's exit status.
+    # The command's STDERR is redirected to FD#4, and the `echo` command to
+    # report the "index|exit status" is redirected to FD#3.
+    # Each command's STDOUT will be connected to the STDIN of the next subshell.
+    # The entire pipeline is run within a container group, which redirects
+    # FD#3 to STDOUT and FD#4 to STDERR so these can be collected.
+    # FD#1 is redirected to STDERR so that any output from the final command
+    # on STDOUT will generate warnings, since the final command should not
+    # attempt to write to STDOUT, as this would interfere with collecting
+    # the exit statuses.
+    #
+    # There is no guarantee as to the order of this output, which is why the
+    # command's index in @commands is passed along with it's exit status.
+    # And, if multiple commands output messages on STDERR, those messages
+    # may be interleaved. Interleaving of the "index|exit status" outputs
+    # should not be an issue, given the small byte size of the data being written.
+    def pipeline
+      parts = []
+      @commands.each_with_index do |command, index|
+        parts << %Q[{ #{ command } 2>&4 ; echo "#{ index }|$?:" >&3 ; }]
+      end
+      %Q[{ #{ parts.join(' | ') } } 3>&1 1>&2 4>&2]
+    end
+
+    def stderr_messages
+      @stderr_messages ||= @stderr.empty? ? false : <<-EOS.gsub(/^ +/, '  ')
+        Pipeline STDERR Messages:
+        (Note: may be interleaved if multiple commands returned error messages)
+
+        #{ @stderr }
+      EOS
+    end
+
+  end
+end