kono_epp_client 0.0.2 → 0.1.0

data/lib/epp/server.rb

@@ -0,0 +1,295 @@
+module KonoEppClient #:nodoc:
+  class Server
+    include REXML
+    include RequiresParameters
+
+    require 'nokogiri'
+
+    attr_accessor :tag, :password, :server, :port, :ssl_version, :old_server, :services, :lang, :extensions, :version, :credit, :timeout
+
+    # ==== Required Attrbiutes
+    #
+    # * <tt>:server</tt> - The EPP server to connect to
+    # * <tt>:tag</tt> - The tag or username used with <tt><login></tt> requests.
+    # * <tt>:password</tt> - The password used with <tt><login></tt> requests.
+    #
+    # ==== Optional Attributes
+    #
+    # * <tt>:port</tt> - The EPP standard port is 700. However, you can choose a different port to use.
+    # * <tt>:clTRID</tt> - The client transaction identifier is an element that EPP specifies MAY be used to uniquely identify the command to the server. You are responsible for maintaining your own transaction identifier space to ensure uniqueness. Defaults to "ABC-12345"
+    # * <tt>:old_server</tt> - Set to true to read and write frames in a way that is compatible with older EPP servers. Default is false.
+    # * <tt>:lang</tt> - Set custom language attribute. Default is 'en'.
+    # * <tt>:services</tt> - Use custom EPP services in the <login> frame. The defaults use the EPP standard domain, contact and host 1.0 services.
+    # * <tt>:extensions</tt> - URLs to custom extensions to standard EPP. Use these to extend the standard EPP (e.g., Nominet uses extensions). Defaults to none.
+    # * <tt>:version</tt> - Set the EPP version. Defaults to "1.0".
+    # * <tt>:transport</tt> - Type of connection (http or tcp). Default to "tcp"
+    # * <tt>:timeout</tt> - Timeou for connections in seconds. Default to "30"
+    # * <tt>:ssl_version</tt> - Version of the ssl protocol versione. Default to TLSv1
+    # * <tt>:ssl_version</tt> - Version of the ssl protocol versione. Default to TLSv1
+    #
+    def initialize(attributes = {})
+      requires!(attributes, :tag, :password, :server)
+
+      @tag          = attributes[:tag]
+      @password     = attributes[:password]
+      @server       = attributes[:server]
+      @port         = attributes[:port]        || 700
+      @old_server   = attributes[:old_server]  || false
+      @lang         = attributes[:lang]        || "en"
+      @services     = attributes[:services]    || ["urn:ietf:params:xml:ns:domain-1.0", "urn:ietf:params:xml:ns:contact-1.0", "urn:ietf:params:xml:ns:host-1.0"]
+      @extensions   = attributes[:extensions]  || []
+      @version      = attributes[:version]     || "1.0"
+      @transport    = attributes[:transport]   || :tcp
+      @timeout      = attributes[:timeout]     || 30
+      @ssl_version  = attributes[:ssl_version] || :TLSv1
+
+      @logged_in  = false
+    end
+
+    def connect_and_hello
+      open_connection
+
+      hello
+    end
+
+    # Closes the connection to the EPP server.
+    def close_connection
+      @connection.close
+    end
+
+    # Sends an XML request to the EPP server, and receives an XML response.
+    # <tt><login></tt> and <tt><logout></tt> requests are also wrapped
+    # around the request, so we can close the socket immediately after
+    # the request is made.
+    def request( xml )
+      # open_connection
+
+      # @logged_in = true if login
+
+      begin
+        @response = send_request( xml )
+      ensure
+        if @logged_in && !old_server
+          @logged_in = false if logout
+        end
+      end
+
+      return @response
+    end
+
+    # Sends a standard login request to the EPP server.
+    def login
+      login = KonoEppLogin.new( tag, password )
+
+      # FIXME: Order matters
+      login.version = version
+      login.lang = lang
+
+      login.services = services
+      login.extensions = extensions
+
+      send_command( login )
+    end
+
+    def change_password( new_password )
+      login = KonoEppLogin.new( tag, password )
+
+      # FIXME: Order matters
+      login.new_password = new_password
+
+      login.version = version
+      login.lang = lang
+
+      login.services = services
+      login.extensions = extensions
+
+      send_command( login )
+    end
+
+    def logged_in?
+      begin
+        poll
+      rescue
+        return false
+      end
+
+      return true
+    end
+
+    # FIXME: Remove command wrappers?
+    def hello
+      send_request( KonoEppHello.new.to_s )
+    end
+
+    def poll( id = nil )
+      poll = KonoEppPoll.new( id ? :ack : :req )
+
+      poll.ack_id = id if id
+
+      send_command( poll )
+    end
+
+    def create_contact( options )
+      contact = KonoEppCreateContact.new options
+      send_command( contact )
+    end
+
+    def check_contacts(ids)
+      send_command( KonoEppCheckContacts.new(ids) )
+    end
+
+    def delete_contact( id )
+      contact = KonoEppDeleteContact.new id
+      send_command( contact )
+    end
+
+    def update_contact( options )
+      contact = KonoEppUpdateContact.new options
+      send_command( contact )
+    end
+
+    def create_domain( options )
+      domain = KonoEppCreateDomain.new options
+      send_command( domain )
+    end
+
+    def check_domains( *domains )
+      send_command( KonoEppCheckDomains.new *domains )
+    end
+
+    def update_domain( options )
+      domain = KonoEppUpdateDomain.new options
+      send_command( domain )
+    end
+
+    def delete_domain( name )
+      domain = KonoEppDeleteDomain.new name
+      send_command( domain )
+    end
+
+    def info_contact( id )
+      contact = KonoEppInfoContact.new id
+      send_command( contact )
+    end
+
+    def info_domain( name )
+      info = KonoEppInfoDomain.new name
+      send_command( info )
+    end
+
+    def transfer_domain(name, authinfo, op, extension: nil)
+      send_command(KonoEppTransferDomain.new( name, authinfo, op, extension: extension))
+    end
+
+    # Sends a standard logout request to the EPP server.
+    def logout
+      send_command( KonoEppLogout.new, 1500 )
+    end
+
+# private
+    # Wrapper which sends XML to the server, and receives
+    # the response in return.
+    def send_request( xml )
+      write( xml )
+      read
+    end
+
+    def send_command( command, expected_result = 1000..1999 )
+      namespaces = { 'extepp' => 'http://www.nic.it/ITNIC-EPP/extepp-2.0',
+                     'xmlns' => "urn:ietf:params:xml:ns:epp-1.0" }
+
+      xml = Nokogiri.XML( send_request( command.to_s ) )
+
+      # TODO: multiple <response> RFC 3730 §2.6
+      result = xml.at_xpath( "/xmlns:epp/xmlns:response[1]/xmlns:result",
+                             namespaces )
+      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if result.nil?
+
+      xmlns_code = result.at_xpath( "@code" )
+      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if xmlns_code.nil?
+
+      response_code = xmlns_code.value.to_i
+
+      xmlns_msg = result.xpath( "xmlns:msg/text ()",
+                                namespaces )
+      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if xmlns_msg.empty?
+
+      result_message = xmlns_msg.text.strip
+
+      # TODO: value
+
+      xmlns_ext_reason = result.xpath( "xmlns:extValue/xmlns:reason",
+                                       namespaces)
+      result_message += ": #{xmlns_ext_reason.text.strip}" unless xmlns_ext_reason.empty?
+
+      xmlns_reason_code = result.xpath( "xmlns:extValue/xmlns:value/extepp:reasonCode",
+                                        namespaces )
+      reason_code = xmlns_reason_code.text.strip.to_i unless xmlns_reason_code.empty?
+
+      credit_msg = xml.xpath( "//extepp:credit/text ()",
+                              namespaces )
+      @credit = credit_msg.text.to_f unless credit_msg.empty?
+
+      if expected_result === response_code
+        return xml
+      end
+
+      args = { :xml           => xml,
+               :response_code => response_code,
+               :reason_code   => reason_code,
+               :message       => result_message }
+
+      case [ response_code, reason_code ]
+        when [2200, 6004]
+          raise KonoEppAuthenticationPasswordExpired.new( args )
+        when [2002, 4015]
+          raise KonoEppLoginNeeded.new( args )
+        when [2304, 9022]
+          raise KonoEppDomainHasStatusCliTransProhibited.new(args)
+        when [2304, 9026]
+          raise KonoEppDomainHasStatusClientUpdateProhibited.new(args)
+        else
+          raise KonoEppErrorResponse.new( args )
+      end
+    end
+
+    # Establishes the connection to the server. If the connection is
+		# established, then this method will call read and return
+		# the EPP <tt><greeting></tt> which is sent by the
+		# server upon connection.
+    def open_connection
+      # FIXME il timeout serve solamente nella versione tcp
+      # FIXME perchè utilizzare un'istanza di classe? non sarebbe meglio avere un metodo che genera il transport
+      #       e successivamente viene utilizzato sempre quello?
+      Timeout.timeout @timeout do
+        case @transport
+        when :tcp
+          @connection = KonoEppClient::Transport::TcpTransport.new(server, port)
+        when :http
+          @connection = KonoEppClient::Transport::HttpTransport.new(server, port,
+                                                                    ssl_version: ssl_version,
+                                                                    cookie_file: "#{@tag.downcase}.cookies.pstore"
+          )
+        end
+      end
+    end
+
+    # Receive an EPP response from the server. Since the connection is blocking,
+    # this method will wait until the connection becomes available for use. If
+    # the connection is broken, a SocketError will be raised. Otherwise,
+    # it will return a string containing the XML from the server.
+    def read
+      Timeout.timeout @timeout do
+        @connection.read
+      end
+    end
+
+    # Send XML to the server. If the socket returns EOF,
+    # the connection has closed and a SocketError is raised.
+    def write( xml )
+      Timeout.timeout @timeout do
+        @connection.write( xml )
+      end
+    end
+  end
+end

data/lib/epp/transport/http.rb

@@ -0,0 +1,71 @@
+require 'net/http'
+
+module KonoEppClient::Transport
+  class HttpTransport
+    include KonoEppClient::Transport
+
+    require 'pstore'
+
+    # @param [String] server
+    # @param [Integer] port
+    # @param [Symbol] ssl_version -> Versione ssl
+    # @param [String] cookie_file -> identifica il nome del file del cookie-store
+    def initialize(server, port, ssl_version: :TLSv1, cookie_file: "cookies.pstore")
+      @net_http = Net::HTTP.new( server, port )
+
+      @net_http.use_ssl = true
+      @net_http.ssl_version = ssl_version
+      @net_http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      #FIXME: Commented because not work on MacOS (dev machine), is necessary for Linux machine?
+      #@net_http.ca_path = '/etc/ssl/certs' 
+
+      # @net_http.set_debug_output $stderr
+       #@net_http.set_debug_output File.open( "/tmp/net.log", "a")
+
+      @store = PStore.new( cookie_file )
+    end
+
+    def read
+      #puts @response.body
+      @response.body
+    end
+
+    def write( xml )
+      @store.transaction do
+        cookie_str = '$Version="1"'
+        @store[:cookies].each do |c|
+          cookie_str += "; #{c[:name]}=#{c[:value]}"
+        end if @store[:cookies]
+
+        header = { "Cookie" => cookie_str }
+
+        @response = @net_http.post( "/", xml, header )
+
+        @store[:cookies] = parse_set_cookie( @response["Set-Cookie"] ) if @response["Set-Cookie"]
+      end
+    end
+
+    def close
+      FileUtils.rm_rf(@store.path)
+    end
+
+  private
+    def parse_set_cookie( string )
+      cookies = []
+
+      string.split( "," ).each do |cookie|
+        tokens = cookie.split ";"
+
+        name, value = tokens[0].split( "=", 2 )
+        # TODO: complete parsing. Maybe encapsulate the cookie as well.
+        cookies << { :name => name, :value => value }
+      end
+
+      return cookies
+    end
+
+    def http_post
+    end
+  end
+end

data/lib/epp/transport/tcp.rb

@@ -0,0 +1,93 @@
+module KonoEppClient::Transport
+  class TcpTransport
+    include KonoEppClient::Transport
+
+    def initialize( server, port )
+      @connection = TCPSocket.new( server, port )
+      @socket     = OpenSSL::SSL::SSLSocket.new( @connection )
+
+      # Synchronously close the connection & socket
+      @socket.sync_close
+
+      # Connect
+      @socket.connect
+
+      # Get the initial frame
+      read
+    end
+
+    def read
+     if old_server
+          data = ""
+          first_char = @socket.read(1)
+
+          if first_char.nil? and @socket.eof?
+            raise SocketError.new("Connection closed by remote server")
+          elsif first_char.nil?
+            raise SocketError.new("Error reading frame from remote server")
+          else
+             data << first_char
+
+             while char = @socket.read(1)
+                data << char
+
+                return data if data =~ %r|<\/epp>\n$|mi # at end
+             end
+          end
+       else
+          header = @socket.read(4)
+
+          if header.nil? and @socket.eof?
+            raise SocketError.new("Connection closed by remote server")
+          elsif header.nil?
+            raise SocketError.new("Error reading frame from remote server")
+          else
+            unpacked_header = header.unpack("N")
+            length = unpacked_header[0]
+
+            if length < 5
+              raise SocketError.new("Got bad frame header length of #{length} bytes from the server")
+            else
+              response = @socket.read(length - 4)
+            end
+          end
+       end
+    end
+
+    def write
+      if defined?( @socket ) and @socket.is_a?( OpenSSL::SSL::SSLSocket )
+        @socket.close
+        @socket = nil
+      end
+
+      if defined?( @connection ) and @connection.is_a?( TCPSocket )
+        @connection.close
+        @connection = nil
+      end
+
+      return true if @connection.nil? and @socket.nil?
+    end
+
+    def close
+      if defined?( @socket ) and @socket.is_a?( OpenSSL::SSL::SSLSocket )
+        @socket.close
+        @socket = nil
+      end
+
+      if defined?( @connection ) and @connection.is_a?( TCPSocket )
+        @connection.close
+        @connection = nil
+      end
+
+      return true if @connection.nil? and @socket.nil?
+    end
+  private
+    # Receive an EPP frame from the server. Since the connection is blocking,
+    # this method will wait until the connection becomes available for use. If
+    # the connection is broken, a SocketError will be raised. Otherwise,
+    # it will return a string containing the XML from the server.
+    def get_frame
+      end
+
+  end
+end

data/lib/epp/transport.rb

@@ -0,0 +1,13 @@
+module KonoEppClient::Transport
+  def read
+    raise NotImplemented.new
+  end
+
+  def write
+    raise NotImplemented.new
+  end
+
+  def close
+    raise NotImplemented.new
+  end
+end

data/lib/kono_epp_client.rb

@@ -4,7 +4,6 @@ require 'openssl'
 require 'socket'
 require 'active_support'
 require 'rexml/document'
-require 'hpricot'
 
 # Package files
 require File.dirname(__FILE__) + '/require_parameters.rb'
@@ -16,19 +15,11 @@ require File.dirname(__FILE__) + '/epp/transport/tcp.rb'
 require File.dirname(__FILE__) + '/epp/transport/http.rb'
 
 require File.dirname(__FILE__) + '/epp/epp_command.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/hello.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/login.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/logout.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/poll.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/create_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/create_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/info_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/info_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/delete_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/delete_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/transfer_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/update_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/update_domain.rb'
+
+# load di tutti i comandi presenti in epp_command
+Dir.glob(File.dirname(__FILE__) + '/epp/epp_command/*.rb').each do |f|
+  require f
+end
 
 module KonoEppClient #:nodoc:
 end

data/lib/require_parameters.rb

@@ -0,0 +1,14 @@
+module RequiresParameters #:nodoc:
+  def requires!(hash, *params)
+    params.each do |param| 
+      if param.is_a?(Array)
+        raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first) 
+
+        valid_options = param[1..-1]
+        raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:connector => 'or')}") unless valid_options.include?(hash[param.first])
+      else
+        raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param) 
+      end
+    end
+  end    
+end

data/spec/epp/epp_command/kono_epp_check_contacts_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+RSpec.describe KonoEppCheckContacts do
+
+  let(:ids){
+    ["mm001",
+     "mb001",
+     "cl001",
+     "bb001"]
+  }
+
+  include_context "like epp command"
+
+  let(:instance) {
+    described_class.new(ids)
+  }
+
+  it "construct", snapshot: 'xml' do
+    expect(rendered.to_s).to have_tag("epp>command>check>check") do
+      ids.each do |t|
+        with_tag("id", text: t)
+      end
+    end
+  end
+
+end

data/spec/epp/epp_command/kono_epp_check_domains_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppCheckDomains do
+  include_context "like epp command"
+
+  let(:instance) do
+    described_class.new("test.it","wow.it")
+  end
+
+  it "construct", snapshot: "xml" do
+    expect(rendered.to_s).to have_tag("epp>command>check>check") do
+        with_tag("name", text: "test.it")
+        with_tag("name", text: "wow.it")
+    end
+  end
+end

data/spec/epp/epp_command/kono_epp_create_domain_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppCreateDomain do
+  include_context "like epp command"
+
+  let(:instance) {
+    KonoEppCreateDomain.new(
+      {name: 'architest.it',
+       period: 1,
+       nameservers:
+         [["ns.test.it", "192.168.100.10"],
+          ["ns2.test.it", "192.168.100.20"],
+          ["ns3.foo.com"]],
+       # contacts
+       registrant: "RRR12",
+       admin: "AAAA12",
+       tech: "TTT12",
+       authinfo: "WWW-test-it"
+      }
+    )
+  }
+
+  it "create", snapshot: "xml" do
+    expect(rendered.to_s).to have_tag("ns")
+    expect(rendered.to_s.downcase).to have_tag("hostattr")
+    expect(rendered.to_s.downcase).to have_tag("ns hostattr" ) do
+      with_tag("hostname",text:"ns2.test.it")
+      with_tag("hostaddr",text:"192.168.100.20",with:{ip:"v4"})
+    end
+    expect(rendered.to_s.downcase).to have_tag("ns hostattr" ) do
+      with_tag("hostname",text:"ns.test.it")
+      with_tag("hostaddr",text:"192.168.100.10",with:{ip:"v4"})
+    end
+    expect(rendered.to_s.downcase).not_to have_tag("ns hostaddr", with: {ip: 'v4'},text:"" )
+  end
+
+end

data/spec/epp/epp_command/kono_epp_transfer_domain_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppTransferDomain do
+
+  include_context "like epp command"
+
+  let(:instance) do
+    described_class.new("test.it", "wee-12-sd", 'request')
+  end
+
+  it "construct", snapshot: 'xml' do
+    expect(rendered.to_s).to have_tag("epp>command>transfer", with: {op: "request"}, count: 1) do
+      with_tag("transfer>name", text: "test.it")
+      with_tag("transfer>authinfo>pw", text: "wee-12-sd")
+    end
+  end
+
+  context "con extension" do
+
+    let(:instance) do
+      described_class.new("test.it", "wee-12-sd", 'request',
+                          extension: {new_registrant: "xx123fd", new_auth_info: "abc-sd934-sd"})
+    end
+
+    it "construct", snapshot: 'xml' do
+      expect(rendered.to_s).to have_tag("epp>command>extension>trade>transfertrade") do
+        with_tag("newregistrant", text: "xx123fd")
+        with_tag("newauthinfo>pw", text: "abc-sd934-sd")
+      end
+    end
+  end
+
+end