epp-client-base 0.11.0

data/lib/epp-client/domain.rb

@@ -0,0 +1,394 @@
+module EPPClient
+  module Domain
+    EPPClient::Poll::PARSERS['domain:panData'] = :domain_pending_action_process
+
+    def domain_check_xml(*domains) # :nodoc:
+      command do |xml|
+	xml.check do
+	  xml.check('xmlns' => EPPClient::SCHEMAS_URL['domain-1.0']) do
+	    domains.each do |dom|
+	      xml.name(dom)
+	    end
+	  end
+	end
+      end
+    end
+
+    # Check the availability of domains
+    #
+    # takes a list of domains as arguments
+    #
+    # returns an array of hashes containing three fields :
+    # [<tt>:name</tt>] The domain name
+    # [<tt>:avail</tt>] Wether the domain is available or not.
+    # [<tt>:reason</tt>] The reason for non availability, if given.
+    def domain_check(*domains)
+      domains.flatten!
+      response = send_request(domain_check_xml(*domains))
+
+      get_result(:xml => response, :callback => :domain_check_process)
+    end
+
+    def domain_check_process(xml) # :nodoc:
+      xml.xpath('epp:resData/domain:chkData/domain:cd', EPPClient::SCHEMAS_URL).map do |dom|
+	ret = {
+	  :name => dom.xpath('domain:name', EPPClient::SCHEMAS_URL).text,
+	  :avail => dom.xpath('domain:name', EPPClient::SCHEMAS_URL).attr('avail').value == '1',
+	}
+	unless (reason = dom.xpath('domain:reason', EPPClient::SCHEMAS_URL).text).empty?
+	  ret[:reason] = reason
+	end
+	ret
+      end
+    end
+
+    def domain_info_xml(args) # :nodoc:
+      command do |xml|
+	xml.info do
+	  xml.info('xmlns' => EPPClient::SCHEMAS_URL['domain-1.0']) do
+	    xml.name(args[:name])
+	    if args.key?(:authInfo)
+	      xml.authInfo do
+		if args.key?(:roid)
+		  xml.pw({:roid => args[:roid]}, args[:authInfo])
+		else
+		  xml.pw(args[:authInfo])
+		end
+	      end
+	    end
+	  end
+	end
+      end
+    end
+
+    # Returns the informations about a domain
+    #
+    # Takes either a unique argument, a string, representing the domain, or a
+    # hash with : <tt>:name</tt> the domain name, and optionnaly
+    # <tt>:authInfo</tt> the authentication information and possibly
+    # <tt>:roid</tt> the contact the authInfo is about.
+    #
+    # Returned is a hash mapping as closely as possible the result expected
+    # from the command as per Section 3.1.2 of RFC 5731 :
+    # [<tt>:name</tt>] The fully qualified name of the domain object.
+    # [<tt>:roid</tt>]
+    #    The Repository Object IDentifier assigned to the domain object when
+    #    the object was created.
+    # [<tt>:status</tt>]
+    #    an optionnal array of elements that contain the current status
+    #    descriptors associated with the domain.
+    # [<tt>:registrant</tt>] one optionnal registrant nic handle.
+    # [<tt>:contacts</tt>]
+    #   an optionnal hash which keys are choosen between +admin+, +billing+ and
+    #   +tech+ and which values are arrays of nic handles for the corresponding
+    #   contact types.
+    # [<tt>:ns</tt>]
+    #   an optional array containing nameservers informations, which can either
+    #   be an array of strings containing the the fully qualified name of a
+    #   host, or an array of hashes containing the following keys :
+    #   [<tt>:hostName</tt>] the fully qualified name of a host.
+    #   [<tt>:hostAddrv4</tt>]
+    #      an optionnal array of ipv4 addresses to be associated with the host.
+    #   [<tt>:hostAddrv6</tt>]
+    #      an optionnal array of ipv6 addresses to be associated with the host.
+    # [<tt>:host</tt>]
+    #    an optionnal array of fully qualified names of the subordinate host
+    #    objects that exist under this superordinate domain object.
+    # [<tt>:clID</tt>] the identifier of the sponsoring client.
+    # [<tt>:crID</tt>]
+    #   an optional identifier of the client that created the domain object.
+    # [<tt>:crDate</tt>] an optional date and time of domain object creation.
+    # [<tt>:exDate</tt>]
+    #   the date and time identifying the end of the domain object's
+    #   registration period.
+    # [<tt>:upID</tt>]
+    #   the identifier of the client that last updated the domain object.
+    # [<tt>:upDate</tt>]
+    #   the date and time of the most recent domain-object modification.
+    # [<tt>:trDate</tt>]
+    #   the date and time of the most recent successful domain-object transfer.
+    # [<tt>:authInfo</tt>]
+    #   authorization information associated with the domain object.
+    def domain_info(args)
+      if String === args
+	args = {:name => args}
+      end
+      response = send_request(domain_info_xml(args))
+
+      get_result(:xml => response, :callback => :domain_info_process)
+    end
+
+    def domain_info_process(xml) # :nodoc:
+      dom = xml.xpath('epp:resData/domain:infData', EPPClient::SCHEMAS_URL)
+      ret = {
+	:name => dom.xpath('domain:name', EPPClient::SCHEMAS_URL).text,
+	:roid => dom.xpath('domain:roid', EPPClient::SCHEMAS_URL).text,
+      }
+      if (status = dom.xpath('domain:status', EPPClient::SCHEMAS_URL)).size > 0
+	ret[:status] = status.map {|s| s.attr('s')}
+      end
+      if (registrant = dom.xpath('domain:registrant', EPPClient::SCHEMAS_URL)).size > 0
+	ret[:registrant] = registrant.text
+      end
+      if (contact = dom.xpath('domain:contact', EPPClient::SCHEMAS_URL)).size > 0
+	ret[:contacts] = contact.inject({}) do |a,c|
+	  s = c.attr('type').to_sym
+	  a[s] ||= []
+	  a[s] << c.text
+	  a
+	end
+      end
+      if (ns = dom.xpath('domain:ns', EPPClient::SCHEMAS_URL)).size > 0
+	if (hostObj = ns.xpath('domain:hostObj', EPPClient::SCHEMAS_URL)).size > 0
+	  ret[:ns] = hostObj.map {|h| h.text}
+	elsif (hostAttr = ns.xpath('domain:hostAttr', EPPClient::SCHEMAS_URL)).size > 0
+	  ret[:ns] = hostAttr.map do |h|
+	    r = { :hostName => h.xpath('domain:hostName', EPPClient::SCHEMAS_URL).text }
+	    if (v4 = h.xpath('domain:hostAddr[@ip="v4"]', EPPClient::SCHEMAS_URL)).size > 0
+	      r[:hostAddrv4] = v4.map {|v| v.text}
+	    end
+	    if (v6 = h.xpath('domain:hostAddr[@ip="v6"]', EPPClient::SCHEMAS_URL)).size > 0
+	      r[:hostAddrv6] = v6.map {|v| v.text}
+	    end
+	    r
+	  end
+	end
+      end
+      if (host = dom.xpath('domain:host', EPPClient::SCHEMAS_URL)).size > 0
+	ret[:host] = host.map {|h| h.text}
+      end
+      %w(clID upID).each do |val|
+	if (r = dom.xpath("domain:#{val}", EPPClient::SCHEMAS_URL)).size > 0
+	  ret[val.to_sym] = r.text
+	end
+      end
+      %w(crDate exDate upDate trDate).each do |val|
+	if (r = dom.xpath("domain:#{val}", EPPClient::SCHEMAS_URL)).size > 0
+	  ret[val.to_sym] = DateTime.parse(r.text)
+	end
+      end
+      if (authInfo = dom.xpath('domain:authInfo', EPPClient::SCHEMAS_URL)).size > 0
+	ret[:authInfo] = authInfo.xpath('domain:pw', EPPClient::SCHEMAS_URL).text
+      end
+      return ret
+    end
+
+    def domain_nss_xml(xml, nss)
+      xml.ns do
+	if nss.first.is_a?(Hash)
+	  nss.each do |ns|
+	    xml.hostAttr do
+	      xml.hostName ns[:hostName]
+	      if ns.key?(:hostAddrv4)
+		ns[:hostAddrv4].each do |v4|
+		  xml.hostAddr({:ip => :v4}, v4)
+		end
+	      end
+	      if ns.key?(:hostAddrv6)
+		ns[:hostAddrv6].each do |v6|
+		  xml.hostAddr({:ip => :v6}, v6)
+		end
+	      end
+	    end
+	  end
+	else
+	  nss.each do |ns|
+	    xml.hostObj ns
+	  end
+	end
+      end
+    end
+
+    def domain_contacts_xml(xml, args)
+      args.each do |type,contacts|
+	contacts.each do |c|
+	  xml.contact({:type => type}, c)
+	end
+      end
+    end
+
+    def domain_create_xml(args) #:nodoc:
+      command do |xml|
+	xml.create do
+	  xml.create('xmlns' => EPPClient::SCHEMAS_URL['domain-1.0']) do
+	    xml.name args[:name]
+
+	    if args.key?(:period)
+	      xml.period({:unit => args[:period][:unit]}, args[:period][:number])
+	    end
+
+	    if args.key?(:ns)
+	      domain_nss_xml(xml, args[:ns])
+	    end
+
+	    xml.registrant args[:registrant] if args.key?(:registrant)
+
+	    if args.key?(:contacts)
+	      domain_contacts_xml(xml, args[:contacts])
+	    end
+
+	    xml.authInfo do
+	      xml.pw args[:authInfo]
+	    end
+	  end
+	end
+      end
+    end
+
+    # Creates a domain
+    #
+    # Takes a hash as an argument, containing the following keys :
+    #
+    # [<tt>:name</tt>] the domain name
+    # [<tt>:period</tt>]
+    #   an optionnal hash containing the period for withch the domain is
+    #   registered with the following keys :
+    #   [<tt>:unit</tt>] the unit of time, either "m"onth or "y"ear.
+    #   [<tt>:number</tt>] the number of unit of time.
+    # [<tt>:ns</tt>]
+    #   an optional array containing nameservers informations, which can either
+    #   be an array of strings containing the nameserver's hostname, or an
+    #   array of hashes containing the following keys :
+    #   [<tt>:hostName</tt>] the hostname of the nameserver.
+    #   [<tt>:hostAddrv4</tt>] an optionnal array of ipv4 addresses.
+    #   [<tt>:hostAddrv6</tt>] an optionnal array of ipv6 addresses.
+    # [<tt>:registrant</tt>] an optionnal registrant nic handle.
+    # [<tt>:contacts</tt>]
+    #   an optionnal hash which keys are choosen between +admin+, +billing+ and
+    #   +tech+ and which values are arrays of nic handles for the corresponding
+    #   contact types.
+    # [<tt>:authInfo</tt>] the password associated with the domain.
+    #
+    # Returns a hash with the following keys :
+    #
+    # [<tt>:name</tt>] the fully qualified name of the domain object.
+    # [<tt>:crDate</tt>] the date and time of domain object creation.
+    # [<tt>:exDate</tt>]
+    #   the date and time identifying the end of the domain object's
+    #   registration period.
+    def domain_create(args)
+      response = send_request(domain_create_xml(args))
+
+      get_result(:xml => response, :callback => :domain_create_process)
+    end
+
+    def domain_create_process(xml) #:nodoc:
+      dom = xml.xpath('epp:resData/domain:creData', EPPClient::SCHEMAS_URL)
+      ret = {
+	:name => dom.xpath('domain:name', EPPClient::SCHEMAS_URL).text,
+	:crDate => DateTime.parse(dom.xpath('domain:crDate', EPPClient::SCHEMAS_URL).text),
+	:upDate => DateTime.parse(dom.xpath('domain:crDate', EPPClient::SCHEMAS_URL).text),
+      }
+    end
+
+    def domain_delete_xml(domain) #:nodoc:
+      command do |xml|
+	xml.delete do
+	  xml.delete('xmlns' => EPPClient::SCHEMAS_URL['domain-1.0']) do
+	    xml.name domain
+	  end
+	end
+      end
+    end
+
+    # Deletes a domain
+    #
+    # Takes a single fully qualified domain name for argument.
+    #
+    # Returns true on success, or raises an exception.
+    def domain_delete(domain)
+      response = send_request(domain_delete_xml(domain))
+
+      get_result(response)
+    end
+
+    def domain_update_xml(args) #:nodoc:
+      command do |xml|
+	xml.update do
+	  xml.update('xmlns' => EPPClient::SCHEMAS_URL['domain-1.0']) do
+	    xml.name args[:name]
+	    [:add, :rem].each do |ar|
+	      if args.key?(ar) && (args[ar].key?(:ns) || args[ar].key?(:contacts) || args[ar].key?(:status))
+		xml.__send__(ar) do
+		  if args[ar].key?(:ns)
+		    domain_nss_xml(xml, args[ar][:ns])
+		  end
+		  if args[ar].key?(:contacts)
+		    domain_contacts_xml(xml, args[ar][:contacts])
+		  end
+		  if args[ar].key?(:status)
+		    args[ar][:status].each do |st,text|
+		      if text.nil?
+			xml.status(:s => st)
+		      else
+			xml.status({:s => st}, text)
+		      end
+		    end
+		  end
+		end
+	      end
+	    end
+	    if args.key?(:chg) && (args[:chg].key?(:registrant) || args[:chg].key?(:authInfo))
+	      xml.chg do
+		if args[:chg].key?(:registrant)
+		  xml.registrant args[:chg][:registrant]
+		end
+		if args[:chg].key?(:authInfo)
+		  xml.authInfo do
+		    xml.pw args[:chg][:authInfo]
+		  end
+		end
+	      end
+	    end
+	  end
+	end
+      end
+    end
+
+    # Updates a domain
+    #
+    # Takes a hash with the name, and at least one of the following keys :
+    # [<tt>:name</tt>]
+    #   the fully qualified name of the domain object to be updated.
+    # [<tt>:add</tt>/<tt>:rem</tt>]
+    #   adds / removes the following data to/from the domain object :
+    #   [<tt>:ns</tt>]
+    #     an optional array containing nameservers informations, which can either
+    #     be an array of strings containing the nameserver's hostname, or an
+    #     array of hashes containing the following keys :
+    #     [<tt>:hostName</tt>] the hostname of the nameserver.
+    #     [<tt>:hostAddrv4</tt>] an optionnal array of ipv4 addresses.
+    #     [<tt>:hostAddrv6</tt>] an optionnal array of ipv6 addresses.
+    #   [<tt>:contacts</tt>]
+    #     an optionnal hash which keys are choosen between +admin+, +billing+ and
+    #     +tech+ and which values are arrays of nic handles for the corresponding
+    #     contact types.
+    #   [<tt>:status</tt>]
+    #     an optional hash with status values to be applied to or removed from
+    #     the object. When specifying a value to be removed, only the attribute
+    #     value is significant; element text is not required to match a value
+    #     for removal.
+    # [<tt>:chg</tt>]
+    #   changes the following in the domain object.
+    #   [<tt>:registrant</tt>] an optionnal registrant nic handle.
+    #   [<tt>:authInfo</tt>] an optional password associated with the domain.
+    #
+    # Returns true on success, or raises an exception.
+    def domain_update(args)
+      response = send_request(domain_update_xml(args))
+
+      get_result(response)
+    end
+
+
+    def domain_pending_action_process(xml) #:nodoc:
+      dom = xml.xpath('epp:resData/domain:panData', EPPClient::SCHEMAS_URL)
+      ret = {
+	:name => dom.xpath('domain:name', EPPClient::SCHEMAS_URL).text,
+	:paResult => dom.xpath('domain:name', EPPClient::SCHEMAS_URL).attribute('paResult').value,
+	:paTRID => get_trid(dom.xpath('domain:paTRID', EPPClient::SCHEMAS_URL)),
+	:paDate => DateTime.parse(dom.xpath('domain:paDate', EPPClient::SCHEMAS_URL).text),
+      }
+    end
+  end
+end

data/lib/epp-client/exceptions.rb

@@ -0,0 +1,21 @@
+module EPPClient
+  class EPPErrorResponse < StandardError
+    attr_accessor :response_xml, :response_code, :message
+
+    # An exception with an added field so that it can store the xml response
+    # that generated it.
+    def initialize(attrs = {})
+      @response_xml = attrs[:xml]
+      @response_code = attrs[:code]
+      @message = attrs[:message]
+    end
+
+    def to_s #:nodoc:
+      "#{@message} (code #{@response_code})"
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}: code: #{@response_code}, message: #{@message.inspect}, xml: #{@response_xml}>"
+    end
+  end
+end

data/lib/epp-client/poll.rb

@@ -0,0 +1,69 @@
+module EPPClient
+  module Poll
+    def poll_req_xml #:nodoc:
+      command do |xml|
+	xml.poll(:op => :req)
+      end
+    end
+
+    # sends a <tt><epp:poll op="req"></tt> command to the server.
+    #
+    # if there is a message in the queue, returns a hash with the following keys :
+    # [<tt>:qDate</tt>] the date and time that the message was enqueued.
+    # [<tt>:msg</tt>, <tt>:msg_xml</tt>]
+    #   a human readble message, the <tt>:msg</tt> version has all the possible
+    #   xml stripped, whereas the <tt>:msg_xml</tt> contains the original
+    #   message.
+    # [<tt>:obj</tt>, <tt>:obj_xml</tt>]
+    #   contains a possible <tt><epp:resData></tt> object, the original one in
+    #   <tt>:obj_xml</tt>, and if a parser is available, the parsed one in
+    #   <tt>:obj</tt>.
+    def poll_req
+      response = send_request(poll_req_xml)
+
+      get_result(:xml => response, :callback => :poll_req_process)
+    end
+
+    PARSERS = {}
+
+    def poll_req_process(xml) #:nodoc:
+      ret = {}
+      if (date = xml.xpath("epp:msgQ/epp:qDate", EPPClient::SCHEMAS_URL)).size > 0
+	ret[:qDate] = DateTime.parse(date.text)
+      end
+      if (msg = xml.xpath("epp:msgQ/epp:msg", EPPClient::SCHEMAS_URL)).size > 0
+	ret[:msg] = msg.text
+	ret[:msg_xml] = msg.to_s
+      end
+      if (obj = xml.xpath('epp:resData', EPPClient::SCHEMAS_URL)).size > 0
+	ret[:obj_xml] = obj.to_s 
+	PARSERS.each do |xpath,parser|
+	  if obj.xpath(xpath, EPPClient::SCHEMAS_URL).size > 0
+	    ret[:obj] = case parser
+			when Symbol
+			  send(parser, xml)
+			else
+			  raise NotImplementedError
+			end
+	  end
+	end
+      end
+      ret
+    end
+
+    def poll_ack_xml(mid) #:nodoc:
+      command do |xml|
+	xml.poll(:op => :ack, :msgID => mid)
+      end
+    end
+
+    # sends a <tt><epp:poll op="ack" msgID="<mid>"></tt> command to the server.
+    # Most of the time, you should not pass any argument, as it will "do the
+    # right thing".
+    def poll_ack(mid = @msgQ_id)
+      response = send_request(poll_ack_xml(mid))
+
+      get_result(response)
+    end
+  end
+end

data/lib/epp-client/session.rb

@@ -0,0 +1,56 @@
+module EPPClient
+  module Session
+
+    # Sends an hello epp command.
+    def hello
+      send_request(command do |xml|
+	xml.hello
+      end)
+    end
+
+    def login_xml(new_pw = nil) #:nodoc:
+      command do |xml|
+	xml.login do
+	  xml.clID(@client_id)
+	  xml.pw(@password)
+	  xml.newPW(new_pw) unless new_pw.nil?
+	  xml.options do
+	    xml.version(@version)
+	    xml.lang(@lang)
+	  end
+	  xml.svcs do
+	    services.each do |s|
+	      xml.objURI(s)
+	    end
+	    unless extensions.empty?
+	      xml.svcExtension do
+		extensions.each do |e|
+		  xml.extURI(e)
+		end
+	      end
+	    end
+	  end
+	end
+      end
+    end
+    private :login_xml
+
+    # Perform the login command on the server. Takes an optionnal argument, the
+    # new password for the account.
+    def login(new_pw = nil)
+      response = send_request(login_xml(new_pw))
+
+      get_result(response)
+    end
+
+    # Performs the logout command, after it, the server terminates the
+    # connection.
+    def logout
+      response = send_request(command do |xml|
+	xml.logout
+      end)
+
+      get_result(response)
+    end
+  end
+end

data/lib/epp-client/ssl.rb

@@ -0,0 +1,46 @@
+module EPPClient
+  module SSL
+    def self.included(base) # :nodoc:
+      base.class_eval do
+	alias_method :open_connection_without_ssl, :open_connection
+	alias_method :open_connection, :open_connection_with_ssl
+      end
+    end
+
+    attr_reader :ssl_cert, :ssl_key
+
+    def ssl_key=(key) #:nodoc:
+      case key
+      when OpenSSL::PKey::RSA
+	@ssl_key = key
+      when String
+	unless key =~ /-----BEGIN RSA PRIVATE KEY-----/
+	  key = File.read(key)
+	end
+	@ssl_key = OpenSSL::PKey::RSA.new(key)
+      else
+	raise ArgumentError, "Must either be an OpenSSL::PKey::RSA object, a filename or a key"
+      end
+    end
+
+    def ssl_cert=(cert) #:nodoc:
+      case cert
+      when OpenSSL::X509::Certificate
+	@ssl_cert = cert
+      when String
+	unless cert =~ /-----BEGIN CERTIFICATE-----/
+	  cert = File.read(cert)
+	end
+	@ssl_cert = OpenSSL::X509::Certificate.new(cert)
+      else
+	raise ArgumentError, "Must either be an OpenSSL::X509::Certificate object, a filename or a certificate"
+      end
+    end
+
+    def open_connection_with_ssl # :nodoc:
+      @context.cert ||= ssl_cert if ssl_cert.is_a?(OpenSSL::X509::Certificate)
+      @context.key ||= ssl_key if ssl_key.is_a?(OpenSSL::PKey::RSA)
+      open_connection_without_ssl
+    end
+  end
+end

data/lib/epp-client/version.rb

@@ -0,0 +1,3 @@
+module EPPClient
+  VERSION = "0.11.0"
+end