resource_helper is currently a Rails plugin that exists to make ActiveResource more compatible with ActiveRecord as well as add some additional functionality. I made some big changes recently, check it out on github

This was one of those bugs that was just killing me. I absolutely could not figure out why some of my new shiny rake tasks were failing. I went through the motions of uninstalling my custom ruby and rails on my Mac and upgrading instead the system installed Ruby then reinstalling rails and all gems.

It was a lot of work, and actually I produced a neato script to help clean gems. (maybe I’ll post it up here soon)

But it didn’t fix the situation. Several hours of google and forum threads that were only somewhat related, I stumbled on an old Rails bug, wherein “require ‘test/unit’” was being called by something or other. Of course it should only be called when testing and when needed. But it was unfortunately being called on EVERY rake task after anything that was called. The problem was that rake was passing the arguments to Test::Unit::AutoRunner which returned errors and generally hosed the parsing of the rake outcome (which is what I was up to).

Anyhoo, here is my workaround. Quick and dirty, but works. CaveatL only use if you are NOT using Test::Unit for anything good. (i.e. you still haven’t switched to rspec ^_ ) Or use the second method listed and control the monkey patch a bit.

It can be used in 1 of two ways, I prefer the latter as it gives more control.

1. Add the module below to the project’s main Rakefile
2. Add a file to lib called “_rake_helper.rb” and paste the module in there.

 require 'lib/tasks/_rake_helper'
 include RakeHelper

Here is the module:

 module Test
   module Unit
     class FakeAutoRunner
       class <<self
         def run
           return true
         end
       end
     end
     begin
       silence_warnings do
         const_set("AutoRunner", FakeAutoRunner)
       end
     rescue
     end
   end
 end

Lots of updates to the application_configurator plugin. Check it out on git http://github.com/rubyisbeautiful/application_configurator/wikis

Also, some rake tasks for refactoring our migrations, on pastie for sake http://pastie.org/266855 do stuff like check for tables with no models, models with no tables, etc…

rake refactor:db # Refactor the database with migrations rake refactor:models # Look for models with no matching table rake refactor:schema # Look for tables in the schema that don’t exist rake refactor:tables # Look for tables that have no matching models

A very basic version of resource_helper as Rails plugin only is live on github

I am about to release resource_helper plugin. I wrote in while working on my client’s project and it has become invaluable to our team. It attempts to bridge the small gaps between ActiveRecord and ActiveResource and make them quack nearly the same. It also adds some convenience methods which I found myself rewriting for every new ActiveResource. I hope to release it by the end of the day today.

Update: plugin released on github

Hehe, my new acronym for god.

The config suggestion I posted earlier works in theory, but I was having some trouble getting it to work from init

What I ended up having to do was add

sleep

# v.0.0.3
# cobbled by Bryan Taylor http://rubyisbeautiful.com
# god - Start/stop/check Unrud via init 
#
# chkconfig: - 85 15
# description: http://god.rubyforge.org/
# processname: god
# config: /etc/god.conf

# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

# Check that networking is up.
[ ${NETWORKING} = "no" ] && exit 0

[ -x /usr/bin/god ] || exit 0

RETVAL=0
prog="god" 

start() {
# Start daemon only
echo -n $"Starting $prog: " 
/usr/bin/god
sleep 5
  RETVAL=$?
  [ $RETVAL -eq 0 ] && {
     touch /var/lock/subsys/$prog
     success $"$prog" 
  }
  echo

#load the configs
if [ -e /u/apps/content/current/config/content.god ] ; then
  echo -n $"Loading content config: " 
  /usr/bin/god load /u/apps/content/current/config/content.god
  echo -n $"Loading admin config: " 
  /usr/bin/god load /u/apps/admin/current/config/admin.god
  sleep 5
  RETVAL=$?
  [ $RETVAL -eq 0 ] && {
     touch /var/lock/subsys/$prog
     success $"$prog" 
   }
   echo
else
  RETVAL=1
fi
return $RETVAL  
}

stop() {
    # Stop daemons.
    echo -n $"Shutting down $prog: " 
    /usr/bin/god quit &
        sleep 5
    RETVAL=$?
    echo
    [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/$prog
    return $RETVAL
}

reload() {
    echo -n "$reloading $prog config: " 
        /usr/bin/god load /u/apps/content/current/config/content.god
        /usr/bin/god load /u/apps/admin/current/config/admin.god
}

# See how we were called.
case "$1" in
    start)
      start
      ;;
    stop)
      stop
      ;;
        reload)
            reload
        ;;
    restart)
      stop
      start
      ;;
    status)
      /usr/bin/god status
      RETVAL=$?
      ;;
    *)
      echo "Usage: god {start|stop|reload|restart|status}" 
      exit 1
  ;;
esac      
exit $RETVAL

Also, I modified the init script a little, as god doesn’t quite behave like a typical *nix daemon.

Update:

via Twitter from Ivey: updates pushed to rubyforge.

I just checked and all is well; still, follow the advice below to get using git.

If you follow the merb core development, you’ll see that Ivey pushed 0.9.3 gems. Unfortunately it appears temporarily broken via the default install from rubyforge. For now, if you haven’t already hooked up to github and merb, now is the perfect time.

> git clone git://github.com/wycats/merb-core.git
> cd merb-core
> rake install
> cd ..
> git clone git://github.com/wycats/merb-more.git
> cd merb-more
> rake install

However poor the taste of the author in choosing a name, it is indeed a great way to monitor, nay, control pretty much anything.

I use god on my local dev box (mac) as well to keep all things developery running.

I got the init script from http://ezinearticles.com/?Why-Rails-Developers-Need-God&id=845672 and all the good info from http://god.rubyforge.org/

Handily, a god init script will of course start your mongrels et al when properly configured. Here is how I use a config template for the many gods-mongrels

host = `hostname`
app = "foo" 

case
when host =~ /theproductionbox/
  ports = %w{ 6400 6401 } 
  RAILS_ROOT = "/u/apps/#{app}/current" 
  shared_path = "/u/apps/#{app}/shared" 
  mongrel_cmd = "/usr/local/bin/ruby /usr/local/bin/mongrel_rails" 
  pid_dir = "#{shared_path}/pids" 
  log_file = "#{shared_path}/log/mongrel.log" 
  uid = 'production_guy'
  gid = uid
  ENV['RAILS_ENV'] ||= 'production'
  rails_env ||= ENV['RAILS_ENV']
  http_host = "fancy.productionbox.com" 
  http_path = "/" 
  http_code = "200" 
when host =~ /somedevbox/
  ports = %w{ 6400 } 
  RAILS_ROOT = "/u/apps/#{app}" 
  shared_path = "/u/apps/#{app}" 
  mongrel_cmd = "/usr/local/bin/ruby /usr/local/bin/mongrel_rails" 
  pid_dir = "#{shared_path}/tmp/pids" 
  log_file = "#{shared_path}/log/mongrel.log" 
  uid = 'development_guy'
  gid = uid
  ENV['RAILS_ENV'] ||= 'development'
  rails_env ||= ENV['RAILS_ENV']
  http_host = "ratbike.devbox.com" 
  http_path = "/" 
  http_code = "200" 
end

ports.each do |port|
  God.watch do |w|
    w.group = app
    w.uid = uid
    w.gid = gid
    w.name = "#{app}-mongrel-#{port}" 
    w.interval = 30.seconds
    w.start = "#{mongrel_cmd} start -d -a 0.0.0.0 -p #{port} -P #{pid_dir}/dispatch.#{port}.pid -e #{rails_env} -c #{RAILS_ROOT} -l #{log_file}" 
    w.stop = "#{mongrel_cmd} stop -P #{pid_dir}/dispatch.#{port}.pid" 
    w.start_grace = 30.seconds
    w.restart_grace = 30.seconds
    w.pid_file = File.join(pid_dir, "dispatch.#{port}.pid")

    w.behavior(:clean_pid_file)

    w.transition(:init, { true => :up, false => :start }) do |on|
      on.condition(:process_running) do |c|
        c.running = true
      end
    end

    w.transition([:start, :restart], :up) do |on|
      on.condition(:process_running) do |c|
        c.running = true
      end
      on.condition(:tries) do |c|
        c.times = 5
        c.transition = :start
      end
    end

    w.transition(:up, :start) do |on|
      on.condition(:process_exits)
    end  

    w.transition(:up, :restart) do |on|
      on.condition(:memory_usage) do |c|
        c.interval = 60.seconds
        c.above = 57.megabytes
        c.times = [4, 5]
      end
      on.condition(:cpu_usage) do |c|
        c.interval = 60.seconds
        c.above = 10.percent
        c.times = [3, 5]
      end
      on.condition(:http_response_code) do |c|
        c.host = http_host
        c.path = http_path
        c.code_is_not = http_code
        c.timeout = 30.seconds
    c.interval = 30.minutes
      end
    end

    # lifecycle
    w.lifecycle do |on|
      on.condition(:flapping) do |c|
        c.to_state = [:start, :restart]
        c.times = 5
        c.within = 5.minute
        c.transition = :unmonitored
        c.retry_in = 10.minutes
        c.retry_times = 5
        c.retry_within = 2.hours
      end
    end
  end
end

God::Contacts::Email.message_settings = {
  :from => 'god@rubyisbeautiful.com'
}

God::Contacts::Email.server_settings = {
  #settings
}

God.contact(:email) do |c|
  c.name = 'bryan'
  c.email = 'bryan@rubyisbeautiful.com'
end