Simone Carletti's Blog » Hosting / Domains

Google changes the maximum number of users for Google Apps

Simone Carletti — Fri, 29 Apr 2011 07:31:13 +0000

I just received an email from Google about upcoming changes to the maximum number of users for Google Apps. When Google Apps was released, Google allowed all accounts to create up to 500 users. The limit was changed in 2009 for free accounts and reduced to 50 users.

Today, Google is changing this limit again to 10 users. Here’s the content of the email.

Hello,

We recently announced upcoming changes to the maximum number of users for Google Apps. We want to let you know that, as a current customer, the changes will not affect you.

As of May 10, any organization that signs up for a new account will be required to use the paid Google Apps for Business product in order to create more than 10 users. We honor our commitment to all existing customers and will allow you to add more than 10 users to your account for DOMAIN at no additional charge, based on the limit in place when you joined us.

Sincerely,

The Google Apps Team

Starting from 10 May 2011, the new maximum number of users for a Google Apps for free account will be set to 10.

Whois 2.0

Simone Carletti — Thu, 17 Mar 2011 20:58:19 +0000

One year after the first major release, almost 2 years after the first commit, 1k commits and 59 versions after, I’m very proud to announce the immediate availability of Whois 2.0.

Whois is an intelligent, pure Ruby, WHOIS client and parser. It provides a flexible and programmable API to query WHOIS servers and look up IP, TLD, and domain WHOIS information. It also offers command-line interface to run WHOIS queries from the console.

This second major release, the 60th since I released the gem, is a very important milestones. I started working on this project with the idea of creating a Ruby parser for each TLD available and it took me two years and countless hours to reach this goal.

Some stats

To give you a rough idea about the complexity of this project, here’s a few numbers about Whois 2.0.

866,706 different WHOIS records (~3.3 GB of data) analyzed as of March 16th, 2011
425 RSpec test files
444 fixture files extracted from real WHOIS records
3787 RSpec examples and an unknown number of matches (sorry, I stopped keeping track of them when they reached 15k assertions) that probably makes this project one of the gems with the largest RSpec test suite
~20.000 lines of code, including the test files
168 different WHOIS parsers

Oh, man. You can’t believe the amount of work required to cover all the existing WHOIS servers, their features and especially their whims.

New and Notable

The increasing support for all existing TLD servers is probably one of the most important changes for this milestone. But the CHANGELOG is very huge and there are a few other changes that are worth a mention.

I already blogged about a few of them.

The #nameservers property now returns a Nameserver object. This change allows the parser to also extract name server IPv4 and IPv6 addresses.
A new caching mechanism reduces the number of instance variables created.
The library now supports the Gem Testers project.
You can now bind a different address or port to the WHOIS socket request.

Last but not least, the Whois::Answer class has been renamed to Whois::Record.

There are a couple of backwards-incompatible changes to the API. These changes were necessary to evolve the API to better reflect the representation of the existing WHOIS responses.

What’s Next?

The Whois library is pretty stable. It is now used in production for several big projects.

The API is mature. A few changes have been made in this major release to support additional WHOIS properties, however I don’t expect big changes in the future.

The following releases will focus on increasing the list of supported properties for each parser, as well closing some of the existing issues.

The biggest change in the API in the near future is likely to be the standardization of the status property.

In the last months I received some great feedback from people using my library with other platforms, such as Java and .NET. This is amazing.

If you have any case study, case history or feedback, please let me know. I would love to learn more about how you use the library.

How to Upgrade

To upgrade to Whois 2.0 please follow the instructions in the documentation page.

Introducing Public Suffix Service 0.5.0

Simone Carletti — Wed, 15 Sep 2010 19:56:20 +0000

Public Suffix Service is a Ruby domain name parser based on the Public Suffix List, the cross-vendor initiative to provide an accurate list of domain name suffixes.

Parsing a domain name is not as simple as you may suppose and, since there is no algorithmic method of finding the highest level at which a domain may be registered for a particular top-level domain (the policies differ with each registry), the only method is to create a list of all top-level domains and the level at which domains can be registered. This is the aim of the effective TLD list.

The Public Suffix Service Ruby library parses domain names using the definitions stored in the Public Suffix List.

This week I released Public Suffix Service 0.5.0. I normally don’t create a post for every minor release of my libraries, but this version is really worth a mention.

Compared to the previous version, there are no public API changes. The only, very significant change is an internal refactoring by Camilo Lopez to the main definition lookup method which results in performance improvement by orders of magnitude.

Here’s a very simple benchmark comparing Public Suffix Service 0.4.0 with 0.5.0.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ ruby bm_pss_gem.rb 0.4.0
Rehearsal -------------------------------------------------
Version 0.4.0 5.540000 0.170000 5.710000 ( 6.682396)
---------------------------------------- total: 5.710000sec

user system total real
Version 0.4.0 5.320000 0.130000 5.450000 ( 5.614912)

$ ruby bm_pss_gem.rb 0.5.0
Rehearsal -------------------------------------------------
Version 0.5.0 0.140000 0.020000 0.160000 ( 0.155435)
---------------------------------------- total: 0.160000sec

user system total real
Version 0.5.0 0.020000 0.000000 0.020000 ( 0.019537)

Yes, there’s no typo. Thanks to Camilo, the library performed the same execution in 0.01 vs 5.16 seconds.

Public Suffix Service 0.4.0 uses the standard algorithm, described in the Public Suffix List website, which is known to not be the most efficient. The new 0.5.0 release adds an internal index that dramatically increases definition lookup.

Thank you very much to Camilo Lopez for his high quality contribution. This patch is probably one of the best demonstrations of what can be the benefits of releasing your libraries as an open source projects. RoboDomain can now take advantage of a much more efficient domain parsing library.

Public Suffix Service 0.5.1, released today, also includes an update to the definition file.

Introducing the Public Suffix List library for Ruby

Simone Carletti — Tue, 01 Jun 2010 09:18:33 +0000

Have you ever found yourself looking for a solution to parse or validate a domain name? Probably, you spent several hours trying to find the most efficient and comprehensive regular expression, but the more examples you found, the more you realized that the final solution doesn’t seem to exist.

And you are right. There is no algorithmic method of finding the highest level at which a domain may be registered for a particular top-level domain (the policies differ with each registry), the only method is to create a list of all top-level domains and the level at which domains can be registered. This is the aim of the effective TLD list.

Here comes the Public Suffix List.

What is the Public Suffix List?

The Public Suffix List is a cross-vendor initiative to provide an accurate list of domain name suffixes.

The Public Suffix List is an initiative of the Mozilla Project, but is maintained as a community resource. It is available for use in any software, but was originally created to meet the needs of browser manufacturers.

A “public suffix” is one under which Internet users can directly register names. Some examples of public suffixes are “.com”, “.co.uk” and “pvt.k12.wy.us”. The Public Suffix List is a list of all known public suffixes.

Does it work with Ruby?

Yeah! Public Suffix Service is a Ruby domain name parser based on the Public Suffix List. To use it you don’t need to download the list or learn how it works. Just install the Gem and you’re done.

1	$ gem install public_suffix_service

Here’s a few examples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# parse a very standard domain name
domain = PublicSuffixService.parse("google.com")
domain.tld
# => "com"
domain.domain
# => "google"
domain.subdomain
# => nil

# parse a less standard domain name
domain = PublicSuffixService.parse("google.co.uk")
domain.tld
# => "co.uk"
domain.domain
# => "google"
domain.subdomain
# => nil

# it works with subdomains too
domain = PublicSuffixService.parse("www.google.co.uk")
domain.tld
# => "co.uk"
domain.domain
# => "google"
domain.subdomain
# => "www"

Domain validation

The Public Suffix Service library offers a quick way to validate a domain.

1
2
3
4

PublicSuffixService.valid?("google.com")
# => true
PublicSuffixService.valid?("www.google.com")
# => true

The main difference compared with the regular expression based solutions is that this library actually validates the domain against a white/black list instead of running a soft check on the TLD size.

1
2
3
4

PublicSuffixService.valid?("google.xx")
# => false
PublicSuffixService.valid?("google.zip")
# => false

Domain transformation

The PublicSuffixService::Domain class provides a bunch of methods to validate and transform a domain name.

1
2
3
4
5
6
7
8
9
10
11
12

domain = PublicSuffixService.parse("www.google.com")

domain.domain?
# => true
domain.is_a_domain?
# => false
domain.is_a_subdomain?
# => true
domain.subdomain
# => "www.google.com"
domain.domain
# => "google.com"

Who uses the Public Suffic List?

The list is used by well known browsers such as Google Chrome, Mozilla Firefox and Opera.

The Public Suffix Service Ruby library was created for RoboDomain and it has been used in production since November 2009.

Ruby Whois 1.0 is here!

Simone Carletti — Sat, 06 Feb 2010 12:54:32 +0000

Whois is an intelligent pure Ruby WHOIS client and parser.

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:

Ability to query registry data for IPv4, IPv6, TLDs, and domain names
Ability to parse WHOIS responses
Flexible and extensible interface (e.g. You can define custom servers on the fly)
Object oriented design, featuring 10 different design patterns
Pure Ruby library, without any external dependency other than Ruby itself
Compatible with Ruby 1.8.6 and greater, including Ruby 1.9 branch
Successfully tested against several Ruby implementations, including Ruby, Ruby Enterprise Edition, JRuby, and MacRuby

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.

1	$ 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.

1
2
3
4
5

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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.

1	$ gem install whois

New in Whois: command line improvements

Simone Carletti — Thu, 04 Feb 2010 20:18:26 +0000

Whois 0.8.0 was released with a new command line tool to perform one-line WHOIS queries.

1	$ 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.

1
2
3
4
5
6
7
8
9
10
11
12

$ 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.

1
2
3
4
5

$ 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/'

Ruby Whois moved to ruby-whois.org

Simone Carletti — Wed, 03 Feb 2010 19:08:44 +0000

The Whois 1.0 release is just around the corner and to celebrate the first major release the library is changing home from my Codestuff site to ruby-whois.org.

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.

New in Whois: property is set?

Simone Carletti — Fri, 22 Jan 2010 22:46:21 +0000

The new Ruby Whois version will offer the ability to check whether a property is set using the standard method? Ruby convention. This means, you no longer need to check whether a property is supported, get the property value and compare it to nil.

1
2
3
4
5
6
7

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.

1
2
3
4
5

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.

1
2
3
4
5
6
7
8
9
10
11
12

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

Ruby Net::DNS 0.6.1 released

Simone Carletti — Mon, 18 Jan 2010 19:29:43 +0000

Net::DNS 0.6.1 is the first maintenance release for the Net::DNS 0.6.x series.

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

1	$ gem install net-dns

New in Whois: Applying the Principle of Least Surprise

Simone Carletti — Sun, 17 Jan 2010 12:28:01 +0000

In the past weeks I’ve been working to improve the Ruby Whois Gem. While most of the effort is actually focused on creating new WHOIS parsers for the existing registries which are more than 400, I also took the time to add some new features.

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 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.

1
2
3
4
5

# 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.

1
2
3
4
5
6
7
8
9
10

a = Whois.query "google.it"

a.domain_id
# => nil

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

a.parser.domain_id
# => PropertyNotSupported