Code BendersCode | Agile Software Development |

Preventing Recursion in Ruby

avdi — Tue, 24 Jan 2012 16:54:06 +0000

Sometimes you need to prevent code from executing recursively. I had to do this recently in order to prevent an infinite recursion in ActiveRecord callbacks. A before-save hook needed to save a parent model attribute, which because of an :autosave option would then try to save the child model, which would then try to save the parent… and so on until the stack overflowed.

Unless the method is directly calling itself, the only way to short-circuit a method when it recurses is to have it set some global flag which it can then check in recursive calls. If the flag is already set, the recursively called method bails out early. Once the original invocation is finished it unsets the flag.

It’s not safe to use a true global variable for this flag, since this would not be threadsafe. The safe way to do it (albeit not a terribly pretty one) is to use thread-local variables.

I decided to go ahead and write a macro which can turn any method into a non-recursive one. Here’s the code:

module RecursionHelpers
def prevent_recursion(method_name)
flag_name = "in:#{name}##{method_name}"
original = instance_method(method_name)

define_method(method_name) do |*args|
return if Thread.current[flag_name]
begin
Thread.current[flag_name] = true
original.bind(self).call(*args)
ensure
Thread.current[flag_name] = nil
end
end
end
end

Let’s take a closer look at that.

The method takes an argument, method_name, which is the name of the method to make non-recursive.

def self.prevent_recursion(method_name)

Then it creates a name for the recursion flag. Since thread-local variables are global for the whole thread, we need a variable name which is reasonably unique. We get one by combining the current class and the method name.

flag_name = "in:#{name}##{method_name}"

We’re going to replace the method with a modified version, so we need to stash the original implementation somewhere. We grab an UnboundMethod object by calling #instance_method() on the current class:

original = instance_method(method_name)

Then we proceed to redefine the method:

define_method(method_name) do |*args|

The first thing the modified method does is check to see if the recursion flag is set. If it is, it bails out.

return if Thread.current[flag_name]

Otherwise, it sets the flag:

Thread.current[flag_name] = true

And then it binds the UnboundMethod stored in original to the current instance. This generates a Method instance, which it proceeds to call, passing any arguments along.

(Note that I wrote this code for a Ruby 1.8 codebase. If it were for 1.9 I would pass the &block down to the original as well. Since blocks in 1.8 can’t accept &block arguments, I can’t do that here so long as I’m using the block form of define_method. So this macro will only work for methods which do not take blocks.)

original.bind(self).call(*args)

Finally, the code ensures that the recursion flag will be unset when the method is finished, even if an exception is raised.

ensure
Thread.current[flag_name] = nil
end

Note that setting a thread-local variable to nil removes it:

Thread.current.keys # => []
Thread.current[:foo] = 42
Thread.current.keys # => [:foo, :__inspect_key__]
Thread.current[:foo] = nil
Thread.current.keys # => [:__inspect_key__]

I have no idea what :__inspect_key__ is, but as you can see the :foo key goes away after setting it to nil.

Let’s take a look at this in practice. Here’s are two methods #foo and #bar (original, no?). #foo is recursive, with #bar as an intermediary, preventing it from passing a recursion flag directly to itself.

class X
def foo
bar
"foo done"
end

def bar
foo
end
end

Calling the #foo method results in a stack overflow:

require './prevent-recursion.rb'

X.new.foo rescue $! # => #

But if we update the method with prevent_recursion, it successfully exits:

require './prevent-recursion.rb'

class X
extend RecursionHelpers

prevent_recursion :foo
end

X.new.foo # => "foo done"

Interview with Avdi Grimm, author of “Exceptional Ruby”

Taus — Fri, 17 Jun 2011 00:30:52 +0000

Miles Forrest interviews Avdi Grimm on his new book “Exceptional Ruby”. Dealing with unexpected failures in code is tough, and oftentimes error processing is dealt with in a haphazard way. Hear the 5 questions you need to ask before writing code to handle unexpected failures, as well as his story about a cascading failure that went from bad to worse.

You can listen to the interview and purchase “Exceptional Ruby” on the Pragmatic Bookshelf website.

Hate Legacy Apps? Then You’ll Love DataMapper

Taus — Wed, 01 Jun 2011 03:45:31 +0000

Ruby on Rails makes it easy to bootstrap a greenfield project. Unfortunately not all projects are greenfield, so sometimes you need to work with a legacy database schema. ActiveRecord is a great choice when you have a full control over your database from the very beginning, but what should you do if you need to connect to a database with a schema that isn’t in-line with Rails conventions?

DataMapper Core Contributor and Code Benders team member, Piotr Solnica, has written a great blog post for our partner Engine Yard entitled Using DataMapper and Rails with Legacy Schemas. Read it and you can say goodbye to your fear of inheriting a legacy app.

Congratulations, Piotr!

Taus — Fri, 18 Mar 2011 20:21:24 +0000

Piotr Solnica, one of our team members, has just been added to the DataMapper Core Team. Dan Kubb, the team lead, wrote:

“Piotr has been involved in DataMapper for several years now, and has been doing some amazing work on the DataMapper Property API, heading up our CI server configuration and many other areas… he’s been extremely helpful inside the channel and out.”

Congrats, Piotr… nicely done!

WordPress Security Plugin for Rackspace Cloud Sites

Taus — Sat, 17 Jul 2010 20:39:03 +0000

Anyone that manages a WordPress site knows that it can be a bit of a challenge to maintain site security. And, if you are managing a lot of them it can be quite an effort.

Today, I found myself cleaning out a site that had been the subject of a malicious attack. And after securing the site, I came across a new WP plugin that is designed to scan and secure WordPress sites that are being hosted on Rackspace Cloud Sites.

The scanner automatically checks file permissions and provides a on-click correction for permissions. It also scans all of your posts for malicious code such as posts containing base64_decode (or edoced_46esab), script tags, hidden css elements or iframes.

So check out the JW Cloud Sites Scanner and send Jackson Whelan a big thanks (and donation if he gets that going)… thanks Jackson!

Code Highlighting

Taus — Fri, 28 Aug 2009 18:01:21 +0000

Testing CodeColorer, the code highlighting plugin…

# Everything, including a literal, is an object, so this works:
-199.abs # 199
"ruby is cool".length # 12
"Your mother is nice.".index("u") # 2
"Nice Day Isn't It?".downcase.split("").sort.uniq.join # " '?acdeinsty"

Nice… Instructions are here.