gandirb 1.1.1 → 2.0.0

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 2.0.0
+
+* Full rewrite to support API version 2.0
+* Tests are now using rspec
+* Moved git repository to https://github.com/pickabee/gandi
+
 == 1.1.1
 
 * Missing gemfile in gem

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Pickabee
+Copyright (c) 2012 Pickabee
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.rdoc

@@ -1,36 +1,34 @@
-= Gandirb - Ruby library for using the Gandi XML-RPC API
+= Gandi - Ruby library for using the Gandi XML-RPC API
 
-This is a ruby library for using the Gandi XML-RPC API.
-It currently only provides methods for using the domain and mail API, but is extensible enough to add hosting in the future.
+A Ruby library for using the Gandi XML-RPC API.
+At the moment support is planned for the Domain, Contact and Operation APIs only, but Hosting and Catalog APIs support may be added in the future.
+Version 2.0.0 and upwards of this gem supports only the Gandi API version 2.0, use version 1.x of the gem if you need to the 1.0 API.
 
-== Howto
+== HOWTO
 
-See http://wiki.gandi.net/fr/api-xml/docs/domain for the full documentation on the API.
-Note the session_id doesn't have to be explicitly provided when calling a method.
+See http://rpc.ote.gandi.net/doc/2.0/index.html for the full documentation about the API.
+Note that the apikey doesn't have to be explicitly provided when calling a method.
 
-It should also be noted that the ruby xml-rpc lib seems to have a bug with the ssl support, resulting in a timeout of about 15 seconds.
-After this time the current connection won't work and result in various exception. 
-This lib takes this issue into account and provides a workaround by restarting the connection. See the comments for Gandi::Base#raw_call for more details.
+Quick example:
+        Gandi.apikey = 'my 24-character API key'
+        Gandi.url # => "https://rpc.ote.gandi.net/xmlrpc/"
+        Gandi.url = Gandi::URL #Use the production URL instead of the default Operational Test and Evaluation URL
+        Gandi.call('version.info') #You do not have to provide the apikey for each call
+        contact = Gandi::Contact.new('FLN123-GANDI')
+        contact.country # => "FR"
 
-Quick example :
-
-        require 'gandi'
-        gandi_session = Gandi::Domain.login 'XXYYY-Gandi', 'mypasswd', Gandi::Domain::TEST_URL #or use Gandi::Domain::URL in production mode
-        gandi_session.account_currency # => "EUR"
-        gandi_session.domain_available ["mycoolwebsite.com"] # => {"mycoolwebsite.com"=>true}
-        gandi_session.domain_available "mycoolwebsite.com" # => true #additional syntax
-        gandi_session.domain_list # => ["mypersonalwebsite.com"]
-
-Detailed RDoc documentation for each method is available using rake rdoc.
+You can read more about the library in USAGE.rdoc.
+Detailed RDoc documentation for each method is available using `rake rdoc`.
 
 == TODO
 
 * More tests
-* Finish adding and cleaning up domain and mail methods
-* Better handling of failures and server exceptions, and stricter params checking
-* Refactor Domain and Base class and add a Session class to separate XML-RPC code and prepare adding hosting methods
+* Refactor the Operation object creation from the other classes
+* Add attributes getters to Domain/Operation/Mailbox/Host classes
+* Refactor the Contact class to match the other classes behaviour (instances of the class should only match existing records)
+* Make the Domain/Contact/etc. classes more ActiveModel-like
+* Better handling of failures and server exceptions, and overall stricter params checking
 
 == Copyright
 
-Copyright (c) 2009 Pickabee. Released under the MIT licence, see LICENSE for details.
-Some parts inspired by http://github.com/jerome/gandi/tree
+Copyright (c) 2012 Pickabee. Released under the MIT licence, see LICENSE for details.

data/Rakefile

@@ -2,22 +2,21 @@ require 'bundler/setup'
 require 'rake'
 require 'bundler/gem_tasks'
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = false
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['-c', '-f progress', '-r ./spec/spec_helper.rb', '--backtrace']
+  t.pattern = 'spec/**/*_spec.rb'
 end
 
-task :default => :test
+task :default  => :spec
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "Gandirb"
   rdoc.main = 'README.rdoc'
-  rdoc.rdoc_files.include('README*', 'CHANGELOG', 'LICENSE')
+  rdoc.rdoc_files.include('README*', 'USAGE*', 'CHANGELOG', 'LICENSE')
   rdoc.rdoc_files.include('lib/**/*.rb')
-  rdoc.options << "--line-numbers"
-  rdoc.options << "--charset=UTF-8"
+  rdoc.options << '--line-numbers'
+  rdoc.options << '--charset=UTF-8'
 end

data/USAGE.rdoc

@@ -0,0 +1,131 @@
+= Setup
+
+== Installation
+
+=== Using bundler
+
+Add the gandi gem requirement to your Gemfile :
+        gem "gandi", "~> 1.0"
+
+Then install the gem with `bundle`.
+
+=== Using Rubygems (or any other Ruby package manager)
+
+Install the gem manually (see your package manager documentation if you are using a Rubygems alternative) :
+        $ gem install gandi
+
+You will have to require the gandi library manually in your application code :
+        require 'gandi'
+
+=== Configuration
+
+Set your API key :
+        Gandi.apikey = 'my 24-character API key'
+See https://www.gandi.net/admin/apixml/ to activate the API for your account and get your apikey.
+
+By default, the library will use the OT&E system when calling the API. 
+See http://rpc.ote.gandi.net/doc/2.0/overview.html#ot-e-system to learn more about the OT&E system.
+You can use the production system by changing the URL :
+        Gandi.url = Gandi::URL
+
+= Description
+
+The Gandi library can be used in two ways : either by calling the API directly, or by using Ruby classes and methods that transparently map to the corresponding API calls.
+
+== API calls
+
+You can call any API method directly by using Gandi.call :
+        Gandi.call('version.info') # => {"api_version"=>"2.0"}
+
+The apikey will automatically be provided as the first argument of the called method.
+
+== Ruby objects
+
+The Gandi library aims to abstract the API calls by providing classes and methods matching Gandi "objects" :
+* Gandi::Contact - a Gandi contact (identified by its handle)
+* Gandi::Domain - a domain name (identified by its fqdn)
+* Gandi::Domain::Forward - A domain forward (identified by its source email) (TODO)
+* Gandi::Domain::Host - A domain host (glue record) (identified by its hostname)
+* Gandi::Domain::Mailbox - a mailbox for a domain name (identified by its login) (TODO)
+* Gandi::Operation - an operation on the Gandi system (identified by its unique id)
+
+Be aware that Ruby classes do not specifically map to Gandi API namespaces.
+For example, Gandi::Domain#nameservers will return an array of nameservers fetched with a previous call to 'domain.info', while Gandi::Domain#nameservers=(nameservers) will call 'domain.nameservers.set'
+
+Here is a (partial) reference of Gandi namespaces and their matching Ruby classes and methods :
+* contact
+  * can_associate(contact, domain) => Gandi::Contact.can_associate(contact, domain)
+  *  can_associate_domain(handle, domain) => Gandi::Contact#can_associate_domain(domain)
+  *  create(contact) => Gandi::Contact.create(contact)
+  *  info(handle='') => Gandi::Contact#info,  Gandi::Contact.info(handle)
+  *  list(opts=nil) => Gandi::Contact.list(opts = {})
+  *  update(handle, contact) => Gandi::Contact#update(contact), Gandi::Contact.update(handle, contact)
+* domain
+  *  available(fqdns) => Gandi::Domain.available(fqdns)
+  *  count(filters=nil) => Gandi::Domain.count(filters = {})
+  *  create(fqdn, params) => Gandi::Domain.create(fqdn, params)
+  *  info(fqdn) => Gandi::Domain#info
+  *  list(opts=nil) => Gandi::Domain.list(opts = {})
+  *  renew(fqdn, params) => Gandi::Domain#renew(params)
+* domain.contacts
+  *  set(fqdn, contacts) => Gandi::Domain#contacts=(contacts)
+* domain.status
+  *  lock(fqdn) => Gandi::Domain#lock
+  *  unlock(fqdn) => Gandi::Domain#unlock
+* domain.host
+  *  count(fqdn[, opts=nil])
+  *  create(hostname, ips)
+  *  delete(hostname)
+  *  info(hostname)
+  *  list(fqdn[, opts=nil])
+  *  update(hostname, ips)
+* domain.mailbox
+  *  count(domain[, opts=nil])
+  *  create(domain, login, params)
+  *  delete(domain, login)
+  *  info(domain, login)
+  *  list(domain[, opts=nil])
+  *  purge(domain, login)
+  *  update(domain, login, params)
+* domain.mailbox.alias
+  *  set(domain, login, aliases)
+* domain.mailbox.responder
+  *  activate(domain, login, params)
+  *  deactivate(domain, login[, params=nil])
+* domain.forward
+  *  count(domain[, opts=nil])
+  *  create(domain, source, params
+  *  delete(domain, source)
+  *  list(domain[, opts=nil])
+  *  update(domain, source, params)
+* domain.packmail
+* domain.tld
+  *  list => Gandi::Domain::Tld.list
+  *  region => Gandi::Domain::Tld.region
+* domain.transferin
+  *  proceed(fqdn, params) => Gandi::Domain#transferin(params)
+* domain.nameservers
+  *  set(fqdn, nameservers) => Gandi::Domain#nameservers=(nameservers)
+* operation
+  *   cancel(apikey, operation) => Gandi::Operation#cancel
+  *   count(apikey[, opts=nil]) => Gandi::Operation.count(opts = {})
+  *   info(apikey, operation) => Gandi::Operation#info
+  *   list(apikey[, opts=nil]) => Gandi::Operation.list(opts = {})
+
+For more information on a Ruby class/method see the matching RDoc.
+
+Note that API calls under the hosting and catalog are not currently implemented. 
+No support is planned for thoses API calls (but pull requests are accepted).
+
+= Use in testing
+
+While using the OT&E system is safe as it will not result in any real billing, integration and unit tests for your application should be repeatable and isolated.
+You can use mocking (and/or stubbing) to avoid calling the XML-RPC methods on the Gandi server and cover all the possible cases.
+
+Example using rspec-mocks:
+        connection_mock = double()
+        connection_mock.should_receive(:call).with('version.info').and_return({"api_version"=>"2.0"})
+        Gandi.connection = connection_mock
+        Gandi.call('version.info') # => {"api_version"=>"2.0"}
+
+Be aware that changing the apikey or URL will reset the connection variable (so you will have to set up your mock again).

data/gandirb.gemspec

@@ -9,25 +9,23 @@ Gem::Specification.new do |s|
 
   s.authors = ["Pickabee"]
   s.email = ""
-  s.homepage = "http://github.com/pickabee/gandirb"
+  s.homepage = "http://github.com/pickabee/gandi"
   s.summary = %q{Ruby library for using the Gandi XML-RPC API}
   s.description = <<-EOL
-  This is a ruby library for using the Gandi XML-RPC API.
-  It currently only provides methods for using the domain and mail API, but is extensible enough to add hosting in the future.
+  A Ruby library for using the Gandi XML-RPC API.
+  At the moment support is planned for the Domain, Contact and Operation APIs only, but Hosting and Catalog APIs support may be added in the future.
   EOL
   s.rubyforge_project = "gandirb"
 
   s.date = Date.today.strftime('%Y-%m-%d')
 
-  s.files = Dir["CHANGELOG", "LICENSE", "README.rdoc", "Gemfile", "Rakefile", "gandirb.gemspec", "{lib}/**/*.rb"]
-  s.test_files = Dir["{test}/**/*.rb"]
+  s.files = Dir["CHANGELOG", "LICENSE", "README.rdoc", "USAGE.rdoc", "Gemfile", "Rakefile", "gandirb.gemspec", "{lib}/**/*.rb"]
+  s.test_files = Dir["{spec}/**/*.rb"]
   s.rdoc_options = ["--line-numbers", "--charset=UTF-8", "--title", "Gandirb", "--main", "README.rdoc"]
-  s.extra_rdoc_files = %w[CHANGELOG LICENSE]
+  s.extra_rdoc_files = %w[USAGE.rdoc CHANGELOG LICENSE]
   s.require_paths = ["lib"]
 
-  s.add_dependency 'activesupport', '>= 2.0'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rdoc'
-  s.add_development_dependency 'shoulda', '< 3'
-  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'rspec', '>= 2.8'
 end

data/lib/gandi/connection.rb

@@ -0,0 +1,65 @@
+require 'xmlrpc/client'
+require 'openssl'
+
+module Gandi
+  class Connection
+    SSL_VERIFY_MODE = OpenSSL::SSL::VERIFY_NONE
+    
+    #The 24-character API key used for authentication.
+    attr_reader :apikey
+    
+    #URL used for connecting to the Gandi API.
+    attr_reader :url
+    
+    def initialize(apikey, url)
+      raise DataError, "You must set the apikey before calling any method" unless apikey
+      @apikey = apikey
+      @url = url
+      connect
+    end
+
+    #Calls a RPC method, automatically setting the apikey as the first argument.
+    def call(method, *arguments)
+      raw_call(method.to_s, @apikey, *arguments)
+    end
+    
+    private
+
+    #Handles RPC calls and exceptions.
+    def raw_call(*args)
+      begin
+        @handler.call(*args)
+      rescue StandardError => e
+        case e
+        when XMLRPC::FaultException
+          case e.faultCode.to_s.chars.first
+          when '1'
+            raise Gandi::NoMethodError, e.faultString 
+          when '5'
+            raise Gandi::DataError, e.faultString
+          else
+            raise Gandi::ServerError, e.faultString
+          end
+        else
+          raise e
+        end
+      end
+    end
+    
+    #Instanciates the XMLRPC handler.
+    def connect
+      @handler = XMLRPC::Client.new_from_uri(@url)
+      #Get rid of SSL warnings "peer certificate won't be verified in this SSL session"
+      #See http://developer.amazonwebservices.com/connect/thread.jspa?threadID=37139
+      #and http://blog.chmouel.com/2008/03/21/ruby-xmlrpc-over-a-self-certified-ssl-with-a-warning/
+      #and http://stackoverflow.com/questions/4748633/how-can-i-make-rubys-xmlrpc-client-ignore-ssl-certificate-errors for ruby 1.9 (which does not set @ssl_context before a request)
+      if @handler.instance_variable_get('@http').use_ssl?
+        if @handler.instance_variable_get('@http').instance_variable_get("@ssl_context") #Ruby 1.8.7
+          @handler.instance_variable_get('@http').instance_variable_get("@ssl_context").verify_mode = SSL_VERIFY_MODE
+        else
+          @handler.instance_variable_get('@http').instance_variable_set(:@verify_mode, SSL_VERIFY_MODE) #Ruby 1.9
+        end
+      end
+    end
+  end
+end

data/lib/gandi/connector.rb

@@ -0,0 +1,7 @@
+module Gandi
+  module Connector
+    def call(method, *arguments) #:nodoc:
+      Gandi.call(method, *arguments)
+    end
+  end
+end

data/lib/gandi/contact.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+module Gandi
+  class Contact
+    include Gandi::GandiObjectMethods
+    
+    #Contact types mapping
+    TYPES = {
+      0 => 'person',
+      1 => 'company',
+      2 => 'association',
+      3 => 'organization',
+      4 => 'reseller'
+    }
+    
+    #Security questions mapping
+    SECURITY_QUESTION_NUM_VALUES = {
+      1 => "What is the name of your favorite city?",
+      2 => "What is your mother’s maiden name?",
+      3 => "What is your favorite food?",
+      4 => "What year were you born in?",
+      5 => "What is your cell phone number?",
+      6 => "In what year was your Gandi account created?"
+    }
+    
+    #Settable contact attributes (ie. not the id or handle)
+    WRITABLE_ATTRIBUTES =  :type, :orgname, :given, :family, :streetaddr, :city, :state, :zip, :country, :phone, :fax, :mobile, 
+                              :tva_number, :siren, :marque, :lang, :newsletter, :obfuscated, :whois_obfuscated, :resell, :shippingaddress, 
+                              :extra_parameters
+    
+    #Additional attributes used when creating an account
+    CREATE_PARAMETERS_ATTRIBUTES =  :password, :email, 
+                                    :jo_announce_page, :jo_announce_number, :jo_declaration_date, :jo_publication_date,
+                                    :security_question_num, :security_question_answer
+    
+    #Attributes returned when calling contact.info or creating/updating a contact
+    INFORMATION_ATTRIBUTES = WRITABLE_ATTRIBUTES + [:id]
+    
+    attr_reader :handle
+    
+    #A new instance of Contact.
+    #Takes a Gandi handle and/or a contact hash with string keys.
+    #When providing only a handle the contact info will be fetched from the API.
+    def initialize(handle = nil, contact = nil)
+      @handle = handle
+      @attributes = {}
+      self.attributes=(contact) if (@handle || contact)
+    end
+    
+    #Test if a contact (defined by its handle) can create that domain.
+    #Takes a domain hash.
+    #TODO allow giving a string for the domain and converting it transparently, or a domain object.
+    #FIXME is checking multiple domains at once possible ? (it may be according to the Gandi documentation).
+    #FIXME OT&E seems to fail instead of returning an error hash (Error on object : OBJECT_APPLICATION (CAUSE_UNKNOWN) [Internal Server Error]).
+    def can_associate_domain(domain)
+      return false unless persisted?
+      self.class.call('contact.can_associate_domain', @handle, domain)
+    end
+    
+    #TODO make this method return a boolean
+    alias_method :can_associate_domain?, :can_associate_domain
+    
+    #Give all information on the given contact.
+    #This should not be directly used as initializing the class already fetches the contact info.
+    def info
+      raise DataError, "Cannot get informations for a new contact" unless persisted?
+      self.class.call('contact.info', @handle)
+    end
+    
+    #Check the same way as check and then update.
+    #FIXME What is check ? Typo for create ?
+    def update(contact)
+      raise DataError, "Cannot update a new contact, use Gandi::Contact.create instead" unless persisted?
+      self.attributes = self.class.call('contact.update', @handle, contact)
+    end
+    
+    (WRITABLE_ATTRIBUTES - [:type]).each do |attr|
+      define_method(attr) do
+        @attributes[attr.to_s]
+      end
+      
+      define_method("#{attr}=") do |value|
+        @attributes[attr.to_s] = value
+      end
+    end
+    
+    #Returns the contact unique identifier.
+    def id
+      @attributes['id']
+    end
+    
+    #Returns the contact type string.
+    def type
+      TYPES[@attributes['type']]
+    end
+    
+    #Sets the contact type (provided with a type string or id).
+    def type=(type_string_or_id)
+      @attributes['type'] = TYPES.invert[type_string_or_id] || type_string_or_id
+    end
+    
+    #Sets a contact attribute value.
+    def []=(attribute, value)
+      raise DataError, "Attribute #{attribute} is read-only" unless WRITABLE_ATTRIBUTES.include?(attribute.to_sym)
+      @attributes[attribute.to_s] = value
+    end
+    
+    #Returns a string containing the handle of the contact.
+    def to_s
+      @handle || ''
+    end
+    
+    #Returns true if the contact exists on Gandi databases.
+    def persisted?
+      !!@handle
+    end
+    
+    class << self
+      #Should have a all optional contact dict then look if he is a person or a company and depending on that call create_person or create_company.
+      #Returns a contact object.
+      #TODO filter params.
+      def create(contact)
+        contact = call('contact.create', contact)
+        self.new(contact['handle'], contact)
+      end
+      
+      #Give all information on the contact linked to the apikey currently used.
+      #Returns a hash.
+      def info
+        call('contact.info')
+      end
+      
+      #Test if a contact (full contact description) can be associated to the domains.
+      #Takes a contact hash and a domain hash.
+      #TODO allow giving a string for the domain and converting it transparently, or a domain object.
+      #FIXME is checking multiple domains at once possible ? (it may be according to the Gandi documentation).
+      #FIXME OT&E seems to fail instead of returning an error hash (Error on object : OBJECT_APPLICATION (CAUSE_UNKNOWN) [Internal Server Error]).
+      def can_associate(contact, domain)
+        call('contact.can_associate', contact, domain)
+      end
+      
+      #TODO make this method return a boolean
+      alias_method :can_associate?, :can_associate
+      
+      #List all contacts linked to the connected user (it will only return contacts when the apikey belong to a reseller).
+      #The array of returned contacts are mapped to contact objects, set map_contacts to false to get contact info hashes.
+      def list(opts = {}, map_contacts = true)
+        contacts = call('contact.list', opts)
+        if map_contacts
+          contacts.map! do |contact|
+            self.new(contact['handle'], contact)
+          end
+        end
+        contacts
+      end
+      
+      #Check the same way as check and then update.
+      #Returns a contact object.
+      #TODO filter params.
+      def update(handle, contact)
+        contact = call('contact.update', handle, contact)
+        self.new(contact['handle'], contact)
+      end
+    end
+    
+    private
+    
+    def attributes=(contact = nil)
+      contact_attributes = contact || info
+      @attributes = contact_attributes.reject {|k,v| !INFORMATION_ATTRIBUTES.include?(k.to_sym) }
+      @attributes['handle'] = @handle || contact_attributes['handle']
+      return @attributes
+    end
+  end
+end

data/lib/gandi/domain/contacts.rb

@@ -0,0 +1,21 @@
+module Gandi
+  class Domain
+    module Contacts
+      #Returns an hash of contacts, keys being the type of contact and values Gandi::Contact objects.
+      #TODO make the contact mapping optional.
+      def contacts
+        @attributes['contacts'].inject({}) { |h, contact| h[contact.first] = Gandi::Contact.new(contact.last['handle']); h }
+      end
+      
+      #Change domain’s contact. Uses the API call domain.contacts.set
+      #Returns a Gandi::Operation object.
+      #NOTE: you cannot change the owner or reseller contacts.
+      #FIXME: is it possible to return the operation object and not the contacts hash passed as a param?
+      #TODO accept Gandi::Contact objects as values for the hash.
+      def contacts=(contacts)
+        operation_hash = self.class.call('domain.contacts.set', @fqdn, contacts)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+    end
+  end
+end

data/lib/gandi/domain/forward.rb

@@ -0,0 +1,58 @@
+module Gandi
+  class Domain
+    class Forward
+      include Gandi::GandiObjectMethods
+      
+      attr_reader :domain, :source
+      
+      def initialize(domain, source, attributes = nil)
+        @domain = domain
+        @source = source
+        @attributes = attributes || self.class.call('domain.forward.list', @domain.fqdn, {'source' => @source}).first
+        raise DataError, "Forward does not exist" unless @attributes
+      end
+      
+      #Return the destinations emails for this forward.
+      def destinations
+        @attributes['destinations']
+      end
+      
+      #Delete a forward.
+      #Return true.
+      def delete
+        self.class.call('domain.forward.delete', @domain.fqdn, @source)
+      end
+      
+      #Update a forward.
+      #Return self.
+      def update(params)
+        @attributes = self.class.call('domain.forward.update', @domain.fqdn, @source, params)
+        return self
+      end
+      
+      class << self
+        #Create a new forward.
+        #Return a Forward object.
+        def create(domain, source, params)
+          forward = call('domain.forward.create', domain.fqdn, source, params)
+          self.new(domain, source, forward)
+        end
+        
+        #Count forwards for a domain.
+        #TODO: accept a fqdn string.
+        def count(domain, opts = {})
+          call('domain.forward.count', domain.fqdn, opts)
+        end
+        
+        #List forwards for specified domain.
+        #Return an array of Forward objects.
+        #TODO: accept a fqdn string.
+        def list(domain, opts = {})
+          call('domain.forward.list', domain.fqdn, opts).map do |forward|
+            self.new(domain, forward['source'], forward)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gandi/domain/host.rb

@@ -0,0 +1,63 @@
+module Gandi
+  class Domain
+    class Host
+      include Gandi::GandiObjectMethods
+      
+      #The hostname of the Host
+      attr_reader :hostname
+      
+      def initialize(hostname, attributes = nil)
+        @hostname = hostname
+        @attributes = attributes || info
+      end
+      
+      #Delete a host.
+      #Returns a Gandi::Operation object.
+      def delete
+        operation_hash = self.class.call('domain.host.delete', @hostname)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+      
+      #Display host information for a given domain.
+      def info
+        self.class.call('domain.host.info', @hostname)
+      end
+      
+      #Return the host IP adresses.
+      def ips
+        @attributes['ips']
+      end
+      
+      #Update a host.
+      #Return a Gandi::Operation object.
+      def update(ips)
+        operation_hash = self.class.call('domain.host.update', @hostname, ips)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+      
+      class << self
+        #Create a host.
+        #Returns a Gandi::Operation object.
+        def create(hostname, ips)
+          operation_hash = call('domain.host.create', hostname, ips)
+          Gandi::Operation.new(operation_hash['id'], operation_hash)
+        end
+        
+        #Count the glue records / hosts of a domain.
+        #TODO: accept a Domain object.
+        def count(fqdn, opts = {})
+          call('domain.host.count', fqdn, opts)
+        end
+        
+        #List the glue records / hosts for a given domain.
+        #Return an array of Host objects.
+        #TODO: accept a Domain object.
+        def list(fqdn, opts = {})
+          call('domain.host.list', fqdn, opts).map do |host|
+            self.new(host['name'], host)
+          end
+        end
+      end
+    end
+  end
+end