epp-client-hostmaster 0.2.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+.DS_Store
+dev

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in epp-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Yuriy Kolodovskyy
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# Hostmaster.UA EPP client library
+
+EPP (Extensible Provisioning Protocol) client library based on [epp-client-base](https://rubygems.org/gems/epp-client-base) gem.
+Full specification see at [Hostmaster.UA EPP Project](https://epp.hostmaster.ua).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'epp-client-hostmaster'
+
+or this line:
+
+    gem 'epp-client-hostmaster', git: 'https://github.com/kolodovskyy/epp-client-hostmaster.git'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install epp-client-hostmaster
+
+## Usage (example)
+
+    require "epp-client/hostmaster"
+
+    #ENV['EPP_CLIENT_DEBUG'] = 'yes'
+
+    c = EPPClient::Hostmaster.new(
+      client_id: 'LOGIN',
+      password: 'PASSWORD',
+      ssl_cert: 'epp.crt',
+      ssl_key: 'epp.key'
+    )
+
+    begin
+      c.open_connection
+      c.login
+      c.hello
+
+      c.contact_check 'test1', 'test2'
+      puts c.contact_info 'test1'
+
+      c.contact_create(
+        id: 'test2',
+        postalInfo: {
+          loc: {
+            name: 'Test name',
+            org: 'Test organization',
+            addr: {
+              street: [ 'Test street' ],
+              city: 'Kiev',
+              pc: '00000',
+              cc: 'UA'
+            }
+          }
+        },
+        voice: '+380.441234567',
+        fax: '+380.441234567',
+        email: 'test@test.com',
+        authInfo: 'testpassword'
+      )
+
+      c.contact_update(
+        id: 'test',
+        chg: {
+          fax: '+380.447654321'
+        }
+      )
+
+      c.contact_delete 'test2'
+
+      c.host_check 'ns1.test.epp.ua', 'ns2.test.epp.ua'
+      c.host_info 'ns1.test.epp.ua'
+      c.host_create name: 'ns2.test.epp.ua', addrv4: [ '8.8.8.8' ]
+      c.host_update(
+        name: 'ns2.test.epp.ua',
+        rem: {
+          addrv4: '8.8.8.8'
+        },
+        add: {
+          addrv4: '8.8.8.8'
+        }
+      )
+      c.host_delete 'ns2.test.epp.ua'
+
+      puts c.domain_check 'test1.epp.ua', 'test2.epp.ua'
+      puts c.domain_info 'test1.epp.ua'
+      c.domain_create(
+        name: 'test3.epp.ua',
+        period: {
+          unit: 'y',
+          number: '1'
+        },
+        ns: [ 'ns1.test.epp.ua' ],
+        registrant: 'test',
+        contacts: {
+          admin: [ 'test' ],
+          tech: [ 'test' ]
+        }
+      )
+
+      puts c.domain_renew(
+        name: 'test.epp.ua',
+        curExpDate: '2013-11-19',
+        period: {
+          unit: 'y',
+          number: '1'
+        }
+      )
+
+      c.domain_delete('test.epp.ua')
+      c.domain_restore('test.epp.ua')
+
+      c.domain_update(
+        name: 'test.epp.ua',
+        chg: {
+          registrant: 'test1'
+        }
+      )
+
+      puts c.poll_req
+      puts c.poll_ack
+
+      puts c.transfer_request name: 'test-transfer.epp.ua', authInfo: '111'
+      puts c.transfer_cancel 'test-transfer.epp.ua'
+      puts c.transfer_query 'test-transfer.epp.ua'
+
+      c.logout
+    rescue => error
+      puts error.to_s
+      puts error.backtrace
+    ensure
+      c.close_connection
+    end
+
+## Maintainers and Authors
+
+Yuriy Kolodovskyy (https://github.com/kolodovskyy)
+
+## License
+
+MIT License. Copyright 2012 [Yuriy Kolodovskyy](http://twitter.com/kolodovskyy)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/epp-client-hostmaster.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'epp-client'
+
+Gem::Specification.new do |gem|
+  gem.name          = "epp-client-hostmaster"
+  gem.version       = EPPClient::Hostmaster::VERSION
+  gem.authors       = ["Yuriy Kolodovskyy"]
+  gem.email         = %w{kolodovskyy@ukrindex.com}
+  gem.description   = %q{Hostmaster.UA EPP client library}
+  gem.summary       = %q{Hostmaster.UA EPP client library}
+  gem.homepage      = "https://github.com/kolodovskyy/epp-client-hostmaster"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = %w{lib}
+
+  gem.add_development_dependency "bundler"
+  gem.add_dependency('epp-client-base', '~> 0.11.0')
+  gem.add_dependency('builder', '~> 3.1.4')
+end

data/lib/epp-client/hostmaster-connection.rb

@@ -0,0 +1,9 @@
+module EPPClient
+  module HostmasterConnection
+    def send_frame(xml)
+      @sent_frame = xml
+      @socket.write([xml.bytesize + 4].pack("N") + xml)
+      sent_frame_to_xml
+    end
+  end
+end

data/lib/epp-client/hostmaster-contact.rb

@@ -0,0 +1,149 @@
+module EPPClient
+  module HostmasterContact
+    def contact_check_xml(*contacts)
+      command do |xml|
+        xml.check do
+          xml.contact :check, 'xmlns:contact' => EPPClient::SCHEMAS_URL['contact-1.1'] do
+            contacts.each { |c| xml.contact :id, c }
+          end
+        end
+      end
+    end
+
+    def contact_info_xml(args)
+      command do |xml|
+        xml.info do
+          xml.contact :info, 'xmlns:contact' => EPPClient::SCHEMAS_URL['contact-1.1'] do
+            xml.contact :id, args[:id]
+            if args.key? :authInfo
+              xml.contact :authInfo do
+                xml.contact :pw, args[:authInfo]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def contact_create_xml(contact)
+      command do |xml|
+        xml.create do
+          xml.contact :create, 'xmlns:contact' => EPPClient::SCHEMAS_URL['contact-1.1'] do
+            if contact.key?(:id)
+              xml.contact :id, contact[:id]
+            else
+              xml.contact :id, 'autonic'
+            end
+            contact[:postalInfo].each do |type,infos|
+              xml.contact :postalInfo, type: type do
+                xml.contact :name, infos[:name]
+                xml.contact :org, infos[:org] if infos.key?(:org)
+                xml.contact :addr do
+                  infos[:addr][:street].each do |street|
+                    xml.contact :street, street
+                  end
+                  xml.contact :city, infos[:addr][:city]
+                  xml.contact :sp, infos[:addr][:sp] if infos[:addr].key? :sp
+                  xml.contact :pc, infos[:addr][:pc] if infos[:addr].key? :pc
+                  xml.contact :cc, infos[:addr][:cc]
+                end
+              end
+            end
+            xml.contact :voice, contact[:voice] if contact.key? :voice
+            xml.contact :fax, contact[:fax] if contact.key? :fax
+            xml.contact :email, contact[:email]
+            xml.contact :authInfo do
+              xml.contact :pw, contact[:authInfo]
+            end
+            if contact.key?(:disclose)
+              xml.contact :disclose, flag: '1' do # TODO: parameter for flag need
+                contact[:disclose].each do |disc|
+                  if disc.key?(:type)
+                    xml.contact disc[:name], type: disc[:type]
+                  else
+                    xml.contact disc[:name]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def contact_delete_xml(contact)
+      command do |xml|
+        xml.delete do
+          xml.contact :delete, 'xmlns:contact' => EPPClient::SCHEMAS_URL['contact-1.1'] do
+            xml.contact :id, contact
+          end
+        end
+      end
+    end
+
+    def contact_update_xml(args)
+      command do |xml|
+        xml.update do
+          xml.contact :update, 'xmlns:contact' => EPPClient::SCHEMAS_URL['contact-1.1'] do
+            xml.contact :id, args[:id]
+            if args.key?(:add) && args[:add].key?(:status)
+              xml.contact :add do
+                args[:add][:status].each do |s|
+                  xml.contact :status, s: s
+                end
+              end
+            end
+            if args.key?(:rem) && args[:rem].key?(:status)
+              xml.contact :rem do
+                args[:rem][:status].each do |s|
+                  xml.contact :status, s: s
+                end
+              end
+            end
+            if args.key?(:chg)
+              contact = args[:chg]
+              xml.contact :chg do
+                if contact.key?(:postalInfo)
+                  contact[:postalInfo].each do |type,infos|
+                    xml.contact :postalInfo, type: type do
+                      xml.contact :name, infos[:name]
+                      xml.contact :org, infos[:org] if infos.key? :org
+                      xml.contact :addr do
+                        infos[:addr][:street].each do |street|
+                          xml.contact :street, street
+                        end
+                        xml.contact :city, infos[:addr][:city]
+                        xml.contact :sp, infos[:addr][:sp] if infos[:addr].key? :sp
+                        xml.contact :pc, infos[:addr][:pc] if infos[:addr].key? :pc
+                        xml.contact :cc, infos[:addr][:cc]
+                      end
+                    end
+                  end
+                end
+                [:voice, :fax, :email].each do |val|
+                  xml.contact val, contact[val] if contact.key? val
+                end
+                if contact.key?(:authInfo)
+                  xml.contact :authInfo do
+                    xml.contact :pw, contact[:authInfo]
+                  end
+                end
+                if contact.key?(:disclose)
+                  xml.contact :disclose, flag: '1' do # TODO: parameter for flag need
+                    contact[:disclose].each do |disc|
+                      if disc.key?(:type)
+                        xml.contact disc[:name], type: disc[:type]
+                      else
+                        xml.contact disc[:name]
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/epp-client/hostmaster-domain.rb

@@ -0,0 +1,183 @@
+module EPPClient
+  module HostmasterDomain
+    def domain_check_xml(*domains) # :nodoc:
+      command do |xml|
+        xml.check do
+          xml.domain :check, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            domains.each {|domain| xml.domain :name, domain}
+          end
+        end
+      end
+    end
+
+    def domain_info_xml(args)
+      command do |xml|
+        xml.info do
+          xml.domain :info, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, args[:name]
+            if args.key? :authInfo
+              xml.domain :authInfo do
+                xml.domain :pw, args[:authInfo]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def domain_nss_xml(xml, nss)
+      xml.domain :ns do
+        if nss.first.is_a? Hash
+          nss.each do |ns|
+            xml.domain :hostAttr do
+              xml.domain :hostName, ns[:hostName]
+              if ns.key?(:hostAddrv4)
+                ns[:hostAddrv4].each do |v4|
+                  xml.domain :hostAddr, {:ip => :v4}, v4
+                end
+              end
+              if ns.key?(:hostAddrv6)
+                ns[:hostAddrv6].each do |v6|
+                  xml.domain :hostAddr, {:ip => :v6}, v6
+                end
+              end
+            end
+          end
+        else
+          nss.each do |ns|
+            xml.domain :hostObj, ns
+          end
+        end
+      end
+    end
+
+    def domain_contacts_xml(xml, args)
+      args.each do |type,contacts|
+        contacts.each do |c|
+          xml.domain :contact, { type: type }, c
+        end
+      end
+    end
+
+    def domain_period_xml(xml, period)
+      xml.domain :period, { unit: period[:unit] }, period[:number]
+    end
+
+    def domain_create_xml(args) #:nodoc:
+      command do |xml|
+        xml.create do
+          xml.domain :create, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, args[:name]
+            domain_period_xml(xml, args[:period]) if args.key?(:period)
+            domain_nss_xml(xml, args[:ns]) if args.key? :ns
+            xml.domain :registrant, args[:registrant]
+            domain_contacts_xml(xml, args[:contacts])
+            xml.domain :license, args[:license] if args.key? :license
+          end
+        end
+      end
+    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),
+        exDate: DateTime.parse(dom.xpath('domain:exDate', EPPClient::SCHEMAS_URL).text),
+      }
+    end
+
+
+    def domain_delete_xml(domain) #:nodoc:
+      command do |xml|
+        xml.delete do
+          xml.domain :delete, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, domain
+          end
+        end
+      end
+    end
+
+    def domain_renew_xml(domain)
+      command do |xml|
+        xml.renew do
+          xml.domain :renew, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, domain[:name]
+            xml.domain :curExpDate, domain[:curExpDate].strftime('%Y-%m-%d')
+            domain_period_xml(xml, domain[:period])
+          end
+        end
+      end
+    end
+
+    # Renew 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>:curExpDate</tt>]
+    #   the date identifying the current end of the domain object
+    #   registration period.
+    # Returns a hash with the following keys :
+    #
+    # [<tt>:name</tt>] the fully qualified name of the domain object.
+    # [<tt>:exDate</tt>]
+    #   the date and time identifying the end of the domain object's
+    #   registration period.
+    def domain_renew(domain)
+      domain[:curExpDate] = DateTime.parse(domain[:curExpDate]) unless domain[:curExpDate].is_a? DateTime
+      response = send_request(domain_renew_xml(domain))
+      get_result(:xml => response, :callback => :domain_renew_process)
+    end
+
+    def domain_renew_process(xml) #:nodoc:
+      dom = xml.xpath('epp:resData/domain:renData', EPPClient::SCHEMAS_URL)
+      ret = {
+        name: dom.xpath('domain:name', EPPClient::SCHEMAS_URL).text,
+        exDate: DateTime.parse(dom.xpath('domain:exDate', EPPClient::SCHEMAS_URL).text)
+      }
+    end
+
+    def domain_update_xml(args) #:nodoc:
+      command do |xml|
+        xml.update do
+          xml.domain :update, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, args[:name]
+            [:add, :rem].each do |ar|
+              next unless args.key?(ar) && (args[ar].key?(:ns) || args[ar].key?(:contacts) || args[ar].key?(:status))
+              xml.domain ar do
+                domain_nss_xml(xml, args[ar][:ns]) if args[ar].key? :ns
+                domain_contacts_xml(xml, args[ar][:contacts]) if args[ar].key? :contacts
+                if args[ar].key? :status
+                  args[ar][:status].each do |st,text|
+                    if text.nil?
+                      xml.domain :status, s: st
+                    else
+                      xml.domain :status, { s: st }, text
+                    end
+                  end
+                end
+              end
+            end
+            if args.key?(:chg) && (args[:chg].key?(:registrant) || args[:chg].key?(:authInfo))
+              xml.domain :chg do
+                xml.domain :registrant, args[:chg][:registrant] if args[:chg].key? :registrant
+                if args[:chg].key? :authInfo
+                  xml.domain :authInfo do
+                    xml.domain :pw, args[:chg][:authInfo]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,223 @@
+require "ipaddr"
+
+module EPPClient
+  module HostmasterHost
+    def host_check_xml(*hosts) #:nodoc:
+      command do |xml|
+        xml.check do
+          xml.host :check, 'xmlns:host' => EPPClient::SCHEMAS_URL['host-1.1'] do
+            hosts.each { |host| xml.host :name, host }
+          end
+        end
+      end
+    end
+
+    # Check the availability of hosts
+    #
+    # takes list of hosts as arguments
+    #
+    # returns an array of hashes containing three fields :
+    # [<tt>:name</tt>] the host name
+    # [<tt>:avail</tt>] availability
+    # [<tt>:reason</tt>]
+    #   the server-specific text to help explain why the object cannot be
+    #   provisioned.
+    #
+    def host_check(*hosts)
+      hosts.flatten!
+
+      response = send_request(host_check_xml(*hosts))
+      get_result(:xml => response, :callback => :host_check_process)
+    end
+
+    def host_check_process(xml) #:nodoc:
+      xml.xpath('epp:resData/host:chkData/host:cd', EPPClient::SCHEMAS_URL).map do |dom|
+        ret = {
+          name: dom.xpath('host:name', EPPClient::SCHEMAS_URL).text,
+          avail: dom.xpath('host:name', EPPClient::SCHEMAS_URL).attr('avail').value == '1',
+        }
+        unless (reason = dom.xpath('host:reason', EPPClient::SCHEMAS_URL).text).empty?
+          ret[:reason] = reason
+        end
+        ret
+      end
+    end
+
+    def host_info_xml(args) #:nodoc:
+      command do |xml|
+        xml.info do
+          xml.host :info, 'xmlns:host' => EPPClient::SCHEMAS_URL['host-1.1'] do
+            xml.host :name, args[:name]
+          end
+        end
+      end
+    end
+
+    # Returns the informations about a host
+    #
+    # Takes either a unique argument, either
+    # a string, representing the host name
+    # or a hash with the following keys :
+    # [<tt>:name</tt>] the host name
+    #
+    # Returned is a hash mapping:
+    # [<tt>:name</tt>] host name.
+    # [<tt>:roid</tt>]
+    #   the Repository Object IDentifier assigned to the host object when
+    #   the object was created.
+    # [<tt>:status</tt>] the status or array of statuses of the host object.
+    # [<tt>:addrv4</tt>] array with IPv4 addresses.
+    # [<tt>:addrv6</tt>] array with IPv6 addresses.
+    # [<tt>:clID</tt>] the identifier of the sponsoring client.
+    # [<tt>:crID</tt>]
+    #   the identifier of the client that created the host object.
+    # [<tt>:crDate</tt>] the date and time of host object creation.
+    # [<tt>:upID</tt>]
+    #   the optional identifier of the client that last updated the host
+    #   object.
+    # [<tt>:upDate</tt>]
+    #   the optional date and time of the most recent host object
+    #   modification.
+    # [<tt>:trDate</tt>]
+    #   the optional date and time of the most recent successful host object
+    #   transfer.
+    def host_info(args)
+      args = { name: args } if args.is_a? String
+      response = send_request(host_info_xml(args))
+      get_result(:xml => response, :callback => :host_info_process)
+    end
+
+    def host_info_process(xml) #:nodoc:
+      host = xml.xpath('epp:resData/host:infData', EPPClient::SCHEMAS_URL)
+      ret = {
+        name: host.xpath('host:name', EPPClient::SCHEMAS_URL).text,
+        roid: host.xpath('host:roid', EPPClient::SCHEMAS_URL).text,
+      }
+      if (status = host.xpath('host:status', EPPClient::SCHEMAS_URL)).size > 0
+        ret[:status] = status.map {|s| s.attr('s')}
+      end
+
+      if (value = host.xpath('host:addr', EPPClient::SCHEMAS_URL, ip: 'v4')).size > 0
+        ret[:addrv4] = value.map {|ip| IPAddr.new(ip.text)}
+      end
+      if (value = host.xpath('host:addr', EPPClient::SCHEMAS_URL, ip: 'v6')).size > 0
+        ret[:addrv6] = value.map {|ip| IPAddr.new(ip.text)}
+      end
+
+      %w(clID crID upID).each do |val|
+        if (value = host.xpath("host:#{val}", EPPClient::SCHEMAS_URL)).size > 0
+          ret[val.to_sym] = value.text
+        end
+      end
+      %w(crDate upDate trDate).each do |val|
+        if (date = host.xpath("host:#{val}", EPPClient::SCHEMAS_URL)).size > 0
+          ret[val.to_sym] = DateTime.parse(date.text)
+        end
+      end
+      ret
+    end
+
+    def host_create_xml(host) #:nodoc:
+      command do |xml|
+        xml.create do
+          xml.host :create, 'xmlns:host' => EPPClient::SCHEMAS_URL['host-1.1'] do
+            xml.host :name, host[:name]
+            %w(addrv4 addrv6).each do |type|
+              next unless host.key? type
+              host[type].each {|ip| xml.host :addr, ip}
+            end
+          end
+        end
+      end
+    end
+
+    # Creates a host
+    #
+    # Takes a hash as an argument containing the following keys :
+    # [<tt>:name</tt>] host name.
+    # [<tt>:addrv4</tt>] array with IPv4 addresses.
+    # [<tt>:addrv6</tt>] array with IPv6 addresses.
+    def host_create(host)
+      %w(addrv4 addrv6).each do |type|
+        next unless host.key? type
+        host[type] = [ host[type] ] unless host[type].is_a? Array
+      end
+      response = send_request(host_create_xml(host))
+      get_result(:xml => response, :callback => :host_create_process)
+    end
+
+    def host_create_process(xml) #:nodoc:
+      host = xml.xpath('epp:resData/host:creData', EPPClient::SCHEMAS_URL)
+      {
+        name: host.xpath('host:name', EPPClient::SCHEMAS_URL).text,
+        crDate: DateTime.parse(host.xpath('host:crDate', EPPClient::SCHEMAS_URL).text)
+      }
+    end
+
+    def host_delete_xml(host) #:nodoc:
+      command do |xml|
+        xml.delete do
+          xml.host :delete, 'xmlns:host' => EPPClient::SCHEMAS_URL['host-1.1'] do
+            xml.host :name, host
+          end
+        end
+      end
+    end
+
+    # Deletes a host
+    #
+    # Takes a single host for argument.
+    #
+    # Returns true on success, or raises an exception.
+    def host_delete(host)
+      response = send_request(host_delete_xml(host))
+      get_result(response)
+    end
+
+    def host_update_xml(args) #:nodoc:
+      command do |xml|
+        xml.update do
+          xml.host :update, 'xmlns:host' => EPPClient::SCHEMAS_URL['host-1.1'] do
+            xml.host :name, args[:name]
+            [:add, :rem].each do |operation|
+              if args.key? operation
+                xml.host operation do
+                  args[operation][:status].each {|s| xml.host :status, s: s} if args[operation].key? :status
+                  %w(addrv4 addrv6).each do |type|
+                    next unless args[operation].key? type
+                    args[operation][type].each {|a| xml.host type, a}
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Updates a host
+    #
+    # Takes a hash with the name, and at least one of the following keys :
+    # [<tt>:name</tt>]
+    #   the server-unique identifier of the host object to be updated.
+    # [<tt>:add</tt>/<tt>:rem</tt>]
+    #   adds or removes the following data from the host object :
+    #   [<tt>:addrv4</tt>] an array of IPv4 addresses.
+    #   [<tt>:addrv6</tt>] an array of IPv6 addresses.
+    #   [<tt>:status</tt>] an array of status to add to/remove from the object.
+    #
+    # Returns true on success, or raises an exception.
+    def host_update(args)
+      [:add, :rem].each do |operation|
+        next unless args.key?(operation)
+        %w(addrv4 addrv6).each do |type|
+          next unless args[operation].key? type
+          args[operation][type] = [ args[operation[type]] ] unless args[operation][type].is_a? Array
+        end
+      end
+      response = send_request(host_update_xml(args))
+      get_result(response)
+    end
+
+  end
+end

data/lib/epp-client/hostmaster-rgp.rb

@@ -0,0 +1,27 @@
+module EPPClient
+  module HostmasterRGP
+    def domain_restore_xml(domain)
+      command do |xml|
+        xml.update do
+          xml.domain :update, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, domain
+          end
+        end
+        xml.extension do
+          xml.rgp :update, 'xmlns:rgp' => EPPClient::SCHEMAS_URL['rgp-1.1'] do
+            xml.rgp :restore, op: 'request'
+          end
+        end
+      end
+    end
+
+    # Restore a domain
+    # Takes a single fully qualified domain name for argument.:
+    #
+    # Returns an array of rgpStatus.
+    def domain_restore(domain)
+      response = send_request(domain_restore_xml(domain))
+      get_result(:xml => response)
+    end
+  end
+end

data/lib/epp-client/hostmaster-transfer.rb

@@ -0,0 +1,42 @@
+module EPPClient
+  module HostmasterTransfer
+    def transfer_xml(domain, op)
+      command do |xml|
+        xml.transfer op: op do
+          xml.domain :transfer, 'xmlns:domain' => EPPClient::SCHEMAS_URL['domain-1.1'] do
+            xml.domain :name, domain[:name]
+            domain_period_xml(xml, domain[:period]) if domain.key? :period
+            if domain.key? :authInfo
+              xml.domain :authInfo do
+                xml.domain :pw, domain[:authInfo]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def transfer(domain, op)
+      domain = { name: domain } if domain.is_a? String
+      response = send_request(transfer_xml(domain, op))
+      get_result(:xml => response, :callback => :transfer_process)
+    end
+
+    %w(request cancel approve reject query).each do |op|
+      define_method("transfer_#{op}") { |domain| transfer(domain, op.to_sym) }
+    end
+
+    def transfer_process(xml)
+      trn = xml.xpath('epp:resData/domain:trnData', EPPClient::SCHEMAS_URL)
+      {
+        name: trn.xpath('domain:name', EPPClient::SCHEMAS_URL).text,
+        trStatus: trn.xpath('domain:trStatus', EPPClient::SCHEMAS_URL).text,
+        reID: trn.xpath('domain:reID', EPPClient::SCHEMAS_URL).text,
+        reDate: DateTime.parse(trn.xpath('domain:reDate', EPPClient::SCHEMAS_URL).text),
+        acID: trn.xpath('domain:acID', EPPClient::SCHEMAS_URL).text,
+        acDate: DateTime.parse(trn.xpath('domain:acDate', EPPClient::SCHEMAS_URL).text),
+        exDate: DateTime.parse(trn.xpath('domain:exDate', EPPClient::SCHEMAS_URL).text)
+      }
+    end
+  end
+end

data/lib/epp-client/hostmaster-xml.rb

@@ -0,0 +1,7 @@
+module EPPClient
+  module HostmasterXML
+    def hello
+      send_request(builder {|xml| xml.hello})
+    end
+  end
+end

data/lib/epp-client/hostmaster.rb

@@ -0,0 +1,41 @@
+require "epp-client/base"
+require "epp-client/hostmaster-xml"
+require "epp-client/hostmaster-connection"
+require "epp-client/hostmaster-domain"
+require "epp-client/hostmaster-contact"
+require "epp-client/hostmaster-host"
+require "epp-client/hostmaster-rgp"
+require "epp-client/hostmaster-transfer"
+
+module EPPClient
+  class Hostmaster < Base
+    VERSION = '0.2.0'
+
+    SCHEMAS = %w(domain-1.1 host-1.1 contact-1.1 rgp-1.1)
+
+    EPPClient::SCHEMAS_URL.merge!(SCHEMAS.inject({}) do |a,s|
+      a[s.sub(/-1\.1$/, '')] = "http://hostmaster.ua/epp/#{s}" if s =~ /-1\.1$/
+      a[s] = "http://hostmaster.ua/epp/#{s}"
+      a
+    end)
+
+    include EPPClient::HostmasterXML
+    include EPPClient::HostmasterConnection
+    include EPPClient::HostmasterDomain
+    include EPPClient::HostmasterContact
+    include EPPClient::HostmasterHost
+    include EPPClient::HostmasterRGP
+    include EPPClient::HostmasterTransfer
+
+    def initialize(attrs)
+      unless attrs.key?(:client_id) && attrs.key?(:password) && attrs.key?(:ssl_cert) && attrs.key?(:ssl_key)
+        raise ArgumentError, "client_id, password, ssl_cert and ssl_key are required"
+      end
+      attrs[:server] ||= 'epp.hostmaster.ua'
+      attrs[:port] ||= 700
+      attrs[:version] ||= '1.0'
+      @services = EPPClient::SCHEMAS_URL.values_at('domain', 'host', 'contact')
+      super(attrs)
+    end
+  end
+end

data/lib/epp-client.rb

@@ -0,0 +1 @@
+require "epp-client/hostmaster"

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: epp-client-hostmaster
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Yuriy Kolodovskyy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: epp-client-base
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.4
+description: Hostmaster.UA EPP client library
+email:
+- kolodovskyy@ukrindex.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- epp-client-hostmaster.gemspec
+- lib/epp-client.rb
+- lib/epp-client/hostmaster-connection.rb
+- lib/epp-client/hostmaster-contact.rb
+- lib/epp-client/hostmaster-domain.rb
+- lib/epp-client/hostmaster-host.rb
+- lib/epp-client/hostmaster-rgp.rb
+- lib/epp-client/hostmaster-transfer.rb
+- lib/epp-client/hostmaster-xml.rb
+- lib/epp-client/hostmaster.rb
+homepage: https://github.com/kolodovskyy/epp-client-hostmaster
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Hostmaster.UA EPP client library
+test_files: []