kono_epp_client 0.1.1 → 2.0.0

data/lib/epp/epp_command/update_contact.rb

@@ -1,115 +0,0 @@
-class KonoEppUpdateContact < KonoEppCommand
-
-  # TODO: Add and remove fields
-  def initialize( options )
-    super( nil, nil )
-
-    command = root.elements['command']
-
-    update = command.add_element "update"
-
-    contact_update = update.add_element( "contact:update", { "xmlns:contact" => "urn:ietf:params:xml:ns:contact-1.0",
-                                                             "xsi:schemaLocation" => "urn:ietf:params:xml:ns:contact-1.0 contact-1.0.xsd" } )
-
-    id = contact_update.add_element "contact:id"
-    id.text = options[:id]
-
-    contact_chg = contact_update.add_element "contact:chg"
-
-    unless options[:name].blank?              \
-           and options[:organization].blank?  \
-           and options[:address].blank?       \
-           and options[:city].blank?          \
-           and options[:state].blank?         \
-           and options[:postal_code].blank?   \
-           and options[:country].blank?
-
-      postal_info = contact_chg.add_element "contact:postalInfo", { "type" => "loc" }
-
-      unless options[:name].blank?
-        name = postal_info.add_element "contact:name"
-        name.text = options[:name]
-      end
-
-      unless options[:organization].blank?
-        organization = postal_info.add_element "contact:org"
-        organization.text = options[:organization]
-      end
-
-      # NOTE: city and country are REQUIRED
-      unless options[:address].blank?         \
-             and options[:city].blank?        \
-             and options[:state].blank?       \
-             and options[:postal_code].blank? \
-             and options[:country].blank?
-
-        addr = postal_info.add_element "contact:addr"
-
-        unless options[:address].blank?
-          street = addr.add_element "contact:street"
-          street.text = options[:address]
-        end
-
-        city = addr.add_element "contact:city"
-        city.text = options[:city]
-
-        unless options[:state].blank?
-          state = addr.add_element "contact:sp"
-          state.text  = options[:state]
-        end
-
-        unless options[:postal_code].blank?
-          postal_code = addr.add_element "contact:pc"
-          postal_code.text = options[:postal_code]
-        end
-
-        country_code = addr.add_element "contact:cc"
-        country_code.text = options[:country]
-      end
-    end
-
-    if options[:voice]
-      voice = contact_chg.add_element "contact:voice"
-      voice.text = options[:voice]
-    end
-
-    if options[:fax]
-      fax = contact_chg.add_element "contact:fax"
-      fax.text = options[:fax]
-    end
-
-    if options[:email]
-      email = contact_chg.add_element "contact:email"
-      email.text = options[:email]
-    end
-
-
-    unless not options.has_key?( :publish ) \
-           and options[:nationality].blank? \
-           and options[:entity_type].blank? \
-           and options[:reg_code].blank?
-
-      # FIXME
-      extension = command.add_element "extension"
-      extension_update = extension.add_element "extcon:update", { "xmlns:extcon"       => 'http://www.nic.it/ITNIC-EPP/extcon-1.0',
-                                                                  "xsi:schemaLocation" => 'http://www.nic.it/ITNIC-EPP/extcon-1.0 extcon-1.0.xsd' }
-      if options.has_key?( :publish )
-        publish = extension_update.add_element "extcon:consentForPublishing"
-        publish.text = options[:publish]
-      end
-
-      if options[:becomes_registrant]
-        extcon_registrant = extension_update.add_element "extcon:registrant"
-
-        extcon_nationality = extcon_registrant.add_element "extcon:nationalityCode"
-        extcon_nationality.text = options[:nationality]
-
-        extcon_entity = extcon_registrant.add_element "extcon:entityType"
-        extcon_entity.text = options[:entity_type]
-
-        extcon_regcode = extcon_registrant.add_element "extcon:regCode"
-        extcon_regcode.text = options[:reg_code]
-      end
-    end
-  end
-end

data/lib/epp/epp_command/update_domain.rb

@@ -1,104 +0,0 @@
-class KonoEppUpdateDomain < KonoEppCommand
-  def initialize(options)
-    super(nil, nil)
-
-    command = root.elements['command']
-    update = command.add_element("update")
-
-    domain_update = update.add_element("domain:update", {"xmlns:domain" => "urn:ietf:params:xml:ns:domain-1.0",
-                                                         "xsi:schemaLocation" => "urn:ietf:params:xml:ns:domain-1.0 domain-1.0.xsd"})
-
-    name = domain_update.add_element "domain:name"
-    name.text = options[:name]
-
-    if not options[:add_nameservers].blank? or options[:add_admin] or options[:add_tech] or options[:add_status]
-      # <domain:add>
-      domain_add = domain_update.add_element "domain:add"
-
-      unless options[:add_nameservers].blank?
-        domain_add_ns = domain_add.add_element "domain:ns"
-
-        options[:add_nameservers].each do |ns|
-          host_attr = domain_add_ns.add_element "domain:hostAttr"
-          host_name = host_attr.add_element "domain:hostName"
-
-          host_name.text = ns[0]
-
-          # FIXME IPv6
-          if ns[1]
-            host_addr = host_attr.add_element "domain:hostAddr", {"ip" => "v4"}
-            host_addr.text = ns[1]
-          end
-        end
-      end
-
-      if options[:add_admin]
-        domain_contact = domain_add.add_element "domain:contact", {"type" => "admin"}
-        domain_contact.text = options[:add_admin]
-      end
-
-      if options[:add_status]
-        domain_add.add_element "domain:status", {"s" => options[:add_status]}
-      end
-
-      if options[:add_tech]
-        domain_contact = domain_add.add_element "domain:contact", {"type" => "tech"}
-        domain_contact.text = options[:add_tech]
-      end
-    end
-
-    if not options[:remove_nameservers].blank? or options[:remove_admin] or options[:remove_tech] or options[:remove_status]
-      # <domain:rem>
-      domain_remove = domain_update.add_element "domain:rem"
-
-      unless options[:remove_nameservers].blank?
-        domain_remove_ns = domain_remove.add_element "domain:ns"
-
-        options[:remove_nameservers].each do |ns_name|
-          host_attr = domain_remove_ns.add_element "domain:hostAttr"
-          host_name = host_attr.add_element "domain:hostName"
-
-          host_name.text = ns_name
-        end
-      end
-
-      if options[:remove_admin]
-        domain_contact = domain_remove.add_element "domain:contact", {"type" => "admin"}
-        domain_contact.text = options[:remove_admin]
-      end
-
-      if options[:remove_status]
-        domain_remove.add_element "domain:status", {"s" => options[:remove_status]}
-      end
-
-      if options[:remove_tech]
-        domain_contact = domain_remove.add_element "domain:contact", {"type" => "tech"}
-        domain_contact.text = options[:remove_tech]
-      end
-    end
-
-    # <domain:chg>
-    if options[:auth_info]
-      domain_change = domain_update.add_element "domain:chg"
-
-      if options[:registrant]
-        domain_registrant = domain_change.add_element "domain:registrant"
-        domain_registrant.text = options[:registrant]
-      end
-
-      domain_authinfo = domain_change.add_element "domain:authInfo"
-
-      domain_pw = domain_authinfo.add_element "domain:pw"
-      domain_pw.text = options[:auth_info]
-    end
-
-    if options[:restore]
-      command.add_element("extension").tap do |ext|
-        ext.add_element("rgp:update", {"xmlns:rgp"=>"urn:ietf:params:xml:ns:rgp-1.0",
-                        "xsi:schemaLocation"=>"urn:ietf:params:xml:ns:rgp-1.0 rgp-1.0.xsd"}).
-          add_element("rgp:restore", {"op"=> "request"})
-      end
-    end
-    # TODO: Registrant
-  end
-end

data/lib/epp/epp_command.rb

@@ -1,15 +0,0 @@
-include REXML
-
-class KonoEppCommand < REXML::Document
-  def initialize( source = nil, context = nil )
-    super( source, context )
-
-    add( XMLDecl.new( "1.0", "UTF-8", "no" ) )
-
-    epp = add_element( "epp", { "xmlns"              => "urn:ietf:params:xml:ns:epp-1.0",
-                                "xmlns:xsi"          => "http://www.w3.org/2001/XMLSchema-instance",
-                                "xsi:schemaLocation" => "urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd" } )
-
-    epp.add_element( "command" )
-  end
-end

data/lib/epp/exceptions.rb

@@ -1,28 +0,0 @@
-class KonoEppErrorResponse < StandardError #:nodoc:
-  attr_accessor :response_xml, :response_code, :reason_code, :message
-
-  # Generic EPP exception. Accepts a response code and a message
-  def initialize(attributes = {})
-    @response_xml = attributes[:xml]
-    @response_code = attributes[:response_code]
-    @reason_code = attributes[:reason_code]
-    @message = attributes[:message]
-  end
-
-  def to_s
-    "#{@message} (reason: #{@reason_code} code: #{@response_code})"
-  end
-end
-
-class KonoEppAuthenticationPasswordExpired < KonoEppErrorResponse ; end
-class KonoEppLoginNeeded < KonoEppErrorResponse ; end
-
-##
-# Errore NIC:
-# 2304=Object status prohibits operation 9022=Domain has status clientTransferProhibited
-class KonoEppDomainHasStatusCliTransProhibited < KonoEppErrorResponse; end
-
-##
-# Errore NIC:
-# 2304=Object status prohibits operation 9026=Domain has status clientUpdateProhibited
-class KonoEppDomainHasStatusClientUpdateProhibited < KonoEppErrorResponse; end

data/lib/epp/transport/tcp.rb

@@ -1,93 +0,0 @@
-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/require_parameters.rb

@@ -1,14 +0,0 @@
-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_create_domain_spec.rb

@@ -1,37 +0,0 @@
-# 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/server_spec.rb

@@ -1,69 +0,0 @@
-RSpec.describe KonoEppClient::Server do
-
-  let(:params) {
-    {
-      tag: "abc",
-      password: "123123",
-      server: "epp.pubtest.nic.it"
-    }
-  }
-
-  let(:instance) { described_class.new(params) }
-
-  describe "initialization" do
-
-    it "base" do
-      expect(instance).to have_attributes(
-                            **params,
-                            port: 700,
-                            old_server: false,
-                            lang: "en",
-                            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: [],
-                            version: "1.0",
-                            transport: :tcp,
-                            transport_options: {},
-                            timeout: 30,
-                            ssl_version: :TLSv1
-                          )
-    end
-  end
-
-  describe "#open_connection" do
-
-    it "default transport" do
-
-      double = instance_double(KonoEppClient::Transport::TcpTransport)
-
-      expect(KonoEppClient::Transport::TcpTransport).to receive(:new).with(params[:server], 700).and_return(double)
-
-      expect { instance.open_connection }.to change { instance.instance_variable_get(:@connection) }.
-        to(double)
-    end
-
-    context "transport http" do
-
-      let(:params) {
-        super().merge(
-          transport: :http,
-          transport_options: {cookie_file: "file_to_coockies"},
-        )
-      }
-
-      it "use http transport" do
-        double = instance_double(KonoEppClient::Transport::HttpTransport)
-
-        expect(KonoEppClient::Transport::HttpTransport).to receive(:new).with(
-          params[:server],
-          700, ssl_version: :TLSv1, cookie_file: "file_to_coockies").and_return(double)
-
-        expect { instance.open_connection }.to change { instance.instance_variable_get(:@connection) }.
-          to(double)
-
-      end
-
-    end
-
-  end
-
-end