benotified 0.0.1

data/lib/be_notified/commands/size_of_file.rb

@@ -0,0 +1,34 @@
+module BeNotified
+  module Commands
+    # Extend Fixnum class and add some handy methods
+    # 
+    # For example:
+    #   size_of_file('file.log') > 4.MB
+    class ::Fixnum
+      def KB
+        self * 1000
+      end
+      
+      def MB
+         self * 1000 * 1000
+      end
+      
+      def GB
+        self * 1000 * 1000 * 1000
+      end
+    end
+    # Get size of the file
+    #
+    # file - The String with file name
+    # 
+    # For example:
+    #
+    #   size_of_file('abc.txt')
+    #
+    # Returns Integer value, size of the file
+    def size_of_file(file)
+      raise ArgumentError if ! File.exists?(file)
+      File.size(file)
+    end
+  end
+end

data/lib/be_notified/configuration.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module BeNotified
+  module Configuration
+    
+    CONFIG_FILE = "#{ENV['HOME']}/.be_notified"
+    
+    # Singleton storing configuration for this library
+    class << self
+      # Main configuration method. It merges default configuration and properties
+      # read from the configuration file. Then it does basic validation
+      #
+      # Returns Hash with options
+      def options
+        @options ||= begin
+          opts = default_options.merge!(config_file_options)
+          raise ArgumentError, "Invalid configuration options for emails #{opts}" if ! email_options_valid?(opts)
+          opts
+        end
+      end
+      
+      # Set of default options
+      #
+      # Returns Hash with default options
+      def default_options
+        {
+          :notifier_type  => BeNotified::Notifiers::Log,
+          :email          => Hash.new { |k,h| k[h] = {}}
+        }
+      end
+         
+      # Read configuration from the file.
+      #
+      # Returns options in JSON format if everything goes fine
+      # Returns empty string in case of error
+      def load_config_file
+        File.open(CONFIG_FILE).read
+      rescue Errno::ENOENT
+        ""
+      end
+      
+      # Parse options from configuration file
+      #
+      # Returns hash with options
+      # Returns empty hash in case of parse exception
+      # Returns empty hash if there were problems with reading the file
+      def config_file_options
+        # Make sure that keys are symbols
+        opts = load_config_file
+        opts == "" ? {} : JSON.parse(opts).symbolize_keys!        
+        
+      rescue JSON::ParserError => e
+        puts "Error while parsing the configuration file: #{e.message}"
+        {}
+      end
+      
+      # Validate email properties
+      #
+      # opts - Hash with options
+      #
+      # Returns true if all options exists and are not empty
+      # Returns true if notifier_type is pointing to use emails
+      def email_options_valid?(opts)
+        # We don't really care about email validation if not using emails for notifications
+        return true if ! email_notifier?(opts)
+
+        opts[:email].symbolize_keys!
+        opts[:email].key?(:smtp_address) && opts[:email][:smtp_address] != "" &&
+        opts[:email].key?(:smtp_port)    && opts[:email][:smtp_port] != "" &&
+        opts[:email].key?(:domain)       && opts[:email][:domain] != "" &&
+        opts[:email].key?(:username)     && opts[:email][:username] != "" &&
+        opts[:email].key?(:password)     && opts[:email][:password] != "" &&
+        opts[:email].key?(:to)           && opts[:email][:to] != "" &&
+        opts[:email].key?(:from)         && opts[:email][:from] != "" &&
+        opts[:email].key?(:subject)      && opts[:email][:subject] != "" 
+      end
+      
+      # When we parse configuration file, notifier_type is a String
+      # However, when we define them in the code, usually we use a class type
+      def email_notifier?(opts)
+        opts[:notifier_type] == BeNotified::Notifiers::Email || opts[:notifier_type] == "BeNotified::Notifiers::Email"
+      end
+    end
+    
+    # Easier and nicer? way for classes that include this module
+    # to access the configuration options
+    def options
+      Configuration.options
+    end
+  end
+end

data/lib/be_notified/monitor.rb

@@ -0,0 +1,77 @@
+require 'be_notified/notifier'
+require 'be_notified/commands'
+
+module BeNotified
+  class Monitor
+    # Include all available commands and configuration
+    include Commands    
+    include Configuration
+   
+    def initialize(&block)
+      # Provide a nice way of accessing methods in this class
+      instance_eval(&block)
+    end
+    
+    # Main method provided by the library
+    # Will send the message to the user when block returns true
+    # 
+    # message - The String with the message send back to user
+    # block   - Block with a THING to monitor
+    #
+    # For example:
+    #
+    #   alert_when("block returns true") { true }
+    #   
+    # Returns nothing.
+    def alert_when(message, &block)
+      if block.call == true
+        notify(message)
+      end
+    end
+    
+    # Get notifier type form configuration
+    def notifier_type
+      options[:notifier_type]
+    end
+    
+    # It is possible to define some configuraiton options
+    # directly in the code (besides configuration file)
+    #
+    # opts - The Hash with options. Currently available:
+    #                  {
+    #                    :logger_file    => Location of the file where application sends log
+    #                    :notifier_type  => Notifier type. Currenty available: BeNotified::Notifiers::Log, BeNotified::Notifiers::Email
+    #                    :email => {
+    #                      :smtp_address => SMTP address
+    #                      :smtp_port    => SMTP port
+    #                      :domain       => Domain name, eg: example.com
+    #                      :username     => Login
+    #                      :password     => Password
+    #                      :to           => Recipient
+    #                      :from         => Sender
+    #                      :subject      => Subject of the message
+    #                    }
+    #
+    # For example:
+    #   configuration({ :notifier_type => BeNotified::Notifiers::Email })
+    #
+    # Returns Hash, merged options from configuration file and defined in the class
+    def configuration(opts)
+      options.merge!(opts)
+    end
+    # Method responsible for notifing the user. Shouldn't be called directly
+    # It gets notifier_type, creates a proper notifier and notifies the user
+    # 
+    # message - The String with the message send back to user
+    #
+    # For example:
+    #
+    #   notify("too many files in this directory")
+    #
+    # Returns nothing.
+    def notify(message)
+      notifier = BeNotified::Notifier.new(notifier_type, message)
+      notifier.notify
+    end
+  end
+end

data/lib/be_notified/notifier.rb

@@ -0,0 +1,104 @@
+require 'log4r' 
+require 'action_mailer'
+
+module BeNotified
+  # Delegate notification to other classes
+  class Notifier
+    # Initializer requires two arguments:
+    #
+    #  notifier_type - String or a Class represending notifier, can be:
+    #                     BeNotified::Notifiers::Log (default)
+    #                     BeNotified::Notifiers::Email
+    #  message - The String, message send to the user
+    def initialize(notifier_type, message)
+      @notifier = notifier_type.class ===  "String" ? eval("#{notifier_type}.new") : notifier_type.new
+      @message  = message
+    end
+    
+    # This method will actually inform the user about the problem
+    #
+    # message - The String with the message that should be passed to user
+    #
+    # For example:
+    #   notify("Server is down")
+    #
+    # Returns nothing
+    def notify
+      @notifier.notify(@message)
+    end
+  end
+  
+
+  module Notifiers
+    
+    # This class will send notifications by email. 
+    # It is using ActionMailer >= 3.0.0
+    class Email
+      include BeNotified::Configuration
+      
+      # Delegated method from BeNotified::Notifier class
+      def notify(message)
+        raise ArgumentError, "You can't use Email notification when Log is set in your configuration" if options[:notifier_type] == BeNotified::Notifiers::Log
+        Mailer.logger = Logger.new(STDOUT)
+        
+        Mailer.smtp_settings = {
+          :address              => options[:email][:smtp_address],
+          :port                 => options[:email][:smtp_port].to_i,
+          :domain               => options[:email][:domain],
+          :user_name            => options[:email][:username],
+          :password             => options[:email][:password],
+          :authentication       => 'plain',
+          :enable_starttls_auto => true  }
+        
+        Mailer.email(message, options).deliver
+      end
+    
+      # Inner class responsible for sending emails
+      class Mailer < ActionMailer::Base
+        
+        def email(message, options)
+          mail_options = {
+            :to       => options[:email][:to],
+            :from     => options[:email][:from],
+            :subject  => options[:email][:subject]            
+          }
+          
+          mail(mail_options) do |format|
+            # Create the body of the message
+            format.text { render :text => "#{message}"}
+          end
+        end
+      end
+    end
+    
+    # This class will notify the user by writing the message to log
+    # Requires Log4r in any version
+    class Log
+      include Log4r
+      include BeNotified::Configuration
+      
+     # Delegated method from BeNotified::Notifier class
+      def notify(message)
+        logger.warn "#{message}"
+      end
+      
+      # This method creates logger instance. Depending on configuration it will
+      # either log to the STDOUT or to the log file.
+      #
+      # Returns instance of logger
+      def logger
+        @logger ||= begin
+          
+          logger = Logger.new 'notify_logger'
+          outputter =  options[:logger_file].nil? ? Outputter.stdout 
+                                    : FileOutputter.new('notify_logger', :filename => options[:logger_file]) 
+
+          logger.outputters << outputter                          
+          logger.level = Log4r::WARN
+          
+          logger
+        end
+      end
+    end
+  end
+end

data/lib/be_notified/version.rb

@@ -0,0 +1,3 @@
+module BeNotified
+  VERSION = "0.0.1"
+end

data/lib/benotified.rb

@@ -0,0 +1,3 @@
+$:.push File.dirname(__FILE__)
+
+require 'be_notified'

data/test/commands/test_host_not_alive.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+
+class TestHostNotAlive < Test::Unit::TestCase
+  include BeNotified::Commands
+  
+  def setup
+    @packets = 1
+  end
+  
+  def test_host_is_up
+    expects(:run_system).with('ping -c 1 example.com').returns(PING_SUCCESS)
+    assert ! host_not_alive?('example.com', @packets )
+  end
+  
+  def test_host_is_down_timeout
+    expects(:run_system).with('ping -c 1 example.com').returns(PING_FAIL)
+    assert host_not_alive?('example.com', @packets)
+  end
+  
+  PING_SUCCESS =<<-END
+64 bytes from example.com: icmp_seq=0 ttl=64 time=0.033 ms
+  END
+  
+  PING_FAIL =<<-END
+Request timeout for icmp_seq 0
+  END
+end

data/test/commands/test_number_of_files.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class TestCommands < Test::Unit::TestCase
+  include BeNotified::Commands
+  
+  def setup
+    files = mock
+    files.stubs(:each).multiple_yields('test1.rb', 'test2.rb', 'test.txt')
+    
+    Dir.stubs(:glob).returns(files)
+  end
+  
+  def test_number_of_files_in_directory
+    File.stubs(:file?).returns(true)
+    
+    assert_equal 3, number_of_files('.')
+  end
+  
+  def test_number_of_files_in_directory_with_given_mask
+    File.stubs(:file?).returns(true)
+    
+    assert_equal(2, number_of_files('.', /\.rb$/))
+  end
+  
+  def test_number_of_files_in_directory_that_doesnt_exist
+    File.stubs(:exists?).returns(false)
+    
+    assert_raise ArgumentError do
+      number_of_files('.')
+    end
+  end
+  
+  def test_number_of_files_in_directory_with_mask
+    File.stubs(:exists?).returns(true)
+    
+    assert_raise ArgumentError do
+      number_of_files('.', "")
+    end
+  end
+  
+  def test_number_of_files_returns_zero_if_there_is_no_files_in_directory
+    File.stubs(:file?).returns(false)
+    
+    assert_equal 0, number_of_files(".")
+  end
+end

data/test/commands/test_program_running.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class TestProgramRunning < Test::Unit::TestCase
+  include BeNotified::Commands
+  
+  def test_program_not_running
+    expects(:run_system).with("ps -ef | grep -i Foobar | grep -v grep").returns("")
+    assert_equal true, program_not_running?('Foobar')
+  end
+  
+  def test_program_running
+    expects(:run_system).with("ps -ef | grep -i Dock | grep -v grep").returns(PS_OUT)
+    assert_equal true, program_running?("Dock")
+  end
+    
+  def test_raising_error_on_windows
+    expects(:running_on_windows?).returns(true)
+    
+    assert_raise RuntimeError do
+      program_running?("Dock")
+    end
+  end
+  
+  PS_OUT =<<-END
+  502   101    97   0   0:08.43 ??         0:44.19 /System/Library/CoreServices/Dock.app/Contents/MacOS/Dock  
+  END
+end

data/test/commands/test_size_of_file.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class TestSizeOfFile < Test::Unit::TestCase
+  include BeNotified::Commands
+  
+  def test_file_doesnt_exist
+    File.expects(:exists?).returns(false)
+    
+    assert_raise ArgumentError do
+      size_of_file("test.txt")
+    end
+  end
+  
+  def test_file_size
+    File.expects(:exists?).returns(true)
+    File.expects(:size).returns(200)
+    
+    assert_equal(200, size_of_file("test.txt"))
+  end
+  
+  def test_file_size_in_KB
+    assert_equal(4_000, 4.KB)
+  end
+  
+  def test_file_size_in_MB
+    assert_equal(4_000_000, 4.MB)
+  end
+  
+  def test_file_size_in_GB
+    assert_equal(4_000_000_000, 4.GB)
+  end
+end