backup-bouchard 4.4.1

data/lib/backup/notifier/base.rb

@@ -0,0 +1,126 @@
+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
+
+      ##
+      # Message to send. Depends on notifier implementation if this is used.
+      # Default: lambda returning:
+      # "#{ message } #{ model.label } (#{ model.trigger })"
+      #
+      # @yieldparam [model] Backup::Model
+      # @yieldparam [data] Hash containing `message` and `key` values.
+      attr_accessor :message
+
+      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
+        @message        ||= lambda do |m, data|
+          "[#{data[:status][:message]}] #{m.label} (#{m.trigger})"
+        end
+      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
+
+      ##
+      # Return status data for message creation
+      def status_data_for(status)
+        {
+          success: {
+            message: "Backup::Success",
+            key: :success
+          },
+          warning: {
+            message: "Backup::Warning",
+            key: :warning
+          },
+          failure: {
+            message: "Backup::Failure",
+            key: :failure
+          }
+        }[status]
+      end
+    end
+  end
+end

data/lib/backup/notifier/campfire.rb

@@ -0,0 +1,61 @@
+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)
+        send_message(message.call(model, status: status_data_for(status)))
+      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[:user] = api_token
+        options[:password] = "x" # Basic Auth
+        options[:expects] = 201 # raise error if unsuccessful
+        Excon.post(uri, options)
+      end
+    end
+  end
+end

data/lib/backup/notifier/command.rb

@@ -0,0 +1,99 @@
+module Backup
+  module Notifier
+    class Command < Base
+      ##
+      # Command to execute.
+      #
+      # Make sure it is accessible from your $PATH, or provide
+      # the absolute path to the command.
+      attr_accessor :command
+
+      ##
+      # Arguments to pass to the command.
+      #
+      # Must be an array of strings or callable objects.
+      #
+      # Callables will be invoked with #call(model, status),
+      # and the return value used as the argument.
+      #
+      # In strings you can use the following placeholders:
+      #
+      # %l - Model label
+      # %t - Model trigger
+      # %d - Backup duration (HH:MM:SS)
+      # %s - Status (success/failure/warning)
+      # %v - Status verb (succeeded/failed/succeeded with warnings)
+      #
+      # All placeholders can be used with uppercase letters to capitalize
+      # the value.
+      #
+      # Defaults to ["%L %v"]
+      attr_accessor :args
+
+      def initialize(model, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @args ||= ["%L %v"]
+      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)
+        IO.popen([@command] + args.map { |arg| format_arg(arg, status) })
+      end
+
+      def format_arg(arg, status)
+        if arg.respond_to?(:call)
+          arg.call(model, status)
+        else
+          arg.gsub(/%(\w)/) do |match|
+            ph = match[1]
+            val = case ph.downcase
+                  when "l"
+                    model.label
+                  when "t"
+                    model.trigger.to_s
+                  when "d"
+                    model.duration
+                  when "v"
+                    status_verb(status)
+                  when "s"
+                    status.to_s
+                  end
+            val.capitalize! if ph == ph.upcase
+            val
+          end
+        end
+      end
+
+      def status_verb(status)
+        case status
+        when :success
+          "succeeded"
+        when :failure
+          "failed"
+        when :warning
+          "succeeded with warnings"
+        end
+      end
+    end
+  end
+end

data/lib/backup/notifier/datadog.rb

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,99 @@
+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)
+        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.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