jruby-quartz 1.2

data/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2009 Nick Zalabak
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README

@@ -0,0 +1,74 @@
+= jruby-quartz
+
+== Instructions
+
+Requires the following jars in your application container and if running with just jruby place these in your $JRUBY_HOME/lib
+
+commons-collections-3.2.x.jar
+commons-logging.jar
+log4j.jar
+quartz-1.6.x.jar
+
+If you are running a current version of JBoss you already have these!
+If you are running an alternative container you will need to check it's lib
+directory for the presence of these jars.
+
+If you need these jars you can find them within the apache commons project and
+the quartz jar on opensymphony
+
+== Installation
+
+  gem install git://github.com/techwhizbang/jruby-quartz.git
+
+== Usage
+
+The best way to leverage jruby-quartz is to simply extend the BaseScheduler and
+implement any number of jobs you need to run.
+
+For example all you need to do is specify some basic attributes including the
+cron expression representing the frequency of the job(s) you want to with it:
+
+class IntegrationScheduler < BaseScheduler
+
+  def initialize(cron_expression)
+    super
+    @cron_expression = cron_expression
+    @base_jobs_group = "IntegrationJobs"
+    @base_triggers_group = "IntegrationTriggers"
+  end
+end
+
+Then just extend the base job by putting all of the work you want to perform inside the
+perform_job method.
+
+class IntegrationJob < Jobs::BaseJob
+
+  def perform_job
+    worker_one = mock('worker class one', :whatever => "123")
+    worker_two = mock('worker class two', :whatever => '123')
+  end
+end
+
+If you are running Rails you can throw the schedule! method into a custom initializer.
+An example of this would be like so:
+Notice the Rails.env /container/, I defined custom environments that only run when
+inside a Java container so that the schedule! method doesn't get fired off during
+testing. 
+
+
+if RUBY_PLATFORM =~ /java/
+
+  LoggerOneScheduler.new("0 0/1 * * * ?").schedule!(Jobs::LoggerOneJob)
+  LoggerTwoScheduler.new("0 0/2 * * * ?").schedule!(Jobs::LoggerTwoJob)
+
+end
+
+If you are planning on using this with a Rails stack, I would recommend using this
+only with Rails 2.2 or higher because thread safety == 1 runtime
+
+1 runtime means your schedule initializer is only called once.
+
+=== Other
+
+Problems, comments, and suggestions all welcome. techwhizbang@gmail.com or visit my blog
+http://techwhizbang.com

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+task :default => :test
+
+task :test do
+  require File.dirname(__FILE__) + '/test/all_tests.rb'
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new do |task|
+  task.main = 'README'
+  task.title = 'jruby-quartz'
+  task.rdoc_dir = 'doc'
+  task.options << "--line-numbers" << "--inline-source"
+  task.rdoc_files.include('README', 'lib/**/*.rb')
+end
+
+specification = Gem::Specification.new do |s|
+	s.name   = "jruby-quartz"
+  s.summary = "Jruby-Quartz is a wrapper library for the Java based Quartz scheduling framework."
+	s.version = "1.2"
+	s.author = 'Nick Zalabak'
+	s.description = "Jruby-Quartz is a wrapper library for the Java based Quartz scheduling framework."
+	s.email = 'techwhizbang@gmail.com'
+  s.homepage = 'http://techwhizbang.com'
+  s.rubyforge_project = 'Jruby-Quartz'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README']
+  s.rdoc_options << '--title' << 'Jruby-Quartz' << '--main' << 'README' << '--line-numbers'
+
+  s.autorequire = 'jruby-quartz'
+  s.files = FileList['{lib,test}/**/*.rb', 'LICENSE', 'README', 'Rakefile'].to_a
+	s.test_file = "test/all_tests.rb"
+end
+
+Rake::GemPackageTask.new(specification) do |package|
+  package.need_zip = false
+  package.need_tar = false
+end

data/lib/base_scheduler.rb

@@ -0,0 +1,81 @@
+java_import org.quartz.SchedulerFactory
+java_import org.quartz.SchedulerException
+java_import org.quartz.Scheduler
+java_import org.quartz.JobDetail
+java_import org.quartz.CronTrigger
+java_import org.quartz.SimpleTrigger
+java_import org.quartz.impl.StdSchedulerFactory
+
+class BaseScheduler
+  attr_reader :scheduler_factory
+
+  attr_accessor :base_jobs_group, :base_triggers_group
+  attr_accessor :job_name, :trigger_name, :cron_expression
+  
+  def initialize(cron_expression=nil)
+    @scheduler_factory = initialize_scheduler_factory
+    @base_jobs_group = "BaseJobsGroup"
+    @base_triggers_group = "BaseTriggersGroup"
+    @job_name = "BaseJob"
+    @trigger_name = "BaseTrigger"
+    @cron_expression = cron_expression
+  end
+
+  def fire!(job_class, options={})
+    begin
+      scheduler = scheduler_factory.get_scheduler
+      scheduler.trigger_job(self.job_name, self.base_jobs_group)
+    rescue Exception => e
+      raise SchedulerError.new(e)
+    end
+  end
+
+  def schedule!(job_class, options={})
+    begin
+      scheduler = scheduler_factory.get_scheduler
+      detail = job_detail_setup(scheduler, job_class)
+      current_trigger = cron_trigger.new(self.trigger_name,
+                                         self.base_triggers_group,
+                                         self.job_name,
+                                         self.base_jobs_group,
+                                         self.cron_expression)
+      scheduler.schedule_job(detail, current_trigger)
+    rescue Exception => e
+      raise SchedulerError.new(e)
+    end
+  end
+
+  protected
+
+  def job_detail_setup(scheduler, job_class)
+    scheduler.set_job_factory(job_factory.new)
+    detail = job_detail.new(self.job_name,
+                            self.base_jobs_group,
+                            job_class.new())
+    detail
+  end
+
+  def trigger
+    SimpleTrigger
+  end
+
+  def initialize_scheduler_factory(options={})
+    StdSchedulerFactory.new
+  end
+
+  def job_factory
+    Jobs::BaseJobFactory
+  end
+
+  def job_detail
+    Jobs::BaseJobDetail
+  end
+
+  def cron_trigger
+    CronTrigger
+  end
+
+  class SchedulerError < StandardError; end
+
+end
+

data/lib/jobs/base_job.rb

@@ -0,0 +1,30 @@
+java_import org.quartz.Job
+java_import org.quartz.JobExecutionContext
+java_import org.quartz.JobExecutionException
+
+module Jobs
+  class BaseJob
+    include org.quartz.Job
+    implement org.quartz.Job
+
+    def initialize(); end
+
+    def execute(context)
+      begin
+        perform_job
+      rescue Exception => e
+        raise JobError.new(e)
+      end
+    end
+
+    def perform_job
+      raise "Subclass must implement the perform job method"
+    end
+
+  end
+
+  class JobError < StandardError ; end
+end
+
+
+

data/lib/jobs/base_job_detail.rb

@@ -0,0 +1,27 @@
+java_import org.quartz.JobDetail
+java_import org.quartz.SchedulerException
+
+module Jobs
+  class BaseJobDetail < org.quartz.JobDetail
+
+    attr_accessor :job
+
+    def initialize(name, group, job)
+      super()
+      set_name name
+      set_group group
+      @job = job
+    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/jobs/base_job_factory.rb

@@ -0,0 +1,15 @@
+java_import org.quartz.spi.JobFactory
+java_import org.quartz.spi.TriggerFiredBundle
+java_import org.quartz.JobDetail
+
+module Jobs
+  class BaseJobFactory
+    include org.quartz.spi.JobFactory
+
+    def new_job bundle
+      bundle.get_job_detail.job
+    end
+  end
+end
+
+

data/lib/jruby-quartz.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/base_scheduler')
+require File.expand_path(File.dirname(__FILE__) + '/jobs/base_job')
+require File.expand_path(File.dirname(__FILE__) + '/jobs/base_job_detail')
+require File.expand_path(File.dirname(__FILE__) + '/jobs/base_job_factory')
+
+module JrubyQuartz
+  VERSION = '1.2'
+end

data/test/all_tests.rb

@@ -0,0 +1 @@
+Dir['**/*_test.rb'].each { |test_case| require test_case }

data/test/integration/jruby_quartz_integration_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class IntegrationScheduler < BaseScheduler
+
+  def initialize(cron_expression)
+    super
+    @job_name = "IntegrationJob"
+    @trigger_name = "IntegrationTrigger"
+    @base_jobs_group = "IntegrationJobs"
+    @base_triggers_group = "IntegrationTriggers"
+    @cron_expression = cron_expression
+  end
+end
+
+class IntegrationJob < Jobs::BaseJob
+
+  def perform_job
+    worker_one = mock('worker class one', :whatever => "123")
+    worker_two = mock('worker class two', :whatever => '123')
+  end
+end
+
+class JrubyQuartzIntegrationTest < Test::Unit::TestCase
+
+  def test_scheduler_implementation
+    integration_scheduler = IntegrationScheduler.new "0 0/1 * * * ?"
+
+    #must stub the scheduler and scheduler factory to avoid invokation of real Quartz thread pool, etc.
+    scheduler = mock('scheduler')
+    scheduler_factory = mock('scheduler factory', :get_scheduler => scheduler)
+
+    scheduler.expects(:schedule_job)
+    scheduler.expects(:set_job_factory)
+    
+    integration_scheduler.expects(:scheduler_factory).returns(scheduler_factory)
+    integration_scheduler.schedule!(IntegrationJob)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/jruby-quartz")

data/test/unit/base_job_detail_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class BaseJobDetailTest < Test::Unit::TestCase
+
+  def test_initialization
+    assert_instance_of(Jobs::BaseJobDetail, Jobs::BaseJobDetail.new("Name", "Group", "Job"))
+  end
+
+  def test_initialization_with_failed_validation
+    assert_raise(NativeException) { Jobs::BaseJobDetail.new(nil, nil, nil) }
+  end
+
+end

data/test/unit/base_job_factory_test.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class BaseJobFactoryTest < Test::Unit::TestCase
+
+  def test_new_job
+    job = mock('job')
+    job_detail = mock('job detail', :job => job)
+    bundle = mock('bundle', :get_job_detail => job_detail)
+    Jobs::BaseJobFactory.new.new_job(bundle)
+  end
+
+end

data/test/unit/base_job_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class BaseJobTest < Test::Unit::TestCase
+
+  def test_initialize
+    assert_instance_of(Jobs::BaseJob, Jobs::BaseJob.new)
+  end
+
+  def test_quartz_job_implement
+    assert_kind_of(org.quartz.Job, Jobs::BaseJob.new)
+  end
+
+  def test_execute
+    context = mock('context')
+    job = Jobs::BaseJob.new
+    job.expects(:perform_job)
+    job.execute(context)
+  end
+
+end

data/test/unit/base_scheduler_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class BaseSchedulerTest < Test::Unit::TestCase
+
+#  def test_singleton_initialization
+#    assert_raise(NoMethodError) { BaseScheduler.new }
+#    assert_not_nil(BaseScheduler.instance)
+#  end
+  
+  def test_scheduler_instance_variables
+    scheduler = BaseScheduler.new "0 0/1 * * * ?"
+    assert_equal scheduler.base_jobs_group, "BaseJobsGroup"
+    assert_equal scheduler.job_name, "BaseJob"
+    assert_equal scheduler.base_triggers_group, "BaseTriggersGroup"
+    assert_equal scheduler.trigger_name, "BaseTrigger"
+    assert_equal scheduler.cron_expression, "0 0/1 * * * ?"
+  end
+
+  def test_trigger_class
+    scheduler = BaseScheduler.new stub
+    assert_kind_of(org.quartz.SimpleTrigger, scheduler.send(:trigger).new)
+  end
+
+  def test_job_factory_class
+    scheduler = BaseScheduler.new stub
+    assert_kind_of(Jobs::BaseJobFactory, scheduler.send(:job_factory).new)
+  end
+
+  def test_job_detail_class
+    scheduler = BaseScheduler.new stub
+    assert_kind_of(Jobs::BaseJobDetail, scheduler.send(:job_detail).new("JobName",
+                                                                                     'JobGroup',
+                                                                                     'JobClass'))
+  end
+
+  def test_scheduler_factory_class
+    scheduler = BaseScheduler.new stub
+    assert_kind_of(StdSchedulerFactory, scheduler.send(:initialize_scheduler_factory))
+  end
+
+  def test_cron_trigger_class
+    scheduler = BaseScheduler.new stub
+    assert_kind_of(CronTrigger, scheduler.send(:cron_trigger).new)
+  end
+
+  def test_schedule_method
+    base_scheduler = BaseScheduler.new stub
+    base_job = mock("base job")
+    scheduler = mock('scheduler')
+    job_factory = mock('job factory')
+    job_detail = mock('job detail')
+    cron_trigger = mock('cron trigger')
+    scheduler_factory = mock('scheduler factory', :get_scheduler => scheduler)
+
+    base_scheduler.expects(:scheduler_factory).returns(scheduler_factory)
+    
+    job_factory.expects(:new).returns(job_factory)
+    base_job.expects(:new).returns(base_job)
+    job_detail.expects(:new).returns(job_detail)
+    cron_trigger.expects(:new).returns(cron_trigger)
+    
+    scheduler.expects(:set_job_factory).with(job_factory)
+    scheduler.expects(:schedule_job).with(job_detail, cron_trigger)
+    
+    base_scheduler.stubs(:job_detail).returns(job_detail)
+    base_scheduler.stubs(:job_factory).returns(job_factory)
+    base_scheduler.stubs(:cron_trigger).returns(cron_trigger)
+    base_scheduler.schedule!(base_job)
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-quartz
+version: !ruby/object:Gem::Version 
+  version: "1.2"
+platform: ruby
+authors: 
+- Nick Zalabak
+autorequire: jruby-quartz
+bindir: bin
+cert_chain: []
+
+date: 2010-01-17 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Jruby-Quartz is a wrapper library for the Java based Quartz scheduling framework.
+email: techwhizbang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/base_scheduler.rb
+- lib/jruby-quartz.rb
+- lib/jobs/base_job.rb
+- lib/jobs/base_job_detail.rb
+- lib/jobs/base_job_factory.rb
+- test/integration/jruby_quartz_integration_test.rb
+- test/unit/base_job_detail_test.rb
+- test/unit/base_job_factory_test.rb
+- test/unit/base_job_test.rb
+- test/unit/base_scheduler_test.rb
+- test/all_tests.rb
+- test/test_helper.rb
+- java/commons-collections-3.2.1.jar
+- java/commons-logging.jar
+- java/log4j.jar
+- java/quartz-1.6.4.jar
+- LICENSE
+- README
+- Rakefile
+has_rdoc: true
+homepage: http://techwhizbang.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Jruby-Quartz
+- --main
+- README
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A JRuby implementation of the Quartz scheduling framework that makes it easy to integrate into Ruby and Rails based projects.
+test_files: []
+