glennr_opensrs 0.3.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "libxml-ruby", "~> 2.1.2"
+
+group :development do
+  gem "nokogiri", "~> 1.4.6"
+  gem "jeweler"
+  gem "git"
+  gem "rake"
+  gem "shoulda"
+  gem "rspec", "~> 2.0"
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    libxml-ruby (2.1.2)
+    nokogiri (1.4.7)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  git
+  jeweler
+  libxml-ruby (~> 2.1.2)
+  nokogiri (~> 1.4.6)
+  rake
+  rspec (~> 2.0)
+  shoulda

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2011 Josh Delsman
+
+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.rdoc

@@ -0,0 +1,97 @@
+= OpenSRS http://travis-ci.org/voxxit/opensrs.png
+
+This (unofficial) OpenSRS gem provides basic support to connect to, and utilize the OpenSRS API. This library has been well-tested in high-performance production
+environments. More information on the API can be located here:
+
+http://www.opensrs.com/site/resources/documentation/api
+
+== Installation
+
+You can install this gem by doing the following:
+
+  $ gem install opensrs
+    
+You can then include it in a Ruby project, like so:
+
+  require 'opensrs'
+    
+Alternatively, you can include it in a Rails 2.x project in the <tt>environment.rb</tt> file, like so:
+
+  config.gem "opensrs"
+    
+For Rails 3.x, use the <tt>Gemfile</tt>:
+
+  gem "opensrs"
+
+== Usage
+
+This library provides basic functionality for interacting with the OpenSRS XML API.
+
+* Connection handling
+* Error reporting
+* XML encoding
+* XML decoding
+
+Currently, the library supports LibXML and Nokogiri as XML parsers. By default, it uses LibXML to parse and generate XML. If you'd like to use Nokogiri (1.4.7 and below) for parsing XML, then in one of your app initializers add the following line:
+
+  OpenSRS::Server.xml_processor = :nokogiri
+
+To connect, instantiate a new <tt>OpenSRS::Server</tt> object:
+
+  server = OpenSRS::Server.new(
+    :server   => "https://rr-n1-tor.opensrs.net:55443/",
+    :username => "testing",
+    :password => "53cr3t",
+    :key      => "c633be3170c7fb3fb29e2f99b84be2410..."
+  )
+
+NOTE: Connecting to OpenSRS requires that you add the IP(s) you're connecting from to their whitelist. Login to the testing or production servers, and add your IP(s) under Profile Management > Add IPs for Script/API Access. IP changes take about one hour to take effect.
+
+Once you have a server connection class, you can build from this to create the methods that you need. For instance, let's say we want to grab our account balance. The OpenSRS XML API takes a couple of attributes for all commands. You can include those here:
+
+  def get_balance
+    server.call(
+      :action => "GET_BALANCE",
+      :object => "BALANCE"
+    )
+  end
+    
+Sometimes you might need to include attributes for the command, such as a cookie, or the data attributes themselves. You can do this, too:
+
+  def create_nameserver(nameserver)
+    server.call(
+      :action => "CREATE",
+      :object => "NAMESERVER",
+      :cookie => "366828736:3210384",
+      :attributes => {
+        :name => nameserver.hostname,
+        :ipaddress => "212.112.123.11"
+      }
+    )
+  end
+    
+Responses from OpenSRS are returned in an OpenSRS::Response object, which gives you access to a multitude of things.
+
+* <tt>response.response</tt> - This gives you the response in a Hash form, which is highly accessible to most other actions in your application.
+* <tt>response.errors</tt> - If there are errors which come back from OpenSRS, they are returned here. If not, it returns nil.
+* <tt>response.success?</tt> - Returns true if the response was labeled as successful. If not, it returns false.
+* <tt>response.request_xml</tt> - Returns raw request XML.
+* <tt>response.response_xml</tt> - Returns raw response XML.
+
+== Bugs/Feature Requests
+
+If you have any bugs or feature requests for this gem, feel free to add them in the Issues portion of the GitHub repository here:
+
+http://github.com/voxxit/opensrs/issues
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. If you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull.
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010-2012 Josh Delsman. Distributed under the MIT license. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift("lib")
+
+require 'rake'
+require 'opensrs'
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "glennr_opensrs"
+    gem.version     = OpenSRS::Version::VERSION
+    gem.summary     = "Provides support to utilize the OpenSRS API with Ruby/Rails."
+    gem.description = "Provides support to utilize the OpenSRS API with Ruby/Rails."
+    gem.email       = "glenn@siyelo.com"
+    gem.homepage    = "http://github.com/glennr/opensrs"
+    gem.license     = "MIT"
+    gem.authors     = ["Josh Delsman", "Glenn Roberts"]
+
+    # Requirements are in Gemfile
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/opensrs.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/opensrs/xml_processor'
+require File.dirname(__FILE__) + '/opensrs/xml_processor/libxml.rb'
+require File.dirname(__FILE__) + '/opensrs/server.rb'
+require File.dirname(__FILE__) + '/opensrs/response.rb'
+require File.dirname(__FILE__) + '/opensrs/version.rb'
+
+module OpenSRS
+end

data/lib/opensrs/response.rb

@@ -0,0 +1,29 @@
+module OpenSRS
+  class Response
+    attr_reader :request_xml, :response_xml
+    attr_accessor :response, :success
+    
+    def initialize(parsed_response, request_xml, response_xml)
+      @response     = parsed_response
+      @request_xml  = request_xml
+      @response_xml = response_xml
+      @success      = success?
+    end
+  
+    # We need to return the error message unless the
+    # response is successful.
+    def errors
+      if !success?
+        if response["response_text"] and response["response_code"]
+          "#{response["response_text"]} (Code #{response["response_code"]})"
+        else
+          "Unknown error"
+        end
+      end
+    end
+  
+    def success?
+      response["is_success"] ? response["is_success"].to_s == "1" : true
+    end
+  end
+end

data/lib/opensrs/server.rb

@@ -0,0 +1,77 @@
+require "uri"
+require "net/https"
+require "digest/md5"
+require "openssl"
+
+module OpenSRS
+  class BadResponse < StandardError; end
+  class TimeoutError < StandardError; end
+
+  class Server
+    attr_accessor :server, :username, :password, :key, :timeout, :open_timeout
+
+    def initialize(options = {})
+      @server   = URI.parse(options[:server] || "https://rr-n1-tor.opensrs.net:55443/")
+      @username = options[:username]
+      @password = options[:password]
+      @key      = options[:key]
+      @timeout  = options[:timeout]
+      @open_timeout  = options[:open_timeout]
+    end
+
+    def call(data = {})
+      xml = xml_processor.build({ :protocol => "XCP" }.merge!(data))
+
+      begin
+        response = http.post(server_path, xml, headers(xml))
+      rescue Net::HTTPBadResponse
+        raise OpenSRS::BadResponse, "Received a bad response from OpenSRS. Please check that your IP address is added to the whitelist, and try again."
+      end
+
+      parsed_response = xml_processor.parse(response.body)
+      return OpenSRS::Response.new(parsed_response, xml, response.body)
+    rescue Timeout::Error => err
+      raise OpenSRS::TimeoutError, err
+    end
+
+    def xml_processor
+      @@xml_processor
+    end
+
+    def self.xml_processor=(name)
+      require File.dirname(__FILE__) + "/xml_processor/#{name.to_s.downcase}"
+      @@xml_processor = OpenSRS::XmlProcessor.const_get("#{name.to_s.capitalize}")
+    end
+
+    OpenSRS::Server.xml_processor = :libxml
+
+    private
+
+    def headers(request)
+      { "Content-Length"  => request.length.to_s,
+        "Content-Type"    => "text/xml",
+        "X-Username"      => username,
+        "X-Signature"     => signature(request)
+      }
+    end
+
+    def signature(request)
+      signature = Digest::MD5.hexdigest(request + key)
+      signature = Digest::MD5.hexdigest(signature + key)
+      signature
+    end
+
+    def http
+      http = Net::HTTP.new(server.host, server.port)
+      http.use_ssl = (server.scheme == "https")
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.read_timeout = http.open_timeout = @timeout if @timeout
+      http.open_timeout = @open_timeout                if @open_timeout
+      http
+    end
+
+    def server_path
+      server.path.empty? ? '/' : server.path
+    end
+  end
+end

data/lib/opensrs/version.rb

@@ -0,0 +1,5 @@
+module OpenSRS
+  class Version
+    VERSION = "0.3.3"
+  end
+end

data/lib/opensrs/xml_processor.rb

@@ -0,0 +1,77 @@
+module OpenSRS
+
+  class XmlProcessor
+
+    # Parses the main data block from OpenSRS and discards
+    # the rest of the response.
+    def self.parse(response)
+      data_block = data_block_element(response)
+
+      raise ArgumentError.new("No data found in document") if !data_block
+
+      return decode_data(data_block)
+    end
+
+    protected
+
+    # Encodes individual elements, and their child elements, for the root XML document.
+    def self.encode_data(data, container = nil)
+      case data.class.to_s
+      when "Array" then return encode_dt_array(data, container)
+      when "Hash"  then return encode_dt_assoc(data, container)
+      when "String", "Numeric", "Date", "Time", "Symbol", "NilClass"
+        return data.to_s
+      else
+        return data.inspect
+      end
+
+      return nil
+    end
+
+    def self.encode_dt_array(data, container)
+      dt_array = new_element(:dt_array, container)
+
+      data.each_with_index do |item, index|
+        item_node = new_element(:item, container)
+        item_node["key"] = index.to_s
+        item_node << encode_data(item, item_node)
+
+        dt_array << item_node
+      end
+
+      return dt_array
+    end
+
+    def self.encode_dt_assoc(data, container)
+      dt_assoc = new_element(:dt_assoc, container)
+
+      data.each do |key, value|
+        item_node = new_element(:item, container)
+        item_node["key"] = key.to_s
+        item_node << encode_data(value, item_node)
+
+        dt_assoc << item_node
+      end
+
+      return dt_assoc
+    end
+
+    # Recursively decodes individual data elements from OpenSRS
+    # server response.
+    def self.decode_data(data)
+      data.each do |element|
+        case element.name
+        when "dt_array"
+          return decode_dt_array_data(element)
+        when "dt_assoc"
+          return decode_dt_assoc_data(element)
+        when "text", "item", "dt_scalar"
+          next if element.content.strip.empty?
+          return element.content.strip
+        end
+      end
+    end
+
+  end
+
+end

data/lib/opensrs/xml_processor/libxml.rb

@@ -0,0 +1,60 @@
+require "libxml"
+
+module OpenSRS
+  class XmlProcessor::Libxml < OpenSRS::XmlProcessor
+    include ::LibXML::XML
+    
+    # First, builds REXML elements for the inputted data. Then, it will
+    # go ahead and build the entire XML document to send to OpenSRS.
+    def self.build(data)
+      xml = Document.new
+      xml.root = envelope = Node.new("OPS_envelope")
+
+      envelope << header = Node.new("header")
+      envelope << body = Node.new("body")
+      header   << Node.new("version", "0.9")
+      body     << data_block = Node.new("data_block")
+
+      data_block << encode_data(data, data_block)
+
+      return xml.to_s
+    end
+
+    protected
+
+    def self.data_block_element(response)
+      doc = Parser.string(response).parse
+      return doc.find("//OPS_envelope/body/data_block/*")
+    end
+
+    def self.decode_dt_array_data(element)
+      dt_array = []
+
+      element.children.each do |item|
+        next if item.empty?
+        dt_array[item.attributes["key"].to_i] = decode_data(item)
+      end
+
+      return dt_array
+    end
+
+    def self.decode_dt_assoc_data(element)
+      dt_assoc = {}
+
+      element.children.each do |item|
+        next if item.content.strip.empty?
+        dt_assoc[item.attributes["key"]] = decode_data(item)
+      end
+
+      return dt_assoc
+    end
+
+    # Accepts two parameters but uses only one; to keep the interface same as other xml parser classes
+    # Is that a side effect of Template pattern?
+    #
+    def self.new_element(element_name, container)
+      return Node.new(element_name.to_s)
+    end
+
+  end
+end