moo_moo 0.1.0

data/lib/moo_moo/config.rb

@@ -0,0 +1,13 @@
+module MooMoo
+  class Config
+    attr_accessor :host
+    attr_accessor :key
+    attr_accessor :user
+    attr_accessor :pass
+    attr_accessor :port
+
+    def initialize
+      @host = 'horizion.opensrs.net'
+    end
+  end
+end

data/lib/moo_moo/opensrs/args.rb

@@ -0,0 +1,109 @@
+module MooMoo
+  class MooMooArgumentError < ArgumentError; end
+
+  class Args
+    attr_reader :required_params, :boolean_params, :optional_params, :one_of_params
+    attr_reader :options
+    # Check the included hash for the included parameters.
+    # Raises MooMooArgumentError when it's mising the proper params
+    #
+    # ==== Example
+    # 
+    #    Args.new(options) do |c|
+    #      c.requries  :user, :pass
+    #      c.booleans  :name
+    #      c.optionals :whatever
+    #    end
+    def initialize(options)
+      @required_params ||= []
+      @boolean_params  ||= []
+      @optional_params ||= []
+      @one_of_params   ||= []
+      @options = options
+
+      yield self
+
+      requires!
+      booleans!
+      one_ofs!
+      valid_options!
+    end
+
+    # Specifies the required arguments
+    def requires(*values)
+      @optional_params.concat(values)
+      @required_params = values
+    end
+
+    # Specifies which arguments are boolean
+    def booleans(*values)
+      @optional_params.concat(values)
+      @boolean_params = values
+    end
+
+    # Specifies which arguments are optional
+    def optionals(*values)
+      @optional_params.concat(values)
+    end
+
+    # Specifies which arguments take one of a set of arguments
+    def one_of(*values)
+      @optional_params.concat(values)
+      @one_of_params = values
+    end
+
+    protected
+
+    # Verifies that all required arguments are present
+    def requires!
+      @required_params.each do |param|
+        key = (param.is_a?(Array) ? param.first : param)
+        verify_required_param(key)
+      end
+    end
+
+
+    # Checks to see if supplied params (which are booleans) contain
+    # either a 1 ("Yes") or 0 ("No") value.
+    def booleans!
+      @boolean_params.each do |param|
+        key = (param.is_a?(Array) ? param.first : param)
+        verify_boolean_param(key)
+      end
+    end
+
+    # Verifies that only valid arguments were set
+    def valid_options!
+      @options.keys.uniq.each do |key|
+        raise MooMoo::MooMooArgumentError.new("Not a valid parameter: #{key}") unless @optional_params.include?(key)
+      end
+    end  
+
+    # Verifies that the one_of arguments were used correctly
+    def one_ofs!
+      if @one_of_params.size > 1
+        specified = @options.keys.select { |key| @one_of_params.include?(key) }.uniq
+        if specified.size > 1 || specified.size == 0
+          raise MooMoo::MooMooArgumentError.new("The parameters may include only one of '#{@one_of_params.join(', ')}'")
+        end
+      else
+        raise MooMoo::MooMooArgumentError.new("One of requires two or more items") unless @one_of_params.empty?
+      end
+    end
+
+    private
+
+    # Internal method for verifiying required arguments
+    def verify_required_param(param)
+      raise MooMoo::MooMooArgumentError.new("Missing required parameter: #{param}") unless @options.has_key?(param)
+      raise MooMoo::MooMooArgumentError.new("Required parameter cannot be blank: #{param}") if (@options[param].nil? || (@options[param].respond_to?(:empty?) && @options[param].empty?))
+    end
+
+    # Internal method for verifying boolean arguments
+    def verify_boolean_param(param)
+      if @options.include?(param) && ![true, false].include?(@options[param])
+        raise MooMoo::MooMooArgumentError.new("Boolean parameter must be \"true\" or \"false\": #{param}")
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/base.rb

@@ -0,0 +1,75 @@
+module MooMoo
+  module OpenSRS
+    autoload :OpenSRSException, 'moo_moo/opensrs/opensrsexception'
+    autoload :Command, 'moo_moo/opensrs/command'
+    autoload :Utils, 'moo_moo/opensrs/utils'
+    autoload :LookupCommands, 'moo_moo/opensrs/lookup_commands'
+    autoload :ProvisioningCommands, 'moo_moo/opensrs/provisioning_commands'
+    autoload :TransferCommands, 'moo_moo/opensrs/transfer_commands'
+    autoload :NameserverCommands, 'moo_moo/opensrs/nameserver_commands'
+    autoload :CookieCommands, 'moo_moo/opensrs/cookie_commands'
+
+    class Base
+      include LookupCommands
+      include ProvisioningCommands
+      include TransferCommands
+      include NameserverCommands
+      include CookieCommands
+      include Utils
+
+      attr_reader :host, :key, :user, :pass, :port
+
+      # Constructor
+      #
+      # === Required
+      #  * <tt>:host</tt> - host of the OpenSRS server
+      #  * <tt>:key</tt> - private key
+      #  * <tt>:user</tt> - username of the reseller
+      #  * <tt>:pass</tt> - password of the rseller
+      #
+      # === Optional
+      #  * <tt>:port</tt> - port to connect on
+      def initialize(host = nil, key = nil, user = nil, pass = nil, port = 55443)
+        @host = host || MooMoo.config.host
+        @key = key || MooMoo.config.key
+        @user = user || MooMoo.config.user
+        @pass = pass || MooMoo.config.pass
+        @port = port || MooMoo.config.port
+      end
+
+      # Runs a command
+      #
+      # === Required
+      #  * <tt>:command</tt> - command to run
+      #  * <tt>:command</tt> - command to run
+      #
+      # === Optional
+      #  * <tt>:params</tt> - parameters for the command
+      #  * <tt>:cookie</tt> - cookie, if the command requires it
+      def run_command(action, object, params = {}, cookie = nil)
+        cmd = Command.new(action, object, params, cookie)
+
+        try_opensrs do
+          result = cmd.run(@host, @key, @user, @port)
+          Response.new(result, params[:key])
+        end
+      end
+
+      private
+
+      # Indexes an array by building a hash with numeric keys
+      #
+      # === Required
+      #  * <tt>:arr</tt> - array to build an indexed hash of
+      def index_array(arr)
+        arr_indexed = {}
+
+        arr.each_with_index do |item, index|
+          arr_indexed[index] = item
+        end
+
+        arr_indexed
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/command.rb

@@ -0,0 +1,190 @@
+require 'rexml/document'
+require 'digest/md5'
+require 'net/http'
+
+module MooMoo
+  module OpenSRS
+    class Command
+      # Constructor
+      #
+      # ==== Required
+      #  * <tt>:action</tt> - action of the command
+      #  * <tt>:object</tt> - object the command operates on
+      #  * <tt>:params</tt> - additional parameters for the command
+      #
+      # ==== Optional
+      #  * <tt>:cookie</tt> - a cookie for the domain if the command requires it
+      def initialize(action, object, params = {}, cookie = nil)
+        @action = action
+        @object = object
+        @params = params
+        @cookie = cookie
+      end
+
+      # Runs the command against OpenSRS server
+      #
+      # ==== Required
+      #  * <tt>:host</tt> - host of the OpenSRS server
+      #  * <tt>:key</tt> - private key for the account
+      #  * <tt>:user</tt> - username for the account
+      #  * <tt>:port</tt> - port to connect to
+      def run(host, key, user, port)
+        xml = build_command(@action, @object, @params, @cookie)
+
+        md5_signature = Digest::MD5.hexdigest(
+          Digest::MD5.hexdigest(
+            xml + key
+          ) + key
+        )
+
+        headers = {
+          'Content-Type' => 'text/xml',
+          'X-Username' => user,
+          'X-Signature' => md5_signature,
+          'Content-Length' => xml.size.to_s
+        }
+
+        http = Net::HTTP.new(URI.encode(host), port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        #http.ca_file = File.join(File.dirname(__FILE__), "../..", "cacert.pem")
+        res = http.post(URI.encode("/"), xml, headers)
+
+        @returned_parameters = parse_response(res.body)
+      end
+
+      private
+
+      # Adds XML child elements to the specified XML element for a given collection
+      #
+      # ==== Required
+      #  * <tt>:elem</tt> - XML element to add the child nodes to
+      #  * <tt>:coll</tt> - collection that will be added as XML child elements
+      def xml_add_collection_as_child(elem, coll)
+        # default collection type is array
+        dt_type = 'dt_array'
+
+        # if it's a hash, make sure the keys aren't numeric
+        if coll.is_a?(Hash)
+          begin
+            Float(coll.keys.first)
+          rescue
+            # the keys weren't numeric, so it really is an association (hash)
+            dt_type = 'dt_assoc'
+          end
+        end
+
+        elem = elem.add_element(dt_type)
+        coll = coll.first if coll.is_a? Array
+
+        coll.each do |key, value|
+          child = elem.add_element('item', {'key' => key})
+          if value.is_a?(Hash) || value.is_a?(Array)
+            xml_add_collection_as_child(child, value)
+          else
+            child.text = value
+          end
+        end
+      end
+
+      # Builds an XML string of the command which can be sent to OpenSRS
+      #
+      # ==== Required
+      #  * <tt>:action</tt> - action of the command
+      #  * <tt>:object</tt> - object the command operates on
+      #
+      # ==== Optional
+      #  * <tt>:attributes</tt> - additional attributes for the command
+      #  * <tt>:cookie</tt> - cookie for the domain if the command requires it
+      def build_command(action, object, attributes = nil, cookie = nil)
+        xml = <<-XML
+
+        <?xml version='1.0' encoding='UTF-8' standalone='no' ?>
+        <!DOCTYPE OPS_envelope SYSTEM 'ops.dtd'>
+        <OPS_envelope>
+          <header>
+            <version>0.9</version>
+          </header>
+          <body>
+            <data_block>
+              <dt_assoc>
+                <item key="protocol">XCP</item>
+                <item key="action">GET_BALANCE</item>
+                <item key="object">BALANCE</item>
+                <item key="registrant_ip"/>
+              </dt_assoc>
+            </data_block>
+          </body>
+        </OPS_envelope>
+        XML
+
+        doc = REXML::Document.new(xml)
+        doc.root.elements["body/data_block/dt_assoc/item[@key='action']"].text = action
+        doc.root.elements["body/data_block/dt_assoc/item[@key='object']"].text = object
+
+        unless cookie.nil?
+          cookie_elem = doc.root.elements["body/data_block/dt_assoc"].add_element('item', {'key' => 'cookie'})
+          cookie_elem.text = cookie
+        end
+
+        unless attributes.nil?
+          elem = doc.root.elements["body/data_block/dt_assoc"].add_element('item', {'key' => 'attributes'})
+          elem = elem.add_element('dt_assoc')
+          attributes.each_pair do |key, value|
+            attrib_elem = elem.add_element('item', {'key' => key})
+            if value.is_a?(Hash) || value.is_a?(Array)
+              xml_add_collection_as_child(attrib_elem, value)
+            else
+              attrib_elem.text = (value.is_a?(String) ? value.dup : value)
+            end
+          end
+        end
+
+        doc.to_s
+      end
+
+      # Parses an XML response from the OpenSRS registry and generates a
+      # hash containing all of the data. Elements with child elements
+      # are converted into hashes themselves, with the :element_text entry
+      # containing any raw text
+      #
+      # ==== Required
+      #  * <tt>data</tt> - data of the response
+      def parse_response(data)
+        doc = REXML::Document.new(data)
+
+        values = {}
+
+        elements = doc.elements["/OPS_envelope/body/data_block/dt_assoc"].select { |item|
+          item.is_a? REXML::Element
+        }
+
+        build_xml_hash(elements)
+      end
+
+      # Builds a hash from a collection of XML elements
+      #
+      # ==== Required
+      #  * <tt>elements</tt> - collection of elemenents
+      def build_xml_hash(elements)
+        data_hash = {}
+
+        elements.each do |elem|
+          key = elem.attributes['key']
+
+          if elem.elements.size > 0
+            if key.nil?
+              data_hash.merge!(build_xml_hash(elem.elements))
+            else
+              data_hash[key] = build_xml_hash(elem.elements)
+            end
+          else
+            data_hash[key] = elem.text unless key.nil?
+          end
+        end
+
+        data_hash
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/cookie_commands.rb

@@ -0,0 +1,52 @@
+module MooMoo
+  module OpenSRS
+    module CookieCommands
+      # Creates a cookie for a domain
+      #
+      # ==== Required
+      #  * <tt>:username</tt> - username of the registrant
+      #  * <tt>:password</tt> - password of the registrant
+      #  * <tt>:domain</tt> - domain to set the cookie for
+      def set_cookie(params)
+        run_command :set, :cookie, {
+          :reg_username => params[:username],
+          :reg_password => params[:password],
+          :domain => params[:domain],
+          :key => 'attributes'
+        }
+      end
+
+      # Deletes a cookie that was previously set
+      #
+      # ==== Required
+      #  * <tt>:cookie</tt> - cookie to delete
+      def delete_cookie(cookie)
+        run_command :delete, :cookie, {
+          :cookie => cookie
+        }, cookie
+      end
+
+      # Updates a cookie to be valid for a different domain
+      #
+      # ==== Required
+      #  * <tt>:old_domain</tt> - domain the cookie is currently set for
+      #  * <tt>:new_domain</tt> - domain to set the cookie for
+      #  * <tt>:cookie</tt> - cookie to update
+      def update_cookie(attribs)
+        run_command :update, :cookie, {
+          :reg_username => MooMoo.config.user,
+          :reg_password => '',
+          :domain => attribs[:old_domain],
+          :domain_new => attribs[:new_domain],
+          :key => 'attributes'
+        }, attribs[:cookie]
+      end
+
+      # Cleanly terminates the connection
+      #
+      def quit_session
+        run_command :quit, :session
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/lookup_commands.rb

@@ -0,0 +1,195 @@
+module MooMoo
+  module OpenSRS
+    module LookupCommands
+      # Determines whether a domain belongs to the reseller
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to check ownership of
+      def belongs_to_rsp?(domain)
+        run_command :belongs_to_rsp, :domain, {
+          :domain => domain,
+          :key => 'attributes'
+        }
+      end
+
+      # Returns the balance of the reseller's account
+      #
+      def get_balance
+        run_command :get_balance, :balance, {
+          :key => 'attributes'
+        }
+      end
+
+      # Lists domains that have been deleted due to expiration or request
+      #
+      def get_deleted_domains
+        run_command :get_deleted_domains, :domain, {
+          :key => 'attributes'
+        }
+      end
+
+      # Queries various types of data associated with a domain
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to query
+      #  * <tt>:cookie</tt> - cookie for the domain
+      #
+      # ==== Optional
+      #  * <tt>:type</tt> - type of query to perform
+      def get_domain(params)
+        params[:type] = 'all_info' unless params[:type]
+
+        run_command :get, :domain, {
+          :type => params[:type],
+          :key => 'attributes'
+        }, params[:cookie]
+      end
+
+      # Queries contact information for a list of domains
+      #
+      # ==== Required
+      #  * <tt>:domains</tt> - domains to get contact information for
+      def get_domains_contacts(*domains)
+        domain_list = {}
+        domains.each_with_index do |domain, index|
+          domain_list[index] = domain
+        end
+
+        run_command :get_domains_contacts, :domain, {
+          :domain_list => domain_list,
+          :key => 'attributes'
+        }
+      end
+
+      # Queries the domains expiring within the specified date range
+      #
+      # ==== Required
+      #  * <tt>:start_date</tt> - beginning date of the expiration range
+      #  * <tt>:end_date</tt> - ending date of the expiration range
+      def get_domains_by_expiredate(attribs)
+        Args.new(attribs) do |c|
+          c.requires :start_date, :end_date
+        end
+
+        run_command :get_domains_by_expiredate, :domain, {
+          :exp_from => attribs[:start_date].to_s,
+          :exp_to => attribs[:end_date].to_s,
+          :key => 'attributes'
+        }
+      end
+
+      # Retrieves the domain notes that detail the history of the domain (renewals, transfers, etc.)
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to get the notes for
+      def get_notes_for_domain(domain)
+        run_command :get_notes, :domain, {
+          :domain => domain,
+          :type => 'domain',
+          :key => 'attributes'
+        }
+      end
+
+      # Retrieves the domain notes based on an order
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to get the notes for
+      #  * <tt>:order_id</tt> - ID of the order
+      def get_notes_for_order(params)
+        run_command :get_notes, :domain, {
+          :domain => params[:domain],
+          :order_id => params[:order_id],
+          :type => 'order',
+          :key => 'attributes'
+        }
+      end
+
+      # Retrieves the domain notes based on a transfer ID
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to get the notes for
+      #  * <tt>:transfer_id</tt> - ID of the transfer
+      def get_notes_for_transfer(params)
+        run_command :get_notes, :domain, {
+          :domain => params[:domain],
+          :transfer_id => params[:transfer_id],
+          :type => 'transfer',
+          :key => 'attributes'
+        }
+      end
+
+      # Queries all information related to an order
+      #
+      # ==== Required
+      #  * <tt>:order_id</tt> - ID of the order
+      def get_order_info(order_id)
+        run_command :get_order_info, :domain, {
+          :order_id => order_id,
+          :key => 'attributes'
+        }
+      end
+
+      # Retrieves information about orders placed for a specific domain
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to get orders for
+      def get_orders_by_domain(domain)
+        run_command :get_orders_by_domain, :domain, {
+          :domain => domain,
+          :key => 'attributes'
+        }
+      end
+
+      # Queries the price of a domain
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to query the price of
+      def get_price(domain)
+        run_command :get_price, :domain, {
+          :domain => domain,
+          :key => 'attributes'
+        }
+      end
+
+      # Queries the properties of the specified Trust Service product
+      #
+      # ==== Required
+      #  * <tt>:product_id</tt> - ID of the product
+      def get_product_info(product_id)
+        run_command :get_product_info, :trust_service, {
+          :product_id => product_id,
+          :key => 'attributes'
+        }
+      end
+
+      # Determines the availability of a domain
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain to check availability of
+      def lookup_domain(domain)
+        run_command :lookup, :domain, {
+          :domain => domain,
+          :key => 'attributes'
+        }
+      end
+
+      # Provides suggestions for a domain name for the specified TLDs
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain
+      #  * <tt>:tlds</tt> - list of TLDs to make suggestions with
+      def name_suggest(domain, tlds)
+        tlds_indexed = {}
+        tlds.each_with_index do |tld, index|
+          tlds_indexed[index] = tld
+        end
+
+        run_command :name_suggest, :domain, {
+          :searchstring => domain,
+          :tlds => tlds_indexed,
+          :key => 'attributes'
+        }
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/nameserver_commands.rb

@@ -0,0 +1,70 @@
+module MooMoo
+  module OpenSRS
+    module NameserverCommands
+      # Creates a nameserver
+      #
+      # ==== Required
+      #  * <tt>:name</tt> - name of the nameserver
+      #  * <tt>:ip</tt> - ip address for the nameserver
+      #  * <tt>:domain</tt> - domain name to create it for
+      #
+      # ==== Optional
+      #  * <tt>:cookie</tt> - cookie for domain
+      def create_nameserver(attribs)
+        Args.new(attribs) do |c|
+          c.requires :name, :ip, :domain
+          c.optionals :cookie
+        end
+
+        cookie = attribs.delete :cookie
+        run_command :create, :nameserver, attribs, cookie
+      end
+
+      # Deletes a nameserver
+      #
+      # ==== Required
+      #  * <tt>:name</tt> - name of the nameserver
+      #  * <tt>:ip</tt> - ip address for the nameserver
+      #  * <tt>:domain</tt> - domain name to create it for
+      #
+      # ==== Optional
+      #  * <tt>:cookie</tt> - cookie for domain
+      def delete_nameserver(attribs, cookie = nil)
+        Args.new(attribs) do |c|
+          c.requires :name, :ip, :domain
+          c.optionals :cookie
+        end
+
+        cookie = attribs.delete :cookie
+        run_command :delete, :nameserver, attribs, cookie
+      end
+
+      # Queries nameservers that exist for the given domain
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain profile to query
+      def get_nameserver(domain)
+        run_command :get, :nameserver, {
+          :name => 'all',
+          :domain => domain,
+          :key => 'attributes'
+        }
+      end
+
+      # Renames a nameserver
+      #
+      # ==== Required
+      #  * <tt>:name</tt> - current name of the nameserver
+      #  * <tt>:ip</tt> - ip address of the name server
+      #  * <tt>:new_name</tt> - new name for the nameserver
+      #  * <tt>:domain</tt> - domain profile the nameserver was created for
+      def modify_nameserver(attribs)
+        Args.new(attribs) do |c|
+          c.requires :name, :ip, :new_name, :domain
+        end
+
+        run_command :modify, :nameserver, attribs
+      end
+    end
+  end
+end