backupii 0.1.0.pre.alpha.1

data/lib/backup/notifier/command.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+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(%r{%(\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 = 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,107 @@
+# frozen_string_literal: true
+
+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,101 @@
+# frozen_string_literal: true
+
+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

data/lib/backup/notifier/hipchat.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "hipchat"
+
+module Backup
+  module Notifier
+    class Hipchat < Base
+      ##
+      # 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
+
+      ##
+      # Custom server URL
+      attr_accessor :server_url
+
+      ##
+      # 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"
+        @api_version    ||= "v1"
+      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)
+        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 }.tap do |h|
+          h[:server_url] = server_url if server_url
+        end
+      end
+
+      # Hipchat::Client will raise an error if unsuccessful.
+      def send_message(msg, color)
+        client = HipChat::Client.new(token, client_options)
+        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
+
+      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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+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)
+        msg = message.call(model, status: status_data_for(status))
+
+        opts = {
+          headers: { "User-Agent" => "Backup/#{VERSION}" }
+            .merge(headers).reject { |_, value| value.nil? }
+            .merge("Content-Type" => "application/x-www-form-urlencoded"),
+          body: URI.encode_www_form({ "message" => msg }
+              .merge(params).reject { |_, value| value.nil? }
+              .merge("status" => status.to_s)),
+          expects: success_codes # raise error if unsuccessful
+        }
+        opts[:ssl_verify_peer] = ssl_verify_peer unless ssl_verify_peer.nil?
+        opts[:ssl_ca_file] = ssl_ca_file if ssl_ca_file
+
+        Excon.post(uri, opts)
+      end
+    end
+  end
+end