epp-client 0.0.3 → 1.0.0

data/lib/epp-client/host/update_response.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Host
+    class UpdateResponse < Response
+      
+    end
+  end
+end

data/lib/epp-client/request.rb

@@ -1,96 +1,51 @@
 module EPP
   # An EPP XML Request
   class Request
-    # Create new instance of EPP::Request.
-    #
-    # @overload initialize(command, payload, transaction_id)
-    #   @param [String, #to_s] command EPP Command to call
-    #   @param [XML::Node, XML::Document, String] payload XML Payload to transmit
-    #   @param [String] transaction_id EPP Transaction ID
-    # @overload initialize(command, transaction_id) {|xml| payload }
-    #   @param [String, #to_s] command EPP Command to call
-    #   @param [String] transaction_id EPP Transaction ID
-    #   @yield [xml] block to construct payload
-    #   @yieldparam [XML::Node] xml XML Node of the command
-    #     for the payload to be added into
-    def initialize(command, *args, &block)
-      @command = XML::Node.new(command)
-
-      cmd = XML::Node.new('command')
-      cmd << @command
-      xml.root << cmd
+    include XMLHelpers
 
-      if block_given?
-        tid, _ = args
-        case block.arity
-        when 1
-          block.call(@command)
-        else
-          @command << block.call
-        end
-      else
-        payload, tid = args
-        unless payload.nil?
-          @command << case payload.class
-            when XML::Node
-              payload
-            when XML::Document
-              xml.import(payload.root)
-            else
-              doc = XML::Parser.string(payload.to_s).parse
-              xml.import(doc.root)
-          end
-        end
-      end
-
-      unless command == 'logout'
-        cmd << XML::Node.new('clTRID', tid || 'ABC-12345')
-      end
+    # Create and return a new EPP Request Payload
+    #
+    # @param [EPP::Request]
+    def initialize(request)
+      @request = request
     end
 
-    # Name of the receivers command
-    # @return [String] command name
-    def command
-      @command.name
+    def namespaces
+      @namespaces
     end
 
     # Receiver in XML form
     # @return [XML::Document] XML of the receiver
     def to_xml
-      xml
+      doc      = XML::Document.new('1.0')
+      doc.root = XML::Node.new('epp')
+      root     = doc.root
+
+      epp_ns   = XML::Namespace.new(root, nil, 'urn:ietf:params:xml:ns:epp-1.0')
+      root.namespaces.namespace = epp_ns
+
+      xsi_ns   = XML::Namespace.new(root, 'xsi', 'http://www.w3.org/2001/XMLSchema-instance')
+      xsi_sL   = XML::Attr.new(root, 'schemaLocation', 'urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd')
+      xsi_sL.namespaces.namespace = xsi_ns
+
+      @namespaces = {'epp' => epp_ns, 'xsi' => xsi_ns}
+
+      @request.set_namespaces(@namespaces) if @request.respond_to?(:set_namespaces)
+      root << @request.to_xml
+
+      doc
     end
 
     # Convert the receiver to a string
     #
     # @param [Hash] opts Formatting options, passed to the XML::Document
     def to_s(opts = {})
-      xml.to_s({:indent => false}.merge(opts))
+      to_xml.to_s({:indent => false}.merge(opts))
     end
 
     # @see Object#inspect
-    def inspect
-      xml.inspect
-    end
-
-    private
-      # Request XML Payload
-      # @see prepare_request
-      def xml
-        @xml ||= prepare_request
-      end
-
-      # Prepares the base XML for the request
-      #
-      # @return [XML::Document]
-      def prepare_request
-        xml = XML::Document.new('1.0')
-        xml.root = XML::Node.new('epp')
-        xml.root.namespaces.namespace =
-          XML::Namespace.new(xml.root, nil, 'urn:ietf:params:xml:ns:epp-1.0')
-        XML::Namespace.new(xml.root, 'xsi', 'http://www.w3.org/2001/XMLSchema-instance')
-        xml.root['xsi:schemaLocation'] = "urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd"
-
-        xml
-      end
+    # def inspect
+    #   "#<#{self.class}>"
+    # end
   end
 end

data/lib/epp-client/requests/abstract.rb

@@ -0,0 +1,30 @@
+module EPP
+  module Requests
+    # @note Abstract class, do not instanciate manually
+    class Abstract
+      include XMLHelpers
+      attr_reader :namespaces
+
+      def set_namespaces(namespaces)
+        @namespaces = namespaces
+      end
+
+      def name
+        raise NotImplementedError, "#name must be overriden by subclasses"
+      end
+
+      # Receiver in XML form
+      # @return [XML::Document] XML of the receiver
+      def to_xml
+        epp_node(name, @namespaces || {})
+      end
+
+      # Convert the receiver to a string
+      #
+      # @param [Hash] opts Formatting options, passed to the XML::Document
+      def to_s(opts = {})
+        to_xml.to_s({:indent => false}.merge(opts))
+      end
+    end
+  end
+end

data/lib/epp-client/requests/command.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../abstract', __FILE__)
+
+module EPP
+  module Requests
+    class Command < Abstract
+      def initialize(tid, command, extension = nil)
+        @tid, @command, @extension = tid, command, extension
+      end
+
+      def name
+        'command'
+      end
+
+      def to_xml
+        node = super
+
+        @command.set_namespaces(@namespaces) if @command.respond_to?(:set_namespaces)
+        @extension.set_namespaces(@namespaces) if @extension && @extension.respond_to?(:set_namespaces)
+
+        node << as_xml(@command)
+        node << as_xml(@extension) if @extension
+        node << epp_node('clTRID', @tid, @namespaces)
+
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/requests/extension.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../abstract', __FILE__)
+
+module EPP
+  module Requests
+    class Extension < Abstract
+      def initialize(*extensions)
+        raise ArgumentError, "you must provide at least one extension" if extensions.compact.empty?
+        @extensions = extensions.compact
+      end
+
+      def name
+        'extension'
+      end
+
+      def to_xml
+        node = super
+
+        Array(@extensions).each do |extension|
+          next if extension.nil?
+          extension.set_namespaces(@namespaces) if extension.respond_to?(:set_namespaces)
+          node << as_xml(extension)
+        end
+
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/requests/hello.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../abstract', __FILE__)
+
+module EPP
+  module Requests
+    # An EPP Hello Request
+    class Hello < Abstract
+      def name
+        'hello'
+      end
+    end
+  end
+end

data/lib/epp-client/response.rb

@@ -15,6 +15,10 @@ module EPP
       code == 1000
     end
 
+    def pending?
+      code == 1001
+    end
+
     # Response code
     # @return [Integer] response code
     def code
@@ -27,14 +31,30 @@ module EPP
       @message ||= result.find('e:msg/text()').first.content.strip
     end
 
+    # Descriptive Error Information
+    # @return [XML::Node] error information
+    def error_value
+      @error_value ||= result.find('e:extValue/e:value/node()').first
+    end
+
+    # Error reason
+    # @return [String] error reason
+    def error_reason
+      unless defined?(@error_reason)
+        reason = result.find('e:extValue/e:reason/text()').first
+        @error_reason = reason && reason.content.strip
+      end
+
+      @error_reason
+    end
+
     # Response data
-    # @return [String] response data
+    # @return [XML::Node, Array<XML::Node>] response data
     def data
-      unless @data
-        list = @xml.find('/e:epp/e:response/e:resData/node()').reject{|n| n.empty?}
-        @data = list.size > 1 ? list : list[0]
+      @data ||= begin
+        list = @xml.find('/e:epp/e:response/e:resData/node()').reject { |n| n.empty? }
+        list.size > 1 ? list : list[0]
       end
-      @data
     end
 
     # Response Message Queue
@@ -43,15 +63,32 @@ module EPP
       @msgQ ||= @xml.find('/e:epp/e:response/e:msgQ').first
     end
 
+    # Response extension block
+    # @return [XML::Node, Array<XML::Node>] extension
+    def extension
+      @extension ||= begin
+        list = @xml.find('/e:epp/e:response/e:extension/node()').reject { |n| n.empty? }
+        list.size > 1 ? list : list[0]
+      end
+    end
+
     # @see Object#inspect
     def inspect
       @xml.inspect
     end
 
-    # Returns a the formatted response XML
-    # @return [String] formatted XML response
+    # Returns the XML response document
+    # @return [XML::Document] XML response document
     def to_xml
-      @xml.to_s(:indent => true)
+      @xml
+    end
+
+    # Convert the receiver to a string
+    #
+    # @param [Hash] opts Formatting options, passed to the XML::Document
+    # @return [String] formatted XML response
+    def to_s(opts = {})
+      @xml.to_s({:indent => false}.merge(opts))
     end
 
     private

data/lib/epp-client/response_helper.rb

@@ -0,0 +1,25 @@
+module EPP
+  module ResponseHelper
+    def value_for_xpath(xpath, base = nil, &block)
+      values_for_xpath(xpath, base, &block).first
+    end
+    def values_for_xpath(xpath, base = nil)
+      nodes_for_xpath(xpath, base).map do |node|
+        if block_given?
+          yield node
+        else
+          case node
+          when XML::Node
+            node.content.strip
+          when XML::Attr
+            node.value
+          end
+        end
+      end
+    end
+    def nodes_for_xpath(xpath, base = nil)
+      base ||= @response.data
+      base.find(xpath, namespaces)
+    end
+  end
+end

data/lib/epp-client/server.rb

@@ -1,18 +1,47 @@
 module EPP
   # A server error
-  class ServerError < RuntimeError; end
+  class ServerError < Error; end
+
+  # A connection error
+  class ConnectionError < Error
+    attr_reader :error, :addr, :peeraddr
+    def initialize(message, addr, peeraddr, error)
+      super(message)
+      @error = error
+      @addr = addr
+      @peeraddr = peeraddr
+    end
+  end
 
   # Handles sending and receiving data to EPP servers.
   # Supports new style EPP servers which include length of payloads in transmission.
   class Server
+    # @!attribute DEFAULT_SERVICES
+    # Provided for legacy clients who might be using it.
+    # The constant has been moved into the EPP::Client class which
+    # is the primary client facing API.
+    #
+    # @deprecated please use EPP::Client::DEFAULT_SERVICES
+    # @see EPP::Client::DEFAULT_SERVICES
 
-    # Default Service URNs
-    DEFAULT_SERVICES = %w(urn:ietf:params:xml:ns:domain-1.0
-      urn:ietf:params:xml:ns:contact-1.0 urn:ietf:params:xml:ns:host-1.0)
+    # Handles emitting warnings for deprecated constants.
+    #
+    # @private
+    # @param [Symbol] const_name Name of the missing constant
+    # @see Module.const_missing
+    def self.const_missing(const_name)
+      case const_name
+      when :DEFAULT_SERVICES
+        warn "EPP::Server::DEFAULT_SERVICES has been deprecated, please use EPP::Client::DEFAULT_SERVICES"
+        EPP::Client::DEFAULT_SERVICES
+      else
+        super
+      end
+    end
 
     # Default connection options
     DEFAULTS = { :port => 700, :compatibility => false, :lang => 'en', :version => '1.0',
-      :extensions => [], :services => DEFAULT_SERVICES }
+      :extensions => [], :services => EPP::Client::DEFAULT_SERVICES, :address_family => nil }
 
     # Receive frame header length
     # @private
@@ -28,6 +57,9 @@ module EPP
     # @option options [String] :version EPP protocol version, default '1.0'
     # @option options [Array<String>] :extensions EPP Extension URNs
     # @option options [Array<String>] :services EPP Service URNs
+    # @option options [String] :address_family 'AF_INET' or 'AF_INET6' or either of the
+    #                          appropriate socket constants. Will cause connections to be
+    #                          limited to this address family. Default try all addresses.
     def initialize(tag, passwd, host, options = {})
       @tag, @passwd, @host = tag, passwd, host
       @options = DEFAULTS.merge(options)
@@ -36,7 +68,9 @@ module EPP
     # Sends a Hello Request to the server
     # @return [Boolean] True if greeting was returned
     def hello
-      send_frame(HelloRequest.new.to_s)
+      hello   = EPP::Requests::Hello.new
+      request = EPP::Request.new(hello)
+      send_frame(request)
       return true if recv_frame =~ /<greeting>/
       false
     end
@@ -52,14 +86,31 @@ module EPP
     #   @yieldparam [XML::Node] xml XML Node of the command
     #     for the payload to be added into
     # @return [Response] EPP Response object
-    def request(command, payload = nil, &block)
-      @req = if payload.nil? && block_given?
-        Request.new(command, next_tid, &block)
-      else
-        Request.new(command, payload, next_tid)
-      end
+    # def request(command, payload = nil, extension = nil, &block)
+    #   @req = if payload.nil? && block_given?
+    #     Request.new(command, req_tid, &block)
+    #   else
+    #     Request.new(command, payload, extension, req_tid)
+    #   end
+    #
+    #   @resp = send_recv_frame(@req)
+    # end
+
+    # @note Primarily an internal method, exposed to enable testing
+    # @param [] command
+    # @param [] extension
+    # @return [EPP::Request]
+    # @see request
+    def prepare_request(command, extension = nil)
+      cmd = EPP::Requests::Command.new(req_tid, command, extension)
+      EPP::Request.new(cmd)
+    end
 
-      @resp = send_recv_frame(@req.to_s)
+    def request(command, extension = nil)
+      @req = command.is_a?(EPP::Request) ? command :
+                prepare_request(command, extension)
+
+      @resp = send_recv_frame(@req)
     end
 
     # Return the Request object created by the last call to #request
@@ -74,13 +125,33 @@ module EPP
     def last_response
       @resp
     end
+    # Return the error from the last login or logout request
+    #
+    # @return [ResponseError] last error from login or logout
+    def last_error
+      @error
+    end
+    # Return the options the receiver was initialized with
+    #
+    # @return [Hash] configuration options
+    def options
+      @options
+    end
+    # Return the greeting XML received during the last connection
+    #
+    # @return [String]
+    def greeting
+      @greeting
+    end
 
     # Runs a block while logged into the receiver
     #
     # @yield logged in EPP server session
     # @example typical usage
-    #   with_login do
-    #     # .. do stuff with logged in session ..
+    #   connection do
+    #     with_login do
+    #       # .. do stuff with logged in session ..
+    #     end
     #   end
     def with_login
       login!
@@ -106,57 +177,81 @@ module EPP
     #     end
     #   end
     def connection
-      @conn = TCPSocket.new(@host, @options[:port])
-      @sock = OpenSSL::SSL::SSLSocket.new(@conn)
-      @sock.sync_close
+      @connection_errors = []
+      addrinfo.each do |_,port,_,addr,_,_,_|
+        retried = false
+        begin
+          @conn = TCPSocket.new(addr, port)
+        rescue Errno::EINVAL => e
+          if retried
+            message = e.message.split(" - ")[1]
+            raise Errno::EINVAL, "#{message}: TCPSocket.new(#{addr.inspect}, #{port.inspect})"
+          end
 
-      begin
-        @sock.connect
-        recv_frame  # Perform initial recv
+          retried = true
+          retry
+        end
 
-        yield
-      ensure
-        @sock.close
-        @conn.close
-        conn = sock = nil
+        @sock = OpenSSL::SSL::SSLSocket.new(@conn)
+        @sock.sync_close = true
+
+        begin
+          @sock.connect
+          @greeting = recv_frame  # Perform initial recv
+
+          return yield
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH => e
+          @connection_errors << e
+          next # try the next address in the list
+        rescue OpenSSL::SSL::SSLError => e
+          # Connection error, most likely the IP isn't in the allow list
+          if e.message =~ /returned=5 errno=0/
+            @connection_errors << ConnectionError.new("SSL Connection error, IP may not be permitted to connect to #{@host}",
+               @conn.addr, @conn.peeraddr, e)
+            next
+          else
+            raise e
+          end
+        ensure
+          @sock.close # closes @conn
+          @conn = @sock = nil
+        end
       end
+
+      # Should only get here if we didn't return from the block above
+
+      addrinfo(true) # Update our addrinfo in case the DNS has changed
+      raise @connection_errors.last unless @connection_errors.empty?
+      raise Errno::EHOSTUNREACH, "Failed to connect to host #{@host}"
     end
     private
-      # @return [String] next transaction id
-      def next_tid
-        @tid ||= 0
-        @tid += 1
-        "%s-%06d" % [@tag, @tid]
+      def addrinfo(refresh = false)
+        @addrinfo = nil if refresh
+        @addrinfo ||= resolve_addrinfo
       end
+      def resolve_addrinfo
+        family = case @options[:address_family]
+        when 'AF_INET',  Socket::AF_INET  then Socket::AF_INET
+        when 'AF_INET6', Socket::AF_INET6 then Socket::AF_INET6
+        else nil end
 
-      # @return [Request] Login Request Payload
-      def login_request
-        Request.new('login', next_tid) do |login|
-          login << XML::Node.new('clID', @tag)
-          login << XML::Node.new('pw', @passwd)
-
-          options = XML::Node.new('options')
-          options << XML::Node.new('version', @options[:version])
-          options << XML::Node.new('lang', @options[:lang])
-          login << options
-
-          svcs = XML::Node.new('svcs')
-          @options[:services].each { |uri| svcs << XML::Node.new('objURI', uri) }
-          login << svcs
-
-          unless @options[:extensions].empty?
-            ext = XML::Node.new('svcExtension')
-            @options[:extensions].each do |uri|
-              ext << XML::Node.new('extURI', uri)
-            end
-            svcs << ext
-          end
-        end
+        Socket.getaddrinfo(@host, @options[:port], family, Socket::SOCK_STREAM)
       end
 
-      # @return [Request] Logout Request Payload
-      def logout_request
-        Request.new('logout')
+      # @return [String] next transaction id
+      def req_tid
+        @req_tid ||= 0
+        @req_tid += 1
+        date = Time.now.strftime("%Y%m%d")
+        "%s-%s%06d" % [@tag, date, @req_tid]
+      end
+
+      # @return [String] next auth transaction id
+      def auth_tid
+        @auth_tid ||= 0
+        @auth_tid += 1
+        date = Time.now.strftime("%Y%m%d")
+        "%s-AUTH-%s%06d" % [@tag, date, @auth_tid]
       end
 
       # Perform login
@@ -165,10 +260,14 @@ module EPP
       # @raise [ResponseError] login failed
       # @see login_request
       def login!
-        response = send_recv_frame(login_request.to_s)
+        @error   = nil
+        login    = EPP::Commands::Login.new(@tag, @passwd, @options)
+        command  = EPP::Requests::Command.new(auth_tid, login)
+        request  = EPP::Request.new(command)
+        response = send_recv_frame(request)
 
         return true if response.code == 1000
-        raise ResponseError.new(response.code, response.message, response.to_xml)
+        raise @error = ResponseError.new(response.code, response.message, response.to_xml)
       end
 
       # Perform logout
@@ -177,10 +276,13 @@ module EPP
       # @raise [ResponseError] logout failed
       # @see logout_request
       def logout!
-        response = send_recv_frame(logout_request.to_s)
+        logout   = EPP::Commands::Logout.new
+        command  = EPP::Requests::Command.new(auth_tid, logout)
+        request  = EPP::Request.new(command)
+        response = send_recv_frame(request)
 
         return true if response.code == 1500
-        raise ResponseError.new(response.code, response.message, response.to_xml)
+        raise @error = ResponseError.new(response.code, response.message, response.to_xml)
       end
 
       # Send a frame and receive its response
@@ -195,9 +297,11 @@ module EPP
       end
 
       # Send XML frame
+      # @param [String,Request] xml Payload to send
       # @return [Integer] number of bytes written
       def send_frame(xml)
-        @sock.write([xml.size + 4].pack("N") + xml)
+        xml = xml.to_s if xml.kind_of?(Request)
+        @sock.write([xml.size + HEADER_LEN].pack("N") + xml)
       end
 
       # Receive XML frame
@@ -211,7 +315,7 @@ module EPP
           raise ServerError, "Failed to read header from remote host"
         else
           len = header.unpack('N')[0]
-          
+
           raise ServerError, "Bad frame header from server, should be greater than #{HEADER_LEN}" unless len > HEADER_LEN
           response = @sock.read(len - HEADER_LEN)
         end