mobilize-base 1.0.0

data/lib/mobilize-base/models/job.rb

@@ -0,0 +1,253 @@
+module Mobilize
+  class Job
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    field :requestor_id, type: String
+    field :name, type: String
+    field :active, type: Boolean #active, inactive
+    field :schedule, type: String
+    field :active_task, type: String
+    field :tasks, type: Hash
+    field :status, type: String
+    field :last_error, type: String
+    field :last_trace, type: String
+    field :last_completed_at, type: Time
+    field :read_handler, type: String
+    field :write_handler, type: String
+    field :param_source, type: String #name of sheet on doc
+    field :param_hash, type: String #JSON
+    field :destination, type: String #output destination - could be file, could be sheet
+
+    index({ requestor_id: 1})
+    index({ name: 1})
+
+    before_destroy :destroy_output_dst_ids
+
+    def worker
+      j = self
+      Mobilize::Resque.find_worker_by_mongo_id(j.id.to_s)
+    end
+
+    def Job.find_by_name(name)
+      Job.where(:name=>name).first
+    end
+
+    def Job.find_all_by_requestor_id(requestor_id)
+      Job.where(:requestor_id=>requestor_id).to_a
+    end
+
+    def Job.find_or_create_by_requestor_id_and_name(requestor_id,name)
+      j = Job.where(:requestor_id=>requestor_id, :name=>name).first
+      j = Job.create(:requestor_id=>requestor_id, :name=>name) unless j
+      return j
+    end
+
+    #called by Resque
+    def Job.perform(id,*args)
+      j = Job.find(id)
+      task_params = j.tasks[j.active_task]
+      begin
+        j.update_status(%{Starting #{j.active_task} task at #{Time.now.utc}})
+        task_output = "Mobilize::#{task_params['handler'].humanize}".constantize.send(j.active_task,id)
+        #this allows user to return false if the stage didn't go as expected and needs to retry
+        #e.g. tried to write to Google but all the accounts were in use
+        return false if task_output == false
+        task_output_dst_id = if task_output.to_s.length==24 and Dataset.find(task_output.to_s)
+                              #user has returned dst as output from task
+                              task_output
+                            else
+                              #store the output in a cache
+                              dst = Dataset.find_or_create_by_requestor_id_and_handler_and_name(j.requestor.id.to_s,'mongoer',"#{j.id.to_s}/#{j.active_task}")
+                              dst.write_cache(task_output.to_s)
+                              dst.id.to_s
+                            end
+        j.tasks[j.active_task]['output_dst_id'] = task_output_dst_id
+        if j.active_task == j.tasks.keys.last
+          j.active_task = nil
+          j.last_error = ""
+          j.last_trace = ""
+          j.last_completed_at = Time.now.utc
+          j.status = %{Completed all tasks at #{Time.now.utc}}
+          j.save!
+          #check for any dependent jobs, if there are, enqueue them
+          r = j.requestor
+          dep_jobs = Job.where(:active=>true, :requestor_id=>r.id.to_s, :schedule=>"after #{j.name}").to_a
+          dep_jobs += Job.where(:active=>true, :schedule=>"after #{r.name}/#{j.name}").to_a
+          #put begin/rescue so all dependencies run
+          dep_jobs.each{|dj| begin;dj.enqueue! unless dj.is_working?;rescue;end}
+        else
+          task_names = j.tasks.keys
+          stage_idx = task_names.index(j.active_task) + 1
+          j.active_task = j.tasks.keys[stage_idx]
+          j.save!
+          #queue up next task
+          j.enqueue!
+        end
+      rescue ScriptError,StandardError => exc
+        #record the failure in Job so it appears on spec sheets
+        j.status='failed'
+        j.save!
+        j.update_status("Failed at #{Time.now.utc.to_s}")
+        j.update_attributes(:last_error=>exc.to_s,:last_trace=>exc.backtrace.to_s)
+        [exc.to_s,exc.backtrace.to_s].join("=>").oputs
+        #raising here will cause the failure to show on the Resque UI
+        raise exc
+      end
+      return true
+    end
+
+    def enqueue!
+      j = self
+      #assign first task if none assigned
+      if j.tasks.blank?
+        #make a hash with the read/write tasks
+        j.update_attributes(:tasks=>{"read_by_job_id"=>{'handler'=>j.read_handler},
+                                     "write_by_job_id"=>{'handler'=>j.write_handler}})
+      end
+      j.update_attributes(:active_task=>"read_by_job_id") if j.active_task.blank?
+      ::Resque::Job.create("mobilize",Job,j.id.to_s,%{#{j.requestor.name}=>#{j.name}})
+      return true
+    end
+
+    #convenience methods
+    def requestor
+      j = self
+      return Requestor.find(j.requestor_id)
+    end
+
+    def restart
+      j = self
+      j.update_attributes(:last_completed_at=>nil)
+      return true
+    end
+
+    def prior_task
+      j = self
+      return nil if j.active_task.nil?
+      task_idx = j.tasks.keys.index(j.active_task)
+      return nil if task_idx==0
+      return j.tasks.keys[task_idx-1]
+    end
+
+    def destination_url
+      j = self
+      return nil if j.destination.nil?
+      destination = j.destination
+      dst = if j.write_handler == 'gsheet'
+              destination = [j.requestor.jobspec_title,j.destination].join("/") if destination.split("/").length==1
+              Dataset.find_by_handler_and_name('gsheeter',destination)
+            elsif j.write_handler == 'gtxt'
+              #all gtxt files must end in gz
+              destination += ".gz" unless destination.ends_with?(".gz")
+              destination = [s.requestor.name,"_"].join + destination unless destination.starts_with?([s.requestor.name,"_"].join)
+              Dataset.find_by_handler_and_name('gtxter',destination)
+            end
+      return dst.url if dst
+    end
+
+    def worker_args
+      j = self
+      Jobtracker.get_worker_args(j.worker)
+    end
+
+    def set_worker_args(args)
+      j = self
+      Jobtracker.set_worker_args(j.worker,args)
+    end
+
+    def cache_params
+      j = self
+      #go to paramsheet and read
+      param_path = if j.paramsheet.split("/").length==1
+                     [j.requestor.jobspec_title,j.paramsheet].join("/")
+                   else
+                     j.paramsheet
+                   end
+      param_sheet = j.requestor.find_or_create_gsheet_by_path(param_path)
+      param_tsv = param_sheet.to_tsv
+      param_dst = j.requestor.gsheets.select{|s| s.path == param_sheet.path}
+      param_dst.cache.write(param_tsv)
+      s.update_attributes(:param_dst_id=>paramdst.id.to_s)
+      (s.requestor.name + "'s #{s.name} params cached").oputs
+      return true
+    end
+
+    def update_status(msg)
+      j = self
+      j.update_attributes(:status=>msg)
+      Mobilize::Resque.update_job_status(j.id.to_s,msg)
+      return true
+    end
+
+    def is_working?
+      j = self
+      Mobilize::Resque.active_mongo_ids.include?(j.id.to_s)
+    end
+
+    def is_due?
+      j = self
+      return false if j.is_working? or j.schedule.to_s.starts_with?("after")
+      last_run = j.last_completed_at
+      #check schedule
+      schedule = j.schedule
+      return true if schedule == 'once' and j.active
+      #strip the "every" from the front if present
+      schedule = schedule.gsub("every","").gsub("."," ").strip
+      value,unit,operator,job_utctime = schedule.split(" ")
+      curr_utctime = Time.now.utc
+      curr_utcdate = curr_utctime.to_date.strftime("%Y-%m-%d")
+      if job_utctime
+        job_utctime = job_utctime.split(" ").first
+        job_utctime = Time.parse([curr_utcdate,job_utctime,"UTC"].join(" "))
+      end
+      #after is the only operator
+      raise "Unknown #{operator.to_s} operator" if operator and operator != "after"
+      if ["hour","hours"].include?(unit)
+        #if it's later than the last run + hour tolerance, is due
+        if last_run.nil? or curr_utctime > (last_run + value.to_i.hour)
+          return true
+        end
+      elsif ["day","days"].include?(unit)
+        if last_run.nil? or curr_utctime.to_date >= (last_run.to_date + value.to_i.day)
+          if operator and job_utctime
+            if curr_utctime>job_utctime and (job_utctime - curr_utctime).abs < 1.hour
+              return true
+            end
+          elsif operator || job_utctime
+            raise "Please specify both an operator and a time in UTC, or neither"
+          else
+            return true
+          end
+        end
+      elsif unit == "day_of_week"
+        if curr_utctime.wday==value and (last_run.nil? or last_run.to_date != curr_utctime.to_date)
+          if operator and job_utctime
+            if curr_utctime>job_utctime and (job_utctime - curr_utctime).abs < 1.hour
+              return true
+            end
+          elsif operator || job_utctime
+            raise "Please specify both an operator and a time in UTC, or neither"
+          else
+            return true
+          end
+        end
+      elsif unit == "day_of_month"
+        if curr_utctime.day==value and (last_run.nil? or last_run.to_date != curr_utctime.to_date)
+          if operator and job_utctime
+            if curr_utctime>job_utctime and (job_utctime - curr_utctime).abs < 1.hour
+              return true
+            end
+          elsif operator || job_utctime
+            raise "Please specify both an operator and a time in UTC, or neither"
+          else
+            return true
+          end
+        end
+      else
+        raise "Unknown #{unit.to_s} time unit"
+      end
+      #if nothing happens, return false
+      return false
+    end
+  end
+end

data/lib/mobilize-base/models/requestor.rb

@@ -0,0 +1,223 @@
+module Mobilize
+  class Requestor
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    field :email, type: String
+    field :oauth, type: String
+    field :name, type: String
+    field :first_name, type: String
+    field :last_name, type: String
+    field :admin_role, type: String
+    field :last_run, type: Time
+    field :status, type: String
+
+    validates_presence_of :name, :message => ' cannot be blank.'
+    validates_uniqueness_of :name, :message => ' has already been used.'
+
+    before_destroy :destroy_jobs
+
+    def Requestor.find_or_create_by_name(name)
+      r = Requestor.where(:name => name).first
+      r = Requestor.create(:name => name) unless r
+      return r
+    end
+
+    def Requestor.find_or_create_by_email(email)
+      r = Requestor.where(:email => email).first
+      r = Requestor.create(:email => email) unless r
+      user_name = email.split("@").first
+      r.update_attributes(:name => user_name) unless r.name.to_s.length>0
+      return r
+    end
+
+    def Requestor.jobs_sheet_headers
+      %w{name active schedule status last_error destination_url read_handler write_handler param_source params destination}
+    end
+
+    def Requestor.perform(id,*args)
+      r = Requestor.find(id.to_s)
+      #reserve email account for read
+      gdrive_email = Gdriver.get_worker_email_by_mongo_id(id)
+      return false unless gdrive_email
+      jobs_sheet = r.jobs_sheet(gdrive_email)
+      #write headers to sheet
+      Requestor.jobs_sheet_headers.each_with_index do |h,h_i|
+        jobs_sheet[1,h_i+1] = h
+      end
+      jobs_sheet.save
+      #read the jobs sheet 
+      #record jobs in DB
+      #deactivate jobs not in sheet
+      r.read_jobs(gdrive_email)
+      #queue up the jobs that are due and active
+      r.jobs.each do |j|
+        begin
+          j.enqueue! if j.active and j.is_due?
+        rescue ScriptError,StandardError => exc
+          #update errors
+          j.update_attributes(:last_error=>exc.to_s,:last_trace=>exc.backtrace.to_s)
+        end
+      end
+      #write any updates to status, error, datasource_url etc.
+      r.write_jobs(gdrive_email)
+      r.update_attributes(:last_run=>Time.now.utc)
+    end
+
+    def jobs_sheet(gdrive_email)#gdrive_email to read with
+      r = self
+      r.find_or_create_gbook_by_title(r.jobspec_title,gdrive_email)
+      jobs_name = [r.jobspec_title,"Jobs"].join("/")
+      r.find_or_create_gsheet_by_name(jobs_name,gdrive_email)
+    end
+
+    def read_jobs(gdrive_email)
+      r = self
+      jobs_sheet = r.jobs_sheet(gdrive_email)
+      rem_jobs = jobs_sheet.to_tsv.tsv_to_hash_array
+      #go through each job, update relevant job with its params
+      loc_jobs = []
+      rem_jobs.each_with_index do |rj,rj_i|
+        #skip bad rows
+        next if (rj['name'].to_s.first == "#" or ['name','schedule','read_handler','write_handler','active'].select{|c| rj[c].to_s.strip==""}.length>0)
+        j = Job.find_or_create_by_requestor_id_and_name(r.id.to_s,rj['name'])
+        #update top line params
+        j.update_attributes(:active => rj['active'],
+                            :schedule => rj['schedule'],
+                            :read_handler => rj['read_handler'],
+                            :write_handler => rj['write_handler'],
+                            :param_source => rj['param_source'],
+                            :params => rj['params'],
+                            :destination => rj['destination'])
+        #update laststatus with "Created job for" if job is due
+        j.update_status("Due and active at #{Time.now.utc}") if j.is_due? and j.active
+        #add this job to list of local ones
+        loc_jobs << j
+      end
+      #deactivate requestor jobs that are not included in sheet;
+      #this makes sure we don't run obsolete jobs
+      (r.jobs.map{|j| j.id.to_s} - loc_jobs.map{|j| j.id.to_s}).each do |rjid|
+        j = Job.find(rjid)
+        if j.active
+          j.update_attributes(:active=>false)
+          r.update_status("Deactivated job:#{r.name}=>#{j.name}")
+        end
+      end
+      r.update_status(r.name + " jobs read at #{Time.now.utc}")
+      return true
+    end
+
+    def write_jobs(gdrive_email) #gdrive_email to update with
+      r = self
+      jobs_sheet = r.jobs_sheet(gdrive_email)
+      rem_jobs = jobs_sheet.to_tsv.tsv_to_hash_array
+      #go through each job, update relevant job with its params
+      headers = Requestor.jobs_sheet_headers
+      #write headers
+      headers.each_with_index do |h,h_i|
+        jobs_sheet[1,h_i+1] = h
+      end
+      #write rows
+      rem_jobs.each_with_index do |rj,rj_i|
+        #skip bad rows
+        next if (rj['name'].to_s.first == "#" or ['name','schedule','read_handler','write_handler','active'].select{|c| rj[c].to_s.strip==""}.length>0)
+        j = r.jobs(rj['name'])
+        #update active to false if this was a run once
+        j.update_attributes(:active=>false) if j.schedule.to_s == 'once'
+        jobs_sheet[rj_i+2,headers.index('active')+1] = j.active.to_s
+        jobs_sheet[rj_i+2,headers.index('status')+1] = j.status.to_s.gsub("\n",";").gsub("\t"," ")
+        jobs_sheet[rj_i+2,headers.index('last_error')+1] = j.last_error.to_s.gsub("\n",";").gsub("\t"," ")
+        jobs_sheet[rj_i+2,headers.index('destination_url')+1] = j.destination_url.to_s
+      end
+      jobs_sheet.save
+      r.update_status(r.name + " jobs written")
+      return true
+    end
+
+    def jobspec_title
+      r = self
+      prefix = "Jobspec_"
+      suffix = ""
+      if Mobilize::Base.env == 'development'
+        suffix = "_dev"
+      elsif Mobilize::Base.env == 'test' or Mobilize::Base.env == 'pry_dev'
+        suffix = "_test"
+      elsif Mobilize::Base.env == 'production' or Mobilize::Base.env == 'integration'
+        suffix = ""
+      else
+        raise "Invalid environment"
+      end
+      title = prefix + r.name + suffix
+      return title
+    end
+
+    #Google doc helper methods
+
+    def find_or_create_gbook_by_title(title,gdrive_email)
+      r = self
+      book_dst = Dataset.find_or_create_by_handler_and_name('gbooker',title)
+      #give dst this requestor if none
+      book_dst.update_attributes(:requestor_id=>r.id.to_s) if book_dst.requestor_id.nil?
+      book = Gbooker.find_or_create_by_dst_id(book_dst.id.to_s,gdrive_email)
+      return book
+    end
+
+    def find_or_create_gsheet_by_name(name,gdrive_email)
+      r = self
+      sheet_dst = Dataset.find_or_create_by_handler_and_name('gsheeter',name)
+      sheet_dst.update_attributes(:requestor_id=>r.id.to_s) if sheet_dst.requestor_id.nil?
+      sheet = Gsheeter.find_or_create_by_dst_id(sheet_dst.id.to_s,gdrive_email)
+      return sheet
+    end
+
+    def jobs(jname=nil)
+      r = self
+      js = Job.find_all_by_requestor_id(r.id.to_s)
+      if jname
+        return js.sel{|j| j.name == jname}.first
+      else
+        return js
+      end
+    end
+
+    def destroy_jobs
+      r = self
+      r.jobs.each{|s| s.delete}
+    end
+
+    def gsheets
+      r = self
+      Dataset.find_all_by_handler_and_requestor_id('gsheet',r.id.to_s)
+    end
+
+    def worker
+      r = self
+      Mobilize::Resque.find_worker_by_mongo_id(r.id.to_s)
+    end
+
+    def update_status(msg)
+      r = self
+      r.update_attributes(:status=>msg)
+      Mobilize::Resque.update_job_status(r.id.to_s,msg)
+      return true
+    end
+
+    def is_working?
+      r = self
+      Mobilize::Resque.active_mongo_ids.include?(r.id.to_s)
+    end
+
+    def is_due?
+      r = self
+      return false if r.is_working?
+      last_due_time = Time.now.utc - Jobtracker.requestor_refresh_freq
+      return true if r.last_run.nil? or r.last_run < last_due_time
+    end
+
+    def enqueue!
+      r = self
+      ::Resque::Job.create("mobilize",Requestor,r.id.to_s,{"name"=>r.name})
+      return true
+    end
+
+  end
+end

data/lib/mobilize-base/tasks/mobilize-base.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'mobilize-base/tasks'

data/lib/mobilize-base/tasks.rb

@@ -0,0 +1,43 @@
+# require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :mobilize do
+
+  desc "Start a Resque worker"
+  task :work do
+    require 'resque'
+    require 'mobilize-base'
+
+    begin
+      worker = Resque::Worker.new(Mobilize::Resque.config['queue_name'])
+    rescue Resque::NoQueueError
+      abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
+    end
+
+    puts "Starting worker #{worker}"
+
+    worker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+
+  desc "Set up config and log folders and files"
+  task :setup do
+    sample_dir = File.dirname(__FILE__) + '/../samples/'
+    sample_files = Dir.entries(sample_dir)
+    config_dir = "#{ENV['PWD']}/config/"
+    log_dir = "#{ENV['PWD']}/log/"
+    unless File.exists?(config_dir)
+      puts "creating config dir"
+      `mkdir #{config_dir}`
+    end
+    unless File.exists?(log_dir)
+      puts "creating log dir"
+      `mkdir #{log_dir}`
+    end
+    sample_files.each do |fname|
+      unless File.exists?("#{config_dir}#{fname}")
+        puts "creating config/#{fname}"
+        `cp #{sample_dir}#{fname} #{config_dir}#{fname}`
+      end
+    end
+  end
+end

data/lib/mobilize-base/version.rb

@@ -0,0 +1,5 @@
+module Mobilize
+  module Base
+    VERSION = "1.0.0"
+  end
+end

data/lib/mobilize-base.rb

@@ -0,0 +1,76 @@
+require "mobilize-base/version"
+require "mobilize-base/extensions/array"
+require "mobilize-base/extensions/hash"
+require "mobilize-base/extensions/object"
+require "mobilize-base/extensions/string"
+#this is the base of the mobilize object, any methods that should be
+#made available application-wide go over here
+#these also define base variables for Rails
+module Mobilize
+  module Base
+    def Base.root
+      begin
+        ::Rails.root
+      rescue
+        ENV['PWD']
+      end
+    end
+    def Base.config(config_name)
+      config_dir = begin
+                     "#{::Rails.root}/config/"
+                   rescue
+                     "#{Base.root}/config/"
+                   end
+      yaml_path = "#{config_dir}#{config_name}.yml"
+      if ::File.exists?(yaml_path)
+        return ::YAML.load_file(yaml_path)
+      else
+        raise "Could not find #{config_name}.yml in #{config_dir}"
+      end
+    end
+    def Base.env
+      begin
+        ::Rails.env
+      rescue
+        #use MOBILIZE_ENV to manually set your environment when you start your app
+        ENV['MOBILIZE_ENV'] || "development"
+      end
+    end
+    def Base.log_path(log_name)
+      log_dir = begin
+                  "#{::Rails.root}/log/"
+                rescue
+                  "#{Base.root}/log/"
+                end
+      log_path = "#{log_dir}#{log_name}.log"
+      if ::File.exists?(log_dir)
+        return log_path
+      else
+        raise "Could not find #{log_dir} folder for logs"
+      end
+    end
+  end
+end
+mongoid_config_path = "#{Mobilize::Base.root}/config/mongoid.yml"
+if File.exists?(mongoid_config_path)
+  require 'mongo'
+  require 'mongoid'
+  Mongoid.load!(mongoid_config_path, Mobilize::Base.env)
+  require "mobilize-base/models/dataset"
+  require "mobilize-base/models/requestor"
+  require "mobilize-base/models/job"
+end
+require 'google_drive'
+require 'resque'
+require "mobilize-base/extensions/resque"
+#specify appropriate redis port per resque.yml
+Resque.redis = "127.0.0.1:#{Mobilize::Resque.config['redis_port']}"
+require 'popen4'
+require "mobilize-base/jobtracker"
+require "mobilize-base/handlers/gdriver"
+require "mobilize-base/extensions/google_drive.rb"
+require "mobilize-base/handlers/mongoer"
+require "mobilize-base/handlers/emailer"
+
+#require "mobilize-base/handlers/*"
+#require "mobilize-base/models/*"

data/lib/samples/gdrive.yml

@@ -0,0 +1,27 @@
+development:
+  owner:
+    email: 'owner_development@host.com'
+    pw: "google_drive_password"
+  admins:
+    - {email: 'admin@host.com'}
+  workers:
+    - {email: 'worker_development001@host.com', pw: "worker001_google_drive_password"}
+    - {email: 'worker_development002@host.com', pw: "worker002_google_drive_password"}
+test:
+  owner:
+    email: 'owner_test@host.com'
+    pw: "google_drive_password"
+  admins:
+    - {email: 'admin@host.com'}
+  workers:
+    - {email: 'worker_test001@host.com', pw: "worker001_google_drive_password"}
+    - {email: 'worker_test002@host.com', pw: "worker002_google_drive_password"}
+production:
+  owner:
+    email: 'owner_production@host.com'
+    pw: "google_drive_password"
+  admins:
+    - {email: 'admin@host.com'}
+  workers:
+    - {email: 'worker_production001@host.com', pw: "worker001_google_drive_password"}
+    - {email: 'worker_production002@host.com', pw: "worker002_google_drive_password"}

data/lib/samples/jobtracker.yml

@@ -0,0 +1,24 @@
+development:
+  #time between Jobtracker sweeps
+  cycle_freq: 10
+  notification_freq: 3600 #1 hour between failure/timeout notifications
+  requestor_refresh_freq: 300 #5 min between requestor checks
+  max_run_time: 14400 # if a job runs for 4h+, notification will be sent
+  admins: #emails to send notifications to
+  - {'email': 'admin@host.com'}
+test:
+  #time between Jobtracker sweeps
+  cycle_freq: 10
+  notification_freq: 3600 #1 hour between failure/timeout notifications
+  requestor_refresh_freq: 300 #5 min between requestor checks
+  max_run_time: 14400 # if a job runs for 4h+, notification will be sent
+  admins: #emails to send notifications to
+  - {'email': 'admin@host.com'}
+production:
+  #time between Jobtracker sweeps
+  cycle_freq: 10
+  notification_freq: 3600 #1 hour between failure/timeout notifications
+  requestor_refresh_freq: 300 #5 min between requestor checks
+  max_run_time: 14400 # if a job runs for 4h+, notification will be sent
+  admins: #emails to send notifications to
+  - {'email': 'admin@host.com'}

data/lib/samples/mongoid.yml

@@ -0,0 +1,21 @@
+development:
+  sessions:
+    default:
+      database: mobilize-development
+      persist_in_safe_mode: true
+      hosts:
+        - 127.0.0.1:27017
+test:
+  sessions:
+    default:
+      database: mobilize-test
+      persist_in_safe_mode: true
+      hosts:
+        - 127.0.0.1:27017
+production:
+  sessions:
+    default:
+      database: mobilize-production
+      persist_in_safe_mode: true
+      hosts:
+        - 127.0.0.1:27017

data/lib/samples/resque.yml

@@ -0,0 +1,12 @@
+development:
+  queue_name: 'mobilize'
+  max_workers: 4
+  redis_port: 6379
+test:
+  queue_name: 'mobilize'
+  max_workers: 4
+  redis_port: 9736
+production:
+  queue_name: 'mobilize'
+  max_workers: 36
+  redis_port: 6379