Here’s how you can make the change, on the fly, inside of your rake task:

task :swimming_pool => :environment do
  ActiveRecord::Base.connection_pool.instance_variable_set('@size', 15)
  ActiveRecord::Base.connection_pool.instance_variable_set('@timeout', 10)
  # Do awesome threaded stuff here
end

The first line of the rake task increases your pool size and the second line changes your timeout when waiting for a connection from the pool. You can adjust those values to whatever you need. That just happened to be what I need for this particular task.

First off, you need to do some before filter work:

skip_before_filter :verify_authenticity_token, :only => [:your_action]
before_filter :semi_verify_authenticity_token, :only => [:your_action]

Then you need a function to define when to check for the token authenticity:

def semi_verify_authenticity_token
  verify_authenticity_token unless request.xhr? # Or whatever other criteria you would use
end

All you really have to do then is make sure that verify_authenticity_token gets called based on the params or request and you should be set. This can be useful for APIs or AJAX calls calls to a given action where you don’t mind skipping the token check, but you still want to enforce it for the regular HTML browser view.

You basically need to simply wrap your code in <pre><code></code></pre> and it handles the rest. Here’s an example:

class ThisIsRuby

  def fun
    puts "This is fun!"
  end

end

test = ThisIsRuby.new
puts test.fun

On a semi-related note, I’m still chasing down some nginx config related gremlins. If you see anything weird, let me know in the comments.

WebbyNode is a newer player in the VPS game and they offer basically the same setup as SliceHost at a lower price.  I also like their ReadyStacks and github friendliness.  I registered and built out a box with Nginx and Percona MySQL.  Everything feels fairly snappy when I’m on the box despite being a low memory VPS.

Going forward I’m going to be moving Twexaminer.com over to this same VPS and run it through Nginx with Unicorn.

If anyone has any questions about the setup, let me know.  If I get a chance later, I’ll try to come up with a short guide on how I got everything working.

If you’re into parsing XML or HTML with ruby then chances are you’re familiar with the various gems out there for getting the job done.  Lately, there have been a lot of things flying around about which is the fastest and to settle it, Aaron Patterson (author of Nokogiri and Mechanize) wrote a test suite.

After it’s release, RubyInside posted about how the tests showed how fast Nokogiri was compared to Hpricot in this article here: Ruby XML Performance Shootout: Nokogiri vs LibXML vs Hpricot vs REXML.  Later in the day, I saw Why’s posting about the release of Hpricot here: hpricot 0.7 and decided to modify Aaron’s tests to use Hpricot.XML and here are the results:

Tests were run at N=5 to get a clearer picture of the differences between the various gems.  At N=2, tests were pretty close, which indicated that a larger sample was needed.

test_IO_parsing(XmlTruth::DOM::XML::LargeDocumentParsingTest) N=5
user     system      total        real   kBps
null          0.690000   0.070000   0.760000 (  0.768641) 46343.68
nokogiri      2.790000   0.130000   2.920000 (  3.015303) 11813.62
libxml-ruby   2.970000   0.140000   3.110000 (  3.130175) 11380.08
hpricot      13.660000   0.370000  14.030000 ( 14.088780) 2528.37
.
test_in_memory_parsing(XmlTruth::DOM::XML::LargeDocumentParsingTest) N=5
user     system      total        real   kBps
null          1.240000   0.010000   1.250000 (  1.260841) 28252.30
nokogiri      4.360000   0.060000   4.420000 (  4.444468) 8014.83
libxml-ruby   4.570000   0.050000   4.620000 (  4.641338) 7674.87
hpricot      13.750000   0.210000  13.960000 ( 14.045647) 2536.13
.
test_simple_xpath(XmlTruth::DOM::XML::LargeDocumentXPathSearchTest) N=5
user     system      total        real   kBps
nokogiri     44.430000   0.300000  44.730000 ( 44.972003) 792.09
libxml-ruby  40.950000   0.210000  41.160000 ( 41.300780) 862.49
hpricot      18.410000   0.090000  18.500000 ( 18.540239) 1921.32
.
test_IO_parsing(XmlTruth::DOM::XML::SmallDocumentParsingTest) N=1944
user     system      total        real   kBps
null          8.150000   0.130000   8.280000 (  8.326070) 4278.17
nokogiri     17.850000   0.100000  17.950000 ( 17.950534) 1984.36
libxml-ruby  19.010000   0.260000  19.270000 ( 19.370769) 1838.87
hpricot      25.320000   0.460000  25.780000 ( 25.827516) 1379.16
.
test_in_memory_parsing(XmlTruth::DOM::XML::SmallDocumentParsingTest) N=1944
user     system      total        real   kBps
null          3.960000   0.030000   3.990000 (  4.005522) 8892.82
nokogiri     18.140000   0.200000  18.340000 ( 18.403396) 1935.53
libxml-ruby  19.760000   0.230000  19.990000 ( 19.999905) 1781.03
hpricot      15.980000   0.150000  16.130000 ( 16.133157) 2207.90
.
Finished in 426.233021 seconds.

5 tests, 0 assertions, 0 failures, 0 errors

You can find my fork of the test suite on github here: Patrick Tulskie’s Fork of XMLTruth

From this small sample of tests, it appears as though Nokogiri and libxml-ruby are similar in performance for most items. This makes sense though since Nokogiri utilizes the native libxml of the current operating environment. Nokogiri clearly excels at parsing larger documents while Hpricot appears to handle smaller, in-memory documents rather quickly.

In real-world scenarios, one might expect Nokogiri to be the ideal solution to parsing large XML or HTML documents from the disk into a database, whereas Hpricot might be a more ideal gem for use in a web crawler where it is rare that a page’s DOM is more than a 1MB.

Please post any other thoughts you might have in the comments.

Naturally I was a little freaked out.

After retracing my steps over the past hour I remembered I had updated my ruby gems with a good ol “sudo gem update.”  I do it all the time so I didn’t see the cause for concern.  I went and looked at the newly installed gems and saw that there was libxml-ruby-1.0.0.  I browsed inside the gem and saw that it had a bin directory that had a ruby executable in it.  Cute.  Whoever the person is who released that needs to pay super close attention to what they are doing in the future.

Anyhow, I uninstalled the gem and when it asked if I wanted to remove the ruby executable I said yes.  This of course trashed the ruby executable in my /usr/bin.  Luckily I was able to retrieve it from Jay Amster and all was well.  If I was to do things over I’d say not to trash the executable and just delete the gem and all of its files.

Having that broken ruby executable in my path devastated my system though.  Half of my Textmate scripts no longer worked, none of my rails apps would execute, etc.  It was awful.  Thankfully I was able to figure it out quickly and hopefully if you run a search for “you need to write me” then you’ll stumble upon this post and know what to do to fix your machine.

UPDATE:

It would appear as though this problem is now resolved.  Maybe I got a bad install of the gem?  Maybe it was just a fluke?  Who knows?  It appears safe to install the latest libxml-ruby now though.

The only real “feature” is that it will now handle full names just fine. Otherwise, the rest of the stuff was mostly performance related.  Here it is:

class String
  # Extension of the string class to properly handle camel names
  def nameize
    if self.match(/ /)
      # If the name has a space in it, we gotta run the parts through the nameizer.
      name = self.split(' ').each { |part| part.nameize! }.join(' ')
      return name
    elsif self.match(/^[A-Z]/)
      # If they took the time to capitalize their name then let's just jump out.
      return self
    else
      # If there are no spaces and there is no prior
      # capitalization then let's downcase the whole thing.
      name = self.downcase
    end
    # Let's now assume that they were lazy...
    return case
    when name.match(/^mac/)
      name.gsub(/^mac/, "").capitalize.insert(0, "Mac")
    when name.match(/^mc/)
      name.gsub(/^mc/, "").capitalize.insert(0, "Mc")
    when name.match(/^o\'/)
      name.split("'").each{ |piece| piece.capitalize! }.join("'")
    else
      name.capitalize # name is a first name or it's not Irish then capitalize it.
    end
  end

  def nameize!
    replace nameize # BANG!
  end

end

As always – question, comments, suggestions – shoot me an email, leave a comment, or hit me on Twitter (@PatrickTulskie).

Yeah it’s great, except this Friday it didn’t happen.  Thanksgiving weekend happened instead so we pushed it to Monday.  Being the silly goose I am, I decided to get a new Macbook on Black Friday.  I restored my stuff from Time Machine, installed my Ruby Gems, and thought all was well.  Monday morning, my turn to present code came up and there was a problem with screen sharing.  Crap.  All of my code is in a git branch that is not pushed to a server yet and the time it would have taken to get to a state where we could present it from another machine would have been too much so we postponed my review until my screen sharing would work.  This was most displeasing to me.

How To Handle It Next Time.

As of late, there has been a lot of talk about bonjour in the ruby world.  There are a lot of really awesome applications that use the technology.  Take for example, gitjour.  It takes an existing git repository and makes it available to machines on the local network through bonjour.  All they would need is the gem and to type “gitjour list” in a terminal window to see what’s available.  That’s badass.

So if we had to rewind to Monday morning, what we should have done is take a functioning machine on the local network and had that person do a clone of my repository to a new working directory and then we could have screen shared that.  It would have taken a fraction of the time that it would have taken to push it to the server with my own local branch, tell someone to get a copy of my branch from the server and what branch to take.  Gitjour would have cut out all of the steps and it would have been quicker since it’s on the local network.

This thought alone makes me want to dive deeper into bonjour and figure out how to use it for various things.  If you have any good resources, post them in the comments or hit me up on Twitter. (http://twitter.com/patricktulskie)

What Was The Screen Sharing Problem?

Turns out iChat 4.0.5 doesn’t know how to view the screen of someone with iChat 4.0.6.  The new Macbook comes with 4.0.6 by default and there is no easy way to upgrade to it.  I downgraded to 4.0.2 from my Blackbook and now all is well.

WARNING: You’re using the Ruby-based MySQL library that ships with Rails. This library is not suited for production. Please install the C-based MySQL library instead (gem install mysql).

Normally I don’t care, but I figured since I was doing some cleanup today and getting things ready to move on to a longer term it might be good to have a properly working MySQL gem.  I like to run with a system that is close to what we run production.  The closer you get, the less surprises you have when you push it live.

More Fixing.  Less Talking.

Damn you’re so pushy sometimes.  Anyhow.  I did a sudo gem install mysql and got another damn error.

Building native extensions.  This could take a while...
ERROR:  Error installing mysql:
ERROR: Failed to build gem native extension.

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby extconf.rb install mysql
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lm... yes
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lz... yes
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lsocket... no
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lnsl... no
checking for mysql_query() in -lmysqlclient... no
*** extconf.rb failed ***
Could not create Makefile due to some reason, probably lack of
necessary libraries and/or headers.  Check the mkmf.log file for more
details.  You may need configuration options.

Oh good.  Another error.  Perfect.  I searched around the interwebs and someone suggested using “–with-mysql-lib=/usr/local/mysql/lib” in the options since that’s where the libraries are located.  It still barfed on me with that.

A Solution Please.

A few more minutes of hunting and pecking and I found the golden command:

sudo gem install mysql -- --with-mysql-config
Building native extensions.  This could take a while...
Successfully installed mysql-2.7
1 gem installed

Now I don’t have any errors when starting my rails applications that use MySQL and I’m closer to what I have in production.

Presidential Candidate Websites.

Shock and horror came over me as I scanned their websites.  There was stuff all over the place, explosive gradients and backgrounds that simply don’t jive.  Youtube videos are injected in every nook and cranny.  Since both websites are full of crap I don’t fell like reading or watching, I thought that I’d go a step further and do a good ol’ W3C Markup Validation on them.  The results were astounding to say the least.

John McCain: 171 Errors, 46 Warnings (217 problems)
Source: W3C

Barack Obama: 220 Errors, 37 Warnings (257 problems)
Source: W3C

You would think that with the Democratic party doing anything and everything to get Barack all over the media, news, magazines, to the point where I check under my bed at night to make sure he’s not there, they would have made sure his website was W3C compliant.  If he wins, what does that say about their concern for web standards.  It makes his “net neutrality” talks sound like complete crap.  McCain’s site is not much better than Obama’s but the fact is that McCain’s site is better.  Winning is winning.

You’d think that my selection process would be over, but you would be wrong.

VP Candidates.

I went to JoeBiden.com and SarahPalin.com and both were serious let downs.  Biden freeloads off of Obama’s website.  Palin’s website says “This space intentionally left blank.”  Serious disappointment.  Not even a picture of Palin for me to hang up on the wall of my gun locker.  Biden too… dude what’s up with that?  You gotta have Obama carry you through the whole damn election?  Complete rubbish from both the elephant and the ass.

For giggles, I ran ‘em through anyway…

Sarah Palin: 5 Errors, 0 Warnings

Joe Biden: 72 Errors, 29 Warnings

…and let me tell you, I did giggle quite a bit.

Because of how atrocious both VP candidates’ sites are, I won’t be including them in my decision.  Their awfulness cancels each other out.  If you wanted to play a numbers game though, Biden’s piggybacking on Obama’s site does more hurt than good.

The Tie Breaker.

Don’t listen to my drivel.  This blog post is balderdash.  You shouldn’t judge your presidential candidate based on how compliant their website is with W3C standards, even if I am.  When you don’t like either candidate, you need to pick one small issue that you can judge the candidates on go from there.  That’s the tie breaker.  Could be something as lofty as religious beliefs or something as trivial as who has a better choice of neck ties.

Fact of the matter is, you need to go out and vote, no matter how irrational and illogical your selection process might be.

Update

Just tested Change.gov and I’m slightly more impressed.  Seems like since Obama is now president-elect he is able to rocket past anything McCain could ever compose with a WYSIWYG with a cup of coffee.  He has created quite a website that is pretty damn compliant.

Change.gov: 20 Errors, 3 Warning

This makes me feel much better, because the one thing that keeps me up at night is web standards.  Seems like we’re getting much closer to changing.