secondhand 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Amphora Reseach Systems Ltd.
+
+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.

data/README.md

@@ -0,0 +1,286 @@
+Secondhand
+==========
+
+Secondhand is a ruby-friendly wrapper around the [Quartz Job Scheduler][0].
+Create jobs, tell Secondhand when they should run, then sit back and enjoy. 
+
+_Secondhand is JRuby only what with Quartz being Java and all._
+
+
+Overview
+--------
+
+Secondhand was created to:
+
+* provide a clean API to job scheduling (with few, if any, dependencies)
+* give you more control over job resource utilization/allocation 
+* take advantage of the Quartz service
+
+You can schedule jobs that will run right away, on a specific date, or use
+a repeating schedule with a familiar cron syntax. Secondhand allows you to 
+adjust the number of Quartz worker threads, and create jobs in a way that makes 
+sense in your environment.
+
+Secondhand does not try to be a full interface to all the power and
+capabilities of Quartz. Think of it more like a nice subset that allows you
+to have robust job scheduling without learning all about Quartz. (You can always
+get to the underlying objects and tinker if you need to.)
+
+Like Resque, Jobs in Secondhand can be any class or module that responds to 
+`perform` and, like some of the other Quartz+Ruby libraries out there, a job 
+can be a block/proc. (Secondhand jobs don't take parameters [yet].)
+
+
+Workers 
+-------
+
+Quartz spawns worker threads to execute jobs when triggers are fired. Secondhand 
+defaults to 5 workers as recommended in the Quartz documentation - while Quartz 
+defaults to 10. Note: Quartz will block itself if all worker threads are busy 
+when a trigger fires.
+
+
+Jobs
+----
+
+A job in Secondhand might look like this:
+
+    class Scan
+      def self.perform # class method
+        do_some_work
+        log_it
+        do_some_more_work
+        close_connections
+      end
+    end
+
+    # To run this job immediately you would use:
+
+    Secondhand.schedule Scan
+
+
+### OR
+
+You can go with the block syntax for an immediate job:
+
+    Secondhand.schedule :the_scan do
+      do_some_work
+      log_it
+      do_some_more_work
+      close_connections
+    end
+
+This scheduled job is added to the Quartz scheduler and associated with a 
+trigger. In the case of the jobs above, the trigger is a `SimpleTrigger` that
+executes immediately.
+
+*Important* 
+Each job must have a unique name. Secondhand calls #to_s on the first 
+parameter and uses that for the job name. This means that you can't schedule the
+same class twice [yet].
+
+While the block syntax is nice to look at it does have some drawbacks. Object 
+allocation happens when the block is created and references to these objects
+are held for the lifetime of the block. In our case, this lifetime is while 
+the Quartz service is running since the job is scheduled, stored, and called by 
+a trigger. 
+
+Having the ability to just schedule a class/module that responds to `perform` as
+a job means that only a reference to that constant is held by the Quartz service
+and object allocation happens when `perform` is executed. 
+
+Thinking of these jobs as atomic units of work may help when deciding how they
+should be scheduled in your application.
+
+## Persisted Jobs
+
+Secondhand just uses the default Quartz RAM job scheduler. This provides no 
+durability for jobs to live after your application exists. It is up to you to 
+make sure they get rescheduled.
+
+
+Usage
+-----
+
+The scheduler must be started before you schedule jobs.
+
+    Secondhand.start(NUM_THREADS)
+
+Then you get to scheduling ...
+
+... job that runs immediately after being scheduled:
+
+    Secondhand.schedule JobClass
+
+... block that runs immediately:
+
+    Secondhand.schedule :some_job do
+      # some job stuff
+    end
+  
+... job that runs on Friday, Dec 10 at 11:53:35 PST:
+
+    Secondhand.schedule JobClass, :at => "Fri Dec 10 22:53:35 -0800 2010" 
+
+... job that runs two minutes from now:
+
+    Secondhand.schedule JobClass, :at => Time.now + 120
+  
+... job that runs every 15 seconds every day:
+
+    Secondhand.schedule JobClass, :with_cron => "0/15 * * * * ? *"
+  
+## :at
+
+Pass in the :at options to provide a specific moment in time for a job to be 
+triggered. This is useful when you want to run a job once - perhaps in response
+to some user input.
+
+## :with_cron
+
+Use :with_cron to provide Secondhand with a cron expression that indicates when
+a job should be triggered. This expression is passed straight to Quartz so all
+options are supported. Just send in a string with the following format:
+
+_From the Quartz CronExpression documentation:_
+
+> Cron expressions are comprised of 6 required fields and one optional field 
+> separated by white space. The fields respectively are described as follows:
+
+    Field Name        Allowed Values    Allowed Special Characters
+
+    Seconds           0-59              , - * /
+    Minutes           0-59              , - * /
+    Hours             0-23              , - * /
+    Day-of-month      1-31              , - * ? / L W
+    Month             1-12 or JAN-DEC   , - * /
+    Day-of-Week       1-7 or SUN-SAT	 	, - * ? / L #
+    Year (Optional)   empty, 1970-2199  , - * /
+  
+> The `*` character is used to specify all values. For example, "*" in the 
+> minute field means "every minute".
+> 
+> The `?` character is allowed for the day-of-month and day-of-week fields. It 
+> is used to specify 'no specific value'. This is useful when you need to 
+> specify something in one of the two fields, but not the other.
+> 
+> The `-` character is used to specify ranges For example "10-12" in the hour 
+> field means "the hours 10, 11 and 12".
+> 
+> The `,` character is used to specify additional values. For example 
+> "MON,WED,FRI" in the day-of-week field means "the days Monday, Wednesday, 
+> and Friday".
+> 
+> The `/` character is used to specify increments. For example "0/15" in the 
+> seconds field means "the seconds 0, 15, 30, and 45". And "5/15" in the seconds 
+> field means "the seconds 5, 20, 35, and 50". Specifying '*' before the '/' is 
+> equivalent to specifying 0 is the value to start with. Essentially, for each 
+> field in the expression, there is a set of numbers that can be turned on or 
+> off. For seconds and minutes, the numbers range from 0 to 59. For hours 0 to 
+> 23, for days of the month 0 to 31, and for months 1 to 12. The "/" character 
+> simply helps you turn on every "nth" value in the given set. Thus "7/6" in the 
+> month field only turns on month "7", it does NOT mean every 6th month, please 
+> note that subtlety.
+> 
+> The `L` character is allowed for the day-of-month and day-of-week fields. This 
+> character is short-hand for "last", but it has different meaning in each of 
+> the two fields. For example, the value "L" in the day-of-month field means 
+> "the last day of the month" - day 31 for January, day 28 for February on 
+> non-leap years. 
+> If used in the day-of-week field by itself, it simply means "7" or "SAT". But 
+> if used in the day-of-week field after another value, it means "the last xxx 
+> day of the month" - for example "6L" means "the last friday of the month". 
+> When using the 'L' option, it is important not to specify lists, or ranges of 
+> values, as you'll get confusing results.
+> 
+> The `W` character is allowed for the day-of-month field. This character is 
+> used to specify the weekday (Monday-Friday) nearest the given day. As an 
+> example, if you were to specify "15W" as the value for the day-of-month field, 
+> the meaning is: "the nearest weekday to the 15th of the month". So if the 15th 
+> is a Saturday, the trigger will fire on Friday the 14th. If the 15th is a 
+> Sunday, the trigger will fire on Monday the 16th. If the 15th is a Tuesday, 
+> then it will fire on Tuesday the 15th. However if you specify "1W" as the 
+> value for day-of-month, and the 1st is a Saturday, the trigger will fire on 
+> Monday the 3rd, as it will not 'jump' over the boundary of a month's days. 
+> The 'W' character can only be specified when the day-of-month is a single day, 
+> not a range or list of days.
+> 
+> The `L` and `W` characters can also be combined for the day-of-month 
+> expression to yield `LW`, which translates to "last weekday of the month".
+> 
+> The `#` character is allowed for the day-of-week field. This character is used 
+> to specify "the nth" XXX day of the month. For example, the value of "6#3" in 
+> the day-of-week field means the third Friday of the month (day 6 = Friday and 
+> "#3" = the 3rd one in the month). Other examples: "2#1" = the first Monday of 
+> the month and "4#5" = the fifth Wednesday of the month. Note that if you 
+> specify "#5" and there is not 5 of the given day-of-week in the month, then 
+> no firing will occur that month. If the '#' character is used, there can only 
+> be one expression in the day-of-week field ("3#1,6#3" is not valid, since 
+> there are two expressions).
+> 
+> The legal characters and the names of months and days of the week are not case 
+> sensitive.
+> 
+> NOTES:
+> 
+> Support for specifying both a day-of-week and a day-of-month value is not 
+> complete (you'll need to use the '?' character in one of these fields).
+> Overflowing ranges is supported - that is, having a larger number on the left 
+> hand side than the right. You might do 22-2 to catch 10 o'clock at night until 
+> 2 o'clock in the morning, or you might have NOV-FEB. It is very important to 
+> note that overuse of overflowing ranges creates ranges that don't make sense 
+> and no effort has been made to determine which interpretation CronExpression 
+> chooses. An example would be "0 0 14-6 ? * FRI-MON".
+
+
+Installation
+------------
+
+  Coming soon to a command line near you.
+  
+
+## Quartz
+
+Version supported in this release: 1.8.4
+
+_Other version may work, but the tests and jars included are for 1.8.4._
+
+All the jars needed for Quartz are in `lib\quartz`. They are used by Secondhand
+unless JRuby::Rack is detected. If JRuby::Rack is present, it is assumed that
+you will have the jars under WEB-INF or get them on the classpath however you
+choose to.
+
+
+What's in a name?
+----------------
+Secondhand was inspired from several other Quartz+Ruby implementations:
+  
+  * quartz-jruby: <https://github.com/artha42/quartz-jruby>
+  * jruby-quartz: <https://github.com/techwhizbang/jruby-quartz>
+  
+Chiefly, quartz-jruby demonstrated what was needed to get the Quartz JobFactory
+replaced with a Ruby class and playing nicely with the other components. Thanks
+vagmi!
+
+The jobs were taken straight from Resque <https://github.com/defunkt/resque> as
+well as some other flourishes here and there.
+
+The project started as a fork of quartz-jruby so I figured it was a second-hand 
+project and the clock reference wasn't bad either.
+
+
+Contributors
+------------
+
+Don Morrison (@elskwid)
+
+
+License
+-------
+
+Copyright (c) 2010 Amphora Research Systems Ltd.
+
+Secondhand is licensed under the MIT license. See LICENSE for details.
+
+
+[0]: http://www.quartz-scheduler.org/

data/Rakefile

@@ -0,0 +1,82 @@
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+
+task :default => ["test"]
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+
+  # Change these as appropriate
+  s.name              = "secondhand"
+  s.version           = "0.1.0"
+  s.summary           = "Secondhand is a ruby-friendly wrapper around the Quartz Job Scheduler. Create jobs, tell Secondhand when they should run, then sit back and enjoy."
+  s.author            = "Don Morrison"
+  s.email             = "elskwid@gmail.com"
+  s.homepage          = "https://github.com/amphora/secondhand"
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README.md)
+  s.rdoc_options      = %w(--main README.md)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(LICENSE Rakefile README.md) + Dir.glob("{test,lib}/**/*")
+  s.require_paths     = ["lib"]
+
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  # s.add_dependency("some_other_gem", "~> 0.1.0")
+
+  # If your tests use any gems, include them here
+  # s.add_development_dependency("mocha") # for example
+end
+
+# This task actually builds the gem. We also regenerate a static
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+#
+# To publish your gem online, install the 'gemcutter' gem; Read more 
+# about that here: http://gemcutter.org/pages/gem_docs
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+# If you don't want to generate the .gemspec file, just remove this line. Reasons
+# why you might want to generate a gemspec:
+#  - using bundler with a git source
+#  - building the gem without rake (i.e. gem build blah.gemspec)
+#  - maybe others?
+task :package => :gemspec
+
+# Generate documentation
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end

data/lib/secondhand.rb

@@ -0,0 +1,89 @@
+require 'java'
+
+# If JRuby::Rack::VERSION is defined then Secondhand is in a servlet. 
+# Secondhand does not need to require jar archives in this case
+# as those should be in WEB-INF/lib and already in the classpath
+unless defined?(JRuby::Rack::VERSION)
+  # jars
+  require 'quartz/log4j-1.2.14.jar'
+  require 'quartz/quartz-1.8.4.jar'
+  require 'quartz/slf4j-api-1.6.0.jar'
+  require 'quartz/slf4j-log4j12-1.6.0.jar'
+end
+
+require 'secondhand/logging'
+require 'secondhand/job'
+require 'secondhand/jobs'
+require 'secondhand/scheduler'
+require 'secondhand/trigger'
+require 'secondhand/version'
+
+module Secondhand
+  import java.lang.System
+  import org.quartz.impl.StdScheduler
+  import org.quartz.impl.StdSchedulerFactory
+
+  extend Scheduler
+  extend self  
+  
+  # Raised when the scheduler is used before being initialized
+  class NoSchedulerError < RuntimeError; end  
+  
+  DEFAULT_GROUP = "SECONDHAND"
+  DEFAULT_THREAD_COUNT = 5
+  @scheduler = nil
+  
+  def reset_thread_count
+    @thread_count = DEFAULT_THREAD_COUNT
+  end
+  
+  def thread_count=(threads)
+    @thread_count = threads
+  end
+  
+  def thread_count
+    reset_thread_count unless @thread_count
+    @thread_count
+  end
+  
+  def start(threads = nil)
+    initialize_scheduler(threads)
+    scheduler.start
+  end
+  alias_method :run, :start
+
+  def initialize_scheduler(threads = nil)
+    @thread_count = threads if threads
+    # Quartz uses this property to set the number of worker threads
+    System.set_property("org.quartz.threadPool.threadCount", @thread_count.to_s)
+    # Stop Quartz from looking for updates
+    System.set_property("org.quartz.scheduler.skipUpdateCheck", "true")
+    # Initialize the default scheduler
+    @scheduler = StdSchedulerFactory.default_scheduler
+    # Set up our custom job factory
+    @scheduler.job_factory = Job::Factory.instance
+  end
+
+  def schedule(job, opts={}, &block)
+    name = job.to_s
+    scheduler.schedule_job(Job.create(name, block ? block : job), Trigger.create(name, opts))
+  end
+
+  # Shortcuts
+  
+  # Raise an error if the scheduler isn't ready - with Quartz we have an order
+  # of operations to follow. This also lets us pass the threads in with .start
+  def scheduler
+    raise NoSchedulerError, "Scheduler isn't initialized. Call Secondhand.start before scheduling jobs." unless @scheduler 
+    @scheduler
+  end
+  
+  def jobs
+    Jobs
+  end
+  
+  def job_names
+    Jobs.names
+  end
+  
+end

data/lib/secondhand/job.rb

@@ -0,0 +1,58 @@
+require 'singleton' # for factory
+
+module Secondhand
+  import org.quartz.JobDetail
+  import org.quartz.spi.JobFactory
+  
+  module Job    
+    
+    def self.create(name, work)
+      # Store the job and work for our job factory impl      
+      Details.new(name, Secondhand::DEFAULT_GROUP, work)
+    end
+    
+    # Quartz croaks with a Ruby created JobClass so, hijack the job here
+    # and bend it to our will
+    class Details < Java::OrgQuartz::JobDetail
+      attr_accessor :job
+      
+      def initialize(name, group, work)
+        super()
+        # name & group are required by Quartz
+        set_name name.to_s
+        set_group group.to_s
+        # add the execute method if needed
+        work.extend Job::Runner unless work.respond_to?(:execute)
+        @job = work
+        self
+      end
+      
+      # Override validate so Quartz doesn't throw an error about the JobClass
+      def validate; end
+
+    end
+
+    # Thin wrapper around a job to provide the expected Quartz interface
+    module Runner
+      def execute(context = nil)
+        self.respond_to?(:call) ? self.call : self.perform        
+      end
+    end
+
+    # Create custom JobFactory to hand out jobs from a Ruby collection
+    # and not from the Quartz job list. Avoids problems with JRuby and
+    # interfaces to and from Ruby.
+    class Factory
+      include Singleton
+      include JobFactory        
+      
+      # Quartz calls new_job on the factory to get the job details
+      #  * event = execution-time data about the job (from Quartz)
+      def new_job(event)      
+        # Get a job from the factory - Quartz calls #execute(context) on this      
+        event.get_job_detail.job  
+      end
+    end
+    
+  end
+end

data/lib/secondhand/jobs.rb

@@ -0,0 +1,25 @@
+module Secondhand  
+  module Jobs
+    extend self
+        
+    # Provide an array-like method to get to the job details
+    def [](name)      
+      details = scheduler.get_job_detail(name, group)
+      details.job if details
+    end
+    
+    def names
+      Array(scheduler.get_job_names(DEFAULT_GROUP))
+    end
+    
+    # Shortcuts
+    
+    def scheduler
+      Secondhand.scheduler
+    end
+    
+    def group
+      Secondhand::DEFAULT_GROUP
+    end
+  end    
+end

data/lib/secondhand/logging.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+
+module Secondhand
+  module Logger
+    import org.apache.log4j
+    extend self  
+    
+    def logger
+      Java::OrgApache::log4j::Logger.get_logger("Secondhand")
+    end
+    
+    def debug(msg)
+      logger.log(Level::DEBUG, msg)
+    end
+    
+    def info(msg)
+      logger.log(Level::INFO, msg)
+    end
+    
+    def error(msg)
+      logger.log(Level::ERROR, msg)
+    end
+    
+    def warn(msg)
+      logger.log(Level::WARN, msg)
+    end    
+    
+  end
+  
+end

data/lib/secondhand/scheduler.rb

@@ -0,0 +1,51 @@
+require 'forwardable'
+
+module Secondhand  
+  module Scheduler
+    extend Forwardable
+    extend self
+    
+    # Add some friendly faces
+    def_delegators :scheduler,  :shutdown,
+                                :stop,
+                                :stop_now,
+                                :started?,
+                                :running?,
+                                :paused?,
+                                :standing_by?,
+                                :shutdown?,
+                                :stopped?
+                                
+                                
+    
+    # Add some sugar on StdScheduler
+    class Java::OrgQuartzImpl::StdScheduler
+      def run
+        start
+      end
+      
+      def stop_now
+        shutdown
+      end
+      
+      def stop
+        shutdown(true) # waits for all jobs to finish
+      end
+      
+      def running?
+        is_started
+      end
+      
+      def paused?
+        is_in_standby_mode
+      end
+      alias_method :standing_by?, :paused?
+      
+      def stopped?
+        is_shutdown
+      end      
+      
+    end
+    
+  end 
+end

data/lib/secondhand/trigger.rb

@@ -0,0 +1,24 @@
+module Secondhand  
+  import org.quartz.CronTrigger
+  import org.quartz.SimpleTrigger    
+  
+  class Trigger    
+    
+    # Return correct Quartz Trigger
+    def self.create(name, opts)
+      args = ["#{name}_trigger", Secondhand::DEFAULT_GROUP]
+      
+      # with_cron trumps other options
+      if opts[:with_cron]
+        args << opts[:with_cron]
+        CronTrigger.new(*(args).compact)
+      else
+        args << opts[:at] || opts[:on]        
+        SimpleTrigger.new(*(args).compact)
+      end
+    end
+    
+  end
+end
+  
+  

data/lib/secondhand/version.rb

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

data/test/integration/test_secondhand_run.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestSecondhandRun < Test::Unit::TestCase  
+  
+  def setup
+    Secondhand.reset_thread_count    
+    org.apache.log4j.BasicConfigurator.configure
+  end
+
+  def test_five_second_cron_job    
+    Secondhand.start(1)
+    assert Secondhand.started?
+    
+    # This job will say 'something' every 5 seconds
+    Secondhand.schedule SaySomething, :with_cron => "0/5 * * * * ?"    
+    assert_equal SaySomething, Secondhand.jobs["SaySomething"]
+    
+    # This job will say 'block something' every 10 seconds
+    Secondhand.schedule "my_block", :with_cron => "0/10 * * * * ?" do
+      puts "block something [10 sec]"
+    end
+
+    # This job will say 'One shot job!' as soon as it is scheduled
+    Secondhand.schedule "one_shot" do
+      puts "One shot job!"
+    end
+        
+    puts "sleeping while the scheduler runs ..."
+    sleep 20
+    
+    Secondhand.stop
+  end
+
+end
+
+class SaySomething
+  # You could add the logging methods to your class
+  # extend Secondhand::Logger
+  
+  def self.perform
+    puts "something [5sec]"  
+    # Or you can just call the logger
+    # Secondhand::Logger.info "something [5sec] --> through Log4J"
+    
+    # With extend Logging from above
+    # self.info "another thing ==> through Log4j"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+
+require 'test/unit'
+require 'time'
+
+# project
+require 'secondhand'
+
+# BasicConfigurator.configure uses a ConsoleAppender by default
+# uncomment to see all the Quartz logging magic!
+# org.apache.log4j.BasicConfigurator.configure
+
+## NullAppender silences log4j messages
+import org.apache.log4j.varia.NullAppender
+org.apache.log4j.BasicConfigurator.configure(NullAppender.new)
+
+module TestHelper
+  #
+end
+
+class Test::Unit::TestCase
+  include TestHelper
+end
+
+## utility classes for tests
+class TestSimpleJob
+  def self.perform
+    "ALLOK"    
+  end
+end
+
+class TestSimpleJob2 < TestSimpleJob; end

data/test/unit/test_job.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestJob < Test::Unit::TestCase
+  
+  def setup
+    Secondhand.start(1)
+    @factory = Secondhand::Job::Factory.instance    
+  end
+
+  def test_simple_job_details
+    details = Secondhand::Job.create "TestSimpleJob2", TestSimpleJob2
+    assert_kind_of Java::OrgQuartz::JobDetail, details
+    assert_equal TestSimpleJob2, details.job
+  end
+
+  def test_simple_class_job
+    details = Secondhand::Job.create "TestSimpleJob", TestSimpleJob
+    assert_equal TestSimpleJob, details.job
+  end
+  
+  def test_simple_named_job_block
+    details = Secondhand::Job.create "some_job", Proc.new{"Some job text"}
+    assert_equal "Some job text", details.job.call
+  end
+  
+  def test_runner_module_on_class
+    details = Secondhand::Job.create "TestSimpleJob2", TestSimpleJob2
+    assert details.job.respond_to?(:execute)
+  end
+  
+  def test_runner_module_on_block
+    details = Secondhand::Job.create "some_other_job", Proc.new{"Some other job text"}    
+    assert details.job.respond_to?(:execute)
+  end
+
+  # job factory tests
+  def test_kind_of
+    assert_kind_of Java::OrgQuartz::spi::JobFactory, @factory
+    assert_kind_of Secondhand::Job::Factory, @factory
+  end
+  
+  def test_respond_to_new_job
+    assert @factory.respond_to?(:new_job)
+  end
+end

data/test/unit/test_jobs.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestJobs < Test::Unit::TestCase
+  
+  def setup
+    Secondhand.start(1)
+  end
+  
+  def test_bracket_method
+    # jobs aren't in this list until they are scheduled - quartz limitation
+    Secondhand.schedule TestSimpleJob
+    assert_equal TestSimpleJob, Secondhand::Jobs["TestSimpleJob"]
+  end
+  
+  def test_names
+    Secondhand.schedule TestSimpleJob2
+    assert Secondhand::Jobs.names.include?("TestSimpleJob2")
+  end
+    
+end

data/test/unit/test_logger.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestLogger < Test::Unit::TestCase
+  
+  def setup
+  end
+
+  class IncludeLogger
+    include Secondhand::Logger
+  end
+  
+
+  def test_included_logger
+    inst = IncludeLogger.new
+    assert inst.respond_to?(:logger)
+    assert inst.respond_to?(:warn)
+  end
+
+  class ExtendLogger
+    extend Secondhand::Logger
+  end
+  
+  def test_extended_logger    
+    klass = ExtendLogger
+    assert klass.respond_to?(:logger)
+    assert klass.respond_to?(:error)    
+  end
+  
+end
+

data/test/unit/test_scheduler.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestScheduler < Test::Unit::TestCase
+  import org.quartz.impl.StdScheduler
+  
+  def setup    
+    Secondhand.reset_thread_count    
+  end
+  
+  def test_default_thread_count    
+    assert_equal 5, Secondhand.thread_count
+  end
+  
+  def test_thread_count_setter    
+    Secondhand.thread_count = 2
+    assert_equal 2, Secondhand.thread_count
+  end
+    
+  def test_scheduler_instance
+    Secondhand.initialize_scheduler
+    assert_instance_of StdScheduler, Secondhand.scheduler
+    assert_equal Secondhand.scheduler, Secondhand.scheduler    
+  end
+  
+  def test_state_and_argument
+    sh = Secondhand
+    sh.start(1)
+    assert sh.running?
+    assert sh.started?
+    assert_equal 1, sh.thread_count
+  end
+  
+end

data/test/unit/test_secondhand.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestSecondhand < Test::Unit::TestCase  
+  
+  def setup
+    # Secondhand.jobs.clear
+    Secondhand.start(1)
+  end  
+    
+  def test_simple_class_job
+    Secondhand.schedule TestSimpleJob
+    assert_equal TestSimpleJob, Secondhand.jobs["TestSimpleJob"]
+  end
+  
+  def test_simple_named_job_block
+    Secondhand.schedule "some_job" do
+      "Some job text"
+    end
+    assert Secondhand.jobs["some_job"].is_a? Proc
+    assert_equal "Some job text", Secondhand.jobs["some_job"].call
+  end
+
+  def test_schedule_simple_job
+    date = Time.now + 120 # 120 seconds from now
+    Secondhand.schedule TestSimpleJob2, :at => date
+    assert_equal TestSimpleJob2, Secondhand.jobs["TestSimpleJob2"]
+  end
+
+end

data/test/unit/test_trigger.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestTrigger < Test::Unit::TestCase
+  
+  def setup
+  end
+
+  def test_at
+    date = "Dec 10 22:53:35 -0800 2011"
+    sched = Secondhand::Trigger.create("some_job", :at => Time.parse(date))
+    assert_kind_of Java::OrgQuartz::SimpleTrigger, sched
+    assert_equal Time.parse(date), Time.parse(sched.get_start_time.to_s)
+  end
+  
+  def test_with_cron
+    exp = "0 0 12 * * ? *"
+    sched = Secondhand::Trigger.create("some_cronjob", :with_cron => exp)
+    assert_kind_of Java::OrgQuartz::CronTrigger, sched
+    assert_equal exp, sched.get_cron_expression
+  end
+  
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: secondhand
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 1
+    - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+  - Don Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-13 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: elskwid@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.md
+files: 
+  - LICENSE
+  - Rakefile
+  - README.md
+  - test/test_helper.rb
+  - test/integration/test_secondhand_run.rb
+  - test/unit/test_job.rb
+  - test/unit/test_jobs.rb
+  - test/unit/test_logger.rb
+  - test/unit/test_scheduler.rb
+  - test/unit/test_secondhand.rb
+  - test/unit/test_trigger.rb
+  - lib/secondhand.rb
+  - lib/quartz/log4j-1.2.14.jar
+  - lib/quartz/quartz-1.8.4.jar
+  - lib/quartz/slf4j-api-1.6.0.jar
+  - lib/quartz/slf4j-log4j12-1.6.0.jar
+  - lib/secondhand/job.rb
+  - lib/secondhand/jobs.rb
+  - lib/secondhand/logging.rb
+  - lib/secondhand/scheduler.rb
+  - lib/secondhand/trigger.rb
+  - lib/secondhand/version.rb
+has_rdoc: true
+homepage: https://github.com/amphora/secondhand
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.md
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Secondhand is a ruby-friendly wrapper around the Quartz Job Scheduler. Create jobs, tell Secondhand when they should run, then sit back and enjoy.
+test_files: []
+