fanforce-app-worker 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b22704a3d47459c5e47cf934525d3a0c7414aab
+  data.tar.gz: 841222ac9823186acad69b8ea3e80d0fb8cf7eef
+SHA512:
+  metadata.gz: c6a5bf7e16db9836358bec430ac3fb263e397771973228aa2985fb0694e5c6355a20dd840eed353f43d08715db6f2adf56a541a5afa26c2c57ffb6cfefd4aa9c
+  data.tar.gz: 0d725b85abf7cfb875e5cf8594dabd9527c5e3e9aa2b464ab339914212dd457278116580d9e7e9f1f674f8c82737041cebc1f67266314a967a465811466f99f0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.DS_Store
+.idea/
+.idea/*
+Gemfile.lock

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p576

data/.yardopts

@@ -0,0 +1,5 @@
+lib/**/*.rb
+--load ./.yardopts.rb
+--markup-provider=redcarpet
+--markup=markdown
+--readme README.md

data/.yardopts.rb

@@ -0,0 +1 @@
+require 'redcarpet/compat'

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development, :test do
+  gem 'rake'
+  gem 'minitest'
+  gem 'rack-test'
+  gem 'simplecov', :require => false
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'github-markup', :require => true
+end

data/README.md

@@ -0,0 +1,4 @@
+fanforce-app-worker
+==
+
+Fanforce worker used by apps to connect with iron_mg and iron_worker_ng

data/Rakefile

@@ -0,0 +1,48 @@
+#!/usr/bin/env rake
+require 'rubygems'
+require 'bundler/setup'
+require 'fileutils'
+require 'logger'
+require 'rake/testtask'
+require 'active_support/all'
+require 'bundler/gem_tasks'
+
+#########################################################################################################
+
+# 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.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-app-worker.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fanforce/app_worker/version'
+
+Gem::Specification.new do |gem|
+  gem.name     = 'fanforce-app-worker'
+  gem.version  = Fanforce::AppWorker::VERSION
+  gem.date     = Time.now.utc.strftime('%Y-%m-%d')
+  gem.summary  = %q{Worker library to help Fanforce apps with background processing}
+
+  gem.authors  = ['Caleb Clark']
+  gem.email    = ['cclark@fanforce.com']
+  gem.homepage = 'http://github.com/fanforce/gem-app-worker'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'iron_mq',       '~> 5.0.1'
+  gem.add_runtime_dependency 'iron_cache',    '~> 1.4.2'
+  gem.add_runtime_dependency 'uuid',          '~> 2.3.7'
+  gem.add_runtime_dependency 'activesupport', '~> 4.1.6'
+  gem.add_runtime_dependency 'redis',         '~> 3.1.0'
+  gem.add_runtime_dependency 'multi_json',    '>= 1.7.2'
+
+  gem.add_runtime_dependency 'fanforce-base', '~> 1.0'
+  gem.add_runtime_dependency 'fanforce-api',  '~> 1.0'
+end

data/lib/fanforce/app_worker.rb

@@ -0,0 +1,10 @@
+require 'logger'
+require 'multi_json'
+require 'active_support/all'
+
+require_relative 'app_worker/version'
+require_relative 'app_worker/utils'
+require_relative 'app_worker/worker'
+require_relative 'app_worker/errors'
+require_relative 'app_worker/runner'
+

data/lib/fanforce/app_worker/errors.rb

@@ -0,0 +1,200 @@
+require 'redis'
+require 'uuid'
+
+class Fanforce::AppWorker::Errors
+  include Fanforce::AppWorker::Utils
+
+  @@redis = nil
+
+  def self.redis
+    @@redis ||= Redis.new(url: Fanforce::AppWorker.redis_url_errorlog)
+  end
+
+  def self.find(queue_id, error_id)
+    Fanforce::AppWorker::Error.new(queue_id, error_id)
+  end
+
+  def self.list(queue_id, from_num=0, to_num=100, reverse=false)
+    error_ids = redis.lrange("ERRORS:#{queue_id}", from_num, to_num)
+    error_ids.reverse! if reverse
+    Fanforce::AppWorker::ErrorList.new(queue_id, error_ids)
+  end
+
+  def self.list_summaries(queue_id, from_num=0, to_num=100, reverse=false)
+    error_ids = redis.lrange("ERRORS:#{queue_id}", from_num, to_num)
+    error_ids.reverse! if reverse
+    Fanforce::AppWorker::ErrorList.new(queue_id, error_ids).summaries
+  end
+
+  def self.delete_all(queue_id, error_ids)
+    Fanforce::AppWorker::ErrorList.new(queue_id, error_ids).delete
+  end
+
+  def self.retry_all(queue_id, error_ids)
+    Fanforce::AppWorker::ErrorList.new(queue_id, error_ids).retry
+  end
+
+  def self.add(queue_id, e, job_data, worker_env)
+    error_id = UUID.generate
+    error = {
+        error_id: error_id,
+        class: Fanforce::AppWorker,
+        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)),
+        iron_token: Fanforce::AppWorker.iron_token,
+        iron_project_id: Fanforce::AppWorker.iron_project_id
+    }
+    redis.multi do
+      redis.rpush("ERRORS:#{queue_id}", error_id)
+      redis.hmset("ERRORS:#{queue_id}:#{error_id}", error.flatten)
+    end
+  rescue => e
+    log.fatal '-----------------------------------------------------'
+    log.fatal 'APPWORKER ERRORED WHILE RECOVERING FROM JOB ERROR:'
+    log.fatal '-----------------------------------------------------'
+    error.each {|k,v| log.fatal "#{k}: #{v}" }
+    log.fatal '-----------------------------------------------------'
+    raise
+  end
+
+end
+
+###################################################################################################################
+
+class Fanforce::AppWorker::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::AppWorker::Errors.redis end
+
+  def self.delete(queue_id, error_id)
+    redis.lrem("ERRORS:#{queue_id}", 0, 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)
+    payload = MultiJson.load(error[:raw_json], symbolize_keys: true) rescue {}
+    queue_id = queue_id.gsub(":#{ENV['DEVELOPER_EMAIL']}", '') if ENV['DEVELOPER_EMAIL']
+    Fanforce::AppWorker.set_config(iron_token: error[:iron_token], iron_project_id: error[:iron_project_id])
+    Fanforce::AppWorker.enqueue(queue_id, payload, :retries => error[:retries] + 1)
+    delete(queue_id, error[:error_id])
+  end
+
+end
+
+###################################################################################################################
+
+class Fanforce::AppWorker::ErrorList
+  Error = Fanforce::AppWorker::Error
+
+  def initialize(queue_id, error_ids)
+    @queue_id = queue_id
+    @error_ids = error_ids
+  end
+
+  def redis; Fanforce::AppWorker::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.multi do
+      redis_responses.map do |redis_response|
+        Error.retry(@queue_id, redis_response.value)
+      end
+    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/app_worker/runner.rb

@@ -0,0 +1,116 @@
+require 'iron_mq'
+require 'fanforce/api'
+require 'timeout'
+
+class Fanforce::AppWorker::Runner
+  include Fanforce::AppWorker::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 '------------------------------------------------------------------------------------'
+    log.debug 'LOADING WORKER ENV'
+
+    @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_from_server
+    load_env_from_worker(@worker_env)
+    ENV.each {|k,v| log.debug "#{k} = #{v}" }
+
+    load_jobs
+  end
+
+  def load_jobs
+    log.debug '------------------------------------------------------------------------------------'
+    log.debug 'PROCESSING JOBS...'
+    log.debug '------------------------------------------------------------------------------------'
+    job_num = 0
+    job_data = nil
+    while job_has_enough_time_to_run and (job = Fanforce::AppWorker.iron_mq.queue(iron_queue_id(@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 = MultiJson.load(job.body, symbolize_keys: true)
+        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_from_server
+    if File.exists?('.developmentenv.rb')
+      require '.developmentenv'
+    elsif File.exists?('.stagingenv.rb')
+      require '.stagingenv'
+    elsif File.exists?('.productionenv.rb')
+      require '.productionenv'
+    end
+  end
+
+  def load_env_from_worker(vars)
+    vars.each {|k,v| ENV[k.to_s]=v }
+  end
+
+  def run_job(job, job_data, &code_block)
+    @current_job = job
+    @current_params  = job_data[:params]
+    @current_retries = job_data[:retries]
+
+    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::AppWorker::Errors.add(@queue_id, e, job_data, @worker_env)
+  end
+
+  def worker_time_remaining
+    time_since_load = Time.now - Fanforce::AppWorker::LOADED_AT
+    MAX_EXECUTION_TIME - time_since_load
+  end
+
+  def job_has_enough_time_to_run
+    time_since_load = Time.now - Fanforce::AppWorker::LOADED_AT
+    return false if time_since_load > MAX_EXECUTION_TIME
+    return false if worker_time_remaining < @min_execution_time
+    return true
+  end
+
+  def delete_job(job=nil)
+    return if job.nil? and @current_job.nil?
+    (job || @current_job).delete
+  rescue Exception => e
+    log.debug "Job could not be deleted: #{e.message}"
+  ensure
+    @current_job = nil
+  end
+
+end

data/lib/fanforce/app_worker/utils.rb

@@ -0,0 +1,13 @@
+module Fanforce::AppWorker::Utils
+  extend self
+  def self.included(base) base.extend(self) end
+
+  def log
+    Fanforce::AppWorker.log
+  end
+
+  def iron_queue_id(iron_queue_id)
+    (ENV['RACK_ENV'] == 'development' && ENV['DEVELOPER_EMAIL']) ? "#{iron_queue_id}:#{ENV['DEVELOPER_EMAIL']}" : iron_queue_id
+  end
+
+end

data/lib/fanforce/app_worker/version.rb

@@ -0,0 +1,5 @@
+class Fanforce
+  class AppWorker
+    VERSION = '1.0.0'
+  end
+end

data/lib/fanforce/app_worker/worker.rb

@@ -0,0 +1,50 @@
+class Fanforce::AppWorker
+
+  LOADED_AT = Time.now
+
+  @@iron = {}
+  @@redis = {}
+  @@log = Logger.new($stdout)
+
+  def self.iron_token
+    @@iron[:token] || ENV['IRON_TOKEN']
+  end
+
+  def self.iron_project_id
+    @@iron[:project_id] || ENV['IRON_PROJECT_ID']
+  end
+
+  def self.iron_mq
+    require 'iron_mq'
+    @@iron[:mq] ||= IronMQ::Client.new(:token => @@iron[:token], :project_id => @@iron[:project_id])
+  end
+
+  def self.redis_url_errorlog
+    @@redis[:url_errorlog] || ENV['REDIS_URL_ERRORLOG'] || (raise 'No REDIS_URL_ERRORLOG found in ENV')
+  end
+
+  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_errorlog] = obj[:redis_url_errorlog] if obj[:redis_url_errorlog]
+  end
+
+  def self.log
+    @@log
+  end
+
+  ##########################################################################################
+
+  def self.enqueue(queue_id, params, options={})
+    raise 'Params being sent to the queue must be a Hash' if !params.is_a?(Hash)
+
+    queue_id = Utils.iron_queue_id(queue_id)
+    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)
+    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::AppWorker do
+
+  before do
+    clean_dbs
+  end
+
+  it 'should enqueue a job' do
+    Fanforce::AppWorker.enqueue('test', {name: 'caleb'})
+    assert Fanforce::AppWorker.iron_mq.queue('test').size == 1
+  end
+
+  it 'should run an enqueued job' do
+    Fanforce::AppWorker.enqueue('test', {name: 'caleb'})
+    processed_job = false
+
+    Fanforce::AppWorker.run({'queue_id' => 'test'}) do |params|
+      processed_job = true
+      assert params[:name] == 'caleb'
+    end
+
+    assert processed_job == true
+    assert Fanforce::AppWorker.iron_mq.queue('test').size == 0
+  end
+
+end

data/test/controllers/error_test.rb

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

data/test/test_helper.rb

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

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: fanforce-app-worker
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Caleb Clark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: iron_mq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+- !ruby/object:Gem::Dependency
+  name: iron_cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.7
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.6
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: fanforce-base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fanforce-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- cclark@fanforce.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- .yardopts
+- .yardopts.rb
+- Gemfile
+- README.md
+- Rakefile
+- fanforce-app-worker.gemspec
+- lib/fanforce/app_worker.rb
+- lib/fanforce/app_worker/errors.rb
+- lib/fanforce/app_worker/runner.rb
+- lib/fanforce/app_worker/utils.rb
+- lib/fanforce/app_worker/version.rb
+- lib/fanforce/app_worker/worker.rb
+- test/controllers/enqueue_test.rb
+- test/controllers/error_test.rb
+- test/test_helper.rb
+homepage: http://github.com/fanforce/gem-app-worker
+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.14
+signing_key: 
+specification_version: 4
+summary: Worker library to help Fanforce apps with background processing
+test_files:
+- test/controllers/enqueue_test.rb
+- test/controllers/error_test.rb
+- test/test_helper.rb
+has_rdoc: