notifyme 0.1 → 0.2

data/CHANGELOG

@@ -1,2 +1,5 @@
+v0.2
+  auto restart the service by the restart_command if it's failed
+
 v0.1-dev
   the first dev-version.

data/README.rdoc

@@ -2,28 +2,35 @@
 
 NotifyMe is a script running as a cronjob in background,  can take care more than one tasks (by Ruby Threads), and push the result to different endpoints(stdout, mail, file etc.) with different formats such as xml, json, csv etc. depends on what's you need.
 
-== Instalation
+== Installation
 
 gem install notifyme
 
 == Run it
 
 # run in the background
-$ notifyme_daemon start -- /path/to/notifyme_config.rb
+
+$ notifyme_daemon start --(double dash here) /path/to/notifyme_config.rb
 
 # debug (use Ctrl + C to stop it)
-$ notifyme_daemon run -- /path/to/notifyme_config.rb
+
+$ notifyme_daemon run --(double dash here) /path/to/notifyme_config.rb
 
 # stop
+
 $ notifyme_daemon stop
 
+== Example
+
+Please check the notifyme_config.rb file.
+
 == Output
 
-The output from every task's command will be processed (send to endpoint) only if the output is not empty, otherwise do noghing.
+The output from every task's command will be processed (send to endpoint) only if the output is not empty, otherwise do nothing.
 
 == Version
 
-v 0.1-dev
+v 0.2
 
 == Author
 

data/lib/notifyme/log/file.rb

@@ -1,15 +1,15 @@
 module NotifyMe
-    module Log
-        class File < Logger
-            def <<(task)
-                file_path = @parameters.is_a?(String) ? 
-                    @parameters : @parameters[:path]
+  module Log
+    class File < Logger
+      def <<(task)
+        file_path = @parameters.is_a?(String) ? 
+          @parameters : @parameters[:path]
 
-                ::File.open(file_path, 'a') do |f|
-                    f.write generate(task)
-                    f.write "\n"
-                end
-            end
+        ::File.open(file_path, 'a') do |f|
+          f.write generate(task)
+          f.write "\n"
         end
+      end
     end
+  end
 end

data/lib/notifyme/log/mail.rb

@@ -1,61 +1,61 @@
 module NotifyMe
-    module Log
-        class Mail < Logger
-            def <<(task)
-                require 'vendor/smtp_add_tls_support.rb'
-
-                param = @parameters
-                param = {} unless param.is_a?(Hash)
-
-                # some default settings
-
-                default_host = 'localhost'
-                if param[:tls]
-                    default_port = 587
-                    Net::SMTP.enable_tls
-                else
-                    default_port = 25
-                    Net::SMTP.disable_tls
-                end
-
-                default_from_email = 'notifyme@' + default_host
-
-                param[:subject] = "NotifyMe report: %s" 
-                param[:subject] = param[:subject] % task.name
-
-                param[:from_email] ||= param[:account]
-                param[:from_email] ||= default_from_email
-
-                param[:body] = param[:body_header].to_s + 
-                    generate(task) +
-                    param[:body_footer].to_s
-
-                smtp = Net::SMTP.new(
-                    (param[:address] || param[:host]) || default_host, 
-                    param[:port] || default_port
-                )
-
-                # go go go!
-                smtp.start(param[:helo_domain] || default_host, 
-                           param[:account], 
-                           param[:password], 
-                           param[:authtype] || :plain) do |mail|
-                    mail.send_message message(param, task), param[:from_email], param[:to_email]
-                end
-            end
-
-            private
-            def message(param, task)
-                time = Time.now
-                "From: #{param[:from_name] || param[:from_email]} <#{param[:from_email]}>\r\n" \
-                << "To: #{param[:to_name] || param[:to_email]} <#{param[:to_email]}>\r\n" \
-                << "Subject: #{param[:subject]}\r\n" \
-                << "Date: #{time.to_s}\r\n" \
-                << "Content-type: text/plain; charset=UTF-8\r\n" \
-                << "Message-Id: <notifyme.#{task.name}.#{time.to_i}@example.com>\r\n" \
-                << "\r\n" \
-                    << param[:body]
-            end
+  module Log
+    class Mail < Logger
+      def <<(task)
+        require 'vendor/smtp_add_tls_support.rb'
+
+        param = @parameters
+        param = {} unless param.is_a?(Hash)
+
+        # some default settings
+
+        default_host = 'localhost'
+        if param[:tls]
+          default_port = 587
+          Net::SMTP.enable_tls
+        else
+          default_port = 25
+          Net::SMTP.disable_tls
         end
+
+        default_from_email = 'notifyme@' + default_host
+
+        param[:subject] = "NotifyMe report: %s" 
+        param[:subject] = param[:subject] % task.name
+
+        param[:from_email] ||= param[:account]
+        param[:from_email] ||= default_from_email
+
+        param[:body] = param[:body_header].to_s + 
+          generate(task) +
+          param[:body_footer].to_s
+
+        smtp = Net::SMTP.new(
+          (param[:address] || param[:host]) || default_host, 
+          param[:port] || default_port
+        )
+
+        # go go go!
+        smtp.start(param[:helo_domain] || default_host, 
+                   param[:account], 
+                   param[:password], 
+                   param[:authtype] || :plain) do |mail|
+          mail.send_message message(param, task), param[:from_email], param[:to_email]
+                   end
+      end
+
+      private
+      def message(param, task)
+        time = Time.now
+        "From: #{param[:from_name] || param[:from_email]} <#{param[:from_email]}>\r\n" \
+        << "To: #{param[:to_name] || param[:to_email]} <#{param[:to_email]}>\r\n" \
+        << "Subject: #{param[:subject]}\r\n" \
+        << "Date: #{time.to_s}\r\n" \
+        << "Content-type: text/plain; charset=UTF-8\r\n" \
+          << "Message-Id: <notifyme.#{task.name}.#{time.to_i}@example.com>\r\n" \
+        << "\r\n" \
+          << param[:body]
+      end
     end
+  end
 end

data/lib/notifyme/log/stdout.rb

@@ -1,10 +1,10 @@
 module NotifyMe
-    module Log
-        class Stdout < Logger
-            def <<(task)
-                puts generate(task)
-                puts
-            end
-        end
+  module Log
+    class Stdout < Logger
+      def <<(task)
+        puts generate(task)
+        puts
+      end
     end
+  end
 end

data/lib/notifyme/log.rb

@@ -1,84 +1,84 @@
 module NotifyMe
-    module Log
-        class Base
-            @logger = nil
-            @parameters = {}
+  module Log
+    class Base
+      @logger = nil
+      @parameters = {}
 
-            def initialize(args)
-                @logger = args.first.to_s.downcase
-                @parameters = args.last
-            end
+      def initialize(args)
+        @logger = args.first.to_s.downcase
+        @parameters = args.last
+      end
 
-            def logger
-                begin
-                    require "notifyme/log/#{@logger}.rb"
-                rescue Exception => e
-                end
-                NotifyMe::Log.const_get(@logger.capitalize).new @parameters
-            end
-
-            def self.default
-                require 'notifyme/log/stdout.rb'
-                NotifyMe::Log::Stdout.new 
-            end
+      def logger
+        begin
+          require "notifyme/log/#{@logger}.rb"
+        rescue Exception => e
         end
+        NotifyMe::Log.const_get(@logger.capitalize).new @parameters
+      end
 
-        class Logger
-            def initialize(parameters = {})
-                @parameters = parameters
-            end
+      def self.default
+        require 'notifyme/log/stdout.rb'
+        NotifyMe::Log::Stdout.new 
+      end
+    end
 
-            protected
-            def generate(task)
-                method("to_#{task.log_format}").call task
-            end
+    class Logger
+      def initialize(parameters = {})
+        @parameters = parameters
+      end
 
-            private
+      protected
+      def generate(task)
+        method("to_#{task.log_format}").call task
+      end
 
-            def to_json(task)
-                require 'json'
-                JSON to_hash(task) 
-            end
+      private
 
-            def to_xml(task)
-                require 'rexml/document'
-                xml = REXML::Element.new 'task'
-                fields.each do |f|
-                    el = REXML::Element.new f.to_s
-                    el.text = task.send(f)
-                    xml.add_element el
-                end
-                xml.to_s
-            end
+      def to_json(task)
+        require 'json'
+        JSON to_hash(task) 
+      end
 
-            def to_csv(task)
-                require 'csv'
-                row = []
-                fields.each do |f|
-                    row << task.send(f)
-                end
-                CSV.generate_line row
-            end
+      def to_xml(task)
+        require 'rexml/document'
+        xml = REXML::Element.new 'task'
+        fields.each do |f|
+          el = REXML::Element.new f.to_s
+          el.text = task.send(f)
+          xml.add_element el
+        end
+        xml.to_s
+      end
 
-            def to_text(task)
-                output = ''
-                fields.each do |f|
-                    output << "#{f}: #{task.send(f)}\n"
-                end
-                output << "\n"
-            end
+      def to_csv(task)
+        require 'csv'
+        row = []
+        fields.each do |f|
+          row << task.send(f)
+        end
+        CSV.generate_line row
+      end
 
-            def to_hash(task)
-                hash = {}
-                fields.each do |f|
-                    hash[f] = task.send(f)
-                end
-                hash
-            end
+      def to_text(task)
+        output = ''
+        fields.each do |f|
+          output << "#{f}: #{task.send(f)}\n"
+        end
+        output << "\n"
+      end
 
-            def fields
-                [:name, :sleep_time, :start_run_time, :end_run_time, :result]
-            end
+      def to_hash(task)
+        hash = {}
+        fields.each do |f|
+          hash[f] = task.send(f)
         end
+        hash
+      end
+
+      def fields
+        [:name, :sleep_time, :start_run_time, :end_run_time, :result]
+      end
     end
+  end
 end

data/lib/notifyme/start.rb

@@ -1,85 +1,94 @@
 module NotifyMe
 
-    VERSION = '0.1'
+  VERSION = '0.1'
 
-    autoload :Task, 'notifyme/task'
-    autoload :Log, 'notifyme/log'
+  autoload :Task, 'notifyme/task'
+  autoload :Log, 'notifyme/log'
 
-    class Start
-        class << self
+  class Start
+    class << self
 
-            # log 
-            @@log_args = nil
-            @@log_format = nil
+      # log 
+      @@log_args = nil
+      @@log_format = nil
 
-            # tasks list
-            @@tasks = []
+      # tasks list
+      @@tasks = []
 
-            def run!
-                puts 'NotifyMe v' + NotifyMe::VERSION
-                new(ARGV[0]).run
-            end
+      def run!
+        puts 'NotifyMe v' + NotifyMe::VERSION
+        new(ARGV[0]).run
+      end
 
-            def config(&block)
-                class_eval &block
-            end
+      def config(&block)
+        class_eval &block
+      end
 
-            private
+      private
 
-            def task(name)
-                raise 'Invalid task calls' unless block_given?
-                task = Task.new
-                task.name = name
-                task.logger ||= NotifyMe::Log::Base.new(@@log_args).logger
-                task.log_format ||= @@log_format
-                yield task
-                @@tasks << task
-            end
+      def task(name)
+        raise 'Invalid task calls' unless block_given?
+        task = Task.new
+        task.name = name
+        task.logger ||= NotifyMe::Log::Base.new(@@log_args).logger
+        task.log_format ||= @@log_format
+        yield task
+        @@tasks << task
+      end
 
-            def log(*args)
-                @@log_args = args
-            end
+      def log(*args)
+        @@log_args = args
+      end
 
-            def log_format(format)
-                @@log_format = format
-            end
-        end
+      def log_format(format)
+        @@log_format = format
+      end
+    end
 
-        def run
-            tasks_thread = []
-            @mutex = Mutex.new
-            @@tasks.each do |task|
-                tasks_thread << Thread.new(task) do
-                    loop do
-                        Thread.current[:name] = task.name
-                        sleep task.sleep_time
-                        run_task(task) if task.command.respond_to? :call
-                    end
-                end
-            end
-
-            tasks_thread.each do |t| t.join end
+    def run
+      tasks_thread = []
+      @mutex = Mutex.new
+      @@tasks.each do |task|
+        tasks_thread << Thread.new(task) do
+          loop do
+            Thread.current[:name] = task.name
+            sleep task.sleep_time
+            run_task(task) if task.command.respond_to? :call
+          end
         end
+      end
 
-        private
-
-        def run_task(task)
-            begin
-                task.start_run_time = Time.now.to_i
-                task.result = task.command.call
-                task.end_run_time = Time.now.to_i
-            rescue Exception => e
-                task.result = e.to_s
-            end
-            unless task.result.to_s.empty?
-                @mutex.synchronize do 
-                    task.logger << task
-                end
-            end
-        end
+      tasks_thread.each do |t| t.join end
+    end
+
+    private
 
-        def initialize(config_file)
-            require config_file
+    def run_task(task)
+      begin
+        task.start_run_time = Time.now.to_i
+        task.result = task.command.call
+        task.end_run_time = Time.now.to_i
+      rescue Exception => e
+        task.result = e.to_s
+      end
+
+      # works fine.
+      return if task.result.to_s.empty?
+
+      # restart the command if need
+      task.restart_command.call if task.restart_command
+
+      @mutex.synchronize do 
+        begin
+          task.logger << task
+        rescue Exception =>  e
+          puts e.backtrace.join("\n")
         end
+      end
+    end
+
+    def initialize(config_file)
+      require config_file
     end
+  end
 end

data/lib/notifyme/task.rb

@@ -1,22 +1,28 @@
 module NotifyMe
-    class Task
-        attr_accessor :name, :sleep_time, :start_run_time, :end_run_time,
-            :logger, :command, :result,
-            :log_format
+  class Task
+    attr_accessor :name, :sleep_time, :start_run_time, :end_run_time,
+      :logger, :command, :restart_command, :result,
+      :log_format
 
-        def command=(cmd)
-            return if cmd.nil?
+    def restart_command=(cmd)
+      @restart_command = get_command(cmd)
+    end
+
+    def command=(cmd)
+      @command = get_command(cmd)
+    end
+
+    private
+    def get_command(cmd)
+      return if cmd.nil?
 
-            unless cmd.is_a?(Proc)
-                cmd = cmd.new if cmd.class.is_a?(Class)
-            end
+      unless cmd.is_a? Proc
+        cmd = cmd.new if cmd.class.is_a?(Class)
+      end
 
-            if cmd.respond_to? :call
-                @command = cmd
-                return
-            end
+      return cmd if cmd.respond_to? :call
 
-            raise 'Invalid command parameter'
-        end
+      raise 'Invalid command parameter'
     end
+  end
 end

data/lib/vendor/smtp_add_tls_support.rb

@@ -52,14 +52,14 @@ Net::SMTP.class_eval do
     check_auth_args user, secret if user or secret
 
     sock = timeout(@open_timeout) {
-        TCPSocket.open(@address, @port)
+      TCPSocket.open(@address, @port)
     }
     @socket = Net::InternetMessageIO.new(sock)
     @socket.read_timeout = @read_timeout
     @socket.debug_output = nil
 
     check_response(critical{
-        recv_response()
+      recv_response()
     })
     do_helo(helodomain)
 

data/notifyme_config.rb

@@ -1,46 +1,44 @@
 class MyTask
-    def call
-        Time.now.to_s
-    end
+  def call
+    Time.now.to_s
+  end
 end
 
-
 NotifyMe::Start.config do
-
-    log :stdout
+  log :stdout
 
 =begin
-    log :mail, 
-        :host => 'smtp.gmail.com',
-        :helo_domain => 'gmail.com',
-        :tls => true,
-
-        :account => 'xxx@gmail.com', 
-        :password => '***',
-
-        :from_email => 'from@gmail.com',
-        :from_name => 'from name',
-        :to_email => 'to@gmail.com',
-        :to_name => 'to name'
-
+  log :mail, 
+    :host => 'smtp.gmail.com',
+    :helo_domain => 'gmail.com',
+    :tls => true,
+
+    :account => 'xxx@gmail.com', 
+    :password => '***',
+
+    :from_email => 'from@gmail.com',
+    :from_name => 'from name',
+    :to_email => 'to@gmail.com',
+    :to_name => 'to name'
 =end
-    # log :file, '/tmp/test.txt'
-    # log :stdout
-    # log :mail, :to_email => 'to@email.com'
 
-    # :csv, :text, :xml, :json
-    log_format :json 
+  # log :file, '/tmp/test.txt'
+  # log :stdout
+  # log :mail, :to_email => 'to@email.com'
 
+  # :csv, :text, :xml, :json
+  log_format :json 
 
-    # add some tasks
+  # add some tasks
 
-    task :checking_disk do |t|
-        t.sleep_time = 1
-        t.command = Proc.new { %x{df -h} }
-    end
+  task :checking_disk do |t|
+    t.sleep_time = 1
+    t.command = Proc.new { %x{df -h} }
+  end
 
-    task :checking_http do |t|
-        t.sleep_time = 2
-        t.command = MyTask
-    end
+  task :checking_http do |t|
+    t.sleep_time = 2
+    t.command = MyTask
+    t.restart_command = lambda { puts "restarted !" }
+  end
 end

metadata

@@ -1,12 +1,11 @@
 --- !ruby/object:Gem::Specification 
 name: notifyme
 version: !ruby/object:Gem::Version 
-  hash: 9
   prerelease: false
   segments: 
   - 0
-  - 1
-  version: "0.1"
+  - 2
+  version: "0.2"
 platform: ruby
 authors: 
 - xianhua.zhou
@@ -14,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-10 00:00:00 +08:00
+date: 2010-11-06 00:00:00 +08:00
 default_executable: notifyme_daemon
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,7 +24,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
         segments: 
         - 1
         - 1
@@ -41,7 +39,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 1
         - 4
@@ -59,12 +56,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/notifyme/task.rb
 - lib/notifyme/start.rb
-- lib/notifyme/log.rb
 - lib/notifyme/log/mail.rb
 - lib/notifyme/log/file.rb
 - lib/notifyme/log/stdout.rb
-- lib/notifyme/task.rb
+- lib/notifyme/log.rb
 - lib/vendor/smtp_add_tls_support.rb
 - lib/notifyme.rb
 - README.rdoc
@@ -87,7 +84,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -96,7 +92,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"