scheduled-robot 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 00600e2154beda443d4a9608c478d9436cbb6d43
+  data.tar.gz: 15a6d90c7e039b069265b9b50039e4f64c9d5f65
+SHA512:
+  metadata.gz: 6cff12eff3603b6d99b412080d4691a94c220b7b13380cda228bbb48c7388dc581c94de9cef9e6fe96bbcdd590c95c31133f60a23146ea0029e32330c25b5db3
+  data.tar.gz: fc810c8d4e38ae0469ebe8834ecd51e7bbeec2ff2af935633abe1bb74f3b0582aa16856e5e9f3c055dfd87ee855e4ac59fb91da4be859f4a871b796c7c62a615

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+doc/*
+pkg/*

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 2.0.0" > .rvmrc
+environment_id="ruby-2.0.0-p0@robot"
+
+# Uncomment the following lines if you want to verify rvm version per project
+rvmrc_rvm_version="1.17.8 (stable)" # 1.10.1 seams as a safe start
+eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+  echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+  return 1
+}
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+if [[ -s Gemfile ]] && {
+  ! builtin command -v bundle >/dev/null ||
+  builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+}
+then
+  printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+  gem install bundler
+fi
+if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+then
+  bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+fi

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+source "http://gems.izea.com"
+
+# Specify your gem's dependencies in robot.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,15 @@
+PATH
+  remote: .
+  specs:
+    robot (0.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  remote: http://gems.izea.com/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  robot!

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2013 IZEA
+
+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, and/or sublicense 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/Manifest.txt

@@ -0,0 +1,14 @@
+.autotest
+changelog.md
+Manifest.txt
+README.md
+Rakefile
+lib/robot.rb
+lib/robot/decorator.rb
+lib/robot/failsafe.rb
+lib/robot/hoptoad.rb
+lib/robot/logger.rb
+lib/robot/synchronizer.rb
+lib/robot/task.rb
+lib/robot/version.rb
+test/test_robot.rb

data/README.md

@@ -0,0 +1,56 @@
+# Robot
+
+__DESCRIPTION:__
+
+Robot does your bidding.  Use it for good, not for evil.
+
+__FEATURES/PROBLEMS:__
+
+* Logs the start / end times of each task.
+* Rescues exceptions so that if a task crashes, it won't take down the Robot
+  itself.
+* Synchronizes tasks using a mutex (either a standard Ruby Mutex or something
+  that implements its interface). This ensures only one instance of Robot will
+  run at a time.
+
+__SYNOPSIS:__
+
+Add the following to an initializer (config/initializers/robot.rb):
+    
+    # the following options can be set here and they wont need to be set in each definition below
+    #this sets default behavoir for robots. redefining these will overwrite the default
+    #set a log file
+    Robot.logger = Logger.new("log/robot.log")
+    #specifying a pid root will default all robots to create a pid at <PID_ROOT>/robot.<DEFINED_NAME>.pid
+    Robot.pid_root = Rails.root("tmp","pids")
+    #will default hoptoad in each robot
+    Robot.hoptoad = HoptoadNotifier
+    #this will default the failsafe ... it already defaults to true ... use this to default to false
+    Robot.failsafe = true
+
+    Robot.define(:hourly) do |robot|
+      # Omit this line if you don't want logging, or define it as a custom logger or it is defined globally
+      # if you want a separate log file for your Robot tasks.
+      robot.logger = Logger.new("log/robot.log")
+  
+      # Omit this line if you don't want to synchronize tasks or it is defined globally. Adding a PIDMutex
+      # here will ensure that only 1 process is running this task at any time.
+      # Note that since PIDMutex uses a file as a locking mechanism, this method
+      # doesn't scale beyond a single filesystem.
+      robot.mutex = PIDMutex.new("tmp/pids/hourly.pid")
+  
+      # Omit this line if you're not using Hoptoad or it is defined globally.
+      robot.hoptoad = HoptoadNotifier
+  
+      # This is true by default, I'm just including it here as an example. If
+      # you set it to false, then there won't be a failsafe mechanism, meaning
+      # any exceptions raised by tasks will be unchecked. You'll usually want to
+      # leave this set to true.
+      robot.failsafe = true
+  
+      robot.perform("Some long-running task") { LongTask.run }
+    end
+
+And then add an entry to crontab to run your new Robot.hourly method:
+
+  @hourly script/runner -e production "Robot.run(:hourly)"

data/Rakefile

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require './lib/robot/version.rb'
+
+Rake::TestTask.new do |t|
+ t.libs << 'test'
+end
+# vim: syntax=ruby

data/changelog.md

@@ -0,0 +1,33 @@
+__0.2.0 / 2012-02-07 Grady Griffin__
+
+* added defaulting most robot options
+  
+  * failsafe
+  * mutex
+  * logger
+  * hoptoad
+
+
+__0.1.0 / 2009-08-27 Dray Lacy__
+
+* 5 minor enhancements
+
+  * Changed the way tasks are run. Rather than becoming methods on the Robot
+    module (now a class), they are invoked using Robot.run(:task_name). So
+    before, where you would call Robot.daily, you should now call
+    Robot.run(:daily).
+  * Moved the logger, mutex, hoptoad, etc. config from class-level to
+    task-level, so you can define different loggers and mutexes for each task.
+  * Changed the failsafe decorator so that it writes to $stderr instead of
+    STDERR.
+  * Also changed the failsafe decorator so that it only writes errors to
+    $stderr if $VERBOSE is set to true (ie. if ruby is being run in strict, or
+    "-w", mode).
+  * Added tests.
+
+__0.0.1 / 2009-08-25 Dray Lacy__
+
+* 1 major enhancement
+
+  * Birthday!
+  * Extracted from SocialSpark

data/lib/mutex/pid_mutex.rb

@@ -0,0 +1,84 @@
+# PIDMutex implements a simple semaphore that can be used to coordinate access
+# to shared data from multiple concurrent processes.  It does this by managing
+# access to a PID file.
+# 
+# Generally, this class is meant to be as close as possible to Ruby's standard
+# Mutex class, so it can be easily swapped in its place for switching between
+# thread- and process-based concurrency.
+class PIDMutex
+  # Amount of time (in seconds) to sleep while waiting for a lock to become
+  # available.
+  PERIOD = 0.005
+
+  # Creates a new PIDMutex using the given +pid_file+.  The +pid_file+ is
+  # expected to be a fully resolved path, but a file need not exist there
+  # (PIDMutex will automatically create it).
+  def initialize(pid_file)
+    @pid_file = pid_file
+
+    # Define a finalizer so that when this object is destroyed, it
+    # automatically unlocks the PID file.
+    ObjectSpace.define_finalizer(self, method(:unlock))
+  end
+
+  # Full path to the PID file.
+  attr_reader :pid_file
+
+  # Returns true if this lock is currently held by some process.
+  def locked?
+    return false unless File.exists?(@pid_file)
+    
+    begin
+      pid = File.read(@pid_file)
+    
+      # if there is nothing in the file, delete the file and return false
+      if pid.to_s.length == 0
+        unlink_pid_file and return false
+      end
+    
+      Process.kill 0, pid.to_i # this will raise Errno::ESRCH if there is a process
+      
+      true
+    rescue Errno::ESRCH => e
+      # no process, lets delete the pid and return false
+      unlink_pid_file and return false
+    end
+    
+  end
+
+  # Obtains a lock, runs the block, and releases the lock when the block
+  # completes.
+  def synchronize # :yields:
+    lock
+    yield
+  ensure
+    unlock
+  end
+
+  # Attempts to grab the lock and waits if it isn‘t available.
+  def lock
+    sleep(PERIOD) until try_lock
+  end
+
+  # Attempts to obtain the lock and returns immediately. Returns true if the
+  # lock was granted.
+  def try_lock
+    if locked?
+      false
+    else
+      File.open(@pid_file, 'w') { |f| f.write(Process.pid) }
+      File.chmod(0644, @pid_file)
+      true
+    end
+  end
+
+  # Removes the file (if any) created by #write_pid_file.
+  def unlock
+    return unless locked?
+    unlink_pid_file
+  end
+  
+  def unlink_pid_file
+    File.unlink(@pid_file)
+  end
+end

data/lib/robot.rb

@@ -0,0 +1,73 @@
+require 'robot/version'
+require 'pathname'
+require 'mutex/pid_mutex'
+
+class Robot
+  autoload :Decorator,    'robot/decorator'
+  autoload :Failsafe,     'robot/failsafe'
+  autoload :Hoptoad,      'robot/hoptoad'
+  autoload :Logger,       'robot/logger'
+  autoload :Synchronizer, 'robot/synchronizer'
+  autoload :Task,         'robot/task'
+  
+  class << self
+    attr_accessor :robots
+    attr_accessor :logger
+    attr_accessor :pid_root
+    attr_accessor :hoptoad
+    attr_accessor :failsafe
+  end
+  
+  self.robots = {}
+  
+  attr_reader :name
+  
+  attr_accessor :logger
+  attr_accessor :mutex
+  attr_accessor :hoptoad
+  attr_accessor :failsafe
+  
+  def log_info(msg)
+    @logger.info(msg) if @logger
+  end
+  
+  def perform(name, &block)
+    @blocks << [name, block]
+  end
+  
+  def run
+    @blocks.each do |(name, block)|
+      task = Task.new(name)
+      task = Synchronizer.new(task, @mutex) if @mutex
+      task = Logger.new(task, @logger)      if @logger
+      task = Hoptoad.new(task, @hoptoad)    if @hoptoad
+      task = Failsafe.new(task)             if @failsafe
+      task.call(&block)
+    end
+  end
+  
+  def self.define(name)
+    instance = new(name)
+    yield(instance)
+    self.robots[instance.name] = instance
+  end
+  
+  def self.robot_by_name(name)
+    self.robots[name] || raise(ArgumentError, "No such robot: #{name}")
+  end
+  
+  def self.run(name)
+    robot_by_name(name).run
+  end
+  
+  private
+  
+  def initialize(name)
+    @name = name
+    @failsafe = self.class.failsafe.nil? ? true : self.class.failsafe
+    @logger = self.class.logger if self.class.logger
+    @hoptoad = self.class.hoptoad if self.class.hoptoad
+    @mutex = PIDMutex.new(self.class.pid_root.join("robot.#{name}.pid")) if self.class.pid_root 
+    @blocks = []
+  end
+end

data/lib/robot/decorator.rb

@@ -0,0 +1,19 @@
+class Robot
+  class Decorator
+    attr_accessor :task
+    
+    def call(&block)
+      @task.call(&block)
+    end
+    
+    def name
+      @task.name
+    end
+    
+    private
+    
+    def initialize(task)
+      @task = task
+    end
+  end
+end

data/lib/robot/failsafe.rb

@@ -0,0 +1,22 @@
+class Robot
+  # Task decorator which rescues any errors raised by the task.
+  class Failsafe < Decorator
+    # Runs the decorated task, rescuing any exceptions that it raises.
+    def call
+      super
+    rescue Exception => exception
+      # Eat any exceptions, so that other tasks can run.
+      handle_exception(exception)
+    end
+    
+    private
+    
+    def handle_exception(exception) # :nodoc:
+      return unless $VERBOSE
+      
+      message = "/!\\ FAILSAFE /!\\  #{Time.now}\n"
+      message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
+      $stderr.puts(message)
+    end
+  end
+end

data/lib/robot/hoptoad.rb

@@ -0,0 +1,24 @@
+class Robot
+  # Task decorator which reports any errors to Hoptoad.
+  class Hoptoad < Decorator
+    # Runs the decorated task, reporting any exceptions that it raises.  Note
+    # that the exceptions will be re-raised.
+    def call
+      super
+    rescue Exception => exception
+      handle_exception(exception)
+      raise
+    end
+    
+    private
+    
+    def initialize(task, notifier)
+      super(task)
+      @notifier = notifier
+    end
+    
+    def handle_exception(exception) # :nodoc:
+      @notifier.notify(exception)
+    end
+  end
+end

data/lib/robot/logger.rb

@@ -0,0 +1,32 @@
+require 'benchmark'
+
+class Robot
+  # Task decorator which adds logging and benchmarking.
+  class Logger < Decorator
+    attr_accessor :logger
+    
+    # Log the running time of the decorated task, as well as any exceptions
+    # that are raised.
+    def call
+      @logger.info("Beginning #{name}")
+      @logger.info('Completed %s (%.5fs)' % [name, Benchmark.realtime { super }])
+    rescue Exception => exception
+      log_exception(exception)
+      raise
+    end
+    
+    private
+    
+    def initialize(task, logger)
+      super(task)
+      @logger = logger
+    end
+    
+    def log_exception(exception)
+      message = "/!\\ ERROR /!\\  #{Time.now}\n"
+      message << "  During task #{name.inspect}\n"
+      message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
+      @logger.fatal(message)
+    end
+  end
+end

data/lib/robot/synchronizer.rb

@@ -0,0 +1,31 @@
+class Robot
+  # Task decorator which wraps the task inside a mutex lock.
+  class Synchronizer < Decorator
+    class SynchronizationError < StandardError # :nodoc:
+    end
+    
+    attr_accessor :mutex
+    
+    # Attempts to obtain a lock on the mutex before delegating to the task's
+    # #call method.  If this method is unable to obtain a lock, it will raise
+    # SynchronizationError.
+    def call
+      if @mutex.try_lock
+        begin
+          super
+        ensure
+          @mutex.unlock
+        end
+      else
+        raise SynchronizationError, "Task #{name.inspect} is already running"
+      end
+    end
+    
+    private
+    
+    def initialize(task, mutex)
+      super(task)
+      @mutex = mutex
+    end
+  end
+end

data/lib/robot/task.rb

@@ -0,0 +1,15 @@
+class Robot
+  class Task
+    attr_reader :name
+    
+    def call
+      yield
+    end
+    
+    private
+    
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/lib/robot/version.rb

@@ -0,0 +1,9 @@
+class Robot
+  module VERSION # :nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY = 0
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/robot.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "robot/version"
+
+Gem::Specification.new do |s|
+  s.name        = "scheduled-robot"
+  s.version     = Robot::VERSION::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dray Lacy", "Grady Griffin", "Brian Fisher"]
+  s.email       = "opensource@izea.com"
+  s.homepage    = "https://github.com/IZEA/robot"
+  s.summary     = %q{Use Robot to run scheduled jobs}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/test_pid_mutex.rb

@@ -0,0 +1,68 @@
+require 'test/unit'
+
+class TestPIDMutex < Test::Unit::TestCase
+  PID_FILE = "tmp/pidmutex.pid"
+  def setup
+    @mutex = PIDMutex.new(PID_FILE)
+  end
+  
+  def teardown
+    # Just in case a test doesn't clean up after itself.
+    File.unlink(PID_FILE) if File.exists?(PID_FILE)
+  end
+  
+  def test_no_file
+    assert !File.exists?(PID_FILE)
+    assert !@mutex.locked?
+  end
+  
+  def test_file_with_no_corresponding_process_should_unlink_file
+    File.open(PID_FILE, 'w') {|f| f.write('111111') }
+    assert !@mutex.locked?
+    assert !File.exists?(PID_FILE), "Checking locked mutex didn't remove erroneous file."
+  end
+  
+  def test_empty_file_should_unlink_file
+    File.open(PID_FILE, 'w') {|f| f.write('') }
+    assert !@mutex.locked?
+    assert !File.exists?(PID_FILE), "Checking locked mutex didn't remove erroneous file."
+  end
+  
+  def test_file_with_current_pid_should_not_unlink_file
+    File.open(PID_FILE, 'w') {|f| f.write(Process.pid.to_s) }
+    assert @mutex.locked?
+    assert File.exists?(PID_FILE), "PID file didn't exist."
+  end
+  
+  def test_locking_mutex_should_create_file
+    assert !File.exists?(PID_FILE), "PID file already exists."
+    @mutex.lock
+    assert File.exists?(PID_FILE), "PID file was not created."
+  end
+  
+  def test_locking_mutex_should_update_locked_status
+    assert !@mutex.locked?
+    @mutex.lock
+    assert @mutex.locked?
+  end
+  
+  def test_synchronize_should_run_given_block
+    block_was_run = false
+    @mutex.synchronize { block_was_run = true }
+    assert block_was_run
+  end
+  
+  def test_unlock_should_deleted_file
+    @mutex.lock
+    assert File.exists?(PID_FILE)
+    @mutex.unlock
+    assert !File.exists?(PID_FILE), "Unlock didn't remove PID file."
+  end
+  
+  def test_unlock_should_update_locked_status
+    @mutex.lock
+    assert @mutex.locked?
+    @mutex.unlock
+    assert !@mutex.locked?
+  end
+end

data/test/test_robot.rb

@@ -0,0 +1,148 @@
+require 'robot'
+require 'test/unit'
+
+class TestRobot < Test::Unit::TestCase
+  class TestError < StandardError
+  end
+  
+  class Mutex
+    def try_lock
+      @allow
+    end
+    
+    def unlock
+    end
+    
+    private
+    
+    def initialize(allow)
+      @allow = allow
+    end
+  end
+  
+  class Logger
+    attr_reader :infos
+    attr_reader :fatals
+    
+    def info(msg)
+      @infos << msg
+    end
+    
+    def fatal(msg)
+      @fatals << msg
+    end
+    
+    private
+    
+    def initialize
+      @infos = []
+      @fatals = []
+    end
+  end
+  
+  def test_run
+    block_was_run = false
+    robot = Robot.new(:test)
+    robot.perform('test') { block_was_run = true }
+    
+    assert ! block_was_run
+    robot.run
+    assert block_was_run
+  end
+  
+  def test_failsafe
+    robot = Robot.new(:test)
+    robot.perform('test') { raise(TestError, "KABOOM") }
+    
+    silence_warnings { assert_nothing_raised { robot.run } }
+  end
+  
+  def test_failsafe_class_default
+    Robot.failsafe = true
+    robot = Robot.new(:test)
+    robot.perform('test') { raise(TestError, "KABOOM") }
+    
+    silence_warnings { assert_nothing_raised { robot.run } }
+  end
+  
+  def test_failsafe_disabled
+    robot = Robot.new(:test)
+    robot.failsafe = false
+    robot.perform('fail') { raise(TestError, "KABOOM") }
+    
+    assert_raises(TestError) { robot.run }
+  end
+  
+  def test_failsafe_disabled_class_default
+    Robot.failsafe = false
+    robot = Robot.new(:test)
+    robot.perform('fail') { raise(TestError, "KABOOM") }
+    
+    assert_raises(TestError) { robot.run }
+  end
+  
+  def test_logger
+    logger = Logger.new
+    robot = Robot.new(:test)
+    robot.logger = logger
+    robot.perform('test') {}
+    
+    assert logger.infos.empty?
+    robot.run
+    assert_equal 2, logger.infos.size
+    assert_equal 'Beginning test', logger.infos.first
+    assert_match /Completed test \(\d+\.\d+s\)/, logger.infos.last
+  end
+  
+  def test_logger_class_default
+    Robot.logger = Logger.new
+    robot = Robot.new(:test)
+    robot.perform('test') {}
+    logger = robot.logger
+    
+    assert logger.infos.empty?
+    robot.run
+    assert_equal 2, logger.infos.size
+    assert_equal 'Beginning test', logger.infos.first
+    assert_match /Completed test \(\d+\.\d+s\)/, logger.infos.last
+  end
+  
+  def test_mutex
+    mutex = Mutex.new(true)
+    robot = Robot.new(:test)
+    robot.mutex = mutex
+    robot.perform('test') {}
+    
+    robot.run
+  end
+  
+  def test_mutex_synchronize_error
+    mutex = Mutex.new(false)
+    robot = Robot.new(:test)
+    robot.mutex = mutex
+    robot.failsafe = false
+    robot.perform('perform') {}
+    
+    exception = assert_raises(Robot::Synchronizer::SynchronizationError) { robot.run }
+    assert_equal 'Task "perform" is already running', exception.message
+  end
+
+  def test_pid_class_default
+    Robot.pid_root = Pathname.pwd.join('tmp')
+    robot = Robot.new(:test)
+    robot.failsafe = false
+    robot.perform('perform') {}
+    assert_equal true,!!robot.mutex
+    assert_equal robot.mutex.class,PIDMutex
+    assert_equal robot.mutex.pid_file.to_s, "#{Robot.pid_root}/robot.test.pid"
+  end
+  
+  private
+  
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: scheduled-robot
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Dray Lacy
+- Grady Griffin
+- Brian Fisher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-23 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: opensource@izea.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- Manifest.txt
+- README.md
+- Rakefile
+- changelog.md
+- lib/mutex/pid_mutex.rb
+- lib/robot.rb
+- lib/robot/decorator.rb
+- lib/robot/failsafe.rb
+- lib/robot/hoptoad.rb
+- lib/robot/logger.rb
+- lib/robot/synchronizer.rb
+- lib/robot/task.rb
+- lib/robot/version.rb
+- robot.gemspec
+- test/test_pid_mutex.rb
+- test/test_robot.rb
+homepage: https://github.com/IZEA/robot
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Use Robot to run scheduled jobs
+test_files:
+- test/test_pid_mutex.rb
+- test/test_robot.rb