backup_zh 4.0.3.1 → 4.2.0

data/lib/backup/notifier/datadog.rb

@@ -0,0 +1,107 @@
+# 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
+
+      attr_deprecate :text,
+        :version => '4.2',
+        :message => 'Please use the `message` attribute. For more information '\
+          'see https://github.com/backup/backup/pull/698'
+
+      ##
+      # 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 ||= "Backup #{ model.label }"
+      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)
+        msg = message.call(model, :status => status_data_for(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(msg, hash)
+      end
+
+      # Dogapi::Client will raise an error if unsuccessful.
+      def send_event(msg, hash)
+        client = Dogapi::Client.new(@api_key)
+        event = Dogapi::Event.new(msg, 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
+
+    end
+  end
+end

data/lib/backup/notifier/flowdock.rb

@@ -61,15 +61,16 @@ module Backup
       # : 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)
+        @tags += default_tags(status)
+        send_message(message.call(model, status: status_data_for(status)))
       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 = Flowdock::Flow.new(
+          :api_token => token, :source => source,
+          :from => {:name => from_name, :address => from_email }
+        )
 
         client.push_to_team_inbox(:subject => subject,
                                   :content => msg,

data/lib/backup/notifier/hipchat.rb

@@ -9,6 +9,11 @@ module Backup
       # The Hipchat API token
       attr_accessor :token
 
+      ##
+      # The Hipchat API version
+      # Either 'v1' or 'v2' (default is 'v1')
+      attr_accessor :api_version
+
       ##
       # Who the notification should appear from
       attr_accessor :from
@@ -45,6 +50,7 @@ module Backup
         @success_color  ||= 'yellow'
         @warning_color  ||= 'yellow'
         @failure_color  ||= 'yellow'
+        @api_version    ||= 'v1'
       end
 
       private
@@ -67,18 +73,18 @@ module Backup
       # : 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)
+        status_data = status_data_for(status)
+        msg = message.call(model, :status => status_data)
+        send_message(msg, status_data[:color])
+      end
+
+      def client_options
+        { api_version: @api_version }
       end
 
       # Hipchat::Client will raise an error if unsuccessful.
       def send_message(msg, color)
-        client = HipChat::Client.new(token)
+        client = HipChat::Client.new(token, client_options)
         rooms_to_notify.each do |room|
           client[room].send(from, msg, :color => color, :notify => notify_users)
         end
@@ -88,6 +94,19 @@ module Backup
         Array(rooms_notified).map {|r| r.split(',').map(&:strip) }.flatten
       end
 
+      def status_data_for(status)
+        data = super(status)
+        data[:color] = status_color_for(status)
+        data
+      end
+
+      def status_color_for(status)
+        {
+          :success => success_color,
+          :warning => warning_color,
+          :failure => failure_color
+        }[status]
+      end
     end
   end
 end

data/lib/backup/notifier/http_post.rb

@@ -95,18 +95,13 @@ module Backup
       # : 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 })"
+        msg = message.call(model, :status => status_data_for(status))
 
         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 }.
+          :body => URI.encode_www_form({ 'message' => msg }.
               merge(params).reject {|k,v| v.nil? }.
               merge('status' => status.to_s)),
           :expects => success_codes # raise error if unsuccessful

data/lib/backup/notifier/mail.rb

@@ -37,6 +37,18 @@ module Backup
       # Receiver Email Address
       attr_accessor :to
 
+      ##
+      # CC receiver Email Address
+      attr_accessor :cc
+
+      ##
+      # BCC receiver Email Address
+      attr_accessor :bcc
+
+      ##
+      # Set reply to email address
+      attr_accessor :reply_to
+
       ##
       # SMTP Server Address
       attr_accessor :address
@@ -148,14 +160,8 @@ module Backup
       # : backup log, if `on_failure` is `true`.
       #
       def notify!(status)
-        tag = case status
-              when :success then '[Backup::Success]'
-              when :warning then '[Backup::Warning]'
-              when :failure then '[Backup::Failure]'
-              end
-
         email = new_email
-        email.subject = "#{ tag } #{ model.label } (#{ model.trigger })"
+        email.subject = message.call(model, :status => status_data_for(status))
 
         send_log = send_log_on.include?(status)
         template = Backup::Template.new({ :model => model, :send_log => send_log })
@@ -214,8 +220,11 @@ module Backup
         end
 
         email = ::Mail.new
-        email.to   = @to
-        email.from = @from
+        email.to       = to
+        email.from     = from
+        email.cc       = cc
+        email.bcc      = bcc
+        email.reply_to = reply_to
         email
       end
 
@@ -224,7 +233,7 @@ module Backup
 end
 
 # Patch mail v2.5.4 Exim delivery method
-# https://github.com/meskyanichi/backup/issues/446
+# https://github.com/backup/backup/issues/446
 # https://github.com/mikel/mail/pull/546
 module Mail
   class Exim

data/lib/backup/notifier/nagios.rb

@@ -14,8 +14,8 @@ module Backup
 
       ##
       # Nagios nrpe configuration file.
-      attr_accessor :send_nsca_cfg     
- 
+      attr_accessor :send_nsca_cfg
+
       ##
       # Name of the Nagios service for the backup check.
       attr_accessor :service_name
@@ -55,12 +55,7 @@ module Backup
       # : Notification will be sent if `on_warning` or `on_success` is `true`.
       #
       def notify!(status)
-        message = case status
-              when :success then 'Completed Successfully'
-              when :warning then 'Completed Successfully (with Warnings)'
-              when :failure then 'Failed'
-              end
-        send_message("#{ message } in #{ model.duration }")
+        send_message(message.call(model, :status => status_data_for(status)))
       end
 
       def send_message(message)

data/lib/backup/notifier/pagerduty.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require 'pagerduty'
+
+module Backup
+  module Notifier
+    class PagerDuty < Base
+
+      ##
+      # PagerDuty Service API Key. Should be a 32 character hex string.
+      attr_accessor :service_key
+
+      ##
+      # Determines if a backup with a warning should resolve an incident rather
+      # than trigger one.
+      #
+      # Defaults to false.
+      attr_accessor :resolve_on_warning
+
+      def initialize(mode, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @resolve_on_warning ||= false
+      end
+
+      private
+
+      ##
+      # Trigger or resolve a PagerDuty incident for this model
+      #
+      # `status` indicates one of the following:
+      #
+      # `:success`
+      # : The backup completed successfully.
+      # : The incident will be resolved if `on_success` is `true`.
+      #
+      # `:warning`
+      # : The backup completed successfully, but warnings were logged.
+      # : An incident will be triggered if `on_warning` or `on_success` is `true`.
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : An incident will be triggered if `on_failure` is `true`.
+      #
+      def notify!(status)
+        incident_description = "Backup - #{model.label}"
+        incident_key = "backup/#{model.trigger}"
+        incident_details = {
+          :incident_key => incident_key,
+          :details => {
+            :trigger => model.trigger,
+            :label => model.label,
+            :started_at => model.started_at,
+            :finished_at => model.finished_at,
+            :duration => model.duration,
+            :status => status,
+            :exception => model.exception
+          }
+        }
+
+        event_type = case status
+                     when :success then :resolve
+                     when :warning then resolve_on_warning ? :resolve : :trigger
+                     when :failure then :trigger
+                     end
+
+        case event_type
+        when :trigger
+          pagerduty.trigger(incident_description, incident_details)
+        when :resolve
+          incident = pagerduty.get_incident(incident_key)
+          incident.resolve(incident_description, incident_details)
+        end
+      end
+
+      def pagerduty
+        @pagerduty ||= Pagerduty.new(service_key)
+      end
+    end
+  end
+end

data/lib/backup/notifier/prowl.rb

@@ -16,6 +16,9 @@ module Backup
       attr_accessor :api_key
 
       def initialize(model, &block)
+        @message = lambda do |model, data|
+          "#{ model.label } (#{ model.trigger })"
+        end
         super
         instance_eval(&block) if block_given?
       end
@@ -40,21 +43,17 @@ module Backup
       # : 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
-        send_message(tag)
+        send_message(status)
       end
 
-      def send_message(message)
+      def send_message(status)
         uri = 'https://api.prowlapp.com/publicapi/add'
+        status_data = status_data_for(status)
         data = {
           :application  => application,
           :apikey       => api_key,
-          :event        => message,
-          :description  => "#{ model.label } (#{ model.trigger })"
+          :event        => status_data[:message],
+          :description  => message.call(model, :status => status_data)
         }
         options = {
           :headers  => { 'Content-Type' => 'application/x-www-form-urlencoded' },

data/lib/backup/notifier/pushover.rb

@@ -51,13 +51,7 @@ module Backup
       # : 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 })"
-        send_message(message)
+        send_message(message.call(model, :status => status_data_for(status)))
       end
 
       def send_message(message)

data/lib/backup/notifier/ses.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'aws/ses'
+
+module Backup
+  module Notifier
+    class Ses < Base
+
+      ##
+      # Amazon Simple Email Service (SES) Credentials
+      attr_accessor :access_key_id, :secret_access_key
+
+      ##
+      # SES Region
+      attr_accessor :region
+
+      ##
+      # Sender Email Address
+      attr_accessor :from
+
+      ##
+      # Receiver Email Address
+      attr_accessor :to
+
+      def initialize(model, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @region ||= 'eu-west-1'
+        @send_log_on ||= [:warning, :failure]
+      end
+
+      ##
+      # Array of statuses for which the log file should be attached.
+      #
+      # Available statuses are: `:success`, `:warning` and `:failure`.
+      # Default: [:warning, :failure]
+      attr_accessor :send_log_on
+
+      private
+
+      def client
+        AWS::SES::Base.new(
+          :access_key_id => access_key_id,
+          :secret_access_key => secret_access_key,
+          :server => "email.#{region}.amazonaws.com"
+        )
+      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` is `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` or `on_success` is `true`.
+      #
+      # `:failure`
+      # : The backup operation failed.
+      # : Notification will be sent, including a copy of the current
+      # : backup log, if `on_failure` is `true`.
+      #
+      def notify!(status)
+        email = ::Mail.new(:to => to, :from => from)
+        email.subject = message.call(model, :status => status_data_for(status))
+
+        send_log = send_log_on.include?(status)
+        template = Backup::Template.new({ :model => model, :send_log => send_log })
+        email.body = template.result('notifier/mail/%s.erb' % status.to_s)
+
+        if send_log
+          email.convert_to_multipart
+          email.attachments["#{ model.time }.#{ model.trigger }.log"] = {
+            :mime_type => 'text/plain;',
+            :content   => Logger.messages.map(&:formatted_lines).flatten.join("\n")
+          }
+        end
+
+        client.send_raw_email(email)
+      end
+    end
+  end
+end