dnsmadeeasy-api 0.9

data/Manifest

@@ -0,0 +1,6 @@
+Manifest
+README.rdoc
+Rakefile
+bin/dme
+lib/dnsmadeeasy/api.rb
+lib/dnsmadeeasy/exceptions.rb

data/README.rdoc

@@ -0,0 +1,37 @@
+=begin rdoc
+= DnsMadeEasy/API
+
+Ruby client for DNSMadeEasy API.
+
+== Installation
+
+# gem install environment
+
+== Usage
+
+  require "rubygems"
+  require "dnsmadeeasy/api"
+  
+  api_key = <your dnsmadeeasy api key>
+  secret_ket = <your dnsmadeeasy secret key>
+  api = DnsMadeEasy::Api(api_key, secret_key)
+  api.list_records "sigfig.com"
+
+To run in sandbox mode (you need an account and api key at sandbox.dnsmadeeasy.com).
+This is a great way to test your application without changing your production DNS entries.
+
+  api = DnsMadeEasy::Api(api_key, secret_key, true)
+  api.list_records "sigfig.com"
+  
+== Command line tool
+
+The client comes with a command line tool "dme". Use "dme --help" to see how to use the command.
+The command line tool requires that your api credentials be stored in /etc/dnsmadeeasy/api.keys as
+  api_key=<api_key>
+  secret_key=<secret_key>
+
+The command line tool also allows the running of queries in the sandbox mode. To do so, create
+/etc/dnsmadeeasy/api_sandbox.keys with your sandbox api key and secret key and use the --sandbox option
+with every command.
+  
+=end

data/Rakefile

@@ -0,0 +1,17 @@
+require "rubygems"
+require "rake"
+require "echoe"
+
+Echoe.new("dnsmadeeasy-api", "0.9") do |p|
+  p.description = "Ruby client for DNSMadeEasy API."
+  p.summary = "Ruby client for DNSMadeEasy API."
+  p.url = "http://rubygems.org/gems/dnsmadeeasy-api"
+  p.author = "Nitesh Goel"
+  p.email = "nitesh@wikinvest.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.install_message = "Create /etc/dnsmadeeasy/api.keys and/or /etc/dnsmadeeasy/api_sandbox.keys with the following information\napi_key=<your api key>\nsecret_key=<your secret key>\nto use the dme binary."
+  p.runtime_dependencies = ["rest-client", "json"]
+  p.development_dependencies = ["rake", "echoe"]
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/bin/dme

@@ -0,0 +1,244 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "dnsmadeeasy/api"
+require "json"
+require "optparse"
+
+class Array
+  def to_s
+    join(", ")
+  end
+end
+
+module DnsMadeEasy
+  class Printer
+    attr_accessor :json
+    
+    def initialize(json=false)
+      @json = json
+    end
+    
+    def help_text
+      valid_commands = {
+        "list-domains"    => "List all domains in the account",
+        "delete-domains"  => "Delete all domains in the account",
+        "create-domain"   => "Create a new domain entry",
+        "delete-domain"   => "Delete a domain entry",
+        "describe-domain" => "Describe a domain entry",
+        "list-records"    => "List records for a domain",
+        "create-record"   => "Create a new dns record",
+        "delete-record"   => "Delete a dns record",
+        "update-record"   => "Update an existing dns record",
+        "describe-record" => "Describe an existing dns record"
+      }
+      help = "Usage: dme command [options]"
+      help << "\nValid commands\n"
+      valid_commands.each do |name, description|
+        help << "\t#{name.ljust(18)}=> #{description}\n"
+      end
+      return help
+    end
+    
+    def show_error(message)
+      if @json
+        output = { "error" => message }
+        puts output.to_json
+      else
+        puts "ERROR: #{message}"
+      end
+      exit 1
+    end
+    
+    def say_bye(message)
+      puts message
+      exit 0
+    end
+    
+    def show_response(response)
+      if @json
+        if response.is_a?(TrueClass) || response.is_a?(FalseClass)
+          response = { :success => response }
+        end
+        puts response.to_json
+      elsif response.is_a?(TrueClass) || response.is_a?(FalseClass)
+        if response
+          puts "Done"
+        else
+          puts "Not done"
+        end
+      elsif response.instance_of?(Array) && response[0].instance_of?(String)
+        response.each do |x|
+          puts x
+        end
+      else
+        table_fields = {}
+        response = [response] if response.instance_of?(Hash)
+        response.each do |x|
+          x.each do |key, value|
+            table_fields[key] ||= []
+            table_fields[key] << value
+          end
+        end
+        max_widths = {}
+        table_fields.each do |key, values|
+          max_width = values.inject(key.to_s.length) { |length, s| [length, s.to_s.length].max }
+          max_widths[key] = max_width
+        end
+        #puts max_widths.inspect
+        row = []
+        table_fields.to_a.each do |column|
+          row[0] ||= []
+          row[0] << column[0].to_s.upcase.ljust(max_widths[column[0]])
+          column[1].each_index do |x|
+            row[x+1] ||= []
+            row[x+1] << column[1][x].to_s.ljust(max_widths[column[0]])
+          end
+        end
+        #puts row.inspect
+        #exit
+        row.map! { |x| "| #{x.join(' | ')} |" }
+        rows = row.length
+        row_length = row[0].length
+        divider = "-"*row_length
+        row.each_index do |x|
+          if x.zero?
+            puts divider
+            puts row[x]
+            puts divider
+          elsif x == rows-1
+            puts row[x]
+            puts divider
+          else
+            puts row[x]
+          end
+        end
+      end
+    end
+  end
+end
+
+printer = DnsMadeEasy::Printer.new
+
+# process input
+domain = nil
+options = {}
+force = false
+record_id = nil
+sandbox = false
+optparse = OptionParser.new do |opts|
+  opts.banner = printer.help_text + "\nOptions\n"
+  opts.on("-f", "--force", "Force operation") do
+    force = true
+  end
+  opts.on("-j", "--json", "Format output as json") do
+    printer.json = true
+  end
+  opts.on("-s", "--sandbox", "Run the sandbox api") do
+    sandbox = true
+  end
+  opts.on("-d", "--domain DOMAIN", "Domain Name") do |d|
+    domain = d
+  end
+  opts.on("-n", "--name HOSTNAME", "Hostname") do |h|
+    options[:name] = h
+  end
+  opts.on("-v", "--value VALUE", "The destination of the entry (IP/relative hostname/hostname)") do |v|
+    options[:data] = v
+  end
+  opts.on("-g", "--gtd GTD", "GTD Location") do |g|
+    options[:gtdLocation] = g
+  end
+  opts.on("-t", "--type TYPE", "The type of dns record") do |t|
+    options[:type] = t.upcase.to_sym
+  end
+  opts.on("-l", "--ttl TTL", "Time to live") do |l|
+    options[:ttl] = l
+  end
+  opts.on("-r", "--record RECORD", "Record id") do |r|
+    record_id = r
+  end
+end
+
+optparse.parse!
+
+auth_file = sandbox ?  "/etc/dnsmadeeasy/api_sandbox.keys" : "/etc/dnsmadeeasy/api.keys"
+begin
+  auth_contents = File.read(auth_file)
+  auth_hash = Hash[auth_contents.split("\n").map { |x| x.split("=") }]
+  api_key = auth_hash["api_key"]
+  secret_key = auth_hash["secret_key"]
+  if api_key.nil? || secret_key.nil?
+    throw new StandardError
+  end
+rescue StandardError => e
+  puts e.inspect
+  printer.show_error "Please create a file #{auth_file} with the following information\napi_key=<your api key>\nsecret_key=<your secret key>"
+end
+
+api = DnsMadeEasy::Api.new(api_key, secret_key, sandbox)
+
+command = ARGV.shift
+
+begin
+  case command
+  when "list-domains"
+    printer.show_response api.list_domains
+  when "delete-domains"
+    unless force
+      puts "The following domains are listed in your account:"
+      printer.show_response api.list_domains
+      puts "Are you sure you want to delete all domains? (yes/no)"
+      response = STDIN.gets.chomp.downcase
+      unless response.downcase == "yes"
+        printer.say_bye "Domains not deleted"
+      end
+    end
+    printer.show_response api.delete_domains!
+  when "create-domain"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.create_domain!(domain)
+  when "delete-domain"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    unless force
+      puts "Are you sure you want to delete #{domain}? (yes/no)"
+      response = STDIN.gets.chomp.downcase
+      unless response.downcase == "yes"
+        printer.say_bye "Domain #{domain} not deleted"
+      end
+    end
+    printer.show_response api.delete_domain!(domain)
+  when "describe-domain"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.describe_domain(domain)
+  when "list-records"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.list_records(domain, options)
+  when "create-record"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.create_record!(domain, options)
+  when "delete-record"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.describe_record(domain, record_id)
+    unless force
+      puts "Are you sure you want to delete this record? (yes/no)"
+      response = STDIN.gets.chomp.downcase
+      unless response.downcase == "yes"
+        printer.say_bye "Record not deleted"
+      end
+    end
+    printer.show_response api.delete_record!(domain, record_id)
+  when "update-record"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.update_record!(domain, record_id, options)
+  when "describe-record"
+    printer.show_error "Please specify a domain name" if domain.nil?
+    printer.show_response api.describe_record(domain, record_id)
+  when "help"
+    help_for_command = ARGV.shift
+    
+  else
+    printer.show_error "Please enter a valid command"
+  end
+rescue DnsMadeEasy::RequestFailedError => e
+  printer.show_error e.message
+end

data/dnsmadeeasy-api.gemspec

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dnsmadeeasy-api}
+  s.version = "0.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Nitesh Goel}]
+  s.date = %q{2011-07-06}
+  s.description = %q{Ruby client for DNSMadeEasy API.}
+  s.email = %q{nitesh@wikinvest.com}
+  s.executables = [%q{dme}]
+  s.extra_rdoc_files = [%q{README.rdoc}, %q{bin/dme}, %q{lib/dnsmadeeasy/api.rb}, %q{lib/dnsmadeeasy/exceptions.rb}]
+  s.files = [%q{Manifest}, %q{README.rdoc}, %q{Rakefile}, %q{bin/dme}, %q{lib/dnsmadeeasy/api.rb}, %q{lib/dnsmadeeasy/exceptions.rb}, %q{dnsmadeeasy-api.gemspec}]
+  s.homepage = %q{http://rubygems.org/gems/dnsmadeeasy-api}
+  s.post_install_message = %q{Create /etc/dnsmadeeasy/api.keys and/or /etc/dnsmadeeasy/api_sandbox.keys with the following information
+api_key=<your api key>
+secret_key=<your secret key>
+to use the dme binary.}
+  s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{Dnsmadeeasy-api}, %q{--main}, %q{README.rdoc}]
+  s.require_paths = [%q{lib}]
+  s.rubyforge_project = %q{dnsmadeeasy-api}
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{Ruby client for DNSMadeEasy API.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rest-client>, [">= 0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<echoe>, [">= 0"])
+    else
+      s.add_dependency(%q<rest-client>, [">= 0"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<echoe>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rest-client>, [">= 0"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<echoe>, [">= 0"])
+  end
+end

data/lib/dnsmadeeasy/api.rb

@@ -0,0 +1,275 @@
+require "rubygems"
+require "time"
+require "openssl"
+require "rest_client"
+require "json"
+require File.dirname(__FILE__)+"/exceptions"
+
+=begin rdoc
+= DnsMadeEasy/API
+
+Ruby client for DNSMadeEasy API.
+
+== Installation
+
+# gem install environment
+
+== Usage
+
+  require "rubygems"
+  require "dnsmadeeasy/api"
+  
+  api_key = <your dnsmadeeasy api key>
+  secret_ket = <your dnsmadeeasy secret key>
+  api = DnsMadeEasy::Api(api_key, secret_key)
+  api.list_records "sigfig.com"
+
+To run in sandbox mode (you need an account and api key at sandbox.dnsmadeeasy.com).
+This is a great way to test your application without changing your production DNS entries.
+
+  api = DnsMadeEasy::Api(api_key, secret_key, true)
+  api.list_records "sigfig.com"
+  
+== Command line tool
+
+The client comes with a command line tool "dme". Use "dme --help" to see how to use the command.
+The command line tool requires that your api credentials be stored in /etc/dnsmadeeasy/api.keys as
+  api_key=<api_key>
+  secret_key=<secret_key>
+
+The command line tool also allows the running of queries in the sandbox mode. To do so, create
+/etc/dnsmadeeasy/api_sandbox.keys with your sandbox api key and secret key and use the --sandbox option
+with every command.
+  
+=end
+
+module DnsMadeEasy
+  TTL_ONE_HOUR = 3600
+  TTL_HALF_HOUR = 1800
+  TTL_FIVE_MINS = 300
+  TTL_ONE_DAY = 86400
+  TTL_ONE_WEEK = 604800
+  
+  class Api
+    # Initialize the class with the api key, the secret key, and an optional
+    # flag to run the queries in DNSMadeEasy's sandbox mode
+    def initialize(api_key, secret_key, sandbox=false)
+      @api_key = api_key
+      @secret_key = secret_key
+      @sandbox = sandbox
+    end
+    
+    # List all domains in the account.
+    # Returns an array of domain names in the account.
+    # Throws DnsMadeEasy::AuthorizationFailedError
+    def list_domains
+      begin
+        response = RestClient.get request_url, headers
+        response_hash = JSON.parse(response)
+        return response_hash.has_key?("list") ? response_hash["list"] : []
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Delete all domains in the account.
+    # Returns true or throws an exception.
+    # Throws DnsMadeEasy::AuthorizationFailedError
+    def delete_domains!
+      begin
+        response = RestClient.delete request_url, headers
+        return true
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Create a new domain entry.
+    # Returns a hash of the newly created domain entry.
+    # Throws DnsMadeEasy::InvalidDomainNameError, DnsMadeEasy::DuplicateDomainError, or DnsMadeEasy::AuthorizationFailedError
+    def create_domain!(domain)
+      begin
+        response = RestClient.put request_url(:path => "#{domain}"), {}, headers
+        return JSON.parse(response)
+      rescue RestClient::BadRequest => e
+        error = JSON.parse(e.http_body)
+        if error["error"][0] == "Invalid domain name."
+          raise DnsMadeEasy::InvalidDomainNameError, domain
+        else
+          raise DnsMadeEasy::DuplicateDomainError, domain
+        end
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Delete a domain entry.
+    # Returns true or throws an exception.
+    # Throws DnsMadeEasy::UnknownDomainError, DnsMadeEasy::RequestFailedError, or DnsMadeEasy::AuthorizationFailedError
+    def delete_domain!(domain)
+      begin
+        response = RestClient.delete request_url(:path => "#{domain}"), headers
+        return true
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownDomainError, domain
+      rescue RestClient::BadRequest => e
+        error = JSON.parse(e.http_body)
+        raise DnsMadeEasy::RequestFailedError, error["error"][0]
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Describe a domain entry.
+    # Returns a hash of the domain entry.
+    # Throws DnsMadeEasy::UnknownDomainError or DnsMadeEasy::AuthorizationFailedError
+    def describe_domain(domain)
+      begin
+        response = RestClient.get request_url(:path => "#{domain}"), headers
+        return JSON.parse(response)
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownDomainError, domain
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # List records for a domain.
+    # Returns an array of hashes, each hash representing a dns entry.
+    # Throws DnsMadeEasy::UnknownDomainError or DnsMadeEasy::AuthorizationFailedError
+    def list_records(domain, filter={})
+      begin
+        response = RestClient.get request_url(:path => "#{domain}/records", :query => filter), headers
+        return JSON.parse(response)
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownDomainError, domain
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Create a new dns record
+    # record should be a hash with the following values:
+    #
+    #   :name        => hostname, e.g. www
+    #   :type        => e.g. :A, :CNAME, :MX, :TXT, :SRV, :NS, :AAAA, :HTTPRED, :PTR
+    #   :data        => publicname, e.g. "66.88.99.44" or "ec2-gibberish.amazonaws.com"
+    #   :gtdLocation => "DEFAULT", (optional, defaults to DEFAULT)
+    #   :ttl         => time to live, e.g. 300
+    #
+    # for :CNAME record type, the domain name is automatically added to the entry unless
+    # the :data field ends in a .
+    # e.g., for domain sigfig.com,
+    # :data => "blog.google.com" for a cname entry resolves to blog.google.com.sigfig.com
+    # but :data => "blog.google.com." resolves to blog.google.com.
+    #
+    # Returns a hash of the newly created dns entry.
+    # Throws DnsMadeEasy::InvalidRecordError, DnsMadeEasy::UnknownDomainError, or DnsMadeEasy::AuthorizationFailedError
+    def create_record!(domain, record)
+      validate_record(record)
+      request_data = {
+        :gtdLocation => "DEFAULT"
+      }.merge(record)
+      begin
+        response = RestClient.post request_url(:path => "#{domain}/records"), request_data.to_json, headers(:content_type => "application/json")
+        return JSON.parse(response)
+      rescue RestClient::BadRequest => e
+        raise DnsMadeEasy::InvalidRecordError, e.http_body
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownDomainError, domain
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Delete a dns record.
+    # Returns true or throws an exception.
+    # Throws DnsMadeEasy::UnknownRecordError, or DnsMadeEasy::AuthorizationFailedError
+    def delete_record!(domain, record_id)
+      begin
+        response = RestClient.delete request_url(:path => "#{domain}/records/#{record_id}"), headers
+        return true
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownRecordError.new(domain, record_id)
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Update an existing dns record
+    # Returns the latest hash of the dns entry.
+    # Throws DnsMadeEasy::InvalidRecordError, DnsMadeEasy::UnknownRecordError, or DnsMadeEasy::AuthorizationFailedError
+    def update_record!(domain, record_id, record)
+      begin
+        response = RestClient.put request_url(:path => "#{domain}/records/#{record_id}"), record.to_json, headers(:content_type => "application/json")
+        return describe_record(domain, record_id)
+      rescue RestClient::BadRequest => e
+        raise DnsMadeEasy::InvalidRecordError, e.http_body
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownRecordError.new(domain, record_id)
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    # Describe an existing dns record.
+    # Returns a hash of the dns entry.
+    # Throws DnsMadeEasy::UnknownRecordError, or DnsMadeEasy::AuthorizationFailedError
+    def describe_record(domain, record_id)
+      begin
+        response = RestClient.get request_url(:path => "#{domain}/records/#{record_id}"), headers
+        return JSON.parse(response)
+      rescue RestClient::ResourceNotFound => e
+        raise DnsMadeEasy::UnknownRecordError.new(domain, record_id)
+      rescue RestClient::Forbidden => e
+        raise DnsMadeEasy::AuthorizationFailedError
+      end
+    end
+    
+    private
+    
+    # Validate a dns record entry
+    def validate_record(record)
+      # check missing fields
+      required_fields = [:ttl, :data, :type, :name]
+      required_fields.each do |field|
+        raise DnsMadeEasy::InvalidRecordError, "Missing field #{field}" unless record.has_key?(field)
+      end
+      
+      # check record types
+      acceptable_types = [:A, :CNAME, :MX, :TXT, :SRV, :NS, :AAAA, :HTTPRED, :PTR]
+      raise DnsMadeEasy::InvalidRecordError, "Invalid record type #{record[:type]}" unless acceptable_types.include?(record[:type])
+      
+      # check non empty fields
+      non_empty_fields = [:ttl, :data]
+      non_empty_fields.each do |field|
+        raise DnsMadeEasy::InvalidRecordError, "Field #{field} cannot be empty" if record[:data].empty?
+        raise DnsMadeEasy::InvalidRecordError, "Field #{field} cannot be nil" if record[:data].nil?
+      end
+    end
+    
+    # Create the api request url
+    def request_url(info={})
+      request_url = @sandbox ? "http://api.sandbox.dnsmadeeasy.com/V1.2/domains" : "http://api.dnsmadeeasy.com/V1.2/domains"
+      request_url = "#{request_url}/#{info[:path]}" if info.has_key?(:path)
+      if info.has_key?(:query) && !info[:query].empty?
+        query = info[:query].to_a.map { |x| "#{x[0]}=#{x[1]}"  }.join("&")
+        request_url = "#{request_url}?#{query}"
+      end
+      return request_url
+    end
+    
+    # Return the api request headers
+    def headers(more_headers={})
+      time_now = Time.now.httpdate
+      hmac = OpenSSL::HMAC.hexdigest('sha1', @secret_key, time_now)
+      default_headers = {
+        :"x-dnsme-hmac" => hmac,
+        :"x-dnsme-requestDate"=> time_now,
+        :"x-dnsme-apiKey" => @api_key,
+        :accept => "application/json"
+      }
+      return default_headers.merge( more_headers )
+    end
+  end
+end

data/lib/dnsmadeeasy/exceptions.rb

@@ -0,0 +1,44 @@
+module DnsMadeEasy
+  # Generic request failure error
+  class RequestFailedError < StandardError
+  end
+  
+  # Error raised when authorization fails
+  class AuthorizationFailedError < RequestFailedError
+    def initialize
+      super "Could not authorize request with the given api key and secret key"
+    end
+  end
+  
+  # Error raised when actions are performed on an domain not listed in the account
+  class UnknownDomainError < RequestFailedError
+    def initialize(domain)
+      super "Domain #{domain} does not exist."
+    end
+  end
+  
+  # Error raised when an invalid domain is being created
+  class InvalidDomainNameError < RequestFailedError
+    def initialize(domain)
+      super "Domain #{domain} is not valid."
+    end
+  end
+  
+  # Error raised when a duplicate domain is being created
+  class DuplicateDomainError < RequestFailedError
+    def initialize(domain)
+      super "Domain #{domain} already exists."
+    end
+  end
+  
+  # Error raised when an unknown record is being modified or deleted
+  class UnknownRecordError < RequestFailedError
+    def initialize(domain, record_id)
+      super "Record id #{record_id} and/or domain #{domain} does not exist"
+    end
+  end
+  
+  # Error raised when an invalid dns entry is being created
+  class InvalidRecordError < RequestFailedError
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: dnsmadeeasy-api
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  version: "0.9"
+platform: ruby
+authors: 
+- Nitesh Goel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: echoe
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Ruby client for DNSMadeEasy API.
+email: nitesh@wikinvest.com
+executables: 
+- dme
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- bin/dme
+- lib/dnsmadeeasy/api.rb
+- lib/dnsmadeeasy/exceptions.rb
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- bin/dme
+- lib/dnsmadeeasy/api.rb
+- lib/dnsmadeeasy/exceptions.rb
+- dnsmadeeasy-api.gemspec
+homepage: http://rubygems.org/gems/dnsmadeeasy-api
+licenses: []
+
+post_install_message: |-
+  Create /etc/dnsmadeeasy/api.keys and/or /etc/dnsmadeeasy/api_sandbox.keys with the following information
+  api_key=<your api key>
+  secret_key=<your secret key>
+  to use the dme binary.
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Dnsmadeeasy-api
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: dnsmadeeasy-api
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Ruby client for DNSMadeEasy API.
+test_files: []
+