taskr 0.1.0

data/lib/public/taskr.css

@@ -0,0 +1,45 @@
+body {
+    font-size: 9pt;
+    font-family: Verdana;
+}
+
+table {
+    border-collapse: collapse;
+}
+
+th, td {
+    font-size: 9pt;
+    padding-left: 2pt;
+    padding-right: 6pt;
+    vertical-align: top;
+}
+
+th {
+    text-align: right;
+}
+
+thead th {
+    background: #dde;
+    text-align: left;
+    font-size: 8pt;
+}
+
+td {
+    
+}
+
+label {
+    font-weight: bold;
+}
+
+tr.expired td {
+    color: #aaa;
+}
+
+tr.expired td.job-id {
+    text-decoration: line-through;
+}
+
+tr.error td {
+    background-color: #faa;
+}

data/lib/taskr.rb

@@ -0,0 +1,83 @@
+# This file is part of Taskr.
+#
+# Taskr is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Taskr is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Taskr.  If not, see <http://www.gnu.org/licenses/>.
+
+$: << File.dirname(File.expand_path(__FILE__))
+require 'taskr/environment'
+
+Camping.goes :Taskr
+Taskr.picnic!
+
+require 'taskr/controllers'
+
+module Taskr
+  @@scheduler = nil
+  def self.scheduler=(scheduler)
+    @@scheduler = scheduler
+  end
+  def self.scheduler
+    @@scheduler
+  end
+end
+
+require 'taskr/actions'
+require 'taskr/models'
+require 'taskr/helpers'
+require 'taskr/views'
+require 'taskr/controllers'
+
+module Taskr
+  include Taskr::Models
+end
+
+include Taskr::Models
+
+def Taskr.create
+  $LOG.info "Initializing Taskr..."
+  Taskr::Models::Base.establish_connection(Taskr::Conf.database)
+  Taskr::Models.create_schema
+  
+  if self::Conf[:external_actions]
+    if self::Conf[:external_actions].kind_of? Array
+      external_actions = self::Conf[:external_actions]
+    else
+      external_actions = [self::Conf[:external_actions]]
+    end
+    external_actions.each do |f|
+      $LOG.info "Loading additional action definitions from #{self::Conf[:external_actions]}..."
+      require f
+    end
+  end
+end
+
+def Taskr.prestart
+  $LOG.info "Starting OpenWFE Scheduler..."
+  
+  Taskr.scheduler = OpenWFE::Scheduler.new
+  Taskr.scheduler.start
+  
+  $LOG.debug "Scheduler is: #{Taskr.scheduler.inspect}"
+  
+  tasks = Taskr::Models::Task.find(:all)
+  
+  $LOG.info "Scheduling #{tasks.length} persisted tasks..."
+  
+  tasks.each do |t|
+    t.schedule! Taskr.scheduler
+  end
+  
+  Taskr.scheduler.instance_variable_get(:@scheduler_thread).run
+end
+
+Taskr.start_picnic

data/lib/taskr/actions.rb

@@ -0,0 +1,230 @@
+# This file is part of Taskr.
+#
+# Taskr is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Taskr is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 'active_resource'
+require 'restr'
+
+
+unless $LOG
+  $LOG = Logger.new(STDERR)
+  $LOG.level = Logger::ERROR
+end
+
+module Taskr
+  module Actions
+    
+    def self.list
+      actions = []
+      Taskr::Actions.constants.each do |m| 
+        a = Taskr::Actions.const_get(m)
+        actions << a if a < Taskr::Actions::Base
+      end
+      return actions
+    end
+    
+    # The base class for all Actions.
+    # Extend this to define your own custom Action.
+    class Base
+      include OpenWFE::Schedulable
+      
+      class_inheritable_accessor :parameters
+      class_inheritable_accessor :description
+      
+      attr_accessor :parameters
+      attr_accessor :task
+      
+      def initialize(parameters)
+        self.parameters = HashWithIndifferentAccess.new(parameters)
+      end
+      
+      def execute
+        raise NotImplementedError, "Implement me!"
+      end
+      
+      def trigger(trigger_args = {})
+        begin
+          $LOG.info("Executing task #{self.task.name}")
+          execute
+          task.update_attribute(:last_triggered, Time.now)
+          task.update_attribute(:last_triggered_error, nil)
+        rescue => e
+          $LOG.error(e)
+          $LOG.debug(e.backtrace.to_s)
+          task.update_attribute(:last_triggered, Time.now)
+          task.update_attribute(:last_triggered_error, {:type => e.class.to_s, :message => e.message})
+          raise e
+        end
+      end
+    end
+    
+    # Do not extend this class. It is used internally to schedule multiple
+    # actions per task. 
+    #
+    # If you want to define your own custom Action, extend Taskr::Actions::Base
+    class Multi
+      include OpenWFE::Schedulable
+      
+      attr_accessor :actions
+      attr_accessor :task
+      
+      def initialize
+        self.actions = []
+      end
+      
+      def trigger(trigger_args = {})
+        begin
+          $LOG.info("Executing task #{self.name}")
+          actions.each do |a|
+            a.execute
+          end
+          # TODO: maybe we should store last_triggered time on a per-action basis?
+          task.update_attribute(:last_triggered, Time.now)
+        rescue => e
+          $LOG.error(e)
+          $LOG.debug("#{e.stacktrace}")
+          task.update_attribute(:last_triggered, Time.now)
+          task.update_attribute(:last_triggered_error, e)
+          raise e
+        end
+      end
+    end
+    
+    class Shell < Base
+      self.parameters = ['command', 'as_user']
+      self.description = "Execute a shell command (be careful!)"
+      
+      def execute
+        if parameters.kind_of? Hash
+          user = parameters['as_user']
+          cmd = parameters['command']
+        else
+          user = nil
+        end
+        
+        if user
+          `sudo -u #{user} #{cmd}`
+        else
+          `#{cmd}`
+        end
+        
+        unless $?.success?
+          raise "Shell command failed (#{$?}): #{cmd}"
+        end
+      end
+    end
+    
+    class Ruby < Base
+      self.parameters = ['code']
+      self.description = "Execute some Ruby code."
+      
+      def execute
+        code = parameters['code']
+        eval code
+      end
+    end
+    
+#    class ActiveResource < Base
+#      self.parameters = ['site', 'resource', 'action', 'parameters']
+#      self.description = "Perform a REST call on a remote service using ActiveResource."
+#      
+#      def execute
+#        $LOG.debug self
+#        ::ActiveResource::Base.logger = $LOG
+#        ::ActiveResource::Base.logger.progname = (task ? task.to_s : self)
+#        
+#        eval %{
+#          class Proxy < ::ActiveResource::Base
+#            self.site = "#{parameters['site']}"
+#            self.collection_name = "#{parameters['resource'].pluralize}"
+#          end
+#        }
+#        
+#        begin
+#          case parameters['action']
+#          when 'create'
+#            obj = Proxy.new(parameters['parameters'])
+#            obj.save
+#          when 'update', "'update' action is not implemented"
+#            raise NotImplementedError
+#          when 'delete'
+#            Proxy.delete(parameters['parameters'])
+#          when 'find'
+#            raise NotImplementedError, "'find' action is not implemented"
+#          else
+#            raise ArgumentError, "unknown action #{parameters['action'].inspect}"
+#          end
+#        rescue ::ActiveResource::ServerError => e
+#          $LOG.error #{self} ERROR: #{e.methods.inspect}"
+#          raise e
+#        end
+#      end
+#    end
+#  
+#    class Howlr < ActiveResource
+#      self.parameters = ['site', 'from', 'recipients', 'subject', 'body']
+#      self.description = "Send a message through a Howlr service."
+#      
+#      def execute
+#        parameters['action'] = 'create'
+#        parameters['resource'] = 'message'
+#        parameters['parameters'] = {
+#          'from' => parameters['from'],
+#          'recipients' => parameters['recipients'],
+#          'subject' => parameters['subject'],
+#          'body' => parameters['body']
+#        }
+#        
+#        super
+#      end
+#    end
+  
+    class Rest < Base
+      self.parameters = ['method', 'url', 'params', 'username', 'password']
+      self.description = "Perform a REST call on a remote service."
+      
+      def execute
+        auth = nil
+        if parameters['username']
+          auth = {}
+          auth['username'] = parameters['username'] if parameters['username']
+          auth['password'] = parameters['password'] if parameters['password']
+        end
+        
+        Restr.logger = $LOG
+        Restr.do(parameters['method'], parameters['url'], parameters['params'], auth)
+      end
+    end
+    
+    class Howlr < Rest
+      self.parameters = ['url', 'from', 'recipients', 'subject', 'body', 'username', 'password']
+      self.description = "Send a message through a Howlr service."
+      
+      def execute
+        parameters['method'] = 'post'
+        parameters['params'] = {
+          'from' => parameters['from'],
+          'recipients' => parameters['recipients'],
+          'subject' => parameters['subject'],
+          'body' => parameters['body'],
+          'format' => 'XML'
+        }
+        
+        super
+      end
+    end
+  end
+end

data/lib/taskr/controllers.rb

@@ -0,0 +1,164 @@
+# This file is part of Taskr.
+#
+# Taskr is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Taskr is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Taskr.  If not, see <http://www.gnu.org/licenses/>.
+
+module Taskr::Controllers
+  
+  class ActionTypes < REST 'action_types'
+    def list
+      @actions = Taskr::Actions.list
+      
+      render :action_list
+    end
+  end
+  
+  class Actions < REST 'actions'
+    def parameters_form(id)
+      @num = @input[:num] || 0
+      @action = Taskr::Actions.list.find {|a| a.to_s =~ Regexp.new("#{id}$")}
+      if @action
+        render :action_parameters_form
+      else
+        @status = 404
+        "Action #{id.inspect} not defined"
+      end
+    end
+    
+    def new
+      @num = @input[:num] || 0
+      @actions = Taskr::Actions.list
+      render :action_form
+    end
+  end
+  
+  class Tasks < REST 'tasks'
+    include Taskr::Models
+    
+    def list
+      @tasks = Task.find(:all, :include => [:task_actions])
+      
+      render :tasks_list
+    end
+    
+    def new
+      @actions = Taskr::Actions.list
+      
+      render :new_task
+    end
+    
+    def read(id)
+      @task = Task.find(id, :include => [:task_actions])
+      
+      render :view_task
+    end
+    
+    def create
+      begin
+        puts @input.class
+        puts @input.to_xml if @input.kind_of?(XmlSimple)
+        puts @input.inspect
+        
+        # the "0" is for compatibility with PHP's Zend_Rest_Client
+        task_data = @input[:task] || @input["0"] || @input
+          
+        name            = task_data[:name]
+        created_by      = @env['REMOTE_HOST']
+        schedule_method = task_data[:schedule_method]
+        schedule_when   = task_data[:schedule_when]
+        
+        @task = Task.new(
+          :name => name,
+          :created_by => created_by,
+          :schedule_method => schedule_method,
+          :schedule_when => schedule_when
+        )
+        
+        # some gymnastics here to provide compatibility for the way various
+        # REST client libraries submit data
+        actions_data = task_data[:actions] || task_data[:action]
+        
+        raise ArgumentError, "Missing action(s) parameter." if actions_data.blank?
+
+        if actions_data.kind_of?(Array)
+          actions = actions_data
+        elsif actions_data["0"]
+          actions = []
+          actions_data.each do |i,a|
+            actions << a
+          end
+        else
+          actions = actions_data[:action]
+        end
+        
+        actions = [actions] unless actions.kind_of? Array
+        puts actions.inspect
+        
+        i = 0
+        actions.each do |a|
+          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
+              raise ArgumentError, 
+                "#{a[:action_class_name].inspect} cannot be used as an action because it does not include the OpenWFE::Schedulable module."
+            end
+          rescue NameError
+            raise ArgumentError, 
+              "#{a[:action_class_name].inspect} is not defined (i.e. there is no such action class)."
+          end
+          
+          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])
+          end
+          
+          @task.task_actions << action
+          i += 1
+        end
+        
+        
+        unless @task.valid?
+          @status = 500
+          return render(:new_task)
+        end
+      
+        
+        @task.schedule! Taskr.scheduler
+        
+        if @task.save
+          location = "/tasks/#{@task.id}?format=#{@format}"
+          $LOG.debug "#{@task} saved successfuly. Setting Location header to #{location.inspect}."
+          @headers['Location'] = location
+        end
+        
+        return render(:view_task)
+      rescue => e
+        puts e.inspect
+        puts e.backtrace
+        raise e
+      end
+    end
+    
+    def destroy(id)
+      @task = Task.find(id)
+      Taskr.scheduler.unschedule(@task.scheduler_job_id) if @task.scheduler_job_id
+      @task.destroy
+      return redirect('/tasks')
+    end
+  end
+end