checkup 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+*~
+.DS_Store
+.rvmrc
+models/
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    checkup (0.0.1)
+      httparty
+      thor (~> 0.14.6)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    httparty (0.9.0)
+      multi_json (~> 1.0)
+      multi_xml
+    multi_json (1.3.6)
+    multi_xml (0.5.1)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  checkup!

data/bin/checkup

@@ -0,0 +1,9 @@
+#! /usr/bin/env ruby
+
+# whole library
+require File.expand_path("../../lib/checkup", __FILE__)
+# cli interface for the binary
+require File.expand_path("../../lib/checkup/cli/utility", __FILE__)
+
+
+Checkup::CLI::Utility.start

data/checkup.gemspec

@@ -0,0 +1,24 @@
+
+
+require File.expand_path('lib/checkup/version')
+
+Gem::Specification.new do |gem|
+  gem.name        = 'checkup'
+  gem.version     = Checkup::Version.current
+  gem.platform    = Gem::Platform::RUBY
+  gem.authors     = 'Heiko Moeller'
+  gem.email       = 'femaref@googlemail.com'
+  gem.homepage    = 'http://rubygems.org/gems/checkup'
+  gem.summary     = ''
+
+  
+  gem.files         = %x[git ls-files].split("\n")
+  gem.test_files    = %x[git ls-files -- {spec}/*].split("\n")
+  gem.require_path  = 'lib'
+
+  gem.executables   = ['checkup']
+
+  gem.add_dependency 'thor',   ['~> 0.14.6']
+  gem.add_dependency 'httparty'
+
+end

data/lib/checkup.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+
+begin
+  require 'thor'
+rescue LoadError
+  puts 'Checkup requires the Thor library'
+  exit 1
+end
+
+module Checkup
+  LIBRARY_PATH = File.join(File.dirname(__FILE__), 'checkup')
+  TEMPLATE_PATH = File.join(File.dirname(__FILE__), '..', 'templates')
+  CLI_PATH = File.join(LIBRARY_PATH, 'cli')
+  CONFIGURATION_PATH = File.join(LIBRARY_PATH, 'configuration')
+  
+  autoload :Binder, File.join(LIBRARY_PATH, 'binder')
+  autoload :Config, File.join(LIBRARY_PATH, 'config')
+  autoload :Dependency, File.join(LIBRARY_PATH, 'dependency')
+  autoload :Errors, File.join(LIBRARY_PATH, 'errors')
+  autoload :Logger, File.join(LIBRARY_PATH, 'logger')
+  autoload :Model, File.join(LIBRARY_PATH, 'model')
+  autoload :Template, File.join(LIBRARY_PATH, 'template')
+  autoload :Version, File.join(LIBRARY_PATH, 'version')
+  
+  module CLI
+    autoload :Utility, File.join(CLI_PATH, 'utility')
+  end
+  
+  module Configuration
+    autoload :Base, File.join(CONFIGURATION_PATH, 'base')
+    autoload :Helpers,  File.join(CONFIGURATION_PATH, 'helpers')
+    
+    module Notifier
+      autoload :Base, File.join(CONFIGURATION_PATH, 'notifier', 'base')
+      autoload :Mail, File.join(CONFIGURATION_PATH, 'notifier', 'mail')
+    end
+    
+    module Service
+      autoload :Base, File.join(CONFIGURATION_PATH, 'service', 'base')
+      autoload :Http, File.join(CONFIGURATION_PATH, 'service', 'http')
+    end
+  end
+  
+  module Notifier
+    autoload :Base, File.join(LIBRARY_PATH, 'notifier', 'base')
+    autoload :Mail, File.join(LIBRARY_PATH, 'notifier', 'mail')
+  end
+  
+  module Service
+    autoload :Base, File.join(LIBRARY_PATH, 'service', 'base')
+    autoload :Http, File.join(LIBRARY_PATH, 'service', 'http')
+  end
+end

data/lib/checkup/binder.rb

@@ -0,0 +1,14 @@
+module Checkup
+  class Binder
+    def initialize(key_and_values)
+      key_and_values.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+    
+    def get_binding
+      binding
+    end
+
+  end
+end  

data/lib/checkup/cli/utility.rb

@@ -0,0 +1,62 @@
+module Checkup
+  module CLI
+    class Utility < Thor
+      include Thor::Actions
+      
+      method_option :trigger, :type => :string,  :required => true, :aliases => ['-t', '--triggers']
+      method_option :root_path, :type => :string, :default => '', :aliases => '-r'
+      desc 'perform', 'executes a named model'
+      def perform
+        root_path = options[:root_path]
+        
+        if root_path == ""
+          root_path = Checkup::Config::DEFAULT_ROOT_PATH
+        end
+              
+        load root_path
+        
+        triggers = options[:trigger].split(",")
+        triggers.map!(&:strip).map! {|t|
+          t.include?('*') ? Model.find_matching(t) : t
+        }.flatten!
+
+        triggers.each do |trigger|
+          model = Model.find(trigger)
+          model.perform!
+          Logger.clear!
+        end
+      end
+      
+      method_option :root_path, :type => :string, :default => '', :aliases => '-r'
+      desc 'list', 'lists all models'
+      def list
+        root_path = options[:root_path]
+        
+        if root_path == ""
+          root_path = Checkup::Config::DEFAULT_ROOT_PATH
+        end
+        
+        load root_path
+        
+        Model.all.each do |model|
+          puts model.trigger
+        end
+      end
+      
+      private
+      
+      def load (path)
+        path = File.expand_path path
+        
+        if !Dir.exists? path
+          FileUtils.mkdir_p path
+        end
+              
+        Dir[File.join(path, "*.rb")].each do |file|
+          Checkup::Config.class_eval File.read(File.expand_path(File.basename(file), path))
+        end
+      end
+      
+    end
+  end
+end

data/lib/checkup/config.rb

@@ -0,0 +1,41 @@
+module Checkup
+  module Config
+    DEFAULT_ROOT_PATH = '~/.checkup'
+  
+    class << self
+      def add_dsl_constants!
+        create_modules(
+          self,
+          [ 
+            # Services
+            ['Http'],
+            # Notifiers
+            ['Mail']
+          ]
+        )
+      end
+
+      def create_modules(scope, names)
+        names.flatten.each do |name|
+          if name.is_a?(Hash)
+            name.each do |key, val|
+              create_modules(get_or_create_empty_module(scope, key), [val])
+            end
+          else
+            get_or_create_empty_module(scope, name)
+          end
+        end
+      end
+
+      def get_or_create_empty_module(scope, const)
+        if scope.const_defined?(const)
+          scope.const_get(const)
+        else
+          scope.const_set(const, Module.new)
+        end
+      end
+    end
+    
+    add_dsl_constants!
+  end
+end

data/lib/checkup/configuration/base.rb

@@ -0,0 +1,6 @@
+module Checkup
+  module Configuration
+    class Base
+    end
+  end
+end

data/lib/checkup/configuration/helpers.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Checkup
+  module Configuration
+    module Helpers
+
+      ##
+      # Finds all the object's getter methods and checks the global
+      # configuration for these methods, if they respond then they will
+      # assign the object's attribute(s) to that particular global configuration's attribute
+      def load_defaults!
+        module_names  = self.class.name.split('::')[1..-1]
+        configuration = Checkup::Configuration
+        module_names.each do |module_name|
+          configuration = configuration.const_get(module_name)
+        end
+
+        getter_methods.each do |attribute|
+          if configuration.respond_to?(attribute)
+            self.send("#{attribute}=", configuration.send(attribute))
+          end
+        end
+      end
+
+      ##
+      # Clears all the defaults that may have been set by the user
+      def clear_defaults!
+        setter_methods.each do |method|
+          self.send(method, nil)
+        end
+      end
+
+      private
+
+      ##
+      # Returns an Array of the setter methods (as String)
+      def setter_methods
+        methods.map do |method|
+          method = method.to_s
+          method if method =~ /^\w(\w|\d|\_)+\=$/ and method != 'taguri='
+        end.compact
+      end
+
+      ##
+      # Returns an Array of getter methods (as String)
+      def getter_methods
+        setter_methods.map {|method| method.sub('=','') }
+      end
+
+    end
+  end
+end

data/lib/checkup/configuration/notifier/base.rb

@@ -0,0 +1,13 @@
+module Checkup
+  module Configuration
+    module Notifier
+      class Base < Configuration::Base
+        class << self
+          attr_accessor :on_success       
+          attr_accessor :on_warning
+          attr_accessor :on_failure
+        end
+      end
+    end
+  end
+end

data/lib/checkup/configuration/notifier/mail.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module Checkup
+  module Configuration
+    module Notifier
+      class Mail < Base
+        class << self
+
+          ##
+          # Mail delivery method to be used by the Mail gem.
+          # Supported methods:
+          #
+          # `:smtp` [::Mail::SMTP] (default)
+          # : Settings used only by this method:
+          # : `address`, `port`, `domain`, `user_name`, `password`
+          # : `authentication`, `enable_starttls_auto`, `openssl_verify_mode`
+          #
+          # `:sendmail` [::Mail::Sendmail]
+          # : Settings used only by this method:
+          # : `sendmail`, `sendmail_args`
+          #
+          # `:exim` [::Mail::Exim]
+          # : Settings used only by this method:
+          # : `exim`, `exim_args`
+          #
+          # `:file` [::Mail::FileDelivery]
+          # : Settings used only by this method:
+          # : `mail_folder`
+          #
+          attr_accessor :delivery_method
+
+          ##
+          # 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
+
+          ##
+          # OpenSSL Verify Mode
+          # Example: none - Only use this option for a self-signed and/or wildcard certificate
+          attr_accessor :openssl_verify_mode
+
+          ##
+          # When using the `:sendmail` `delivery_method` option,
+          # this may be used to specify the absolute path to `sendmail` (if needed)
+          # Example: '/usr/sbin/sendmail'
+          attr_accessor :sendmail
+
+          ##
+          # Optional arguments to pass to `sendmail`
+          # Note that this will override the defaults set by the Mail gem (currently: '-i -t')
+          # So, if set here, be sure to set all the arguments you require.
+          # Example: '-i -t -X/tmp/traffic.log'
+          attr_accessor :sendmail_args
+
+          ##
+          # When using the `:exim` `delivery_method` option,
+          # this may be used to specify the absolute path to `exim` (if needed)
+          # Example: '/usr/sbin/exim'
+          attr_accessor :exim
+
+          ##
+          # Optional arguments to pass to `exim`
+          # Note that this will override the defaults set by the Mail gem (currently: '-i -t')
+          # So, if set here, be sure to set all the arguments you require.
+          # Example: '-i -t -X/tmp/traffic.log'
+          attr_accessor :exim_args
+
+          ##
+          # Folder where mail will be kept when using the `:file` `delivery_method` option.
+          # Default location is '$HOME/backup-mails'
+          # Example: '/tmp/test-mails'
+          attr_accessor :mail_folder
+
+        end
+      end
+    end
+  end
+end

data/lib/checkup/configuration/service/base.rb

@@ -0,0 +1,10 @@
+module Checkup
+  module Configuration
+    module Service
+      class Base < Configuration::Base
+        class << self
+        end
+      end
+    end
+  end
+end

data/lib/checkup/configuration/service/http.rb

@@ -0,0 +1,14 @@
+module Checkup
+  module Configuration
+    module Service
+      class Http < Base
+        class << self
+          attr_accessor :url
+          attr_accessor :method
+          attr_accessor :expected_code
+          attr_accessor :expected_response
+        end
+      end
+    end
+  end
+end

data/lib/checkup/dependency.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Checkup
+  # Small dependency loader, so we don't have to require all possible gems in the Gemfile
+  class Dependency  
+    def self.all
+      @all ||= {
+        'mail' => {
+          :require => 'mail',
+          :version => '>= 2.4.0',
+          :for     => 'Sending Emails (Mail Notifier)'
+        },
+        'httparty' => {
+          :require => 'httparty',
+          :version => '>= 0',
+          :for     => 'Http up check'
+        }
+      }
+    end
+    
+    def self.load (name)
+      begin
+        gem(name, all[name][:version])
+        require(all[name][:require])
+      rescue LoadError
+        Logger.error Errors::Dependency::LoadError.new(<<-EOS)
+          Dependency missing
+          Dependency required for:
+          #{all[name][:for]}
+          To install the gem, issue the following command:
+          > gem install #{name} -v '#{all[name][:version]}'
+          Please try again after installing the missing dependency.
+        EOS
+        exit 1
+      end
+    end
+  end
+end

data/lib/checkup/errors.rb

@@ -0,0 +1,80 @@
+module Checkup
+  # when included, automatically creates new Exceptions depending on the Const passed in
+  module ErrorsHelper
+    def const_missing(const)
+      if const.to_s.end_with?('Error')
+        module_eval("class #{const} < Checkup::Errors::Error; end")
+      else
+        module_eval("module #{const}; extend Checkup::ErrorsHelper; end")
+      end
+      const_get(const)
+    end
+  end
+  
+  module Errors
+    extend ErrorsHelper
+    
+    class Error < StandardError
+    
+      def self.wrap(orig_err, msg = nil)
+        new(msg, orig_err)
+      end
+
+      def initialize(msg = nil, orig_err = nil)
+        super(msg)
+        set_backtrace(orig_err.backtrace) if @orig_err = orig_err
+      end
+
+      def to_s
+        return @to_s if @to_s
+        orig_to_s = super()
+
+        if orig_to_s == self.class.to_s
+          msg = orig_err_msg ?
+              "#{orig_err_class}: #{orig_err_msg}" : orig_err_class
+        else
+          msg = format_msg(orig_to_s)
+          msg << "\n  Reason: #{orig_err_class}" + (orig_err_msg ?
+              "\n  #{orig_err_msg}" : ' (no message given)') if @orig_err
+        end
+
+        @to_s = msg ? msg_prefix + msg : class_name
+      end
+
+      private
+
+      def msg_prefix
+        @msg_prefix ||= class_name + ': '
+      end
+
+      def orig_msg
+        @orig_msg ||= to_s.sub(msg_prefix, '')
+      end
+
+      def class_name
+        @class_name ||= self.class.to_s.sub('Checkup::Errors::', '')
+      end
+
+      def orig_err_class
+        return unless @orig_err
+
+        @orig_err_class ||= @orig_err.is_a?(Errors::Error) ?
+            @orig_err.send(:class_name) : @orig_err.class.to_s
+      end
+
+      def orig_err_msg
+        return unless @orig_err
+        return @orig_err_msg unless @orig_err_msg.nil?
+
+        msg = @orig_err.is_a?(Errors::Error) ?
+            @orig_err.send(:orig_msg) : @orig_err.to_s
+        @orig_err_msg = (msg == orig_err_class) ?
+            false : format_msg(msg)
+      end
+
+      def format_msg(msg)
+        msg.gsub(/^ */, '  ').strip
+      end
+    end
+  end
+end

data/lib/checkup/logger.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module Checkup
+  module Logger
+    class << self
+
+      attr_accessor :quiet
+
+      ##
+      # Outputs a messages to the console and writes it to the backup.log
+      def message(string)
+        to_console  loggify(string, :message, :green)
+        to_file     loggify(string, :message)
+      end
+
+      ##
+      # Outputs an error to the console and writes it to the backup.log
+      # Called when an Exception has caused the backup process to abort.
+      def error(string)
+        @has_errors = true
+        to_console  loggify(string, :error,   :red), true
+        to_file     loggify(string, :error)
+      end
+
+      ##
+      # Outputs a notice to the console and writes it to the backup.log
+      # Sets #has_warnings? true so :on_warning notifications will be sent
+      def warn(string)
+        @has_warnings = true
+        to_console  loggify(string, :warning, :yellow), true
+        to_file     loggify(string, :warning)
+      end
+
+      # Outputs the data as if it were a regular 'puts' command,
+      # but also logs it to the backup.log
+      def normal(string)
+        to_console  loggify(string)
+        to_file     loggify(string)
+      end
+
+      ##
+      # Silently logs data to the log file
+      def silent(string)
+        to_file     loggify(string, :silent)
+      end
+
+      ##
+      # Returns an Array of all messages written to the log file for this session
+      def messages
+        @messages ||= []
+      end
+      
+      def has_errors?
+        @has_errors ||= false
+      end
+
+      ##
+      # Returns true if any warnings have been issued
+      def has_warnings?
+        @has_warnings ||= false
+      end
+
+      def clear!
+        messages.clear
+        @has_warnings = false
+      end
+
+      def truncate!(max_bytes = 500_000)
+        log_file = File.join(Config.log_path, 'checkup.log')
+        return unless File.exist?(log_file)
+
+        if File.stat(log_file).size > max_bytes
+          FileUtils.mv(log_file, log_file + '~')
+          File.open(log_file + '~', 'r') do |io_in|
+            File.open(log_file, 'w') do |io_out|
+              io_in.seek(-max_bytes, IO::SEEK_END) && io_in.gets
+              while line = io_in.gets
+                io_out.puts line
+              end
+            end
+          end
+          FileUtils.rm_f(log_file + '~')
+        end
+      end
+
+      private
+
+      ##
+      # Returns the time in [YYYY/MM/DD HH:MM:SS] format
+      def time
+        Time.now.strftime("%Y/%m/%d %H:%M:%S")
+      end
+
+      ##
+      # Receives a String, or an Object that responds to #to_s (e.g. an
+      # Exception), from one of the messaging methods and converts it into an
+      # Array of Strings, split on newline separators. Each line is then
+      # formatted into a log format based on the given options, and the Array
+      # returned to be passed to to_console() and/or to_file().
+      def loggify(string, type = false, color = false)
+        lines = string.to_s.split("\n")
+        if type
+          type = send(color, type) if color
+          time_now = time
+          lines.map {|line| "[#{time_now}][#{type}] #{line}" }
+        else
+          lines
+        end
+      end
+
+      ##
+      # Receives an Array of Strings to be written to the console.
+      def to_console(lines, stderr = false)
+        return if quiet
+        lines.each {|line| stderr ? Kernel.warn(line) : puts(line) }
+      end
+
+      ##
+      # Receives an Array of Strings to be written to the log file.
+      def to_file(lines)
+       # File.open(File.join(Config.log_path, 'checkup.log'), 'a') do |file|
+       #   lines.each {|line| file.puts line }
+       # end
+       # messages.push(*lines)
+      end
+
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "32" (for green)
+      def green(string)
+        colorize(string, 32)
+      end
+
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "33" (for yellow)
+      def yellow(string)
+        colorize(string, 33)
+      end
+
+      ##
+      # Invokes the #colorize method the with provided string
+      # and the color code "31" (for red)
+      def red(string)
+        colorize(string, 31)
+      end
+
+      ##
+      # Wraps the provided string in colorizing tags to provide
+      # easier to view output to the client
+      def colorize(string, code)
+        "\e[#{code}m#{string}\e[0m"
+      end
+
+    end
+  end
+end

data/lib/checkup/model.rb

@@ -0,0 +1,119 @@
+module Checkup
+  class Model
+    class << self
+      def all
+        @all ||= []
+      end
+
+      def find(trigger)
+        trigger = trigger.to_s
+        all.each do |model|
+          return model if model.trigger == trigger
+        end
+        raise Errors::Model::MissingTriggerError,
+            "Could not find trigger '#{trigger}'."
+      end
+
+      def find_matching(trigger)
+        regex = /^#{ trigger.to_s.gsub('*', '(.*)') }$/
+        all.select {|model| regex =~ model.trigger }
+      end
+    end
+  
+    attr_reader :trigger
+    attr_reader :description
+  
+  
+    def initialize(trigger, description, &block)
+      @trigger = trigger.to_s
+      @description = description.to_s
+      @started_at = Time.now
+      
+      @services = []
+      @notifiers = []
+      
+      instance_eval(&block) if block_given?
+      Model.all << self
+    end
+    
+    def service(name, &block)
+      @services << get_class_from_scope(Service, name).new(self, &block)
+    end
+    
+    def notify_with(name, &block)
+      @notifiers << get_class_from_scope(Notifier, name).new(self, &block)
+    end
+    
+    def perform!
+      log!(:started)
+    
+      
+      @services.each do |service|
+        service_result = true
+        begin
+          Logger.message "Starting service #{service.identifier}"
+          service_result &&= service.perform!
+        rescue StandardError => e
+          service_result = false
+          self.notify! :error, service, "#{service.identifier}: #{e.message}"
+          Logger.error e.message
+        end
+        
+        message = "Finished service #{service.identifier}"
+        
+        if !service_result
+          message += " (with errors)"
+          Logger.error message
+        else
+          Logger.message message
+        end
+        
+      end      
+      
+      log!(:finished)
+    end
+    
+    def get_class_from_scope(scope, name)
+      klass = scope
+      name = name.to_s.sub(/^Checkup::Config::/, '')
+      name.split('::').each do |chunk|
+        klass = klass.const_get(chunk)
+      end
+      klass
+    end
+    
+    def log!(action)
+      case action
+      when :started
+        Logger.message "Started model '(#{trigger})'!\n" +
+            "[ checkup #{ Version.current } : #{ RUBY_DESCRIPTION } ]"
+
+      when :finished
+        msg = "Finished '(#{ trigger })' " +
+              "Completed %s in #{ elapsed_time }"
+        if Logger.has_warnings?
+          Logger.warn msg % 'Successfully (with Warnings)'
+        elsif Logger.has_errors?
+          Logger.error msg % 'with errors'
+        else
+          Logger.message msg % 'Successfully'
+        end
+      end
+    end
+    
+    def notify! (status, origin, message)
+      @notifiers.each do |notifier|
+        notifier.notify! status, origin, message
+      end
+    end
+
+    def elapsed_time
+      duration  = Time.now.to_i - @started_at.to_i
+      hours     = duration / 3600
+      remainder = duration - (hours * 3600)
+      minutes   = remainder / 60
+      seconds   = remainder - (minutes * 60)
+      '%02d:%02d:%02d' % [hours, minutes, seconds]
+    end
+  end
+end

data/lib/checkup/notifier/base.rb

@@ -0,0 +1,26 @@
+module Checkup
+  module Notifier
+    class Base
+      include Checkup::Configuration::Helpers
+      
+      attr_accessor :on_success
+      alias :notify_on_success? :on_success
+      
+      attr_accessor :on_warning
+      alias :notify_on_warning? :on_warning
+
+      attr_accessor :on_failure
+      alias :notify_on_failure? :on_failure
+    
+      def initialize(model)
+        @model = model
+        load_defaults!
+        
+        yield self
+      end
+      
+      def perform!
+      end      
+    end
+  end
+end

data/lib/checkup/notifier/mail.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+
+Checkup::Dependency.load('mail')
+
+module Checkup
+  module Notifier
+    class Mail < Base
+
+      ##
+      # Mail delivery method to be used by the Mail gem.
+      # Supported methods:
+      #
+      # `:smtp` [::Mail::SMTP] (default)
+      # : Settings used only by this method:
+      # : `address`, `port`, `domain`, `user_name`, `password`
+      # : `authentication`, `enable_starttls_auto`, `openssl_verify_mode`
+      #
+      # `:sendmail` [::Mail::Sendmail]
+      # : Settings used only by this method:
+      # : `sendmail`, `sendmail_args`
+      #
+      # `:exim` [::Mail::Exim]
+      # : Settings used only by this method:
+      # : `exim`, `exim_args`
+      #
+      # `:file` [::Mail::FileDelivery]
+      # : Settings used only by this method:
+      # : `mail_folder`
+      #
+      attr_accessor :delivery_method
+
+      ##
+      # 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
+
+      ##
+      # OpenSSL Verify Mode
+      # Example: none - Only use this option for a self-signed and/or wildcard certificate
+      attr_accessor :openssl_verify_mode
+
+      ##
+      # When using the `:sendmail` `delivery_method` option,
+      # this may be used to specify the absolute path to `sendmail` (if needed)
+      # Example: '/usr/sbin/sendmail'
+      attr_accessor :sendmail
+
+      ##
+      # Optional arguments to pass to `sendmail`
+      # Note that this will override the defaults set by the Mail gem (currently: '-i -t')
+      # So, if set here, be sure to set all the arguments you require.
+      # Example: '-i -t -X/tmp/traffic.log'
+      attr_accessor :sendmail_args
+
+      ##
+      # When using the `:exim` `delivery_method` option,
+      # this may be used to specify the absolute path to `exim` (if needed)
+      # Example: '/usr/sbin/exim'
+      attr_accessor :exim
+
+      ##
+      # Optional arguments to pass to `exim`
+      # Note that this will override the defaults set by the Mail gem (currently: '-i -t')
+      # So, if set here, be sure to set all the arguments you require.
+      # Example: '-i -t -X/tmp/traffic.log'
+      attr_accessor :exim_args
+
+      ##
+      # Folder where mail will be kept when using the `:file` `delivery_method` option.
+      # Default location is '$HOME/Backup/emails'
+      # Example: '/tmp/test-mails'
+      attr_accessor :mail_folder
+
+      def initialize(model, &block)
+        super(model)
+
+        instance_eval(&block) if block_given?
+      end
+
+      def notify!(status, origin, message)
+        email = new_email
+        email.subject = "[Checkup::#{status}] #{@model.trigger}"
+        template = Checkup::Template.new ({ :origin => origin, :message => message })
+        email.body    = template.result('notifier/mail/%s.erb' % status.to_s)
+
+        email.deliver!
+      end
+      
+      private
+
+      ##
+      # Configures the Mail gem by setting the defaults.
+      # Creates and returns a new email, based on the @delivery_method used.
+      def new_email
+        method = %w{ smtp sendmail exim file test }.
+            index(@delivery_method.to_s) ? @delivery_method.to_s : 'smtp'
+
+        options =
+            case method
+            when 'smtp'
+              { :address              => @address,
+                :port                 => @port,
+                :domain               => @domain,
+                :user_name            => @user_name,
+                :password             => @password,
+                :authentication       => @authentication,
+                :enable_starttls_auto => @enable_starttls_auto,
+                :openssl_verify_mode  => @openssl_verify_mode }
+            when 'sendmail'
+              opts = {}
+              opts.merge!(:location  => File.expand_path(@sendmail)) if @sendmail
+              opts.merge!(:arguments => @sendmail_args) if @sendmail_args
+              opts
+            when 'exim'
+              opts = {}
+              opts.merge!(:location  => File.expand_path(@exim)) if @exim
+              opts.merge!(:arguments => @exim_args) if @exim_args
+              opts
+            when 'file'
+              @mail_folder ||= File.join(Config.root_path, 'emails')
+              { :location => File.expand_path(@mail_folder) }
+            when 'test' then {}
+            end
+
+        ::Mail.defaults do
+          delivery_method method.to_sym, options
+        end
+
+        email = ::Mail.new
+        email.to   = @to
+        email.from = @from
+        email
+      end
+    end
+  end
+end

data/lib/checkup/service/base.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Checkup
+  module Service
+    class Base
+      include Checkup::Configuration::Helpers
+    
+      def initialize(model)
+        @model = model
+        load_defaults!
+        
+        yield self
+      end
+      
+      def perform!
+      end
+      
+      def identifier
+      end
+      
+    end
+  end
+end

data/lib/checkup/service/http.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+Checkup::Dependency.load('httparty')
+
+module Checkup
+  module Service
+    class Http < Base
+      attr_accessor :url
+      attr_accessor :method
+      attr_accessor :expected_code
+      attr_accessor :expected_response
+      
+      def perform!
+        super
+        
+        response = ::HTTParty.send(self.method.to_sym, self.url)
+        
+        Logger.message "Got #{response.code} from #{self.url}"
+        
+        result = response.code == self.expected_code
+        
+        if !result
+          raise Checkup::Errors::Service::Http::AssertError, 
+            "Expected code #{self.expected_code}, got #{response.code}"
+        end
+        
+        if self.expected_response.is_a? Regexp
+          result &&= !!self.expected_response.match(response.body)
+          if !result
+            raise Checkup::Errors::Service::Http::RegexpError,
+              "Expected match for #{self.expected_response.to_s}"
+          end
+        else
+          result &&= self.expected_response == response.body
+            raise Checkup::Errors::Service::Http::AssertError, 
+              "Expected response #{self.expected_response}"
+        end
+        
+        return result
+      end
+      
+      def identifier
+        return "#{self.method} #{self.url}"
+      end
+    end
+  end
+end

data/lib/checkup/template.rb

@@ -0,0 +1,33 @@
+require 'erb'
+
+module Checkup
+  class Template
+   
+    attr_accessor :binding
+
+    def initialize(object = nil)
+      if object.is_a?(Binding)
+        @binding = object
+      elsif object.is_a?(Hash)
+        @binding = Checkup::Binder.new(object).get_binding
+      else
+        @binding = nil
+      end
+    end
+
+    def render(file)
+      puts result(file)
+    end
+
+    def result(file)
+      ERB.new(file_contents(file), nil, '<>').result(binding)
+    end
+
+  private
+
+    def file_contents(file)
+      File.read(File.join(Checkup::TEMPLATE_PATH, file))
+    end
+
+  end
+end

data/lib/checkup/version.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Checkup
+  class Version
+
+    ##
+    # Change the MAJOR, MINOR and PATCH constants below
+    # to adjust the version of the Backup gem
+    #
+    # MAJOR:
+    #  Defines the major version
+    # MINOR:
+    #  Defines the minor version
+    # PATCH:
+    #  Defines the patch version
+    MAJOR, MINOR, PATCH = 0, 0, 2
+
+    ##
+    # Returns the major version ( big release based off of multiple minor releases )
+    def self.major
+      MAJOR
+    end
+
+    ##
+    # Returns the minor version ( small release based off of multiple patches )
+    def self.minor
+      MINOR
+    end
+
+    ##
+    # Returns the patch version ( updates, features and (crucial) bug fixes )
+    def self.patch
+      PATCH
+    end
+
+    ##
+    # Returns the current version of the Backup gem ( qualified for the gemspec )
+    def self.current
+      "#{major}.#{minor}.#{patch}"
+    end
+
+  end
+end

data/templates/notifier/mail/error.erb

@@ -0,0 +1,3 @@
+Service "<%= @origin.identifier %>" failed with 
+
+<%= @message %>

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: checkup
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Heiko Moeller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: femaref@googlemail.com
+executables:
+- checkup
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- bin/checkup
+- checkup.gemspec
+- lib/checkup.rb
+- lib/checkup/binder.rb
+- lib/checkup/cli/utility.rb
+- lib/checkup/config.rb
+- lib/checkup/configuration/base.rb
+- lib/checkup/configuration/helpers.rb
+- lib/checkup/configuration/notifier/base.rb
+- lib/checkup/configuration/notifier/mail.rb
+- lib/checkup/configuration/service/base.rb
+- lib/checkup/configuration/service/http.rb
+- lib/checkup/dependency.rb
+- lib/checkup/errors.rb
+- lib/checkup/logger.rb
+- lib/checkup/model.rb
+- lib/checkup/notifier/base.rb
+- lib/checkup/notifier/mail.rb
+- lib/checkup/service/base.rb
+- lib/checkup/service/http.rb
+- lib/checkup/template.rb
+- lib/checkup/version.rb
+- templates/notifier/mail/error.erb
+homepage: http://rubygems.org/gems/checkup
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ''
+test_files: []