taskr 0.2.1 → 0.3.0

data/CHANGELOG.txt

@@ -1,27 +1 @@
-=== 0.2.1 :: 2008-02-28
-
-* Updated for compatibility with picnic 0.6.1.
-
-=== 0.2.0 :: 2008-01-03
-
-* Added Taskr4rails action and accompanying Rails plugin for
-  executing code on a remote Rails server. See
-  http://code.google.com/p/ruby-taskr/wiki/Taskr4rails for
-  details.
-* The Howlr action now takes an optional content_type parameter
-  to allow for sending out HTML-formatted messages.
-* Better error reporting for Restr-based actions. The remote server's
-  response body is now included in Taskr's error report and the 
-  remote output is printed to the log more cleanly.
-* Change to REST API: the 'action(s)' parameter is now a bit looser. 
-  You can use 'action' or 'actions' interchangeably, whether you're 
-  scheduling multiple actions or just one.
-* Fixed some routing problems in the HTML views.
-* The ActiveResource and PHP examples have been updated with
-  some more illustrative code and better explanations.
-* Misc bugs fixed while writing extensive documentation. See
-  wiki pages at http://code.google.com/p/ruby-taskr/w/list.
-
-=== 0.1.0 :: 2007-12-21
-
-* First public release.
+See History.txt

data/History.txt

@@ -0,0 +1,41 @@
+=== 0.3.0 :: 2008-06-19
+
+* Added "Run Now" function allowing a task to be immediately triggered.
+* The Rest action can now take the 'params' parameter as a CGI string
+  (e.g. foo=bar&blah=hello&taskr=awesome). The string does not have
+  to be properly URI-encoded, since the algorithm for parsing it simply
+  splits it based on & and = symbols.
+* Changed Scheduler gem from the old OpenWFE to the new Rufus.
+* Task executions are now logged to the new log_entries table. These
+  log entries are viewable under the task detail page.
+* Exceptions raised when a task is run manually are now handled gracefully
+  (or rather, silently, since they should be logged by the action).
+* Blank parameter values are now correctly stored as NULL rather than 0.
+
+=== 0.2.1 :: 2008-02-28
+
+* Updated for compatibility with picnic 0.6.1.
+
+=== 0.2.0 :: 2008-01-03
+
+* Added Taskr4rails action and accompanying Rails plugin for
+  executing code on a remote Rails server. See
+  http://code.google.com/p/ruby-taskr/wiki/Taskr4rails for
+  details.
+* The Howlr action now takes an optional content_type parameter
+  to allow for sending out HTML-formatted messages.
+* Better error reporting for Restr-based actions. The remote server's
+  response body is now included in Taskr's error report and the 
+  remote output is printed to the log more cleanly.
+* Change to REST API: the 'action(s)' parameter is now a bit looser. 
+  You can use 'action' or 'actions' interchangeably, whether you're 
+  scheduling multiple actions or just one.
+* Fixed some routing problems in the HTML views.
+* The ActiveResource and PHP examples have been updated with
+  some more illustrative code and better explanations.
+* Misc bugs fixed while writing extensive documentation. See
+  wiki pages at http://code.google.com/p/ruby-taskr/w/list.
+
+=== 0.1.0 :: 2007-12-21
+
+* First public release.

data/Rakefile

@@ -11,9 +11,9 @@ require 'hoe'
 include FileUtils
 require File.join(File.dirname(__FILE__), 'lib', 'taskr', 'version')
 
-AUTHOR = "URBACON\mzukowski"  # can also be an array of Authors
-EMAIL = "your contact email for bug fixes and info"
-DESCRIPTION = "description of gem"
+AUTHOR = "Matt Zukowski"  # can also be an array of Authors
+EMAIL = "matt at roughest dot net"
+DESCRIPTION = "cron-like scheduler service with a RESTful interface"
 GEM_NAME = "taskr" # what ppl will type to install your gem
 RUBYFORGE_PROJECT = "taskr" # The unix name for your project
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
@@ -54,9 +54,10 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   #p.spec_extras    - A hash of extra values to set in the gemspec.
   
   p.extra_deps = [
-    ['picnic', '~>0.6.1'], 
-    ['reststop', '~>0.2.0'], 
-    'openwferu-scheduler'
+    ['picnic', '~> 0.6.4'], 
+    ['reststop', '~> 0.3.0'], 
+    ['restr', '~> 0.4.0'], 
+    ['rufus-scheduler', '~> 1.0.7']
   ]
   p.spec_extras = {:executables => ['taskr', 'taskr-ctl']}
 end

data/config.example.yml

@@ -4,10 +4,10 @@
 # !!! Be sure to use spaces instead of tabs for indentation, as YAML is very
 # !!! sensitive to white-space inconsistencies!
 
-##### HTTP SERVER #####################################################################
+##### HTTP SERVER ##############################################################
 
-# Under what HTTP environment are you running the Fluxr server? The following methods
-# are currently supported:
+# Under what HTTP environment are you running the Fluxr server? The following 
+# methods are currently supported:
 #
 # webrick -- simple stand-alone HTTP server; this is the default method
 # mongrel -- fast stand-alone HTTP server; much faster than webrick, but 
@@ -34,16 +34,16 @@ port: 7007
 #server: mongrel
 #port: 7007
 
-# It is possible to run mongrel over SSL, but you will need to use a reverse proxy
-# (try Pound or Apache).
+# It is possible to run mongrel over SSL, but you will need to use a reverse 
+# proxy (try Pound or Apache).
 
 
-##### DATABASE ########################################################################
+##### DATABASE #################################################################
 
 # Taskr needs a database to persist its state between restarts.
 # 
-# By default, we use MySQL, since it is widely used and does not require any additional
-# ruby libraries besides ActiveRecord.
+# By default, we use MySQL, since it is widely used and does not require any 
+# additional ruby libraries besides ActiveRecord.
 #
 # With MySQL, your config would be something like the following:
 # (be sure to create the taskr database in MySQL beforehand,
@@ -57,8 +57,8 @@ database:
   host: localhost
 
 
-# Instead of MySQL you can use SQLite3, PostgreSQL, MSSQL, or anything else supported 
-# by ActiveRecord.
+# Instead of MySQL you can use SQLite3, PostgreSQL, MSSQL, or anything else 
+# supported by ActiveRecord.
 #
 # If you do not have a database server available, you can try using the SQLite3
 # back-end. SQLite3 does not require it's own server. Instead all data is stored
@@ -70,20 +70,39 @@ database:
 #  dbfile: /var/lib/taskr.db
 
 
-##### AUTHENTICATION ##################################################################
+##### AUTHENTICATION ###########################################################
 
-# Taskr supports basic HTTP authentication. Uncomment this if you want Taskr to demand
-# a username and password from clients. Note that this isn't very secure unless
-# you run Taskr over HTTPS (see the webrick SSL example above).
+# Taskr supports two methods for authentication: Basic HTTP and CAS. 
+
+### Basic HTTP Example
+# Uset the following if you want Taskr to demand a username and password from 
+# the user using basic HTTP authentication clients. Note that this isn't very 
+# secure unless you run Taskr over HTTPS (see the webrick SSL example above).
 
 #authentication:
+#  method: basic
 #  username: taskr
 #  password: task!
 
+### CAS Example
+# Use the following if you want Taskr to demand a username and password using
+# Single Sign-On CAS (Central Authentication System). For more information on 
+# CAS see http://code.google.com/p/rubycas-server/.
+# The cas_base_url setting should be the URL of your CAS server.
+
+#authenticatoin:
+#  method: cas
+#  cas_base_url: https://login.example.foo/cas
+
 
-##### LOGGING #########################################################################
+##### LOGGING ##################################################################
 
-# This log is where you'll want to look in case of problems. 
+### System Log
+# This is the general server log where Taskr writes information about web requests.
+# You'll want to look here if you encounter general problems with Taskr's
+# operation. Do not confuse this log with the task log, which records information
+# about the various schedules jobs. The task log is kept in your database and
+# is completely separate (see below). 
 # 
 # By default, we will try to create a log file named 'taskr.log' in the current 
 # directory (the directory where you're running taskr from). A better place to put 
@@ -98,3 +117,60 @@ log:
   level: DEBUG
 #  file: /var/log/taskr.log
 #  level: INFO
+
+### Task Log
+# This is where Taskr records detailed information about your scheduled jobs (tasks).
+# Every time a task is triggered, information about the execution is recorded
+# in this log (i.e. whether the task executed successfuly, its output, etc.)
+# The Task Log is stored in the Taskr database under the log_entries table.
+#
+# Here you can configure the logging level. The "INFO" level is generally a good 
+# choice for production systems, although you may want to keep this at "DEBUG" 
+# if you want to keep a close eye on your tasks -- this is a good idea 
+# especially when setting up a new Taskr system.
+#
+# Note that in order to prevent log data from accumulating indefinitely, you
+# should set up a "RotateTaskLog" action in your Taskr server. This will
+# delete old logs as per the parameters you provide (do this via the
+# normal Taskr web interface as you would to set up any other task -- just
+# select "RotateTaskLog" for the action).
+
+task_log:
+  # ERROR, WARN, INFO, or DEBUG
+  level: DEBUG
+  
+  
+##### MISC #####################################################################
+
+### Custom Task Definitions
+# You can define your own task action behaviour by specifying an external ruby
+# filename. On startup, Taskr will load any action definitions from this file,
+# making them available when scheduling new tasks (you should see your custom
+# task classes listed in the Actions pulldown on the new task page).
+#
+# Custom task definitions must:
+# - be defined under the Taskr::Actions module
+# - extend the Taskr::Actions::Base class
+# - implement a 'execute' method (this is what will be executed when your
+#   action is triggered)
+# - define a 'parameters' class attribute which should be an Array listing
+#   the names of the parameters that your action takes
+# - define a 'description' class attribute which should provide a brief
+#   description for what your action does (this will show up in the web UI) 
+#
+# Here is an example of a trivial custom action:
+#
+#  module Taskr
+#    module Actions
+#      class MyCustomAction < Taskr::Actions::Base
+#        self.parameters = ['alpha', 'beta']
+#        self.description = "Multiplies the given parameters and prints the result to stdout."
+#
+#        def execute
+#          puts parameters['alpha'].to_i * parameters['beta'].to_i
+#        end
+#      end
+#    end
+#  end
+
+#external_actions: /path/to/file.rb

data/lib/taskr.rb

@@ -76,9 +76,9 @@ def Taskr.create
 end
 
 def Taskr.prestart
-  $LOG.info "Starting OpenWFE Scheduler..."
+  $LOG.info "Starting Rufus Scheduler..."
   
-  Taskr.scheduler = OpenWFE::Scheduler.new
+  Taskr.scheduler = Rufus::Scheduler.new
   Taskr.scheduler.start
   
   $LOG.debug "Scheduler is: #{Taskr.scheduler.inspect}"

data/lib/taskr/actions.rb

@@ -13,7 +13,7 @@
 # You should have received a copy of the GNU General Public License
 # along with Taskr.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'openwfe/util/scheduler'
+require 'rufus/scheduler'
 
 #require 'active_resource'
 require 'restr'
@@ -39,13 +39,14 @@ module Taskr
     # The base class for all Actions.
     # Extend this to define your own custom Action.
     class Base
-      include OpenWFE::Schedulable
+      include Rufus::Schedulable
       
       class_inheritable_accessor :parameters
       class_inheritable_accessor :description
       
       attr_accessor :parameters
       attr_accessor :task
+      attr_accessor :task_action
       
       def initialize(parameters)
         self.parameters = HashWithIndifferentAccess.new(parameters)
@@ -72,6 +73,10 @@ module Taskr
           raise e
         end
       end
+      
+      def to_s
+        "#{self.class.name}(#{parameters.inspect})"
+      end
     end
     
     # Do not extend this class. It is used internally to schedule multiple
@@ -79,7 +84,7 @@ module Taskr
     #
     # If you want to define your own custom Action, extend Taskr::Actions::Base
     class Multi
-      include OpenWFE::Schedulable
+      include Rufus::Schedulable
       
       attr_accessor :actions
       attr_accessor :task
@@ -90,22 +95,39 @@ module Taskr
       
       def trigger(trigger_args = {})
         begin
-          $LOG.info("Executing task #{self.name}")
+          $LOG.info("Executing task #{self.task.name}")
           actions.each do |a|
             a.execute
+            LogEntry.info(a, "Action #{a} executed.")
           end
           # TODO: maybe we should store last_triggered time on a per-action basis?
           task.update_attribute(:last_triggered, Time.now)
+          task.update_attribute(:last_triggered_error, nil)
         rescue => e
           $LOG.error(e)
-          $LOG.debug("#{e.stacktrace}")
+          $LOG.debug("#{e.backtrace}")
           task.update_attribute(:last_triggered, Time.now)
-          task.update_attribute(:last_triggered_error, e)
+          task.update_attribute(:last_triggered_error, {:type => e.class.to_s, :details => "#{e.message}"})
+          # FIXME: Maybe actions should be responseible for logging their errors, otherwise we double-log the same error.
+          LogEntry.error(task, "Task #{task} raised an exception: \n#{e.class}: #{e.message}\n#{e.backtrace}")
           raise e
         end
       end
     end
     
+    class RotateTaskLog < Base
+      self.parameters = ['delete_old_log_entries_after_days']
+      self.description = "Deletes old task log entries from this Taskr server's database."
+      
+      def execute
+        num = parameters['delete_old_log_entries_after_days'].to_i
+        
+        cond = ['timestamp < ?', Time.now - num.days]
+        LogEntry.delete_all(cond)
+        LogEntry.debug(task_action, "Deleted log entries with conditions: #{cond.inspect}")
+      end
+    end
+    
     class Shell < Base
       self.parameters = ['command', 'as_user']
       self.description = "Execute a shell command (be careful!)"
@@ -118,14 +140,29 @@ module Taskr
           user = nil
         end
         
-        if user
-          `sudo -u #{user} #{cmd}`
-        else
-          `#{cmd}`
+        unless user.blank?
+          cmd = "sudo -u #{user} #{cmd}"
         end
         
+        outio = StringIO.new
+        errio = StringIO.new
+        old_stdout, $stdout = $stdout, outio
+        old_stderr, $stderr = $stderr, errio
+        
+        out = `#{cmd}`
+        
+        err = errio.string
+        out = outio.string
+        LogEntry.debug(task_action, out) unless out.blank?
+        LogEntry.error(task_action, err) unless err.blank?
+        
+        $stdout = old_stdout
+        $stderr = old_stderr
+        
         unless $?.success?
-          raise "Shell command failed (#{$?}): #{cmd}"
+          msg = "Shell command #{cmd.inspect} failed (returned code #{$?}): #{out}"
+          LogEntry.error(task_action, msg)
+          raise msg
         end
       end
     end
@@ -135,11 +172,26 @@ module Taskr
       self.description = "Execute some Ruby code."
       
       def execute
+        outio = StringIO.new
+        errio = StringIO.new
+        old_stdout, $stdout = $stdout, outio
+        old_stderr, $stderr = $stderr, errio
+        
         code = parameters['code']
-        eval code
+        eval(code)
+        
+        err = errio.string
+        out = outio.string
+        LogEntry.debug(task_action, out) unless out.blank?
+        LogEntry.error(task_action, err) unless err.blank?
+        
+        $stdout = old_stdout
+        $stderr = old_stderr
       end
     end
-    
+
+
+# This is too complicated... we use Restr instead.
 #    class ActiveResource < Base
 #      self.parameters = ['site', 'resource', 'action', 'parameters']
 #      self.description = "Perform a REST call on a remote service using ActiveResource."
@@ -207,8 +259,17 @@ module Taskr
           auth['password'] = parameters['password'] if parameters['password']
         end
         
-        Restr.logger = $LOG
-        Restr.do(parameters['method'], parameters['url'], parameters['params'], auth)
+        if parameters['params'].kind_of? String
+          params2 = {}
+          parameters['params'].split('&').collect do |p|
+            key, value = p.split('=')
+            params2[key] = value
+          end
+          parameters['params'] = params2
+        end
+        
+        Restr.logger = LogEntry.logger_for_action(task_action)
+        Restr.do(parameters['method'], parameters['url'], (parameters['params'] unless parameters['params'].blank?), auth)
       end
     end
     
@@ -246,7 +307,7 @@ module Taskr
         }
         
         
-        Restr.logger = $LOG
+        Restr.logger = LogEntry.logger_for_action(task_action)
         Restr.post(parameters['url'], data)
       end
     end

data/lib/taskr/controllers.rb

@@ -45,25 +45,30 @@ module Taskr::Controllers
   class Tasks < REST 'tasks'
     include Taskr::Models
     
+    # List of tasks.
     def list
       @tasks = Task.find(:all, :include => [:task_actions])
       
       render :tasks_list
     end
     
+    # Input for a new task.
     def new
       @actions = Taskr::Actions.list
       
       render :new_task
     end
     
+    # Retrieve details for an existing task.
     def read(id)
       @task = Task.find(id, :include => [:task_actions])
       
       render :view_task
     end
     
+    # Create and schedule a new task.
     def create
+      puts @input.inspect
       begin
         # the "0" is for compatibility with PHP's Zend_Rest_Client
         task_data = @input[:task] || @input["0"] || @input
@@ -72,12 +77,14 @@ module Taskr::Controllers
         created_by      = @env['REMOTE_HOST']
         schedule_method = task_data[:schedule_method]
         schedule_when   = task_data[:schedule_when]
+        memo            = task_data[:memo]
         
         @task = Task.new(
           :name => name,
           :created_by => created_by,
           :schedule_method => schedule_method,
-          :schedule_when => schedule_when
+          :schedule_when => schedule_when,
+          :memo => memo
         )
         
         # some gymnastics here to provide compatibility for the way various
@@ -98,19 +105,19 @@ module Taskr::Controllers
         end
         
         actions = [actions] unless actions.kind_of? Array
-        puts actions.inspect
+        #puts actions.inspect
         
         i = 0
         actions.each do |a|
-          puts a.inspect
+          #puts a.inspect
           action_class_name = a[:action_class_name]
           action_class_name = "Taskr::Actions::#{action_class_name}" unless action_class_name =~ /^Taskr::Actions::/
           
           begin
             action_class = action_class_name.constantize
-            unless action_class.include? OpenWFE::Schedulable
+            unless action_class.include? Rufus::Schedulable
               raise ArgumentError, 
-                "#{a[:action_class_name].inspect} cannot be used as an action because it does not include the OpenWFE::Schedulable module."
+                "#{a[:action_class_name].inspect} cannot be used as an action because it does not include the Rufus::Schedulable module."
             end
           rescue NameError
             raise ArgumentError, 
@@ -119,8 +126,11 @@ module Taskr::Controllers
           
           action = TaskAction.new(:order => a[:order] || i, :action_class_name => action_class_name)
           
+          
           action_class.parameters.each do |p|
-            action.action_parameters << TaskActionParameter.new(:name => p, :value => a[p])
+            value = a[p]
+            value = nil if value.blank?
+            action.action_parameters << TaskActionParameter.new(:name => p, :value => value)
           end
           
           @task.task_actions << action
@@ -150,7 +160,24 @@ module Taskr::Controllers
         raise e
       end
     end
+
+    def run(id)
+      @task = Task.find(id, :include => [:task_actions])
+      
+      action = @task.prepare_action
+      
+      LogEntry.info(@task, "Manually executing task #{@task}.")
+      
+      begin
+        action.trigger
+      rescue
+        # ok to catch exception silently. it should have gotten logged by the action
+      end
+      
+      render :view_task
+    end
     
+    # Unschedule and delete an existing task.
     def destroy(id)
       @task = Task.find(id)
       if @task.scheduler_job_id
@@ -158,7 +185,27 @@ module Taskr::Controllers
         Taskr.scheduler.unschedule(@task.scheduler_job_id)
       end
       @task.destroy
-      return redirect(R(Tasks, :list))
+      
+      if @task.frozen?
+        @status = 200
+        if @format == :XML
+          ""
+        else
+          return redirect(R(Tasks, :list))
+        end
+      else
+        _error("Task #{id} was not destroyed.", 500)
+      end
+    end
+  end
+  
+  class LogEntries < REST 'log_entries'
+    def list
+      @log_entries = LogEntry.find(:all, 
+        :conditions => ['task_id = ?', @input[:task_id]],
+        :order => 'timestamp DESC, id DESC')
+      
+      render :log_entries_list
     end
   end
 end

data/lib/taskr/environment.rb

@@ -44,5 +44,5 @@ require 'camping/db'
 
 require 'reststop'
 
-gem 'openwferu-scheduler', '~> 0.9.16'
-require 'openwfe/util/scheduler'
+gem 'rufus-scheduler', '~> 1.0.7'
+require 'rufus/scheduler'

data/lib/taskr/models.rb

@@ -17,7 +17,7 @@ require 'camping/db'
 require 'openwfe/util/scheduler'
 require 'date'
 
-class OpenWFE::Scheduler
+class Rufus::Scheduler
   public :duration_to_f
 end
 
@@ -62,26 +62,8 @@ module Taskr::Models
       
       $LOG.debug "Scheduling task #{name.inspect}: #{self.inspect}"
       
-      if task_actions.length == 1
-        ta = task_actions.first
-        
-        parameters = {}
-        ta.action_parameters.each{|p| parameters[p.name] = p.value}
-        
-        action = (ta.action_class.kind_of?(Class) ? ta.action_class : ta.action_class.constantize).new(parameters)
-        action.task = self
-      elsif task_actions.length > 1
-        action = Taskr::Actions::Multi.new
-        task_actions.each do |ta|
-          parameters = {}
-          ta.action_parameters.each{|p| parameters[p.name] = p.value}
-          
-          a = (ta.action_class.kind_of?(Class) ? ta.action_class : ta.action_class.constantize).new(parameters)
-          a.task = self
-          
-          action.actions << a 
-        end
-        action.task = self
+      if task_actions.length > 0
+        action = prepare_action
       else
         $LOG.warn "Task #{name.inspect} has no actions and as a result will not be scheduled!"
         return false
@@ -107,6 +89,36 @@ module Taskr::Models
       return job_id
     end
     
+    def prepare_action
+      if task_actions.length == 1
+        ta = task_actions.first
+        
+        parameters = {}
+        ta.action_parameters.each{|p| parameters[p.name] = p.value}
+        
+        action = (ta.action_class.kind_of?(Class) ? ta.action_class : ta.action_class.constantize).new(parameters)
+        action.task = self
+        action.task_action = ta
+      elsif task_actions.length > 1
+        action = Taskr::Actions::Multi.new
+        task_actions.each do |ta|
+          parameters = {}
+          ta.action_parameters.each{|p| parameters[p.name] = p.value}
+          
+          a = (ta.action_class.kind_of?(Class) ? ta.action_class : ta.action_class.constantize).new(parameters)
+          a.task = self
+          a.task_action = ta
+          
+          action.actions << a 
+        end
+        action.task = self
+      else
+        raise "Task #{name.inspect} has no actions!"
+      end
+      
+      action
+    end
+    
     def next_trigger_time
       # TODO: need to figure out how to calulate trigger_time for these.. for now return :unknown
       return :unknown unless schedule_method == 'at' || schedule_method == 'in'
@@ -122,10 +134,12 @@ module Taskr::Models
       # treat 0000-00-00 00:00:00 as nil
       Time.send(Base.default_timezone, *time_array) rescue DateTime.new(*time_array[0..5]) rescue nil
     end
+
     
     def to_s
-      "#<#{self.class}:#{self.id}>"
+      "#{name.inspect}@#{schedule_when}"
     end
+    
   end
   
   class TaskAction < Base
@@ -136,6 +150,12 @@ module Taskr::Models
       :foreign_key => :task_action_id,
       :dependent => :destroy
     
+    has_many :log_entries
+    has_one :last_log_entry,
+      :class_name => 'LogEntry',
+      :foreign_key => :task_id,
+      :order => 'timestamp DESC'
+    
     validates_associated :action_parameters
     
     def action_class=(class_name)
@@ -166,7 +186,7 @@ module Taskr::Models
     end
     
     def to_s
-      "#<#{self.class}:#{self.id}>"
+      "#{self.class.name.demodulize}(#{task_action})"
     end
   end
 
@@ -188,7 +208,82 @@ module Taskr::Models
     end
     
     def to_s
-      "#<#{self.class}:#{self.id}>"
+      "#{self.class.name.demodulize}(#{name}:#{value})"
+    end
+  end
+  
+  class LogEntry < Base
+    belongs_to :task
+    belongs_to :task_action
+    
+    class << self
+      def log(level, action_or_task, data)
+        level = level.upcase
+        if action_or_task.kind_of? TaskAction
+          action = action_or_task
+          task = action.task
+        elsif action_or_task.kind_of? Task
+          action = nil
+          task = action_or_task
+        elsif action_or_task.kind_of? Integer
+          action = TaskAction.find(action_or_task)
+          task = action.task
+        elsif action_or_task.kind_of? Taskr::Actions::Base
+          action = action_or_task.task_action
+          task = action.task
+        else
+          raise ArgumentError, "#{action_or_task.inspect} is not a valid Task or TaskAction!"
+        end
+        
+        threshold = Taskr::Conf[:task_log][:level].upcase if Taskr::Conf[:task_log] && Taskr::Conf[:task_log][:level]
+        
+        if threshold.blank? || 
+            ['DEBUG', 'INFO', 'WARN', 'ERROR'].index(threshold) <= ['DEBUG', 'INFO', 'WARN', 'ERROR'].index(level) 
+          LogEntry.create(
+            :level => level,
+            :timestamp => Time.now,
+            :task => task,
+            :task_action => action,
+            :data => data
+          )
+        end
+      end
+      
+      # Produces a Logger-like class that will create log entries for the given
+      # TaskAction. The returned object exploses behaviour much like a standard
+      # Ruby Logger, so that it can be used in place of a Logger when necessary. 
+      def logger_for_action(action)
+        ActionLogger.new(action)
+      end
+    
+      ['debug', 'info', 'warn', 'error'].each do |level|
+        define_method(level) do |action, data|
+          log(level, action, data)
+        end
+      end
+    end
+    
+    # Exposes a Logger-like interface for logging entries for some particular
+    # TaskAction.
+    class ActionLogger
+      def initialize(action)
+        @action = action
+      end
+      
+      def method_missing(method, data)
+        LogEntry.send(method, @action, "#{"#{@progname}: " unless @progname.blank?}#{data}")
+      end
+      
+      def respond_to?(method)
+        [:debug, :info, :warn, :error].include?(method)
+      end
+      
+      def progname
+        action.task.name
+      end
+      
+      def progname=(p)
+      end
     end
   end
 
@@ -235,4 +330,36 @@ module Taskr::Models
       drop_table :taskr_tasks
     end
   end
+  
+  class AddLoggingTables < V 0.3
+    def self.up
+      $LOG.info("Creating logging tables")
+      
+      create_table :taskr_log_entries, :force => true do |t|
+        t.column :task_id, :integer
+        t.column :task_action_id, :integer
+        
+        t.column :timestamp, :timestamp, :null => false
+        t.column :level, :string, :null => false
+        t.column :data, :text
+      end
+      
+      add_index :taskr_log_entries, :task_id
+      add_index :taskr_log_entries, :task_action_id
+    end
+    
+    def self.down
+      drop_table :taskr_log_entries
+    end
+  end
+  
+  class AddMemoToTasks < V 0.3001
+    def self.up
+      add_column :taskr_tasks, :memo, :text
+    end
+    
+    def self.down
+      remove_column :taskr_tasks, :memo
+    end
+  end
 end

data/lib/taskr/version.rb

@@ -1,8 +1,8 @@
 module Taskr #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 2
-    TINY  = 1
+    MINOR = 3
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/taskr/views.rb

@@ -30,13 +30,6 @@ module Taskr::Views
     def view_task
       @task.to_xml(:root => 'task')#, :include => [:task_actions])
     end
-    
-    def create_task_result
-      taskr_response_xml(@task.valid? ? 'success' : 'failure') do
-        text @task.to_xml
-        text @task.errors.to_xml unless @task.valid?
-      end
-    end
   end
   
   module HTML
@@ -128,6 +121,12 @@ module Taskr::Views
             input :type => 'text', :name => 'schedule_when', :size => 30
           end
           
+          p do
+            label 'description/memo' 
+            br
+            textarea(:name => 'memo', :cols => '60', :rows => '4'){""}
+          end
+          
           action_form
           
           p do
@@ -153,8 +152,11 @@ module Taskr::Views
     
     def view_task
       html_scaffold do
-        form(:method => 'delete', :style => 'display: inline') do
-          button(:type => 'submit', :value => 'delete') {"Delete"}
+        form(:method => 'delete', :style => 'display: inline', :action => R(@task)) do
+          button(:type => 'submit', :value => 'delete', :onclick => 'return confirm("Are you sure you want to unschedule and delete this task?")') {"Delete"}
+        end
+        form(:method => 'put', :style => 'display: inline', :action => R(@task, 'run')) do
+          button(:type => 'submit', :value => 'run') {"Run Now!"}
         end
         br
         a(:href => R(Tasks, :list)) {"Back to Task List"}
@@ -169,6 +171,10 @@ module Taskr::Views
             th "Schedule:"
             td "#{@task.schedule_method} #{@task.schedule_when}"
           end
+          tr do
+            th "Description/Memo:"
+            td "#{@task.memo}"
+          end
           tr do
             th "Job ID:"
             td @task.scheduler_job_id
@@ -215,6 +221,8 @@ module Taskr::Views
             td @task.created_on
           end
         end
+        
+        iframe(:src => R(LogEntries, :list, :task_id => @task.id), :style => 'width: 100%; margin-top: 20px;')
       end
     end
     
@@ -276,6 +284,33 @@ module Taskr::Views
       
     end
    
+    def log_entries_list
+      h2 "Log"
+      table do
+        @log_entries.each do |entry|
+          case entry.level.downcase.intern
+          when :error
+            bg_color = '#faa'
+          when :warn
+            bg_color = '#ffa'
+          when :info
+            bg_color = '#aaf'
+          when :debug
+            bg_color = '#eee'
+          else
+            bg_color = '#fff; '+entry.level.inspect
+          end
+          tr do
+            td(:style => "vertical-align: top; font-size: 9pt; white-space: nowrap; background: #{bg_color}") do
+              entry.timestamp
+            end
+            td(:style => "vertical-align: top; font-size: 9pt; background-color: #{bg_color}; font-size: 9pt; font-family: monospace") do
+              entry.data.gsub(/<\/?(html|body)>/, '').gsub(/\n/, "<br />")
+            end
+          end
+        end
+      end
+    end
   end
   
   default_format :HTML

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: taskr
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
-- URBACONmzukowski
+- Matt Zukowski
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-02-28 00:00:00 -05:00
+date: 2008-06-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.6.1
+        version: 0.6.4
     version: 
 - !ruby/object:Gem::Dependency 
   name: reststop
@@ -28,19 +28,28 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.2.0
+        version: 0.3.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: openwferu-scheduler
+  name: restr
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rufus-scheduler
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 1.0.7
     version: 
-description: description of gem
-email: your contact email for bug fixes and info
+description: cron-like scheduler service with a RESTful interface
+email: matt at roughest dot net
 executables: 
 - taskr
 - taskr-ctl
@@ -114,6 +123,6 @@ rubyforge_project: taskr
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
-summary: description of gem
+summary: cron-like scheduler service with a RESTful interface
 test_files: 
 - test/taskr_test.rb