trinidad_scheduler_extension 0.1.0

data/LICENSE

@@ -0,0 +1,26 @@
+== TrinidadScheduler Extension
+
+Copyright (c) 2011 Brandon Dewitt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== Additional Bundled Software
+
+Quartz Scheduler is licensed according to the terms of Apache License, Version 2.0 (current). See http://www.apache.org/licenses/LICENSE-2.0 for details.

data/README

@@ -0,0 +1,127 @@
+Trinidad Scheduler Extension
+===
+Trinidad Scheduler uses Quartz to schedule processes for execution.  It can be run as a server extension to Trinidad and/or a Web Application extension
+for Trinidad.  If run as a Server extension all schedulers will get the server configuration options each option that is defined at the Web Application
+level will override the Server option.  
+
+Trinidad Scheduler creates a unique scheduler for each web application.
+
+Most processes we schedule are scheduled using the *Cron* Trigger and *run_later*
+
+Install Gem
+---
+    gem install trinidad_scheduler_extension
+    
+Configure Trinidad
+---
+In either the Server *extensions* block or the Web Application *extentions* block add "scheduler"
+
+    extensions:
+      scheduler:
+
+Example Usage
+---
+It is valid to use the top level scheduling methods and run_later together
+
+    class ScheduledLog < TrinidadScheduler.Cron "0/5 * * * * ?"
+      def run
+        _logger.info "Executed every 5 seconds"
+        
+        TrinidadScheduler.run_later do 
+          _logger.info "Executed after a 3 second delay"
+        end
+      end
+    end
+
+Laziness
+---
+Trinidad Scheduler is very lazy.  Schedulers will only be instantiated when they are needed to execute a job or to setup a schedule for execution.
+This laziness extends to even runtime definition of classes and use of run_later in conditional statements.  When a run_later block is encountered or
+a class is defined at runtime that inherits from a TrinidadScheduler base method the scheduler will be created and started (if it does not exist)
+
+If schedules are defined during application initialization then the scheduler will not be started until after the application is started by Tomcat.
+
+(The lazy nature of TrinidadScheduler also gives the user time to define a logger outstide of the default configured log4j StdOut logger that 
+is included with TrinidadScheduler)
+
+Usage
+===
+The extension defines several methods that return classes based on the configuration options provided.  These methods map to the scheduler trigger type
+that Quartz provides.  The implemented triggers are CronTrigger, SimpleTrigger, and DateIntervalTrigger. 
+
+Cron Trigger
+---
+To define a process to be run based on a [cron expression] (http://en.wikipedia.org/wiki/CRON_expression#CRON_expression)
+
+    class ScheduledClass < TrinidadScheduler.Cron "0/5 * * * * ?"
+      def run
+        _logger.info "I am printed every 5 seconds"
+      end
+    end
+
+The method *TrinidadScheduler.Cron* takes a cron expression as it's only argument and returns a class.  This anonymous class is the parent of
+ScheduledClass and does the work to wrap ScheduledClass for use as a CronTrigger in Quartz.
+
+The instance method "run" must be defined because it is called when the scheduled process is triggered.  *_logger* is an instance variable available
+in ScheduledClass which gives the class access to the Quartz logger that is configured.   
+
+Simple Trigger
+---
+Schedule an INFO log message every 5 seconds starting now, setting the end is not necessary in this context, but is done
+    
+    class TestJob < TrinidadScheduler.Simple :start => Time.now, :end => Time.now + 240, :repeat 3, :interval => 5000
+      def run
+        _logger.info "I am inside this block" #=> prints "I am inside this block" every 5 seconds
+      end
+    end
+
+The Simple Trigger will execute based on options passed to the method *TrinidadScheduler.Simple*, the options available are outlined
+above in the example, none of them are necessary if you only want to trigger the process once.   You can define a start and end time as well as how many
+times to fire the trigger along with an interval to be observed between trigger execution.
+
+DateInterval Trigger
+---
+Schedule an INFO log message every 5 seconds starting now and ending after 4 minutes
+    
+    class TestJob < TrinidadScheduler.DateInterval :start => Time.now, :end => Time.now + 240, :unit => :second, :interval => 5
+      def run
+        _logger.info "I am inside this block" #=> prints "I am inside this block" every 5 seconds
+      end
+    end
+
+The DateInterval Trigger will execute a triggered process based on the configuration options passed.  For more information on using the DateInterval
+trigger consult the source. 
+
+run_later
+---
+Schedules a block of code to run in another Thread after execution proceeds in the current Thread
+*after the job runs it removes itself from the job scheduler 
+
+Using run_later with default 3 second delay
+
+    TrinidadScheduler.run_later do
+      _logger.info "I am inside this block" #=> prints "I am inside this block" 
+    end
+  
+Using run_later with 20 second delay
+
+    TrinidadScheduler.run_later(:delay => 20) do
+      _logger.info "I am inside this block" #=> prints "I am inside this block" 
+    end 
+    
+Behind the scemes *run_later* is actually implemented using an anonymous class that inherits from TrinidadScheduler.Simple to schedule the run.
+
+
+Inspiration
+---
+Open Source software is a community effort - thanks to all, but the following were instrumental in the inspiration for TrinidadScheduler.
+
+    [techwhizbang] (https://github.com/techwhizbang/jruby-quartz) for handling of Quartz JobFactory
+    [why_metaid] (https://github.com/evaryont/why_metaid) for metaid extension
+    [TERRACOTTA] (http://www.terracotta.org/) for continued support Quartz Scheduler
+    [calavera] (https://github.com/calavera/trinidad) for Trinidad Server
+
+
+Copyright
+---
+Copyright (c) 2011 Brandon Dewitt<brandon+trinidad_scheduler@myjibe.com>. See LICENSE for details.    

data/lib/trinidad_scheduler_extension.rb

@@ -0,0 +1,22 @@
+require 'java'
+
+require 'trinidad'
+require 'trinidad/jars'
+
+# Jar files that are needed
+require 'trinidad_scheduler_extension/jars/log4j-1.2.16'
+require "trinidad_scheduler_extension/jars/slf4j-api-1.6.1"
+require "trinidad_scheduler_extension/jars/slf4j-log4j12-1.6.1"
+require "trinidad_scheduler_extension/jars/quartz-1.8.4"
+
+# Trinidad Scheduler Extension files
+require 'trinidad_scheduler_extension/version.rb'
+require 'trinidad_scheduler_extension/trinidad_scheduler'
+require 'trinidad_scheduler_extension/extensions/object'
+require 'trinidad_scheduler_extension/scheduler_listener'
+require 'trinidad_scheduler_extension/job_detail'
+require 'trinidad_scheduler_extension/job_factory'
+require 'trinidad_scheduler_extension/scheduled_job'
+require 'trinidad_scheduler_extension/app_job'
+require 'trinidad_scheduler_extension/scheduler_extension'
+

data/lib/trinidad_scheduler_extension/app_job.rb

@@ -0,0 +1,152 @@
+module TrinidadScheduler  
+  module AppJob
+    include org.quartz.Job    
+    include TrinidadScheduler::ScheduledJob 
+    
+    def self.included(other_obj)
+      new_job = TrinidadScheduler::JobDetail.new("#{ other_obj.job_detail_name rescue other_obj }", "#{other_obj}", other_obj)
+      begin 
+        TrinidadScheduler[$servlet_context].schedule_job(new_job, other_obj.trigger)
+      rescue Exception => ex
+        raise JobError.new(ex)
+      end
+    end
+  end
+  
+  # Method to schedule a block of code to run in another Thread after execution proceeds in the current Thread
+  # after the job runs it removes itself from the job scheduler 
+  #
+  # @example Running run_later with default 3 second delay
+  #   TrinidadScheduler.run_later do
+  #     _logger.info "I am inside this block" #=> prints "I am inside this block" 
+  #   end
+  #
+  # @example Running run_later with 20 second delay
+  #   TrinidadScheduler.run_later(:delay => 20) do
+  #     _logger.info "I am inside this block" #=> prints "I am inside this block" 
+  #   end  
+  #
+  # @param [Hash] opts the options for the process to be run
+  # @option opts [Integer] :delay the number of seconds delay before the block is triggered
+  # @param [Block] the block that will be run in a separate Thread after the delay
+  def self.run_later(opts={:delay=>3}, &blk)
+    Class.new(TrinidadScheduler.Simple :start => (Time.now + opts[:delay])) do 
+      meta_def(:job_detail_name){ Time.now.to_i.to_s << Time.now.usec.to_s }
+      meta_def(:run_proc){ blk }
+      
+      def run
+        self.class.run_proc.call
+      end  
+    end
+  end
+  
+  # Method to return an inheritable class for scheduling a CronTrigger Job 
+  # the class that inherits from this method will have it's instance run method executed based on the cron_expression
+  #
+  # @example Schedule an INFO log message every 5 seconds
+  #   class TestJob < TrinidadScheduler.Cron "0/5 * * * * ?"
+  #     def run
+  #       _logger.info "I am inside this block" #=> prints "I am inside this block" every 5 seconds
+  #     end
+  #   end
+  #
+  # @param [String] cron_expression the Cron Expression that defines the CronTrigger for the job class   
+  # @return [Class] a new Class that is run by the CronTrigger that is defined
+  def self.Cron(cron_expression)
+    Class.new do
+      meta_def(:cron){ cron_expression }
+      
+      def self.inherited(subclass) 
+        meta_def :trigger do
+          org.quartz.CronTrigger.new("#{subclass}" + ".trigger", "#{subclass}", self.cron)
+        end
+
+        subclass.send(:include, TrinidadScheduler::AppJob)
+      end
+    end  
+  end
+  
+  # Method to return an inheritable class for scheduling a SimpleTrigger Job 
+  # the class that inherits from this method will have it's instance run method executed based on the options passed
+  #
+  # @example Schedule an INFO log message every 5 seconds starting now, setting the end is not necessary in this context, but it done
+  #   class TestJob < TrinidadScheduler.Simple :start => Time.now, :end => Time.now + 240, :repeat 3, :interval => 5000
+  #     def run
+  #       _logger.info "I am inside this block" #=> prints "I am inside this block" every 5 seconds
+  #     end
+  #   end
+  #
+  # @param [Hash] opts the options for the SimpleTrigger
+  # @option opts [java.util.Date, Time] :start the starting time of the trigger
+  # @option opts [java.util.Date, Time] :end the ending time of the trigger
+  # @option opts [Integer] :repeat the number of times to repeat the job (defaults to 0)
+  # @option opts [Integer] :interval the number of milliseconds between runs
+  # @return [Class] a new anonymous Class that is the parent of the Class run by the SimpleTrigger that is defined
+  def self.Simple(opts={})    
+    opts[:start] ||= java.util.Date.new(Time.now.to_i*1000)
+    opts[:start] = java.util.Date.new(opts[:start].to_i*1000) if opts[:start].class == Time
+    
+    opts[:end] ||= java.util.Date.new((Time.now + 10.years).to_i*1000)
+    opts[:end] = java.util.Date.new(opts[:end].to_i*1000) if opts[:end].class == Time
+    
+    opts[:repeat] ||= 0
+    opts[:interval] ||= 0
+    
+    Class.new do
+      meta_def(:opts){ opts }
+
+      def self.inherited(subclass)
+        meta_def :trigger do
+          org.quartz.SimpleTrigger.new("#{subclass}" + ".trigger", "#{subclass}", 
+                                       self.opts[:start], self.opts[:end], 
+                                       self.opts[:repeat], self.opts[:interval])
+        end 
+        
+        subclass.send(:include, TrinidadScheduler::AppJob)
+      end
+    end  
+  end
+  
+  # Method to return an inheritable class for scheduling a DateIntervalTrigger Job 
+  # the class that inherits from this method will have it's instance run method executed based on the options passed
+  #
+  # @example Schedule an INFO log message every 5 seconds starting now and ending after 4 minutes
+  #   class TestJob < TrinidadScheduler.DateInterval :start => Time.now, :end => Time.now + 240, :unit => :second, :interval => 5
+  #     def run
+  #       _logger.info "I am inside this block" #=> prints "I am inside this block" every 5 seconds
+  #     end
+  #   end
+  #
+  # @param [Hash] opts the options for the DateIntervalTrigger
+  # @option opts [java.util.Date, Time] :start the starting time of the trigger
+  # @option opts [java.util.Date, Time] :end the ending time of the trigger
+  # @option opts [Symbol, String] :unit the defined unit (:day, :second, :year, :month, :week)
+  # @option opts [Integer] :interval the number of units between runs
+  # @return [Class] a new anonymous Class that is the parent of the Class run by the SimpleTrigger that is defined
+  def self.DateInterval(opts={})    
+    opts[:start] ||= java.util.Date.new(Time.now.to_i*1000)
+    opts[:start] = java.util.Date.new(opts[:start].to_i*1000) if opts[:start].class == Time
+    
+    opts[:end] ||= java.util.Date.new((Time.now + 10.years).to_i*1000)
+    opts[:end] = java.util.Date.new(opts[:end].to_i*1000) if opts[:end].class == Time
+    
+    opts[:unit] ||= :day
+    opts[:unit] = org.quartz.DateIntervalTrigger::IntervalUnit.value_of(opts[:unit].to_s.upcase)
+
+    opts[:interval] ||= 1
+    
+    Class.new do
+      meta_def(:opts){ opts }
+
+      def self.inherited(subclass) 
+        meta_def :trigger do
+          org.quartz.DateIntervalTrigger.new("#{subclass}" + ".trigger", "#{subclass}", 
+                                             self.opts[:start], self.opts[:end], 
+                                             self.opts[:unit], self.opts[:interval])        
+        end
+        
+        subclass.send(:include, TrinidadScheduler::AppJob)
+      end
+    end  
+  end
+end

data/lib/trinidad_scheduler_extension/config/log4j.properties

@@ -0,0 +1,11 @@
+#
+# our log4j properties / configuration file
+#
+# STDOUT appender
+log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
+log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
+log4j.appender.STDOUT.layout.ConversionPattern=%d %p [%t] %C{1} - %m\n
+
+# use the STDOUT appender. set the level to INFO.
+log4j.rootLogger=INFO, STDOUT
+

data/lib/trinidad_scheduler_extension/extensions/object.rb

@@ -0,0 +1,12 @@
+# Metaid == a few simple metaclass helper
+# (See http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html.)
+class Object
+   # The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval &blk; metaclass.instance_eval &blk; end
+
+   # Adds methods to a metaclass
+   def meta_def name, &blk
+     meta_eval { define_method name, &blk }
+   end
+end

data/lib/trinidad_scheduler_extension/job_detail.rb

@@ -0,0 +1,20 @@
+module TrinidadScheduler 
+  class JobDetail < org.quartz.JobDetail
+    
+    attr_accessor :job
+    
+    def initialize(name, group, job_class)
+      super()
+      set_name name
+      set_group group
+      @job = job_class.new
+    end
+    
+    def validate()
+      raise org.quartz.SchedulerException.new("Job's name cannot be null",
+        org.quartz.SchedulerException.ERR_CLIENT_ERROR) if get_name == nil
+      raise org.quartz.SchedulerException.new("Job's group cannot be null",
+        org.quartz.SchedulerException.ERR_CLIENT_ERROR) if get_group == nil  
+    end  
+  end
+end

data/lib/trinidad_scheduler_extension/job_factory.rb

@@ -0,0 +1,9 @@
+module TrinidadScheduler
+  class JobFactory
+    include org.quartz.spi.JobFactory
+    
+    def new_job bundle
+      bundle.get_job_detail.job
+    end
+  end
+end

data/lib/trinidad_scheduler_extension/scheduled_job.rb

@@ -0,0 +1,22 @@
+module TrinidadScheduler
+  module ScheduledJob
+    class JobError < StandardError; end
+    
+    attr_accessor :_context
+    attr_accessor :_logger
+    
+    def run
+      raise "Implement a [run] method if you are going to use #{self.class} as a job class"
+    end  
+      
+    def execute(context)
+      begin 
+        @_context = context
+        @_logger = org.apache.log4j.Logger.getLogger("#{self.class}")
+        run()
+      rescue Exception => ex
+        raise JobError.new(ex)
+      end
+    end
+  end
+end

data/lib/trinidad_scheduler_extension/scheduler_extension.rb

@@ -0,0 +1,18 @@
+module Trinidad  
+  module Extensions
+    
+    class SchedulerWebAppExtension < WebAppExtension
+      
+      def configure(tomcat, app_context)
+        app_context.add_lifecycle_listener(TrinidadScheduler::WebAppListener.new(app_context.servlet_context, @options))
+      end
+    end
+    
+    class SchedulerServerExtension < ServerExtension
+      
+      def configure(tomcat)
+        tomcat.get_host.add_container_listener(TrinidadScheduler::GlobalListener.new(@options))
+      end
+    end
+  end
+end    

data/lib/trinidad_scheduler_extension/scheduler_listener.rb

@@ -0,0 +1,42 @@
+module TrinidadScheduler
+  class WebAppListener
+    include org.apache.catalina.LifecycleListener
+    
+    def initialize(servlet_context, options)
+      @servlet_context = servlet_context
+      @options = options         
+      TrinidadScheduler.store_scheduler_options(@servlet_context, @options)
+    end
+    
+    def needs_started?
+      TrinidadScheduler.scheduler_exists?(@servlet_context) && !TrinidadScheduler[@servlet_context].is_started
+    end
+    
+    def lifecycle_event(event)
+      case event.type
+      when org.apache.catalina.Lifecycle::START_EVENT then
+        if needs_started?
+          TrinidadScheduler[@servlet_context].start
+          TrinidadScheduler[@servlet_context].resume_all
+        end
+        
+        TrinidadScheduler.set_servlet_started(@servlet_context)
+      end
+    end
+  end
+
+  class GlobalListener
+    include org.apache.catalina.ContainerListener
+    
+    def initialize(options)
+      @options = options
+    end
+    
+    def container_event(event)
+      case event.type
+      when org.apache.catalina.Container::ADD_CHILD_EVENT then
+        event.data.add_lifecycle_listener(TrinidadScheduler::WebAppListener.new(event.data.servlet_context, @options))
+      end
+    end
+  end
+end

data/lib/trinidad_scheduler_extension/trinidad_scheduler.rb

@@ -0,0 +1,131 @@
+module TrinidadScheduler
+  CONFIG_HOME = File.expand_path(File.dirname(__FILE__) + "/trinidad_scheduler_extension/config")
+  JAR_HOME = File.expand_path(File.dirname(__FILE__) + "/trinidad_scheduler_extension/jars")
+  
+  # Sets log4j properties if not established by Application Servers
+  # TrinidadScheduler is really lazy so this is only set when a scheduler is needed
+  def self.trinidad_scheduler_init_log4j
+    if java.lang.System.get_property('log4j.configuration').nil? 
+      java.lang.System.set_property('log4j.configuration', java.io.File.new("#{CONFIG_HOME}/log4j.properties").to_url.to_s)
+    end
+  end 
+  
+  # Standardizing the naming of the variables that are stored on the context
+  def self.context_path(path)
+    path.gsub("/", "") == "" ? "Default" : path.gsub("/", "").capitalize
+  end
+  
+  # Assists in lazily evaluating if a scheduler is needed for a context
+  # 
+  # @param [ServletContext] context
+  # @return [Boolean]
+  def self.scheduler_exists?(context)
+    !!context.get_attribute(scheduler_name(context))
+  end
+  
+  # Tomcat event callbacks are good for static systems but JRuby allows dynamic definition of classes and function
+  # so I am storing a variable on the servlet context that allow the extension to check if the servlet has been started
+  # during lazy evaluation of the need for a scheduler and/or starting the scheduler
+  #
+  # @param [ServletContext] context
+  # @return [Boolean]
+  def self.servlet_started?(context)
+    !!context.get_attribute(started_name(context))
+  end
+  
+  # Helper to centralize the operations on the servlet contexts, sets the servlet started variable when the context is started, reguardless of whether
+  # a scheduler exists or not
+  # 
+  # @param [ServletContext] context
+  def self.set_servlet_started(context)
+    context.set_attribute(started_name(context), true)
+  end
+  
+  # Helper method that attaches the configuration options from the Trinidad config file to the ServletContext
+  #
+  # @param [ServletContext] context
+  # @param [Hash] options
+  def self.store_scheduler_options(context, options)
+    context.set_attribute(options_name(context), options)
+  end
+
+  # Centralized definition of where variables will be stored on the ServletContext
+  def self.started_name(context)
+    "TrinidadScheduler::#{context_path(context.context_path)}::ServletStarted"
+  end
+  
+  def self.options_name(context)
+    "TrinidadScheduler::#{context_path(context.context_path)}::SchedulerOptions"
+  end
+  
+  def self.scheduler_name(context)
+    "TrinidadScheduler::#{context_path(context.context_path)}::Scheduler"
+  end
+  
+  # Bracket accessor defined to retreive the scheduler for a context
+  # if no scheduler is attached to the context then one is created and attached at time of access and returned
+  # 
+  # @param [ServletContext] context
+  # @return [org.quartz.impl.StdScheduler]
+  def self.[](context)
+    if !scheduler_exists?(context)
+      self.trinidad_scheduler_init_log4j
+      self[context] = self.quartz_scheduler(context, context.get_attribute(options_name(context)))
+    end
+    
+    scheduler = context.get_attribute(scheduler_name(context)) 
+    
+    if !scheduler.is_started && servlet_started?(context)
+      scheduler.start
+      scheduler.resume_all
+    end
+    
+    return scheduler
+  end
+  
+  # Bracket assignment operator, will attach the scheduler passed to the context in the brackets
+  #
+  # @param [ServletContext] context
+  # @param [org.quartz.impl.StdScheduler] scheduler
+  def self.[]=(context, scheduler)
+    context.set_attribute(scheduler_name(context), scheduler)
+  end 
+  
+  # Method to build and return Quartz schedulers
+  #
+  # @param [ServletContext] context
+  # @param [Hash] opts, the options to configure the scheduler with 
+  def self.quartz_scheduler(context, opts={})
+    options = {:wrapped => false, :thread_count => 10, :thread_priority => 5}
+    options.merge!(opts)
+    options[:name] = context_path(context.context_path)
+    
+    scheduler_factory = org.quartz.impl.StdSchedulerFactory.new
+    scheduler_factory.initialize(quartz_properties(options))
+    scheduler = scheduler_factory.get_scheduler
+    scheduler.set_job_factory(TrinidadScheduler::JobFactory.new)
+    scheduler.pause_all
+    return scheduler
+  end
+  
+  # Properties stream for initializing a scheduler
+  # Currently restricts schedulers to RAMJobStore and SimpleThreadPool
+  def self.quartz_properties(opts={})
+    prop_string = java.lang.String.new("
+      org.quartz.scheduler.rmi.export = false
+      org.quartz.scheduler.rmi.proxy = false
+      org.quartz.scheduler.wrapJobExecutionInUserTransaction = #{opts[:wrapped]}
+      org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
+      org.quartz.threadPool.threadCount = #{opts[:thread_count]}
+      org.quartz.threadPool.threadPriority = #{opts[:thread_priority]}
+      org.quartz.threadPool.threadNamePrefix = WorkerThread::#{opts[:name]}
+      org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
+      org.quartz.jobStore.misfireThreshold = 60000
+      org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore")
+    
+    qp = java.util.Properties.new 
+    qp.load(java.io.ByteArrayInputStream.new(prop_string.getBytes()))
+    qp.set_property("org.quartz.scheduler.instanceName", "Quartz::#{opts[:name]}::Application")
+    return qp
+  end
+end

data/lib/trinidad_scheduler_extension/version.rb

@@ -0,0 +1,3 @@
+module TrinidadScheduler
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: trinidad_scheduler_extension
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+  - Brandon Dewitt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: trinidad_jars
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+description: Extension to support scheduled jobs in Trinidad
+email: brandon+trinidad_scheduler@myjibe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - LICENSE
+  - README
+files: 
+  - LICENSE
+  - README
+  - lib/trinidad_scheduler_extension.rb
+  - lib/trinidad_scheduler_extension/app_job.rb
+  - lib/trinidad_scheduler_extension/config/log4j.properties
+  - lib/trinidad_scheduler_extension/extensions/object.rb
+  - lib/trinidad_scheduler_extension/jars/log4j-1.2.16.jar
+  - lib/trinidad_scheduler_extension/jars/quartz-1.8.4.jar
+  - lib/trinidad_scheduler_extension/jars/slf4j-api-1.6.1.jar
+  - lib/trinidad_scheduler_extension/jars/slf4j-log4j12-1.6.1.jar
+  - lib/trinidad_scheduler_extension/job_detail.rb
+  - lib/trinidad_scheduler_extension/job_factory.rb
+  - lib/trinidad_scheduler_extension/scheduled_job.rb
+  - lib/trinidad_scheduler_extension/scheduler_extension.rb
+  - lib/trinidad_scheduler_extension/scheduler_listener.rb
+  - lib/trinidad_scheduler_extension/trinidad_scheduler.rb
+  - lib/trinidad_scheduler_extension/version.rb
+has_rdoc: true
+homepage: https://github.com/bdewitt/trinidad_scheduler_extension
+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.6.1
+signing_key: 
+specification_version: 3
+summary: "Extension to support scheduled jobs in Trinidad: Extension"
+test_files: []
+