chore 0.2.0

data/bin/chore-client

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'chore'
+require 'chore/constants'
+require 'trollop'
+
+opts = Trollop::options do
+  banner "chore-client"
+
+  opt :host, "host name of chore-server", :default => 'localhost'
+  opt :port, "port of chore-server", :default => Chore::Constants::DEFAULT_LISTEN_PORT
+
+  opt :chore, "name of chore", :type => :string
+  opt :action, "action (start, finish, status, fail, etc)", :type => :string
+end
+
+Trollop::die :chore, "chore name required" if !opts[:chore]
+Trollop::die :action, "action required" if !opts[:action]
+
+server = opts[:host]
+port = opts[:port]
+
+Chore.set_server(server, port)
+
+Chore.public_method(opts[:action]).call(opts[:chore])

data/bin/chore-server

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'chore'
+require 'chore/server'
+require 'chore/constants'
+require 'trollop'
+
+opts = Trollop::options do
+  banner "chore-server"
+
+  opt :listen_port, "Port to listen for client status submissions", :default => Chore::Constants::DEFAULT_LISTEN_PORT
+  opt :cli_port, "Port for chore-status requests", :default => Chore::Constants::DEFAULT_CLI_PORT
+  opt :web_port, "Port for web status server", :default => Chore::Constants::DEFAULT_WEB_PORT
+end
+
+
+# TODO: Real command line options instead of this
+listen_port = opts[:listen_port]
+cli_port = opts[:cli_port]
+web_port = opts[:web_port]
+
+EventMachine::run do
+  EventMachine::PeriodicTimer.new(60) { Chore::Store.expire }
+  EventMachine::open_datagram_socket('0.0.0.0', listen_port, ChoreCollect)
+  EventMachine::start_server('0.0.0.0', cli_port, ChoreDisplay)
+  EventMachine::start_server('0.0.0.0', web_port, ChoreWeb)
+end

data/bin/chore-status

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'chore/constants'
+require 'trollop'
+
+opts = Trollop::options do
+  banner "chore-status"
+
+  opt :host, "host name of chore-server", :default => 'localhost'
+  opt :port, "port of chore-server", :default => Chore::Constants::DEFAULT_CLI_PORT
+end
+
+server = opts[:host]
+port = opts[:port]
+
+begin
+  sock = TCPSocket.open(server,port)
+  sock.puts ".\r\n"
+
+  while next_line = sock.gets
+    puts next_line
+  end
+
+  sock.close
+rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT => ex
+  puts "Couldn't connect to chore-server at #{server}:#{port}"
+end

data/lib/chore.rb

@@ -0,0 +1,110 @@
+require 'socket'
+require 'json'
+require 'chore/constants'
+
+# Client module to access the server.  Basic usage is something like:
+# 
+#    Chore.monitor('task') do
+#      # ...
+#    end
+# 
+# Refer to the various methods for additional options
+module Chore
+
+  # Override the default server settings
+  def self.set_server ip, port
+    @@server_ip = ip
+    @@server_port = port
+  end
+  
+  # Let the server know that you've started a task.
+  # Options you can include are:
+  #
+  # [:do_every]     Indicate that the task should run every X seconds.
+  #                 If this does not happen, show task status in RED.
+  #
+  # [:grace_period] Allow a grace period for the above option.  If we
+  #                 are late but withing the grace period, show task
+  #                 status in YELLOW.
+  #
+  # [:finish_in]    Indicate that the task should finish in X seconds.
+  #                 If we haven't received a finish message by then,
+  #                 show the task in RED.
+  #
+  # [:expire_in]    Remove the task after X seconds.  This may be useful
+  #                 to keep the task list clean.
+  def self.start task, opts={}
+    opts[:start_time] ||= Time.now().to_i
+    send( [:start, task, opts] )
+  end
+
+  # Provide an optional status message that can be updated.
+  # Only the last status message is retained.
+  def self.status task, message
+    send( [:status_update, task, { :status_note => message}] )
+  end
+
+  # Manually indicate that a task has finished
+  def self.finish task, opts={}
+    opts[:finish_time] ||= Time.now().to_i
+    send( [:finish, task, opts] )
+  end
+  
+  # Remove a task from monitoring.
+  def self.pop task, opts={}
+    send( [:pop, task, opts] )
+  end
+
+  # Manually indicate that a task has failed.
+  #
+  # [:error] optional error message
+  def self.fail task, opts={}
+    opts[:fail_time] ||= Time.now().to_i
+    send( [:fail, task, opts] )
+  end
+  
+  # Automatically run Chore.start, execute a code block, and
+  # automatically run Chore.finish (or Chore.fail in the case
+  # of an exception) when the block finishes.
+  #
+  # All options from .start, .finish, and .fail may be passed
+  # in as options.
+  #
+  # In addition to normal opts, :pop => true
+  # will automatically remove the task from the store
+  def self.monitor task, opts={}, &code
+    pop = false
+    if opts[:pop]
+      pop = true
+      opts.delete(:pop)
+    end
+    
+    Chore.start(task, opts)
+    begin
+      code.call()
+      if pop
+        Chore.pop(task)
+      else
+        Chore.finish(task)
+      end
+    rescue Exception => ex
+      Chore.fail(task, :error => "#{ex.class} - #{ex.message}")
+      raise
+    end
+  end
+
+private
+  
+  @@server_ip = '127.0.0.1'
+  @@server_port = Chore::Constants::DEFAULT_LISTEN_PORT
+
+  def self.send msg
+    UDPSocket.new.send(sanitize(msg).to_s, 0, @@server_ip, @@server_port)
+    nil
+  end
+
+  #only allow good options
+  def self.sanitize msg
+    msg.to_json
+  end
+end

data/lib/chore/constants.rb

@@ -0,0 +1,7 @@
+module Chore
+  module Constants
+    DEFAULT_LISTEN_PORT = 32786
+    DEFAULT_WEB_PORT = 43210
+    DEFAULT_CLI_PORT = 43211
+  end
+end

data/lib/chore/server.rb

@@ -0,0 +1,101 @@
+require 'eventmachine'
+require 'evma_httpserver'
+require 'chore/store'
+require 'json'
+
+# Process submissions from a client and save it in the store.
+module ChoreCollect
+  @@data_collector = EM.spawn do |chore_info|
+    Chore::Store.update_chore(chore_info)
+  end
+
+  # Sends data to the data_collector spawned process to add
+  # to the data store.
+  def chore_collect chore_info
+    @@data_collector.notify chore_info
+  end
+
+  def receive_data(data)
+    chore_info = JSON.parse(data)
+    chore_collect chore_info
+  end
+end
+
+# Provide colorized text output for the CLI interface.
+module ChoreDisplay
+    def colorize str, color
+      color_code = case color
+                   when :red then 31
+                   when :green then 32
+                   when :yellow then 33
+                   else raise "BAD COLOR #{str} #{color}"
+                   end
+      "\033[#{color_code}m#{str}\033[0m"
+    end
+
+    def text_statuses
+
+      status_lines = []
+      Chore::Store.iterate_statuses do |status|
+        status_line = "#{status[:job]} - #{status[:status]}ed #{Time.at(status[:start_time])}"
+        status_line += " (#{status[:notes].join(', ')})" if !status[:notes].empty?
+        status_lines << colorize(status_line, status[:state])
+      end
+      
+      status_lines.join("\n") + "\n"
+    end
+    
+
+  def receive_data(data)
+    send_data(text_statuses)
+    close_connection_after_writing
+  end
+end
+
+# A basic webserver that provides a single web page with chore
+# statues
+class ChoreWeb < EventMachine::Connection
+  include EventMachine::HttpServer
+
+  def process_http_request
+    resp = EventMachine::DelegatedHttpResponse.new(self)
+
+    html = <<-html
+<html>
+<head>
+<style type="text/css">
+body {font-family:monospace;background-color:#CCCCCC;}
+.red {color:red;}
+.yellow {color:yellow;}
+.green {color:green;}
+table, th, td { border: 1px solid black;}
+</style>
+</head>
+<body>
+<h1>Chores</h1>
+<table>
+<tr><th>Job</th><th>Status</th><th>Time</th><th>Notes</th></tr>
+html
+
+    Chore::Store.iterate_statuses do |status|
+      row = "<tr class='#{status[:state]}'><td>#{status[:job]}</td><td>#{status[:status]}ed</td><td>#{Time.at(status[:start_time])}</td>"
+      if !status[:notes].empty?
+        row += "<td>(#{status[:notes].join(', ')})</td>"
+      else
+        row += "<td>&nbsp;</td>"
+      end
+      
+      row += "</tr>\n"
+      html << row 
+    end
+
+    html << "</body></html>"
+
+    resp.status = 200
+    resp.content = html
+    resp.send_response
+  end
+  
+end
+
+

data/lib/chore/store.rb

@@ -0,0 +1,137 @@
+require 'eventmachine'
+require 'chore/time_help'
+
+module Chore
+  # A semi-persistant store for all of our chore data.  Right now
+  # it's just a hash that won't survive a server restart.
+  module Store
+    #
+    # Process data with a spawned process in the background 
+    #
+
+    def self.update_chore chore_info
+      state = chore_info[0]
+      chore = chore_info[1]
+      opts = chore_info[2]
+      opts['status'] = state
+      
+      if state == "pop"
+        Store.get.delete(chore)
+      else
+        if Store.get[chore].nil?
+          Store.get[chore] = {}
+        end
+
+        Store.get[chore] = Store.get[chore].merge(opts)
+      end
+    end
+
+    # Remove anything that's currently expired from the store.
+    def self.expire
+      expired_tasks = []
+      
+      Chore::Store.get.each_pair do |task, params|
+        if params['expire_in']
+          start_time = params['start_time'].to_i
+          expire_in = params['expire_in'].to_i
+          expire_time = start_time + expire_in
+          
+          if expire_time < Time.now().to_i
+            expired_tasks << task
+          end
+        end
+      end
+
+      expired_tasks.each do |task|
+        Chore::Store.get.delete(task)
+      end
+    end
+
+    # get status of a single chore
+    def self.get_chore chore_name
+      chore_name = chore_name.to_s
+      chore_data = Store.get[chore_name]
+
+      return nil if chore_data.nil?
+      
+      build_status(chore_name, chore_data)
+    end
+
+    # Climb through the internal store and return a processed and
+    # abstracted list of tasks to the consumer.
+    def self.iterate_statuses
+      ret = []
+      Store.get.keys.each do |chore_name|
+        yield get_chore(chore_name)
+      end
+    end
+
+  private
+    @@store = {}
+
+    def self.get
+      @@store
+    end
+
+    def self.build_status chore_name, status_info
+        status = status_info['status'].to_sym
+        run_time = status_info['start_time']
+        run_time = 0 if !run_time
+
+        current_time = Time.now.to_i
+        do_every = status_info['do_every']
+        grace_period = status_info['grace_period']
+
+        notes = []
+        state = :red
+
+        if status == :fail
+          state = :red
+          if status_info['error']
+            notes << status_info['error']
+          else
+            notes << "FAILED!!!"
+          end
+          
+        elsif status == :finish
+          finish_time = status_info['finish_time']
+          finish_in = status_info['finish_in']
+
+          if finish_in.nil?
+            state = :green
+          elsif (run_time + finish_in) >= finish_time
+            state = :green
+          else
+            state = :red
+            notes << "Finished, but #{finish_time - (run_time + finish_in)} seconds late!!!"
+          end
+        elsif status == :start || status == :status_update
+          if do_every
+            if run_time + do_every >= current_time
+              state = :green
+              notes << "Should run every #{Chore::TimeHelp.elapsed_human_time(do_every)}"
+            elsif grace_period && run_time + do_every + grace_period > current_time
+              state = :yellow
+              notes << "Job should run every #{Chore::TimeHelp.elapsed_human_time(do_every)}, but has a grace period of #{Chore::TimeHelp.elapsed_human_time(grace_period)}"
+            else
+              state = :red
+              notes << "Job should run every #{Chore::TimeHelp.elapsed_human_time(do_every)}, but hasn't run since #{Time.at(run_time)}"
+            end
+          else
+            state = :green
+          end
+
+          if status_info['expire_in']
+            expire_in = Time.at(status_info['start_time'] + status_info['expire_in'].to_i)
+            notes << "Will expire in #{expire_in}"
+          end
+
+          notes << "Status: #{status_info['status_note']}" if status_info['status_note']
+        end
+        
+        info = {:job => chore_name, :state => state, :status => status, :start_time => run_time, :notes => notes}
+    end
+
+
+  end
+end

data/lib/chore/time_help.rb

@@ -0,0 +1,26 @@
+module Chore
+  module TimeHelp
+    # Show stuff like "7 weeks, 3 days, 4 hours" instead of 
+    # 13252363477 seconds since epoch
+    def self.elapsed_human_time seconds
+      remaining_ticks = seconds
+      human_text = ""
+
+      [[60,:seconds],[60,:minutes],[24,:hours],[7, :days]].each do |ticks, unit|
+        above = remaining_ticks / ticks
+        below = remaining_ticks % ticks
+
+        if below != 0
+          unit = unit[0..-2] if below == 1
+          human_text = "#{below} #{unit} " + human_text
+        end
+
+        remaining_ticks = above
+        if above == 0
+          break
+          end
+      end
+      human_text.strip
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: chore
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Pikimal, LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: eventmachine_httpserver
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.16.2
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Monitor chorse
+email: grant@pikimal.com
+executables: 
+- chore-server
+- chore-status
+- chore-client
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/chore.rb
+- lib/chore/server.rb
+- lib/chore/time_help.rb
+- lib/chore/store.rb
+- lib/chore/constants.rb
+- bin/chore-server
+- bin/chore-status
+- bin/chore-client
+homepage: http://github.com/pikimal/chore
+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.11
+signing_key: 
+specification_version: 3
+summary: Monitor chores
+test_files: []
+