fanforce-worker 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6707557f88a07288620dce7bf2e456991b1f5558
-  data.tar.gz: 41e20bd48e785450baa0482adf798d1287bb4277
+  metadata.gz: d36e19ed57fc30867e1b0f89a4b79c364eb53585
+  data.tar.gz: 7ead02630173e5c0838edec00eda291796c54745
 SHA512:
-  metadata.gz: edbdd2e67600ce6d76a928043c3674b49fa598e351f3d80023b4b941c4c2cd2015b5a912ec52c0cc28565a86c119823cab7d0594426a9968ba3e61b0770ce16d
-  data.tar.gz: 4ef09cd549fcf89844c0a0d748144769509da5da4db97b608780735415fb22b83793f4aae78f1db8d475ff3ad2e5b7d40608a9e491580500db323f91cf383310
+  metadata.gz: 53aa7c5275e2a824637d3c4f5d65ae7312cd92d356145153c076c2242bda2dc1043e47e05a455e4649169a6c00bfd7fec598638c032b1b2cf9f9277867e29ff0
+  data.tar.gz: 67c2b488289bbf1e5eb400bd5721c2f33e3473b9ea87aaf1e846ae558fddc975c392613f373aafc16a9612f6c0dfe8e7f8240dc9d737b218ab0fa8bd1ba21b9c

data/Gemfile

@@ -1,2 +1,8 @@
 source 'https://rubygems.org'
 gemspec
+
+group :development, :test do
+  gem 'rake'
+  gem 'minitest'
+  gem 'rack-test'
+end

data/Rakefile

@@ -1,16 +1,48 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+#!/usr/bin/env rake
+require 'rubygems'
+require 'bundler/setup'
 require 'fileutils'
-include FileUtils
+require 'logger'
+require 'rake/testtask'
+require 'active_support/all'
+require 'bundler/gem_tasks'
+
+#########################################################################################################
 
-# Default Rake task is compile
-#task :default => :compile
+# Load ENV vars
+if FileTest.exist?('.powenv')
+  File.open('.powenv', 'rb') do |powenv|
+    contents = powenv.read
 
-########################################################################
+    lines = contents.gsub('export ', '').split(/\n\r?/).reject{|line| line.blank?}
+    lines.each do |line|
+      keyValue = line.split('=', 2)
+      next unless keyValue.count == 2
+      ENV[keyValue.first] = keyValue.last.gsub("'",'').gsub('"','')
+    end
+  end
+end if !ENV['RACK_ENV'] or ENV['RACK_ENV'] == 'development'
 
 Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.libs.push "test"
+  t.libs.push 'lib'
+  t.libs.push 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end
+
+#########################################################################################################
+
+Rake::TaskManager.record_task_metadata = true
+
+task :default do
+  puts "\nAVAILABLE TASKS:"
+  Rake.application.options.show_tasks = :tasks
+  Rake.application.options.full_description = false
+  Rake.application.options.show_task_pattern = //
+  Rake.application.display_tasks_and_comments
+  puts "\n"
+end
+
+task :environment do
+
+end

data/fanforce-worker.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'iron_cache',    '~> 1.4.2'
   gem.add_runtime_dependency 'uuidtools',     '~> 2.1.4'
   gem.add_runtime_dependency 'activesupport', '3.2.13'
+  gem.add_runtime_dependency 'redis',         '~> 3.0.7'
 
   gem.add_runtime_dependency 'fanforce-api', '~> 0.18'
 end

data/lib/fanforce/worker.rb

@@ -1,4 +1,7 @@
 class Fanforce
+  require 'logger'
+  require 'active_support/all'
+  require_relative 'worker/utils'
   require_relative 'worker/version'
   require_relative 'worker/worker'
 end

data/lib/fanforce/worker/errors.rb

@@ -0,0 +1,189 @@
+require 'redis'
+require 'uuidtools'
+
+class Fanforce::Worker::Errors
+  include Fanforce::Worker::Utils
+
+  @@redis = nil
+
+  def self.redis
+    @@redis ||= Redis.new(url: Fanforce::Worker.redis_url)
+  end
+
+  def self.find(queue_id, error_id)
+    Fanforce::Worker::Error.new(queue_id, error_id)
+  end
+
+  def self.list(queue_id, from_num=0, to_num=100)
+    error_ids = redis.lrange("ERRORS:#{queue_id}", from_num, to_num)
+    Fanforce::Worker::ErrorList.new(queue_id, error_ids)
+  end
+
+  def self.list_summaries(queue_id, from_num=0, to_num=100)
+    error_ids = redis.lrange("ERRORS:#{queue_id}", from_num, to_num)
+    Fanforce::Worker::ErrorList.new(queue_id, error_ids).summaries
+  end
+
+  def self.delete_all(queue_id, error_ids)
+    Fanforce::Worker::ErrorList.new(queue_id, error_ids).delete
+  end
+
+  def self.retry_all(queue_id, error_ids)
+    Fanforce::Worker::ErrorList.new(queue_id, error_ids).retry
+  end
+
+  def self.add(queue_id, e, job_data, worker_env)
+    error_id = UUIDTools::UUID.random_create.to_s
+    error = {
+        error_id: error_id,
+        exception: e.class.name,
+        http_code: (e.code if e.respond_to?(:code)),
+        message: e.message,
+        backtrace: e.backtrace.to_json,
+        errored_at: Time.now,
+        queue_id: queue_id,
+        raw_json: job_data[:params].to_json,
+        env_vars: worker_env.to_json,
+        retries: job_data[:retries],
+        curl_command: (e.curl_command if e.respond_to?(:curl_command))
+    }
+    redis.rpush("ERRORS:#{queue_id}", error_id)
+    redis.hmset("ERRORS:#{queue_id}:#{error_id}", error.flatten)
+  rescue => e
+    log.fatal '-----------------------------------------------------'
+    log.fatal 'WORKER ERROR WHILE RECOVERING FROM JOB ERROR:'
+    log.fatal e.message
+    log.fatal e.backtrace
+    log.fatal '-----------------------------------------------------'
+    log.fatal 'JOB ERROR:'
+    error.each {|k,v| log.fatal "#{k}: #{v}" }
+  end
+
+end
+
+###################################################################################################################
+
+class Fanforce::Worker::Error
+
+  def initialize(queue_id, error_id)
+    @queue_id = queue_id
+    @error_id = error_id
+  end
+
+  def delete
+    self.class.delete(@queue_id, @error_id)
+    return nil
+  end
+
+  def details
+    v = self.class.get_details(@queue_id, @error_id)
+    self.class.format_details(v)
+  end
+
+  def summary
+    v = self.class.get_summary(@queue_id, @error_id)
+    self.class.format_summary(v)
+  end
+
+  def retry
+    v = Error.get_all(@queue_id, @error_id)
+    Error.retry(@queue_id, v)
+  end
+
+  ###################################################################################################################
+
+  SUMMARY_FIELDS = [:error_id, :exception, :message, :errored_at, :raw_json, :retries]
+  DETAIL_FIELDS = [:error_id, :exception, :http_code, :message, :backtrace, :errored_at, :raw_json, :env_vars, :retries, :curl_command]
+
+  def self.redis; Fanforce::Worker::Errors.redis end
+
+  def self.delete(queue_id, error_id)
+    redis.srem("ERRORS:#{queue_id}", error_id)
+    redis.del("ERRORS:#{queue_id}:#{error_id}")
+  end
+
+  def self.get_summary(queue_id, error_id)
+    redis.hmget("ERRORS:#{queue_id}:#{error_id}", *SUMMARY_FIELDS)
+  end
+
+  def self.format_summary(summary)
+    format(Hash[SUMMARY_FIELDS.zip(summary)])
+  end
+
+  def self.format(error)
+    error.each do |k,v|
+      error[k] = case k
+        when :backtrace then MultiJson.load(v) rescue []
+        when :env_vars then  MultiJson.load(v) rescue {}
+        when :retries then v.to_i
+        else v
+      end
+    end
+  end
+
+  def self.get_details(queue_id, error_id)
+    redis.hmget("ERRORS:#{queue_id}:#{error_id}", *DETAIL_FIELDS)
+  end
+
+  def self.format_details(details)
+    format(Hash[DETAIL_FIELDS.zip(details)])
+  end
+
+  def self.get_all(queue_id, error_id)
+    redis.hgetall("ERRORS:#{queue_id}:#{error_id}")
+  end
+
+  def self.retry(queue_id, raw_error)
+    error = format(raw_error.symbolize_keys)
+    params = MultiJson.load(v, symbolize_keys: true) rescue {}
+    Fanforce::Worker.enqueue(queue_id, params, :retries => error[:retries] + 1)
+    delete(:queue_id, error[:_id])
+  end
+
+end
+
+###################################################################################################################
+
+class Fanforce::Worker::ErrorList
+  Error = Fanforce::Worker::Error
+
+  def initialize(queue_id, error_ids)
+    @queue_id = queue_id
+    @error_ids = error_ids
+  end
+
+  def redis; Fanforce::Worker::Errors.redis end
+
+  def summaries
+    redis_responses = []
+    redis.multi do
+      @error_ids.each do |error_id|
+        redis_responses << Error.get_summary(@queue_id, error_id)
+      end
+    end
+    redis_responses.map do |redis_response|
+      Error.format_summary(redis_response.value)
+    end
+  end
+
+  def retry
+    redis_responses = []
+    redis.multi do
+      @error_ids.each do |error_id|
+        redis_responses << Error.get_all(@queue_id, error_id)
+      end
+    end
+    redis_responses.map do |redis_response|
+      Error.retry(@queue_id, redis_response.value)
+    end
+  end
+
+  def delete
+    redis.multi do
+      @error_ids.each do |error_id|
+        Error.delete(@queue_id, error_id)
+      end
+    end
+    return nil
+  end
+end

data/lib/fanforce/worker/runner.rb

@@ -0,0 +1,111 @@
+require 'iron_mq'
+require 'fanforce/api'
+require 'timeout'
+
+class Fanforce::Worker::Runner
+  include Fanforce::Worker::Utils
+
+  MAX_EXECUTION_TIME = 3300
+  class Timeout < RuntimeError; end
+
+  def initialize(worker_data, min_execution_time=300, &code_block)
+    raise "min_execution_time was set to #{min_execution_time}, which is #{min_execution_time - MAX_EXECUTION_TIME} seconds too long" if min_execution_time > MAX_EXECUTION_TIME
+    log.debug 'LOADING WORKER ENV'
+
+    @worker_started_at = Time.now
+
+    @queue_id   = worker_data['queue_id'] || (raise 'worker_data must contain queue_id')
+    @worker_env = worker_data['env_vars'] || {}
+
+    @min_execution_time = min_execution_time
+    @code_block = code_block
+
+    load_env
+    load_jobs
+  end
+
+  def load_jobs
+    log.debug 'PROCESSING JOBS...'
+    log.debug '------------------------------------------------------------------------------------'
+    job_num = 0
+    job_data = nil
+    while job_has_enough_time_to_run and (job = Fanforce::Worker.iron_mq.queue(@queue_id).get(timeout: 3600)) do
+      log.debug "- JOB #{job_num+=1}: #{job.body}"
+      timeout(worker_time_remaining, Timeout) do
+        job_data = nil
+        job_data = Fanforce.decode_json(job.body)
+        run_job(job, job_data, &@code_block)
+      end
+      delete_job
+      log.debug '------------------------------------------------------------------------------------'
+    end
+    delete_job
+    log.debug 'WINDING DOWN WORKER!'
+
+  rescue Exception => e
+    handle_job_loading_error(e, job, job_data)
+  end
+
+  def load_env
+    if File.exists?('.developmentenv.rb')
+      require '.developmentenv'
+    elsif File.exists?('.stagingenv.rb')
+      require '.stagingenv'
+    elsif File.exists?('.productionenv.rb')
+      require '.productionenv'
+    end
+  end
+
+  def run_job(job, job_data, &code_block)
+    @current_job = job
+    @current_params  = job_data[:params]
+    @current_retries = job_data[:retries]
+
+    set_env_vars(@worker_env)
+    code_block.call(job_data[:params].clone, retries: job_data[:retries], queue_id: @queue_id)
+    delete_job(job)
+
+  rescue Exception => e
+    handle_job_error(e, job, job_data)
+  end
+
+  def handle_job_loading_error(e, job, job_data)
+    raise($!, "#{$!}: THERE IS NO JOB", $!.backtrace) if job.nil?
+
+    delete_job(job)
+    log.debug 'REMOVED JOB FROM QUEUE, BUT COULD NOT SAVE TO ERROR CACHE...'
+    raise($!, "#{$!}: #{job_data.to_json}", $!.backtrace)
+  end
+
+  def handle_job_error(e, job, job_data)
+    raise($!, "#{$!}: THERE IS NO JOB", $!.backtrace) if job.nil?
+
+    delete_job(job)
+    require_relative 'errors'
+    log.debug 'REMOVED JOB FROM QUEUE, AND SAVING TO ERROR CACHE...'
+    Fanforce::Worker::Errors.add(@queue_id, e, job_data, @worker_env)
+  end
+
+  def worker_time_remaining
+    time_since_load = Time.now - @worker_started_at
+    MAX_EXECUTION_TIME - time_since_load
+  end
+
+  def job_has_enough_time_to_run
+    time_since_load = Time.now - @worker_started_at
+    return false if time_since_load > MAX_EXECUTION_TIME
+    return false if worker_time_remaining < @min_execution_time
+    return true
+  end
+
+  def set_env_vars(vars)
+    vars.each {|k,v| ENV[k.to_s]=v }
+  end
+
+  def delete_job(job=nil)
+    return if job.nil? and @current_job.nil?
+    (job || @current_job).delete
+    @current_job = nil
+  end
+
+end

data/lib/fanforce/worker/utils.rb

@@ -0,0 +1,10 @@
+module Fanforce::Worker::Utils
+
+  extend Fanforce::Worker::Utils
+  def self.included(base) base.extend(self) end
+
+  def log
+    Fanforce::Worker.log
+  end
+
+end

data/lib/fanforce/worker/version.rb

@@ -1,5 +1,5 @@
 class Fanforce
   class Worker
-    VERSION = '0.16.0'
+    VERSION = '0.17.0'
   end
 end

data/lib/fanforce/worker/worker.rb

@@ -1,251 +1,48 @@
-require 'timeout'
-
 class Fanforce::Worker
 
-  class Timeout < RuntimeError; end
-
-  LOADED_AT = Time.now
-  MAX_EXECUTION_TIME = 3300
+  @@iron = {}
+  @@redis = {}
+  @@log = Logger.new($stdout)
 
-  def initialize(opts={})
-    @opts = opts
-  end
-
-  def iron_mq
-    require 'iron_mq'
-    @iron_mq ||= IronMQ::Client.new(:token => @opts[:token] || ENV['IRON_TOKEN'], :project_id => @opts[:project_id] || ENV['IRON_PROJECT_ID'])
+  def self.iron_token
+    @@iron[:token] || ENV['IRON_TOKEN']
   end
 
-  def iron_cache
-    require 'iron_cache'
-    @iron_cache ||= IronCache::Client.new(:token => @opts[:token] || ENV['IRON_TOKEN'], :project_id => @opts[:project_id] || ENV['IRON_PROJECT_ID'])
+  def self.iron_project_id
+    @@iron[:project_id] || ENV['IRON_PROJECT_ID']
   end
 
-  def enqueue(queue_id, params, options={})
-    retries = (options[:retries].present?) ? options.delete(:retries) : 0
-    raise 'Params being sent to the queue must be a Hash' if !params.is_a?(Hash)
-    iron_mq.queue(queue_id).post({params: params, retries: retries}.to_json, options)
-  end
-
-  def add_error(queue_id, error)
-    require 'uuidtools'
-    details_id = UUIDTools::UUID.random_create.to_s
-    iron_cache.cache("#{queue_id}-ERRORS").put(details_id, error.to_json)
-    iron_mq.queue("#{queue_id}-ERRORS").post({
-        details_id: details_id,
-        http_code: error[:http_code],
-        exception: truncate(error[:exception]),
-        message: truncate(error[:message].to_s),
-        params: truncate(error[:params].to_json),
-        errored_at: error[:errored_at],
-        retries: error[:retries],
-        env_vars: truncate(error[:env_vars].to_json),
-        curl_command: truncate(error[:curl_command].to_s)
-    }.to_json)
-  rescue => e
-    puts '-----------------------------------------------------'
-    puts 'WORKER ERROR WHILE RECOVERING FROM JOB ERROR:'
-    puts e.message
-    puts e.backtrace
-    puts '-----------------------------------------------------'
-    puts 'JOB ERROR:'
-    puts "details_id: #{details_id}"
-    puts "http_code: #{error[:http_code]}"
-    puts "exception: #{truncate(error[:exception])}"
-    puts "message: #{truncate(error[:message].to_s)}"
-    puts "params: #{truncate(error[:params].to_json)}"
-    puts "errored_at: #{error[:errored_at]}"
-    puts "retries: #{error[:retries]}"
-    puts "env_vars: #{truncate(error[:env_vars].to_json)}"
-    puts "curl_command: #{truncate(error[:curl_command].to_s)}"
-  end
-
-  def delete_error(queue_id, job_id, details_id)
-    iron_mq.queue("#{queue_id}-ERRORS").delete(job_id)
-    iron_cache.cache("#{queue_id}-ERRORS").delete(details_id)
+  def self.iron_mq
+    require 'iron_mq'
+    @@iron[:mq] ||= IronMQ::Client.new(:token => @@iron[:token], :project_id => @@iron[:project_id])
   end
 
-  def error_details(queue_id, details_id)
-    cache = iron_cache.cache("#{queue_id}-ERRORS").get(details_id)
-    MultiJson.load(cache.value, :symbolize_keys => true)
+  def self.redis_url
+    @@redis[:url] || ENV['REDIS_URL_ERRORLOG']
   end
 
-  def retry_error(queue_id, job_id, details_id)
-    cache = iron_cache.cache("#{queue_id}-ERRORS").get(details_id)
-    cache_data = MultiJson.load(cache.value, :symbolize_keys => true)
-    enqueue(queue_id, cache_data[:params], :retries => cache_data[:retries] + 1)
-
-    cache.delete and iron_mq.queue("#{queue_id}-ERRORS").delete(job_id)
+  def self.set_config(obj)
+    @@iron[:token] = obj[:iron_token] if obj[:iron_token]
+    @@iron[:project_id] = obj[:iron_project_id] if obj[:iron_project_id]
+    @@redis[:url] = obj[:redis_url] if obj[:redis_url]
   end
 
-  def truncate(text, length=130, truncate_string="...")
-    if text
-      l = length - truncate_string.chars.to_a.length
-      chars = text.chars.to_a
-      (chars.length > length ? chars[0...l].join('') + truncate_string : text).to_s
-    end
+  def self.log
+    @@log
   end
 
   ##########################################################################################
 
   def self.enqueue(queue_id, params, options={})
-    self.new.enqueue(queue_id, params, options)
-  end
-
-  def self.add_error(queue_id, error)
-    self.new.add_error(queue_id, error)
-  end
-
-  ##########################################################################################
-
-  def self.current_queue_id=(queue_id)
-    @current_queue_id = queue_id
-  end
-
-  def self.current_queue_id
-    @current_queue_id
-  end
-
-  def self.current_worker_env=(env_vars)
-    @current_worker_env = env_vars
-  end
-
-  def self.current_worker_env
-    @current_worker_env
-  end
-
-  def self.current_params=(params)
-    @current_params = params
-  end
-
-  def self.current_params
-    @current_params
-  end
-
-  def self.current_retries=(retries)
-    @current_retries = retries
-  end
-
-  def self.current_retries
-    @current_retries
-  end
-
-  def self.current_job=(job)
-    @current_job = job
-  end
-
-  def self.current_job
-    @current_job
-  end
+    raise 'Params being sent to the queue must be a Hash' if !params.is_a?(Hash)
 
-  def self.load_env
-    if File.exists?('.developmentenv.rb')
-      require '.developmentenv'
-    elsif File.exists?('.stagingenv.rb')
-      require '.stagingenv'
-    elsif File.exists?('.productionenv.rb')
-      require '.productionenv'
-    end
+    retries = (options[:retries].present?) ? options.delete(:retries) : 0
+    iron_mq.queue(queue_id).post({params: params, retries: retries}.to_json, options)
   end
 
   def self.run(worker_data, min_execution_time=300, &code_block)
-    raise "min_execution_time was set to #{min_execution_time}, which is #{min_execution_time - MAX_EXECUTION_TIME} seconds too long" if min_execution_time > MAX_EXECUTION_TIME
-
-    puts 'LOADING WORKER ENV...'
-    load_env
-    require 'iron_mq'
-    require 'iron_cache'
-    require 'fanforce/api'
-    require 'active_support/all'
-
-    self.current_queue_id   = worker_data['queue_id']
-    self.current_worker_env = worker_data['env_vars']
-    queue = IronMQ::Client.new.queue(current_queue_id)
-
-    puts 'PROCESSING JOBS...'
-    puts '------------------------------------------------------------------------------------'
-    job_num = 0
-    job_data = nil
-    while job_has_enough_time_to_run(min_execution_time) and (job = queue.get(timeout: 3600)) do
-      puts "- JOB #{job_num+=1}: #{job.body}"
-      timeout(worker_time_remaining, Fanforce::Worker::Timeout) do
-        job_data = nil
-        job_data = Fanforce.decode_json(job.body)
-        run_job(job, job_data, &code_block)
-      end
-      self.delete_job
-      puts '------------------------------------------------------------------------------------'
-    end
-    self.delete_job
-    puts 'WINDING DOWN WORKER!'
-  rescue Exception => e
-    handle_job_loading_error(e, job, job_data)
-  end
-
-  def self.worker_time_remaining
-    time_since_load = Time.now - LOADED_AT
-    MAX_EXECUTION_TIME - time_since_load
-  end
-
-  def self.job_has_enough_time_to_run(min_execution_time)
-    time_since_load = Time.now - LOADED_AT
-    return false if time_since_load > MAX_EXECUTION_TIME
-    return false if worker_time_remaining < min_execution_time
-    return true
-  end
-
-  def self.retry(options)
-    self.new.enqueue(current_queue_id, current_params, options.merge(retries: current_retries + 1))
-  end
-
-  def self.run_job(job, job_data, &code_block)
-    self.current_job = job
-    self.current_params  = job_data[:params]
-    self.current_retries = job_data[:retries]
-
-    set_env_vars(current_worker_env)
-    code_block.call(job_data[:params].clone, retries: job_data[:retries], queue_id: current_queue_id)
-    self.delete_job(job)
-
-  rescue Exception => e
-    handle_job_error(e, job, job_data)
-  end
-
-  def self.handle_job_loading_error(e, job, job_data)
-    raise($!, "#{$!}: THERE IS NO JOB", $!.backtrace) if job.nil?
-
-    self.delete_job(job)
-    puts 'REMOVED JOB FROM QUEUE, BUT COULD NOT SAVE TO ERROR CACHE...'
-    raise($!, "#{$!}: #{job_data.to_json}", $!.backtrace)
-  end
-
-  def self.handle_job_error(e, job, job_data)
-    raise($!, "#{$!}: THERE IS NO JOB", $!.backtrace) if job.nil?
-
-    error = job_data.merge(
-        http_code: (e.code if e.respond_to?(:code)),
-        exception: e.class.name,
-        message: e.message,
-        backtrace: e.backtrace,
-        errored_at: Time.now,
-        env_vars: current_worker_env
-    )
-    error[:curl_command] = e.curl_command if e.respond_to?(:curl_command)
-
-    self.delete_job(job)
-    puts 'REMOVED JOB FROM QUEUE, AND SAVING TO ERROR CACHE...'
-    puts error.to_json
-    self.add_error current_queue_id, error
-  end
-
-  def self.delete_job(job=nil)
-    return if job.nil? and current_job.nil?
-    (job || current_job).delete
-    self.current_job = nil
-  end
-
-  def self.set_env_vars(vars)
-    vars.each {|k,v| ENV[k.to_s]=v }
+    require_relative 'runner'
+    Runner.new(worker_data, min_execution_time, &code_block)
   end
 
 end

data/test/controllers/enqueue_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+describe Fanforce::Worker do
+
+  before do
+    clean_dbs
+  end
+
+  it 'should enqueue a job' do
+    Fanforce::Worker.enqueue('test', {name: 'caleb'})
+    assert Fanforce::Worker.iron_mq.queue('test').size == 1
+  end
+
+  it 'should run an enqueued job' do
+    Fanforce::Worker.enqueue('test', {name: 'caleb'})
+    processed_job = false
+
+    Fanforce::Worker.run({'queue_id' => 'test'}) do |params|
+      processed_job = true
+      assert params[:name] == 'caleb'
+    end
+
+    assert processed_job == true
+    assert Fanforce::Worker.iron_mq.queue('test').size == 0
+  end
+
+end

data/test/controllers/error_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'fanforce/worker/errors'
+
+describe Fanforce::Worker::Errors do
+
+  before do
+    clean_dbs
+  end
+
+  it 'should save error to redis' do
+    Fanforce::Worker.enqueue('test', {name: 'caleb'})
+    ran_job = false
+
+    Fanforce::Worker.run({'queue_id' => 'test'}) do |params|
+      ran_job = true
+      raise 'test'
+    end
+    assert ran_job == true
+    assert Fanforce::Worker::Errors.list_summaries('test').size == 1
+    assert Fanforce::Worker.iron_mq.queue('test').size == 0
+  end
+
+  it 'should correctly retry error' do
+    Fanforce::Worker.enqueue('test', {name: 'caleb'})
+
+    Fanforce::Worker.run({'queue_id' => 'test'}) do |params|
+      raise 'test'
+    end
+    assert Fanforce::Worker::Errors.list('test').retry
+    assert Fanforce::Worker.iron_mq.queue('test').size == 1
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'rack/test'
+
+ENV['RACK_ENV'] = 'test'
+
+require 'fanforce/worker'
+require 'fanforce/worker/errors'
+
+# Clean databases before each test case
+def clean_dbs
+  Fanforce::Worker.set_config(
+      iron_token: 'TF0YNz8na2H_reJ7_EoRnQAeKHM',
+      iron_project_id: '53725dfe0db3ef0005000001',
+      redis_url: 'redis://localhost:6379/5'
+  )
+  Fanforce::Worker.iron_mq.queues.all.each do |queue|
+    queue.delete_queue
+  end
+  Fanforce::Worker::Errors.redis.flushdb
+  Fanforce::Worker.log.level = Logger::FATAL
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fanforce-worker
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Caleb Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-09 00:00:00.000000000 Z
+date: 2014-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iron_mq
@@ -66,6 +66,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.7
 - !ruby/object:Gem::Dependency
   name: fanforce-api
   requirement: !ruby/object:Gem::Requirement
@@ -93,8 +107,14 @@ files:
 - Rakefile
 - fanforce-worker.gemspec
 - lib/fanforce/worker.rb
+- lib/fanforce/worker/errors.rb
+- lib/fanforce/worker/runner.rb
+- lib/fanforce/worker/utils.rb
 - lib/fanforce/worker/version.rb
 - lib/fanforce/worker/worker.rb
+- test/controllers/enqueue_test.rb
+- test/controllers/error_test.rb
+- test/test_helper.rb
 homepage: http://github.com/fanforce/fanforce-worker
 licenses: []
 metadata: {}
@@ -118,4 +138,7 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Fanforce worker used by various Fanforce addons for background processing.
-test_files: []
+test_files:
+- test/controllers/enqueue_test.rb
+- test/controllers/error_test.rb
+- test/test_helper.rb