backup_zh 4.0.3.1

data/lib/backup/notifier/base.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+module Backup
+  module Notifier
+    class Error < Backup::Error; end
+
+    class Base
+      include Utilities::Helpers
+      include Config::Helpers
+
+      ##
+      # 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
+
+      ##
+      # Number of times to retry failed attempts to send notification.
+      # Default: 10
+      attr_accessor :max_retries
+
+      ##
+      # Time in seconds to pause before each retry.
+      # Default: 30
+      attr_accessor :retry_waitsec
+
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+        load_defaults!
+
+        @on_success = true if on_success.nil?
+        @on_warning = true if on_warning.nil?
+        @on_failure = true if on_failure.nil?
+        @max_retries    ||= 10
+        @retry_waitsec  ||= 30
+      end
+
+      # This method is called from an ensure block in Model#perform! and must
+      # not raise any exceptions. However, each Notifier's #notify! method
+      # should raise an exception if the request fails so it may be retried.
+      def perform!
+        status = case model.exit_status
+                 when 0
+                   :success if notify_on_success?
+                 when 1
+                   :warning if notify_on_success? || notify_on_warning?
+                 else
+                   :failure if notify_on_failure?
+                 end
+
+        if status
+          Logger.info "Sending notification using #{ notifier_name }..."
+          with_retries { notify!(status) }
+        end
+
+      rescue Exception => err
+        Logger.error Error.wrap(err, "#{ notifier_name } Failed!")
+      end
+
+      private
+
+      def with_retries
+        retries = 0
+        begin
+          yield
+        rescue StandardError, Timeout::Error => err
+          retries += 1
+          raise if retries > max_retries
+
+          Logger.info Error.wrap(err, "Retry ##{ retries } of #{ max_retries }.")
+          sleep(retry_waitsec)
+          retry
+        end
+      end
+
+      ##
+      # Return the notifier name, with Backup namespace removed
+      def notifier_name
+        self.class.to_s.sub('Backup::', '')
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/campfire.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'json'
+
+module Backup
+  module Notifier
+    class Campfire < Base
+
+      ##
+      # Campfire api authentication token
+      attr_accessor :api_token
+
+      ##
+      # Campfire account's subdomain
+      attr_accessor :subdomain
+
+      ##
+      # Campfire account's room id
+      attr_accessor :room_id
+
+      def initialize(model, &block)
+        super
+        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` is `true`.
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      def notify!(status)
+        tag = case status
+              when :success then '[Backup::Success]'
+              when :warning then '[Backup::Warning]'
+              when :failure then '[Backup::Failure]'
+              end
+        message = "#{ tag } #{ model.label } (#{ model.trigger })"
+        send_message(message)
+      end
+
+      def send_message(message)
+        uri = "https://#{ subdomain }.campfirenow.com/room/#{ room_id }/speak.json"
+        options = {
+          :headers  => { 'Content-Type' => 'application/json' },
+          :body     => JSON.dump(
+            { :message => { :body => message, :type => 'Textmessage' } }
+          )
+        }
+        options.merge!(:user => api_token, :password => 'x') # Basic Auth
+        options.merge!(:expects => 201) # raise error if unsuccessful
+        Excon.post(uri, options)
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/flowdock.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+require 'flowdock'
+
+module Backup
+  module Notifier
+    class FlowDock < Base
+
+      ##
+      # The Flowdock API token
+      attr_accessor :token
+
+      ##
+      # Who the notification should appear from
+      attr_accessor :from_name
+
+      # Which email the notification should appear from
+      attr_accessor :from_email
+
+      ##
+      # source for message
+      attr_accessor :source
+
+      ##
+      # Subject for message
+      attr_accessor :subject
+
+      ##
+      # tag message in inbox
+      attr_accessor :tags
+
+      ##
+      # link for message
+      attr_accessor :link
+
+      def initialize(model, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @subject        ||= default_subject
+        @source         ||= default_source
+        @tags           ||= []
+      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` is `true`.
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      def notify!(status)
+        @tags  += default_tags(status)
+        message = "#{ model.label } (#{ model.trigger })"
+        send_message(message)
+      end
+
+      # Flowdock::Client will raise an error if unsuccessful.
+      def send_message(msg)
+        client = Flowdock::Flow.new(:api_token => token, :source => source,
+                                    :from => {:name => from_name, :address => from_email })
+
+        client.push_to_team_inbox(:subject => subject,
+                                  :content => msg,
+                                  :tags => tags,
+                                  :link => link )
+      end
+
+      # set related tags
+      def default_tags(status)
+        case status
+        when :success then ['#BackupSuccess']
+        when :warning then ['#BackupWarning']
+        when :failure then ['#BackupFailure']
+        end
+      end
+
+
+      #set default source
+      def default_source
+        "Backup #{ model.label }"
+      end
+
+      # set default subject
+      def default_subject
+        'Backup Notification'
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/hipchat.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+require '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
+
+      ##
+      # Notify users in the room
+      attr_accessor :notify_users
+
+      ##
+      # 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
+
+      def initialize(model, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @notify_users   ||= false
+        @rooms_notified ||= []
+        @success_color  ||= 'yellow'
+        @warning_color  ||= 'yellow'
+        @failure_color  ||= 'yellow'
+      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` is `true`.
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      def notify!(status)
+        tag, color = case status
+                     when :success then ['[Backup::Success]', success_color]
+                     when :warning then ['[Backup::Warning]', warning_color]
+                     when :failure then ['[Backup::Failure]', failure_color]
+                     end
+        message = "#{ tag } #{ model.label } (#{ model.trigger })"
+        send_message(message, color)
+      end
+
+      # Hipchat::Client will raise an error if unsuccessful.
+      def send_message(msg, color)
+        client = HipChat::Client.new(token)
+        rooms_to_notify.each do |room|
+          client[room].send(from, msg, :color => color, :notify => notify_users)
+        end
+      end
+
+      def rooms_to_notify
+        Array(rooms_notified).map {|r| r.split(',').map(&:strip) }.flatten
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/http_post.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+require 'uri'
+
+module Backup
+  module Notifier
+    class HttpPost < Base
+
+      ##
+      # URI to post notification to.
+      #
+      # URI scheme may be `http` or `https`.
+      #
+      # If Basic Authentication is needed, supply the `user:password` in the URI.
+      # e.g. 'https://user:pass@www.example.com/path'
+      #
+      # Port may also be supplied.
+      # e.g. 'http://www.example.com:8080/path'
+      attr_accessor :uri
+
+      ##
+      # Hash of additional HTTP headers to send.
+      #
+      # This notifier sets the following headers:
+      # { 'User-Agent'   => "Backup/#{ Backup::VERSION }",
+      #   'Content-Type' => 'x-www-form-urlencoded' }
+      #
+      # 'Content-Type' may not be changed.
+      # 'User-Agent' may be overridden or omitted by setting it to +nil+.
+      # e.g. { 'Authorization' => 'my_auth_info', 'User-Agent' => nil }
+      attr_accessor :headers
+
+      ##
+      # Hash of additional POST parameters to send.
+      #
+      # This notifier will set two parameters:
+      # { 'status'  => 'success|warning|failure',
+      #   'message' => '[Backup::(Success|Warning|Failure)] label (trigger)' }
+      #
+      # 'status' may not be changed.
+      # 'message' may be overridden or omitted by setting a +nil+ value.
+      # e.g. { 'auth_token' => 'my_token', 'message' => nil }
+      attr_accessor :params
+
+      ##
+      # Successful HTTP Status Code(s) that should be returned.
+      #
+      # This may be a single code or an Array of acceptable codes.
+      # e.g. [200, 201, 204]
+      #
+      # If any other response code is returned, the request will be retried
+      # using `max_retries` and `retry_waitsec`.
+      #
+      # Default: 200
+      attr_accessor :success_codes
+
+      ##
+      # Verify the server's certificate when using SSL.
+      #
+      # This will default to +true+ for most systems.
+      # It may be forced by setting to +true+, or disabled by setting to +false+.
+      attr_accessor :ssl_verify_peer
+
+      ##
+      # Path to a +cacert.pem+ file to use for +ssl_verify_peer+.
+      #
+      # This is provided (via Excon), but may be specified if needed.
+      attr_accessor :ssl_ca_file
+
+      def initialize(model, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @headers ||= {}
+        @params  ||= {}
+        @success_codes ||= 200
+      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` is `true`.
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent if `on_warning` or `on_success` is `true`.
+      #
+      def notify!(status)
+        tag = case status
+              when :success then '[Backup::Success]'
+              when :failure then '[Backup::Failure]'
+              when :warning then '[Backup::Warning]'
+              end
+        message = "#{ tag } #{ model.label } (#{ model.trigger })"
+
+        opts = {
+          :headers => { 'User-Agent' => "Backup/#{ VERSION }" }.
+              merge(headers).reject {|k,v| v.nil? }.
+              merge('Content-Type' => 'application/x-www-form-urlencoded'),
+          :body => URI.encode_www_form({ 'message' => message }.
+              merge(params).reject {|k,v| v.nil? }.
+              merge('status' => status.to_s)),
+          :expects => success_codes # raise error if unsuccessful
+        }
+        opts.merge!(:ssl_verify_peer => ssl_verify_peer) unless ssl_verify_peer.nil?
+        opts.merge!(:ssl_ca_file => ssl_ca_file) if ssl_ca_file
+
+        Excon.post(uri, opts)
+      end
+
+    end
+  end
+end