notifyme 0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+v0.1-dev
+  the first dev-version.

data/INSTALL

@@ -0,0 +1 @@
+See the README file.

data/README.rdoc

@@ -0,0 +1,30 @@
+== Introduction
+
+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
+
+gem install notifyme
+
+== Run it
+
+# run in the background
+$ notifyme_daemon start -- /path/to/notifyme_config.rb
+
+# debug (use Ctrl + C to stop it)
+$ notifyme_daemon run -- /path/to/notifyme_config.rb
+
+# stop
+$ notifyme_daemon stop
+
+== Output
+
+The output from every task's command will be processed (send to endpoint) only if the output is not empty, otherwise do noghing.
+
+== Version
+
+v 0.1-dev
+
+== Author
+
+xianhua.zhou@gmail.com

data/bin/notifyme

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'notifyme'
+
+NotifyMe::Start.run!

data/bin/notifyme_daemon

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'daemons'
+
+Daemons.run File.dirname(__FILE__) + '/notifyme', :dir_mode => :system

data/lib/notifyme/log/file.rb

@@ -0,0 +1,15 @@
+module NotifyMe
+    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
+        end
+    end
+end

data/lib/notifyme/log/mail.rb

@@ -0,0 +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
+        end
+    end
+end

data/lib/notifyme/log/stdout.rb

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

data/lib/notifyme/log.rb

@@ -0,0 +1,84 @@
+module NotifyMe
+    module Log
+        class Base
+            @logger = nil
+            @parameters = {}
+
+            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
+        end
+
+        class Logger
+            def initialize(parameters = {})
+                @parameters = parameters
+            end
+
+            protected
+            def generate(task)
+                method("to_#{task.log_format}").call task
+            end
+
+            private
+
+            def to_json(task)
+                require 'json'
+                JSON to_hash(task) 
+            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_csv(task)
+                require 'csv'
+                row = []
+                fields.each do |f|
+                    row << task.send(f)
+                end
+                CSV.generate_line row
+            end
+
+            def to_text(task)
+                output = ''
+                fields.each do |f|
+                    output << "#{f}: #{task.send(f)}\n"
+                end
+                output << "\n"
+            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

@@ -0,0 +1,85 @@
+module NotifyMe
+
+    VERSION = '0.1'
+
+    autoload :Task, 'notifyme/task'
+    autoload :Log, 'notifyme/log'
+
+    class Start
+        class << self
+
+            # log 
+            @@log_args = nil
+            @@log_format = nil
+
+            # tasks list
+            @@tasks = []
+
+            def run!
+                puts 'NotifyMe v' + NotifyMe::VERSION
+                new(ARGV[0]).run
+            end
+
+            def config(&block)
+                class_eval &block
+            end
+
+            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 log(*args)
+                @@log_args = args
+            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
+        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
+
+        def initialize(config_file)
+            require config_file
+        end
+    end
+end

data/lib/notifyme/task.rb

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

data/lib/notifyme.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'thread'
+require 'notifyme/start'

data/lib/vendor/smtp_add_tls_support.rb

@@ -0,0 +1,113 @@
+# http://happiness-is-slavery.net/wp-content/rails-plugins/smtp_add_tls_support/lib/smtp_add_tls_support.rb
+
+require 'net/smtp'
+require 'timeout'
+
+begin
+  require 'openssl'
+rescue LoadError
+end
+
+Net::SMTP.class_eval do
+
+  alias_method :old_initialize, :initialize
+  def initialize(hostname, port)
+    @usetls = @@usetls
+    old_initialize hostname, port
+  end
+
+  @@usetls = false
+
+  def self.enable_tls()
+    @@usetls = true
+  end
+
+  def self.disable_tls()
+    @@usetls = false
+  end
+
+  def self.use_tls?()
+    @@usetls
+  end
+
+  def use_tls?()
+    @usetls
+  end
+
+  def enable_tls()
+    @usetls = true
+  end
+
+  def disable_tls()
+    @usetls = false
+  end
+
+  def use_tls?()
+    @usetls
+  end
+
+  private
+  def do_start(helodomain, user, secret, authtype)
+    raise IOError 'SMTP session already started' if @started
+    check_auth_args user, secret if user or secret
+
+    sock = timeout(@open_timeout) {
+        TCPSocket.open(@address, @port)
+    }
+    @socket = Net::InternetMessageIO.new(sock)
+    @socket.read_timeout = @read_timeout
+    @socket.debug_output = nil
+
+    check_response(critical{
+        recv_response()
+    })
+    do_helo(helodomain)
+
+    if @usetls 
+      raise 'openssl is not installed' unless defined?(OpenSSL)
+      ssl = OpenSSL::SSL::SSLSocket.new(sock)
+      starttls
+      ssl.sync_close = true
+      ssl.connect
+
+      @socket = Net::InternetMessageIO.new(ssl)
+      @socket.read_timeout = @read_timeout
+      @socket.debug_output = nil
+      do_helo(helodomain)
+    end
+
+    authenticate user, secret, authtype if user
+    @started = true
+  ensure
+    @socket.close if not @started and @socket and not @socket.closed?
+  end
+
+  def do_helo(helodomain)
+    begin
+      if @esmtp
+        ehlo helodomain
+      else
+        helo helodomain
+      end
+    rescue Net::ProtocolError
+      if @esmtp
+        @esmtp = false
+        @error_occured = false
+        retry
+      end
+      raise
+    end
+  end
+
+  def starttls
+    getok('STARTTLS')
+  end
+
+  def quit
+    begin
+      getok('QUIT')
+    rescue EOFError
+      # gmail sucks
+    end
+  end
+end

data/notifyme_config.rb

@@ -0,0 +1,46 @@
+class MyTask
+    def call
+        Time.now.to_s
+    end
+end
+
+
+NotifyMe::Start.config do
+
+    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'
+
+=end
+    # log :file, '/tmp/test.txt'
+    # log :stdout
+    # log :mail, :to_email => 'to@email.com'
+
+    # :csv, :text, :xml, :json
+    log_format :json 
+
+
+    # add some tasks
+
+    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
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: notifyme
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- xianhua.zhou
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-10 00:00:00 +08:00
+default_executable: notifyme_daemon
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id002
+description: NotifyMe takes care more than one tasks and process their results for you, it's similar to the *NIX's cronjob.
+email: xianhua.zhou@gmail.com
+executables: 
+- notifyme_daemon
+- notifyme
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- 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/vendor/smtp_add_tls_support.rb
+- lib/notifyme.rb
+- README.rdoc
+- CHANGELOG
+- INSTALL
+- notifyme_config.rb
+- bin/notifyme
+- bin/notifyme_daemon
+has_rdoc: true
+homepage: http://github.com/xianhuazhou/NotifyMe
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: notifyme
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: It's a kind of cronjob.
+test_files: []
+