It is a OS-independent library and doesn’t require external C libraries or Gems: it is a 100% Ruby software with all the advantages and disadvantages that it involves. This software was developed to power RoboDomain and it eventually become a standalone library.

Whois provides the following key features:

• Pure Ruby library, without any additional dependency
• Compatible with Ruby 1.8.6 and greater, including Ruby 1.9
• Successfully tested against multiple Ruby platforms and versions including Ruby, Ruby Enterprise Edition and MacRuby
• Ability to query registry data for IPv4, IPv6 and top level domains
• Ability to parse WHOIS responses
• Flexible and extensible interface (ex. You can define custom servers on the fly)
• Object oriented design

Whois 1.0

Whois 1.0 is the first major release since I started working on the library one year ago. It reached an high level of maturity and stability and you can safely consider it production ready.

Compared with previous version, Whois 1.0 includes a really huge CHANGELOG (more than 100 lines!). The most important features are:

• Updates to existing definitions
• 48 New WHOIS Parsers
• Ability to check whether a property is set
• Command Line Improvements
• Changes to the internal Answer/Parser architecture to improve usability

Last but not least, a dedicated site is now available at ruby-whois.org.

A Retrospective

Whois 1.0 is a really important milestone. The first Whois release was just another WHOIS library. Yes, it offered support for all existing TLDs, but that was just the beginning. My idea was to creare a library to be able to parse and access all WHOIS responses with a single, standardized, object oriented API.

The current Whois library perfectly fit this milestone. Unfortunately, there’s still a big number of unsupported server, but I’m working really hard to reduce the gap. Also, in the last months a small number of users contributed back with servers, patches, changes and I’m really grateful to them.

If you look at the CHANGELOG, Whois has improved day after day.

The Client side

Whois 1.0 is a pure Ruby WHOIS client. It means you can install and use it on any platform where Ruby is supported, including (but not limited to) Microsoft Windows, Linux, MacOSX and Solaris.

This is one of the most important feature, compared with other WHOIS libraries. Whois is shipped with a Command Line Interface you can use to lookup a domain.

$ ruby-whois google.com

And this works on Windows too!

Whois is an intelligent Whois client. It means, you don’t need to know anything about WHOIS, Dns or TLD. Simply feed the client with the domain you want to lookup, and wait for the response.

require 'rubygems'
require 'whois'

a = Whois.query "google.com"
puts a

Whois will automatically choose the best WHOIS server according to the given query. If the query is a domain, Whois will try to find a server for the corresponding TLD. If the query is an IPv4 or IPv6, Whois will send the request to the corresponding management authority.

TLD and IP definitions are included in the package and read when the library is loaded. You can always update/change them at runtime.

The Parser side

Until now, Whois just seems to be an other powerful-but-standard WHOIS client. But this is not true.

The biggest difference between Whois and other WHOIS libraries, is that Whois can parse and decompose a raw WHOIS response into a powerful Ruby object.
This means, you can access WHOIS property calling a simple method rather than dealing with complex regular expressions in order to extract the data you need.

require 'rubygems'
require 'whois'

a = Whois.query "google.it"
puts a.available?
# => false

a.nameservers.each do |nameserver|
  puts nameserver
end
# => ns1.google.com
# => ns4.google.com
# => ns2.google.com
# => ns3.google.com

puts a.created_on
# => Fri Dec 10 00:00:00 +0100 1999
puts a.expires_on
# => Sat Nov 27 00:00:00 +0100 2010

You can read more at ruby-whois.org.

RoboDomain

Whois library has been creates to power RoboDomain project. With Robodomain you can keep track of any domain in one single place: log transactions, store notes, check domain status and enjoy our network tools.

Be sure to signup for an invitation code if you want to join the beta program.

Contribute

Whois is an open source project and released under the terms of the MIT license.

You can contribute by suggesting new features and reporting bugs or you can fork away the project and submit your changes.

Do you have a question? Need an help with the library? Join the discussion group.

Enjoy Ruby Whois 1.0.

$ gem install whois

Related posts:

1. Ruby has a new WHOIS library
2. Ruby Whois preview: WHOIS answer and parser
3. Ruby Whois 0.8.0

$ ruby-whois google.com

WHOIS requests can fail and, unfortunately, the existing version of the CLI doesn’t handle this case very well. When an exception is raised, the CLI exits printing an unfriendly Ruby stack trace.

$ ruby-whois karnaugh.za.net
/Users/weppos/.rvm/ruby-1.8.7-p174/lib/ruby/1.8/timeout.rb:60:in `ask_the_socket': execution expired (Timeout::Error)
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/server/adapters/base.rb:77:in `query_the_socket'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/server/adapters/standard.rb:34:in `request'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/server/adapters/base.rb:52:in `query'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/server/adapters/base.rb:66:in `with_buffer'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/server/adapters/base.rb:51:in `query'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/client.rb:72:in `query'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/lib/whois/client.rb:70:in `query'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/gems/whois-0.8.1/bin/ruby-whois:37
    from /Users/weppos/.rvm/gems/ruby/1.8.7/bin/ruby-whois:19:in `load'
    from /Users/weppos/.rvm/gems/ruby/1.8.7/bin/ruby-whois:19

I’m happy to say that now his is just a bad memory. In case of error, the new CLI writes the error message to STDERR then terminates the execution and sets the exit status to 1.

$ ruby-whois karnaugh.za.net
Request Timeout

$ ruby-whois google.es
This TLD has no whois server, but you can access the whois database at `https://www.nic.es/'

Related posts:

1. Ruby has a new WHOIS library
2. Ruby Whois preview: WHOIS answer and parser
3. Ruby Whois 0.8.1

The repository is still hosted on GitHub and in the next days I’ll probably migrate the issue management as well.

The design of the new Whois website is clearly influenced by this website and Rack::Cache. All HTML files are automatically generated using Jekyll. The new site contains all the existing documentation published on the legacy wiki, reorganized and updated. As soon as Whois 1.0 will be available, I promise to spend some time writing more details about the advanced features such as creating WHOIS parsers and using the answer object.

Related posts:

1. Ruby Whois preview: WHOIS answer and parser
2. Ruby has a new WHOIS library
3. Whois 0.9.0: WHOIS parsers, CLI and performances

a = Whois.query "google.it"
a.created_on?
# => true

a = Whois.query "notregistered.it"
a.created_on?
# => false

Two important aspects to keep in mind. First, this method works only at answer level.

a = Whois.query "google.it"
a.created_on?
# => true
a.parser.created_on?
# => NoMethodError

Second, this method doesn’t care whether the property is supported or not. It returns false either if the property is not supported or the value is nil.

a = Whois.query "notregistered.it"

# created_on is a property supported
# by .it TLD parser and empty for this
# specific query
a.created_on?
# => false

# domain_is is not a property supported
# by .it TLD parser
a.domain_id?
# => false

Related posts:

1. New in Whois: Applying the Principle of Least Surprise
2. Ruby Whois 0.8.1
3. Ruby Whois 0.8.0

I really like the way how Google Chrome deals with OpenSearch. When you browse and OpenSearch-aware site, Google Chrome fetches the OSDD file and make it immediately available as a shortcut in the address bar. For example, if you open a couple of pages in this site then you type simone you should see the following behavior.

Google Chrome suggests an available OpenSearch provider

If you hit tab, the autocomplete list disappears and you enter the “OpenSearch mode”. You can now enter the search query and confirm to view the search results.

Google Chrome integrates OpenSearch provider in the address bar

Creating an OpenSearch OSDD is as simple as writing less than 10 lines of XML code. Here’s mine. For more information visit the OpenSearch website.

PS. If you are a Ruby developer, here’s my Builder template. Replace TITLE, DESCRIPTION and PATH_TO_SEARCH with your own variables.

xml.instruct!
xml.OpenSearchDescription "xmlns" => "http://a9.com/-/spec/opensearch/1.1/",
                          "xmlns:moz" => "http://www.mozilla.org/2006/browser/search/" do
  xml.ShortName "TITLE"
  xml.Description "DESCRIPTION"
  xml.InputEncoding "UTF-8"
  xml.Url :type => "text/html", :method => "get", :template => "PATH_TO_SEARCH?q={searchTerms}"

  xml.moz :SearchForm, "PATH_TO_SEARCH"

end

Related posts:

1. How to run Google Chrome OS on Mac OS X with VMWare Fusion
2. Google Chrome OS User Agent
3. Google Site performance tool says Google is not serving Gzipped resources

It doesn’t provide any new feature, just delicious bug fixes including a major issue with Reverse DNS (#6) and IPAddr handling (#5). We also improved the test suite to ensure those bugs won’t show up in the future.

We are already working on the Net::DNS 0.7.x family. The new minor version will include some major internal refactoring to improve performance and reliability. There are also some open tickets we would like to address.

As usual, upgrade/install with

$ gem install net-dns

Related posts:

1. Ruby Net::DNS 0.6.0
2. Ruby Whois 0.8.0
3. Ruby Whois 1.0 is here!

One important change is strictly focused on applying the principle of least surprise in the Whois::Answer design. Prior the changes, calling a method on a Whois::Answer instance to read a property value might result in 3 different behaviors:

# the property is supported, return the value
a = Whois.query "google.it"
a.created_on?
# => Fri Dec 10 00:00:00 +0100 1999

# the property is supported but blank, return the value
a = Whois.query "notregistered.it"
a.created_on?
# => nil

# the property is not supported, raise an exception
a = Whois.query "google.it"
a.domain_id?
# => PropertyNotSupported

Whether the parser supports a property depends on the WHOIS record. For instance, a .name WHOIS response doesn’t contain the domain expiration thus the property expires_on is not supported. Contrariwise, the .it WHOIS response contains that value thus you can safely call expires_on to get the property value.

How do you deal with supported/unsupported properties? With the old Whois version you would have to check whether a property is supported before actually calling the getter method.

# the property is supported, return the value
a = Whois.query "google.it"
if a.property_supported?(:domain_id)
  a.domain_id
end

That worked well but was… horrible. Dogfooding the library working on RoboDomain I ended up with the conclusion this wasn’t the behavior an user would expect. For this reason, the new Whois version returns the value if the property is supported, nil otherwise regardless property status.

This change only affects the answer object. If for some reason you need to know whether a property is supported, you can always use the property_supported? method or access the underlying parser implementation.

a = Whois.query "google.it"

a.domain_id
# => nil

a.supported?(:domain_id)
# => false

a.parser.domain_id
# => PropertyNotSupported

Related posts:

1. New in Whois: property is set?
2. Ruby Whois 0.8.1
3. Ruby Whois 0.8.0

But how slow are Ruby Exceptions?

The answer to this question really depends on how complex is your code. Here I just want to show you a very simple example, extracted from a really strategic RoboDomain DNS sorting algorithm.

The code is fairly simple: the value for an A record is expected to be an IP Address while the value for a NS record is expected to be represented by a FQDN as string. The code should parse the data and return the normalized value depending on some conditions.

The first version of the algorithm is completely based on Exceptions. IPAddr raises an ArgumentError when the argument is not a valid IP Address. In this case, the script gracefully returns the value as string.

The second version checks against the record value (I agree with you that is quite empiric, but representative for the sake of this benchmark).

The third version is a less empiric alternative that uses some regular expressions to check whether the data looks like an IP before actually feeding the IPAddr class. Under the hood, the IPAddr class performs a really similar task, the only difference here is that in the latter case I’m not using Exceptions at all.

Results speak for themselves. *

(*) As pointed out by Curtis Summers in the comments,a huge amount of time is actually spent by IPAddr trying to resolve the hostname. For more benchmarks, also look at this test.

With Ruby 1.8.7, the algorithm (note, this is a super-simplified version of the original algorithm) is about 37 times slower when Exceptions are involved.

$ ruby if_vs_exception.rb
Rehearsal ------------------------------------------------
NS exception   4.330000   5.750000  10.080000 ( 37.599575)
NS if          0.140000   0.010000   0.150000 (  0.136280)
NS regexp      0.450000   0.000000   0.450000 (  0.454040)
A exception    2.010000   0.020000   2.030000 (  2.047711)
A if           2.060000   0.020000   2.080000 (  2.074642)
A regepx       2.030000   0.020000   2.050000 (  2.054930)
-------------------------------------- total: 16.840000sec

                   user     system      total        real
NS exception   4.420000   5.810000  10.230000 ( 38.350608)
NS if          0.130000   0.000000   0.130000 (  0.130863)
NS regexp      0.450000   0.000000   0.450000 (  0.447975)
A exception    2.000000   0.020000   2.020000 (  2.016231)
A if           2.020000   0.020000   2.040000 (  2.043085)
A regepx       2.030000   0.020000   2.050000 (  2.048402)

The same story with Ruby 1.9.1.

Rehearsal ------------------------------------------------
NS exception   4.650000   5.800000  10.450000 ( 39.134858)
NS if          0.080000   0.000000   0.080000 (  0.079427)
NS regexp      0.320000   0.000000   0.320000 (  0.320389)
A exception    1.180000   0.010000   1.190000 (  1.182892)
A if           1.200000   0.000000   1.200000 (  1.209433)
A regepx       1.220000   0.000000   1.220000 (  1.219345)
-------------------------------------- total: 14.460000sec

                   user     system      total        real
NS exception   4.520000   5.720000  10.240000 ( 37.931455)
NS if          0.080000   0.000000   0.080000 (  0.078286)
NS regexp      0.320000   0.000000   0.320000 (  0.320988)
A exception    1.190000   0.000000   1.190000 (  1.186198)
A if           1.210000   0.010000   1.220000 (  1.220254)
A regepx       1.220000   0.000000   1.220000 (  1.215634)

Does this mean I should forget about Exceptions?

Absolutely no! I love Exceptions and you should love them too. However, Exceptions should not be expected and, in some circumstances, an if can be much more convenient, or at least, efficient.

One important lesson to learn from these benchmarks is that exceptions should not be part of the regular application flow. This shouldn’t prevent you to use them to handle unexpected situations and exception performance shouldn’t be a big deal in this case.

A lesson learned from this specific case, is to avoid using exceptions in place of conditional statements to handle not exceptional situations.

UPDATE: for more interesting comments, check out the Reddit page.

Related posts:

1. Re-raise a Ruby exception in a Rails rescue_from statement
2. Inside Ruby on Rails: Rescuable and rescue_from

Loser = Struct.new(:id, :name)
Winner = SuperStruct.new(:id, :name)

# The default Struct accepts up to N arguments
# where N is the total number of elements defined in the Struct.
Loser.new(:id => "1", :name => "John Doe")
# => #<struct Loser id={:name=>"John Doe", :id=>"1"}, name=nil>

Winner.new(:id => "1", :name => "John Doe")
# => #<struct Winner id="1", name="John Doe">

Because the first argument is mapped to the :id element, the Hash is stored as value for the id attribute.
In a standard Ruby Struct I have to map each Hash value to the specific position in the Struct, loosing the flexibility of passing a Hash with optional keys.

hash = { :name => "John Doe" }

Loser.new(hash)
# => #<struct Loser id={:name=>"John Doe"}, name=nil>
Loser.new(nil, hash[:name])
# => #<struct Loser id=nil, name="John Doe">

Winner.new(hash)
# => #<struct Winner id=nil, name="John Doe">

Also, I’d like to be able to pass a block to the initialize method and yield on self.

Loser.new do |c|
  c.name = "John Doe"
end
# => #<struct Loser id=nil, name=nil>
# Name is not set

Winner.new do |c|
  c.name = "John Doe"
end
# => #<struct Winner id=nil, name="John Doe">
# Hurra! Name is set!

I called it RubyStruct. It was created for the Ruby Whois, but ultimately I found myself using it quite often in my projects and I decided to package it in a single file along with a basic test suite.

Here’s the library.

Related posts:

1. Ruby has a new WHOIS library
2. Ruby Whois 0.8.1
3. rake console: a custom irb instance for your Ruby GEM

Redmine 0.9.0 offers tons of improvements but one among all forced my decision to upgrade without waiting for a final release: Rails 2.3.5. Redmine 0.8.x is built on Rails 2.1.0 and there seems to be some kind of weird Rails-Redmine-Passenger-Ruby EE memory leaks.

With the new release, Redmine has changed the most part of its URLs. The development team basically migrated all routes to a more RESTful-oriented architecture. They did a wonderful job, unfortunately they probably chose the worst way to ensure backward-compatibility: duplication.

All the old routes are still available along with the new ones and this can cause several duplicate content issues. To patch the problem, I configured some Apache redirection rules in order to permanently redirect the old URLs to the new ones.

The gist doesn’t pretend to solve all issues. It’s just a quick and (quite) dirty fix.

From Redmine side, I would have setup a Rails Metal to redirect all the old URLs to the new ones. This is not as efficient as relying on the web server, but this is compatible with any user environment.

Feel free to fork, clone and update the gist. After all, this is a Git repository!

Related posts:

1. Apache .htaccess query string redirects
2. Configuring a Git repository with Redmine
3. Generic Apache configuration snippets