backup-ssh 4.1.10

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/datadog.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+require 'dogapi'
+
+module Backup
+  module Notifier
+    class DataDog < Base
+
+      ##
+      # The DataDog API key
+      attr_accessor :api_key
+
+      ##
+      # The title of the event
+      attr_accessor :title
+
+      ##
+      # The text information for the event
+      attr_accessor :text
+
+      ##
+      # The timestamp for the event
+      attr_accessor :date_happened
+
+      ##
+      # The priority of the event (low/normal)
+      attr_accessor :priority
+
+      ##
+      # The host that generated the event
+      attr_accessor :host
+
+      ##
+      # The tags for this host (should be an array)
+      attr_accessor :tags
+
+      ##
+      # The alert_type of the event (error/warning/info/success)
+      attr_accessor :alert_type
+
+      ##
+      # The aggregation_key for the event
+      attr_accessor :aggregation_key
+
+      ##
+      # The source_type for the event (nagios, hudson, jenkins, user, my apps, feed, chef, puppet, git, bitbucket, fabric, capistrano)
+      attr_accessor :source_type_name
+
+      def initialize(model, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @title          ||= default_title
+        @text           ||= default_text
+      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)
+        hash = {alert_type: default_alert_type(status)}
+        hash.store(:msg_title,        @title)
+        hash.store(:date_happened,    @date_happened)    if @date_happened
+        hash.store(:priority,         @priority)         if @priority
+        hash.store(:host,             @host)             if @host
+        hash.store(:tags,             @tags)             if @tags
+        hash.store(:aggregation_key,  @aggregation_key)  if @aggregation_key
+        hash.store(:source_type_name, @source_type_name) if @source_type_name
+        hash.store(:alert_type,       @alert_type)       if @alert_type
+        send_event(hash)
+      end
+
+      # Dogapi::Client will raise an error if unsuccessful.
+      def send_event(hash)
+        client = Dogapi::Client.new(@api_key)
+        event = Dogapi::Event.new(@text, hash)
+        client.emit_event(event)
+      end
+
+      # set alert type
+      def default_alert_type(status)
+        case status
+        when :success then 'success'
+        when :warning then 'warning'
+        when :failure then 'error'
+        end
+      end
+
+      # set default title
+      def default_title
+        "Backup #{ model.label }"
+      end
+
+      # set default text
+      def default_text
+        "Backup Notification for #{ model.label }"
+      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