interu-backup 3.0.16

data/lib/backup/notifier/binder.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Backup
+  module Notifier
+    class Binder
+
+      ##
+      # Shortcut to create a new instance of a binder, setting
+      # the instance variables using a Hash of key/values and getting
+      # the instance's binding. This returns the binding of the new Binder instance
+      def self.bind(key_and_values = {})
+        Binder.new(key_and_values).get_binding
+      end
+
+      ##
+      # Creates a new Backup::Notifier::Binder instance. Loops through the provided
+      # Hash to set instance variables
+      def initialize(key_and_values)
+        key_and_values.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      ##
+      # Returns the binding (needs a wrapper method because #binding is a private method)
+      def get_binding
+        binding
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/campfire.rb

@@ -0,0 +1,194 @@
+# encoding: utf-8
+
+##
+# If the Ruby version of this process is 1.8.x or less
+# then use the JSON gem. Otherwise if the current process is running
+# Ruby 1.9.x or later then it is built in and we can load it from the Ruby core lib
+if RUBY_VERSION < '1.9.0'
+  Backup::Dependency.load('json')
+else
+  require 'json'
+end
+
+##
+# Load the HTTParty library from the gem
+Backup::Dependency.load('httparty')
+
+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
+
+      ##
+      # Container for the Model object
+      attr_accessor :model
+
+      ##
+      # Instantiates a new Backup::Notifier::Campfire object
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        set_defaults!
+      end
+
+      ##
+      # Performs the notification
+      # Takes an exception object that might've been created if an exception occurred.
+      # If this is the case it'll invoke notify_failure!(exception), otherwise, if no
+      # error was raised, it'll go ahead and notify_success!
+      #
+      # If'll only perform these if on_success is true or on_failure is true
+      def perform!(model, exception = false)
+        @model = model
+
+        if notify_on_success? and exception.eql?(false)
+          log!
+          notify_success!
+        elsif notify_on_failure? and not exception.eql?(false)
+          log!
+          notify_failure!(exception)
+        end
+      end
+
+    private
+
+      ##
+      # Sends a message informing the user that the backup operation
+      # proceeded without any errors
+      def notify_success!
+        send_message("[Backup::Succeeded] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      end
+
+      ##
+      # Sends a message informing the user that the backup operation
+      # raised an exception
+      def notify_failure!(exception)
+        send_message("[Backup::Failed] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      end
+
+      ##
+      # Setting up credentials
+      def set_defaults!
+        @campfire_client = {
+          :api_token => @api_token,
+          :subdomain => @subdomain,
+          :room_id   => @room_id
+        }
+      end
+
+      ##
+      # Creates a new Campfire::Interface object and passes in the
+      # campfire clients "room_id", "subdomain" and "api_token". Using this object
+      # the provided "message" will be sent to the desired Campfire chat room
+      def send_message(message)
+        room = Interface.room(
+          @campfire_client[:room_id],
+          @campfire_client[:subdomain],
+          @campfire_client[:api_token]
+        )
+        room.message(message)
+      end
+
+      ##
+      # The Campfire::Interface acts as the Interface for the Campfire class.
+      # It uses the HTTParty library and the Campfire::Room class to communicate
+      # with the Campfire rooms. HTTParty provides the Campfire::Interface with the methods
+      # necessary to communicate (inside the HTTParty module) such as the class methods:
+      # * post
+      # * base_uri
+      # * basic_auth
+      class Interface
+        include HTTParty
+
+        ##
+        # We communicate using the JSON data format
+        headers 'Content-Type' => 'application/json'
+
+        ##
+        # Instantiates a new Campfire::Room object with
+        # the provided arguments and returns this object
+        def self.room(room_id, subdomain, api_token)
+          Room.new(room_id, subdomain, api_token)
+        end
+      end
+
+      ##
+      # The Campfire::Room acts as a model for an actual room on the Campfire service.
+      # And it uses the Campfire::Interface's (HTTParty) class methods to communicate based
+      # on the provided parameters (room_id, subdomain and api_token)
+      class Room
+
+        ##
+        # Campfire api authentication api_token
+        attr_accessor :api_token
+
+        ##
+        # Campfire account's subdomain
+        attr_accessor :subdomain
+
+        ##
+        # Campfire account's room id
+        attr_accessor :room_id
+
+        ##
+        # Instantiates a new Campfire::Room object and sets all the
+        # necessary arguments (@room_id, @subdomain, @api_token)
+        def initialize(room_id, subdomain, api_token)
+          @room_id   = room_id
+          @subdomain = subdomain
+          @api_token = api_token
+        end
+
+        ##
+        # Wrapper method for the #send_message (private) method
+        def message(message)
+          send_message(message)
+        end
+
+      private
+
+        ##
+        # Takes a "message" as argument, the "type" defaults to "Textmessage".
+        # This method builds up a POST request with the necessary params (serialized to JSON format)
+        # and sends it to the Campfire service in order to submit the message
+        def send_message(message, type = 'Textmessage')
+          post 'speak', :body => {
+            :message => {
+              :body => message,
+              :type => type
+            }
+          }.to_json
+        end
+
+        ##
+        # Builds/sets up the Campfire::Interface attributes and submits
+        # the POST request that was built in the #send_message (private) method
+        def post(action, options = {})
+          Interface.base_uri("https://#{subdomain}.campfirenow.com")
+          Interface.basic_auth(api_token, 'x')
+          Interface.post(room_url_for(action), options)
+        end
+
+        ##
+        # Returns the url for the specified room (in JSON format)
+        def room_url_for(action)
+          "/room/#{room_id}/#{action}.json"
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/mail.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+##
+# Only load the Mail gem and Erb library when using Mail notifications
+Backup::Dependency.load('mail')
+require 'erb'
+
+module Backup
+  module Notifier
+    class Mail < Base
+
+      ##
+      # Container for the Mail object
+      attr_accessor :mail
+
+      ##
+      # Container for the Model object
+      attr_accessor :model
+
+      ##
+      # Sender and Receiver email addresses
+      # Examples:
+      #  sender   - my.email.address@gmail.com
+      #  receiver - your.email.address@gmail.com
+      attr_accessor :from, :to
+
+      ##
+      # The address to use
+      # Example: smtp.gmail.com
+      attr_accessor :address
+
+      ##
+      # The port to connect to
+      # Example: 587
+      attr_accessor :port
+
+      ##
+      # Your domain (if applicable)
+      # Example: mydomain.com
+      attr_accessor :domain
+
+      ##
+      # Username and Password (sender email's credentials)
+      # Examples:
+      #  user_name - meskyanichi
+      #  password  - my_secret_password
+      attr_accessor :user_name, :password
+
+      ##
+      # Authentication type
+      # Example: plain
+      attr_accessor :authentication
+
+      ##
+      # Automatically set TLS
+      # Example: true
+      attr_accessor :enable_starttls_auto
+
+      ##
+      # Instantiates a new Backup::Notifier::Mail object
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        set_defaults!
+      end
+
+      ##
+      # Performs the notification
+      # Takes an exception object that might've been created if an exception occurred.
+      # If this is the case it'll invoke notify_failure!(exception), otherwise, if no
+      # error was raised, it'll go ahead and notify_success!
+      #
+      # If'll only perform these if on_success is true or on_failure is true
+      def perform!(model, exception = false)
+        @model = model
+
+        if notify_on_success? and exception.eql?(false)
+          log!
+          notify_success!
+        elsif notify_on_failure? and not exception.eql?(false)
+          log!
+          notify_failure!(exception)
+        end
+      end
+
+    private
+
+      ##
+      # Sends an email informing the user that the backup operation
+      # proceeded without any errors
+      def notify_success!
+        mail[:subject] = "[Backup::Succeeded] #{model.label} (#{model.trigger})"
+        mail[:body]    = read_template('notify_success', Binder.bind(:model => @model))
+        mail.deliver!
+      end
+
+      ##
+      # Sends an email informing the user that the backup operation
+      # raised an exception and will send the user the error details
+      def notify_failure!(exception)
+        mail[:subject] = "[Backup::Failed] #{model.label} (#{model.trigger})"
+        mail[:body]    = read_template('notify_failure', Binder.bind(:model => @model, :exception => exception))
+        mail.deliver!
+      end
+
+      ##
+      # Configures the Mail gem by setting the defaults.
+      # Instantiates the @mail object with the @to and @from attributes
+      def set_defaults!
+        defaults = {
+          :address              => @address,
+          :port                 => @port,
+          :domain               => @domain,
+          :user_name            => @user_name,
+          :password             => @password,
+          :authentication       => @authentication,
+          :enable_starttls_auto => @enable_starttls_auto
+        }
+
+        ::Mail.defaults do
+          delivery_method :smtp, defaults
+        end
+
+        @mail        = ::Mail.new
+        @mail[:from] = @from
+        @mail[:to]   = @to
+      end
+
+      ##
+      # Returns the path to the templates, appended by the passed in argument
+      def read_template(file, binder)
+        ERB.new(File.read(
+          File.join( File.dirname(__FILE__), "templates", "#{file}.erb" )
+        )).result(binder)
+      end
+
+    end
+  end
+end

data/lib/backup/notifier/presently.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+Backup::Dependency.load('httparty')
+
+module Backup
+  module Notifier
+    class Presently < Base
+
+      ##
+      # Container for the Presently Client object
+      attr_accessor :presently_client
+
+      ##
+      # Container for the Model object
+      attr_accessor :model
+
+      ##
+      # Presently subdomain
+      attr_accessor :subdomain
+
+      ##
+      # Presently credentials
+      attr_accessor :user_name, :password
+
+      ##
+      # Group id
+      attr_accessor :group_id
+
+      ##
+      # Instantiates a new Backup::Notifier::Presently object
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        set_defaults!
+      end
+
+      ##
+      # Performs the notification
+      # Takes an exception object that might've been created if an exception occurred.
+      # If this is the case it'll invoke notify_failure!(exception), otherwise, if no
+      # error was raised, it'll go ahead and notify_success!
+      #
+      # If'll only perform these if on_success is true or on_failure is true
+      def perform!(model, exception = false)
+        @model = model
+
+        if notify_on_success? and exception.eql?(false)
+          log!
+          notify_success!
+        elsif notify_on_failure? and not exception.eql?(false)
+          log!
+          notify_failure!(exception)
+        end
+      end
+
+    private
+
+      ##
+      # Sends a tweet informing the user that the backup operation
+      # proceeded without any errors
+      def notify_success!
+        presently_client.update("[Backup::Succeeded] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      end
+
+      ##
+      # Sends a tweet informing the user that the backup operation
+      # raised an exception
+      def notify_failure!(exception)
+        presently_client.update("[Backup::Failed] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      end
+
+      ##
+      # Create a default Presently::Client object
+      def set_defaults!
+        @presently_client = Client.new subdomain, user_name, password, group_id
+      end
+
+      class Client
+        include HTTParty
+
+        attr_accessor :subdomain, :user_name, :password, :group_id
+
+        def initialize(subdomain, user_name, password, group_id)
+          @subdomain = subdomain
+          @user_name = user_name
+          @password = password
+          @group_id = group_id
+
+          self.class.base_uri "https://#{subdomain}.presently.com"
+          self.class.basic_auth user_name, password
+        end
+
+        def update(message)
+          message = "d @#{group_id} #{message}" if group_id
+          self.class.post "/api/twitter/statuses/update.json", :body => {
+            :status => message,
+            :source => "Backup Notifier"
+          }
+        end
+      end
+    end
+  end
+end