eycloud-recipe-delayed_job 1.0

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    eycloud-recipe-delayed_job (1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  eycloud-recipe-delayed_job!
+  rake

data/README.markdown

@@ -0,0 +1,100 @@
+# Delayed Job recipe for EY Cloud
+
+This cookbook can serve as a good starting point for setting up Delayed Job support in your application. 
+In this recipe your Delayed Job workers will be set up to run under monit. The number of workers will
+vary based on the size of the instance running Delayed Job.
+
+This recipe will setup `delayed_job` on a Solo instance environment or on named Utility instances in a cluster environment. 
+
+Name your Utility instances with prefixes: `dj`, `delayed_job`, `delayedjob`. For example, `dj1`, `delayedjob4`.
+
+If you want `delayed_job` to run on App instances instead of Utility, you will need to modify the recipe.
+
+TODO: if no corresponding dj|delayed_job|delayedjob named Utility instances, then install DJ on the app instances.
+
+## How many workers do I get?
+
+The number of parallel workers is based on the instance type.
+
+Solo instances allocate a single Delayed Job worker because the instance is primarily for running the Application and its database.
+
+For each `dj` utility instance the number of workers is determined by the `delayed_job_worker_count` library helper:
+
+``` ruby
+def delayed_job_worker_count(instance_type)
+  case instance_type
+  when "m1.small"
+    3
+  when "m1.medium"
+    4
+  when "m1.large"
+    8
+  when "m1.xlarge"
+    12
+  when "m2.xlarge"
+    10
+  when "m2.2xlarge"
+    10
+  when "m2.4xlarge"
+    24
+  when "c1.medium"
+    4
+  when "c1.xlarge"
+    24
+  else
+    2
+  end
+end
+```
+
+To learn more about each instance type, see the [AWS EC2 Instance Type](http://aws.amazon.com/ec2/instance-types/ "Amazon EC2 Instance Types") page.
+
+## Installation
+
+This recipe must be installed as `delayed_job` and not `eycloud-recipe-delayed_job`.
+
+## Simple Installation
+
+To add this recipe to your collection of recipes, or as your first recipe, you can use the helpful `ey-recipes` command line tool:
+
+    cd myapp
+    gem install engineyard engineyard-recipes
+    ey-recipes init
+    ey-recipes clone git://github.com/engineyard/eycloud-recipe-delayed_job.git -n delayed_job
+    ey recipes upload --apply
+
+If you want to have your recipes run during deploy (rather than the separate `ey recipes upload --apply` step):
+
+    ey-recipes init -d
+    ey-recipes clone git://github.com/engineyard/eycloud-recipe-delayed_job.git -n delayed_job
+    git add .; git commit -m "added delayed job recipe"; git push origin master
+    ey deploy
+
+## Manual Installation
+
+Clone/copy this repository into a `cookbooks/delayed_job` folder (such that you have a `cookbooks/delayed_job/recipes/default.rb` file).
+
+Then add the following to `cookbooks/main/recipes/default.rb`:
+
+    require_recipe "delayed_job"
+    
+Make sure this and any customizations to the recipe are committed to your own fork of this 
+repository.
+
+Then to upload and apply to EY Cloud for a given environment:
+
+    ey recipes upload --apply -e target-environment
+
+## Restarting your workers
+
+This recipe does NOT restart your workers. The reason for this is that shipping your application and
+rebuilding your instances (i.e. running chef) are not always done at the same time. It is best to 
+restart your Delayed Job workers when you ship (deploy) your application code. To do this, add a
+deploy hook to perform the following:
+
+    sudo "monit -g dj_<app_name> restart all"
+    
+Make sure to replace <app_name> with the name of your application. You likely want to use the
+after_restart hook for this. See our [Deploy Hook](http://docs.engineyard.com/appcloud/howtos/deployment/use-deploy-hooks-with-engine-yard-appcloud) documentation
+for more information on using deploy hooks.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/eycloud-recipe-delayed_job.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+version = "1.0" # get from metadata.json or .rb
+
+Gem::Specification.new do |s|
+  s.name        = "eycloud-recipe-delayed_job"
+  s.version     = version
+  s.authors     = ["Dr Nic Williams"]
+  s.email       = ["drnicwilliams@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Delayed Job for EY Cloud} # from metadata
+  s.description = %q{Delayed Job for EY Cloud} # from metadata long_description
+
+  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"]
+
+  s.add_development_dependency("rake")
+end

data/libraries/delayed_job_applications.rb

@@ -0,0 +1,8 @@
+class Chef
+  class Recipe
+    # Only Rails applications (containing script/runner) are valid
+    def delayed_job_applications
+      node[:applications]
+    end
+  end
+end

data/libraries/delayed_job_worker_count.rb

@@ -0,0 +1,29 @@
+class Chef
+  class Recipe
+    # If you change this, please copy it back into the README as documentation
+    def delayed_job_worker_count(instance_type)
+      case instance_type
+      when "m1.small"
+        3
+      when "m1.medium"
+        4
+      when "m1.large"
+        8
+      when "m1.xlarge"
+        12
+      when "m2.xlarge"
+        10
+      when "m2.2xlarge"
+        10
+      when "m2.4xlarge"
+        24
+      when "c1.medium"
+        4
+      when "c1.xlarge"
+        24
+      else
+        2
+      end
+    end
+  end
+end

data/metadata.json

@@ -0,0 +1,12 @@
+{
+  "license": "MIT",
+  "maintainer": "Engine Yard LLC",
+  "maintainer_email": "drnic@engineyard.com",
+  "version": "1.0",
+  "description": "Delayed Job for EY Cloud",
+  "name": "delayed_job",
+  "attributes": {
+
+  },
+  "long_description": ""
+}

data/metadata.rb

@@ -0,0 +1,6 @@
+name              "delayed_job"
+description       "Delayed Job for EY Cloud"
+long_description  IO.read(File.join(File.dirname(__FILE__), 'README.md'))
+maintainer        "Engine Yard LLC"
+maintainer_email  "drnic@engineyard.com"
+version           "1.0"

data/recipes/configure.rb

@@ -0,0 +1,35 @@
+#
+# Cookbook Name:: delayed_job
+# Recipe:: configure
+#
+
+# This recipe will setup `delayed_job` on a Solo instance environment or on named Utility instances in a cluster environment. 
+# Name your Utility instances with prefixes: `dj`, `delayed_job`, `delayedjob`. For example, `dj1`, `delayedjob4`.
+if node[:instance_role] == "solo" || node[:instance_role] == "eylocal" || 
+        (node[:instance_role] == "util" && node[:name] =~ /^(dj|delayed_job|delayedjob)/)
+  delayed_job_applications().each do |app_name,data|
+  
+    # determine the number of workers to run based on instance size
+    if node[:instance_role] == 'solo' || node[:instance_role] == 'eylocal'
+      worker_count = 1
+    else
+      worker_count = delayed_job_worker_count(node[:ec2][:instance_type])
+    end
+    
+    worker_count.times do |count|
+      template "/etc/monit.d/delayed_job#{count+1}.#{app_name}.monitrc" do
+        source "dj.monitrc.erb"
+        owner "root"
+        group "root"
+        mode 0644
+        variables({
+          :app_name => app_name,
+          :user => node[:owner_name],
+          :worker_name => "delayed_job#{count+1}",
+          :framework_env => node[:environment][:framework_env]
+        })
+      end
+    end
+    
+  end
+end

data/recipes/default.rb

@@ -0,0 +1,9 @@
+#
+# Cookbook Name:: delayed_job
+# Recipe:: default
+#
+
+require_recipe "delayed_job::install"
+require_recipe "delayed_job::configure"
+require_recipe "delayed_job::restart"
+

data/recipes/install.rb

@@ -0,0 +1,26 @@
+#
+# Cookbook Name:: delayed_job
+# Recipe:: install
+#
+
+# This recipe will setup `delayed_job` on a Solo instance environment or on named Utility instances in a cluster environment. 
+# Name your Utility instances with prefixes: `dj`, `delayed_job`, `delayedjob`. For example, `dj1`, `delayedjob4`.
+if node[:instance_role] == "solo" || node[:instance_role] == "eylocal" || 
+        (node[:instance_role] == "util" && node[:name] =~ /^(dj|delayed_job|delayedjob)/)
+  delayed_job_applications().each do |app_name,data|
+  
+    directory "/engineyard/bin" do
+      owner "root"
+      group "root"
+      mode 0755
+    end
+
+    template "/engineyard/bin/dj" do
+      source "dj.erb"
+      owner "root"
+      group "root"
+      mode 0755
+    end
+    
+  end
+end

data/recipes/restart.rb

@@ -0,0 +1,18 @@
+#
+# Cookbook Name:: delayed_job
+# Recipe:: restart
+#
+
+# This recipe will setup `delayed_job` on a Solo instance environment or on named Utility instances in a cluster environment. 
+# Name your Utility instances with prefixes: `dj`, `delayed_job`, `delayedjob`. For example, `dj1`, `delayedjob4`.
+if node[:instance_role] == "solo" || node[:instance_role] == "eylocal" || 
+        (node[:instance_role] == "util" && node[:name] =~ /^(dj|delayed_job|delayedjob)/)
+  delayed_job_applications().each do |app_name,data|
+    
+    execute "monit-reload-restart" do
+      command "sleep 30 && monit reload && monit restart all -g dj_#{app_name}"
+      action :run
+    end
+      
+  end
+end

data/templates/default/dj.erb

@@ -0,0 +1,182 @@
+#!/bin/sh
+#
+# This script starts and stops the Dj daemon
+# This script belongs in /engineyard/bin/dj
+#
+PATH=/bin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:$PATH
+CURDIR=`pwd`
+
+usage() {
+  echo "Usage: $0 <appname> {start|stop} enviroment [name maximum_priority minimum_priority]"
+  exit 1
+}
+
+if [ $# -lt 3 ]; then usage; fi
+
+if [ $4 ]; then
+  NAME="_$4"
+
+  if [ $5 ]; then
+    OPTIONS=":max_priority=>$5"
+    if [ $6 ]; then
+      OPTIONS="$OPTIONS,:min_priority=>$6"
+    fi
+    OPTIONS="{$OPTIONS}"
+  fi
+fi
+
+if [ "`whoami`" != "root" ]; then
+  logger -t `basename $0` -s "Must be run as root" 
+  exit 1
+fi
+## Function definitions - casual readers encouraged to skip this ##
+rm_lockfile(){
+  if [ -e $LOCK_FILE ]; then
+   logger -t "monit_dj:$WORKER[$$]" "removing $LOCK_FILE for `cat $LOCK_FILE`"
+   rm $LOCK_FILE
+  fi
+}
+
+lock(){
+  RESULT=0
+  if [ -e $LOCK_FILE ]; then
+    LAST_LOCK_PID=`cat $LOCK_FILE`
+    if [ -n $LAST_LOCK_PID -a -z "`ps axo pid|grep $LAST_LOCK_PID`" -a -f $LOCK_FILE ];then
+      sleep 1
+      logger -t "monit-dj:$WORKER[$$]" "Removing stale lock file for $WORKER ($LAST_LOCK_PID)"
+      rm $LOCK_FILE 2>&1
+    else
+      logger -t "monit-dj:$WORKER[$$]" "Monit already messing with $WORKER ($LAST_LOCK_PID)"
+      RESULT=1
+      exit_cleanly 
+    fi
+  fi
+  echo $$ > $LOCK_FILE
+}
+
+exit_cleanly() {
+  cd $CURDIR
+  logger -t "mont-dj:$WORKER[$$]" "exiting wrapper cleanly with $RESULT"
+  exit $RESULT
+}
+
+unlock_and_exit_cleanly(){
+  rm_lockfile
+  exit_cleanly
+}
+
+## End function definitions ##
+#set -x
+WORKER=$1$NAME
+LOCK_FILE="/tmp/$WORKER.monit-lock"
+BUNDLER_COMMAND="ruby"
+RAILS_ROOT=/data/$1/current
+if [ -d $RAILS_ROOT ]; then
+  if [ -f $RAILS_ROOT/Gemfile ]; then
+    if [ -d $RAILS_ROOT/ey_bundler_binstubs ]; then
+      PATH=$RAILS_ROOT/ey_bundler_binstubs:$PATH
+    else
+      BUNDLER_COMMAND="bundle exec ruby"
+    fi
+  fi
+  
+  RAILS_ENV=$3
+  export $RAILS_ENV
+  RUNNER='runner'
+  #RAILS_SCRIPTS="$RAILS_ROOT/script"
+  RAILS_SCRIPTS="$RAILS_ROOT/script"
+  [ -f $RAILS_SCRIPTS/rails ] && chmod a+x $RAILS_SCRIPTS/rails && RUNNER="rails runner"
+  cd $RAILS_ROOT
+  PID_FILE=/var/run/engineyard/dj/$1/dj$NAME.pid
+  USER=`stat -c"%U" /data/$1/current/`
+  HOME="/home/$USER" ; export HOME
+  RESULT=0
+  GRACE_TIME=${GRACE_TIME:-60}
+  let "GRACE_TIME=$GRACE_TIME*4"
+
+  mkdir -p /var/run/engineyard/dj/$1
+
+  case "$2" in
+    start)
+      lock
+      cd $RAILS_ROOT
+      HAS_DJ_COMMAND="RAILS_ENV=$RAILS_ENV $BUNDLER_COMMAND $RAILS_SCRIPTS/$RUNNER -e $RAILS_ENV \"require 'delayed/command';puts defined?(Delayed::Command)\" 2>/dev/null"
+      has_dj_command=$(sudo -u $USER -H /bin/bash -c "$HAS_DJ_COMMAND")
+      if [[ $has_dj_command == "constant" ]];then
+        OPTIONS=${OPTIONS:-[]}
+        HAS_BEFORE_FORK="RAILS_ENV=$RAILS_ENV $BUNDLER_COMMAND $RAILS_SCRIPTS/$RUNNER -e $RAILS_ENV \"require 'delayed/worker';puts Delayed::Worker.respond_to?(:before_fork)\" 2>/dev/null"
+        has_before_fork=$(sudo -u $USER -H /bin/bash -c "$HAS_BEFORE_FORK")
+        if [[ $has_before_fork == "true" ]];then
+          RUNNER_COMMAND="require 'delayed/command';Delayed::Worker.before_fork;Delayed::Command.new($OPTIONS).run"
+        else
+          RUNNER_COMMAND="require 'delayed/command';Delayed::Command.new($OPTIONS).run"
+        fi
+      else
+        RUNNER_COMMAND="Delayed::Worker.new($OPTIONS).start"
+      fi
+      
+      COMMAND="$BUNDLER_COMMAND $RAILS_SCRIPTS/$RUNNER -e $RAILS_ENV \"$RUNNER_COMMAND\""
+      logger -t "monit-dj:$WORKER[$$]" "DJ Worker starting from $PPID"
+      if [ -f $PID_FILE ]; then
+        PID=`cat $PID_FILE`
+        if [ -n "$PID" ];then
+          logger -t "monit-dj:$WORKER[$$]" "There is already a  PID file for delayed Job [$PID]"
+          if [ -d /proc/$PID ]; then
+            logger -t "monit-dj:$WORKER[$$]" "Dj worker is already running with PID of $PID"
+            RESULT=1
+          else
+            logger -t "monit-dj:$WORKER[$$]" "Removing stale pid file for $WORKER"
+            rm -f $PID_FILE
+          fi
+        fi
+      fi
+      
+      if [ $RESULT -eq 0 ]; then
+        logger -t "monit-dj:$WORKER[$$]" "issuing command $COMMAND in $PWD for $USER"
+        sudo -u $USER -H /bin/bash -c "$COMMAND"  & 
+        NEW_PID=$!
+        RESULT=$?
+        logger -t "monit-dj:$WORKER[$$]" "$WORKER started as  $NEW_PID : $RESULT"
+        echo $NEW_PID > $PID_FILE
+      fi
+      unlock_and_exit_cleanly
+    ;;
+   stop)
+     lock
+     logger -t "monit_dj:$WORKER[$$]" "Stopping  DJ worker:"
+     if [ -f $PID_FILE ]; then
+       PID=$(cat $PID_FILE)
+
+       # Find children
+       WORKER_PID=$(ps axo pid,ppid,command|awk '$2=='$PID' {print $1}')
+       
+       kill -15 $PID $PPID; # kill worker and any child that it may have at this very moment
+       logger -t "monit-dj:$WORKER[$$]" "Stopping DJ Worker Process $PID $PPID"
+
+       SLEEP_COUNT=0
+       while [ -e /proc/$PID ]; do
+         sleep .25 
+         let "SLEEP_COUNT+=1"
+         let "REPORT_TIME = $SLEEP_COUNT%4"
+         if(( "$SLEEP_COUNT" > $GRACE_TIME )); then
+           logger -t "monit-dj:$WORKER[$$]" "Stopping DJ Worker Child Process $PID wait exceeded, killing it"
+           kill -9 $PID 2>/dev/null; true
+           break 
+         elif(( $REPORT_TIME == 0 ));then
+           let "RUNTIME = $SLEEP_COUNT/4"
+           logger -t "monit-dj:$WORKER[$$]" "Waiting for $PID to die ( for $RUNTIME seconds now)"
+         fi
+       done 
+     fi
+
+     [ -e "$PID_FILE" ] && rm -f $PID_FILE
+     unlock_and_exit_cleanly
+     ;;
+   *)
+     usage
+    ;;
+   esac
+else
+  echo "/data/$1/current doesn't exist."
+  usage
+fi

data/templates/default/dj.monitrc.erb

@@ -0,0 +1,6 @@
+check process <%= @worker_name %>
+  with pidfile /var/run/engineyard/dj/<%= @app_name %>/dj_<%= @worker_name %>.pid
+  start program = "/engineyard/bin/dj <%= @app_name %> start <%= @framework_env %> <%= @worker_name %>" with timeout 60 seconds
+  stop program = "/engineyard/bin/dj <%= @app_name %> stop <%= @framework_env %> <%= @worker_name %>" with timeout 60 seconds
+  if totalmem is greater than 300 MB then restart # eating up memory?
+  group dj_<%= @app_name %>

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: eycloud-recipe-delayed_job
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Dr Nic Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70271935729380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70271935729380
+description: Delayed Job for EY Cloud
+email:
+- drnicwilliams@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
+- eycloud-recipe-delayed_job.gemspec
+- libraries/delayed_job_applications.rb
+- libraries/delayed_job_worker_count.rb
+- metadata.json
+- metadata.rb
+- recipes/configure.rb
+- recipes/default.rb
+- recipes/install.rb
+- recipes/restart.rb
+- templates/default/dj.erb
+- templates/default/dj.monitrc.erb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3120554601435364730
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3120554601435364730
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Delayed Job for EY Cloud
+test_files: []