moo_moo 0.1.1 → 0.2.0

data/lib/moo_moo/opensrs/args.rb

@@ -1,109 +0,0 @@
-module MooMoo
-  module OpenSRS
-    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
-end

data/lib/moo_moo/opensrs/base.rb

@@ -1,73 +0,0 @@
-module MooMoo
-  module OpenSRS
-    class Base
-      include LookupCommands
-      include ProvisioningCommands
-      include TransferCommands
-      include NameserverCommands
-      include CookieCommands
-
-      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
-
-      def try_opensrs
-        begin
-          yield
-        rescue Exception => e
-          raise OpenSRSException, e.message
-        end
-      end
-    end
-  end
-end

data/lib/moo_moo/opensrs/command.rb

@@ -1,190 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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