dnsimple-ruby 0.1.0

data/README

@@ -0,0 +1,10 @@
+A Ruby wrapper for the DNSimple API.
+
+== Credentials ==
+
+Create a file in your home directory called .dnsimple
+
+In this file add the following:
+
+username: YOUR_USERNAME
+password: YOUR_PASSWORD

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/dnsimple

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/dnsimple'

data/bin/dnsimple.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'dnsimple'
+require 'dnsimple/cli'
+
+cli = DNSimple::CLI.new
+
+require 'optparse'
+
+options = {}
+
+global = OptionParser.new do |opts|
+  opts.on("-s", "--site [ARG]") do |site|
+    DNSimple::Client.base_uri site
+  end
+  opts.on("-u", "--username [ARG]") do |username|
+    DNSimple::Client.username = username
+  end
+  opts.on("-p", "--password [ARG]") do |password|
+    DNSimple::Client.password = password
+  end
+end
+
+subcommands = { 
+  'create' => OptionParser.new do |opts|
+     opts.on("--template [ARG]") do |opt|
+       options[:template] = opt 
+     end
+   end,
+  'record:create' => OptionParser.new do |opts|
+     opts.on("--prio [ARG]") do |prio|
+       options[:prio] = prio 
+     end
+  end,
+}
+
+global.order!
+command = ARGV.shift
+if command.nil?
+  puts "You must specify a command"
+else
+  options_parser = subcommands[command]
+  options_parser.order! if options_parser
+  begin
+    cli.execute(command, ARGV, options)
+  rescue DNSimple::CommandNotFound => e
+    puts e.message
+  end
+end

data/lib/dnsimple.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'pp'
+require 'httparty'
+
+require 'dnsimple/client'
+require 'dnsimple/error'
+require 'dnsimple/domain'
+require 'dnsimple/record'
+require 'dnsimple/template'

data/lib/dnsimple/cli.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+
+module DNSimple
+  
+  class CommandNotFound < RuntimeError
+  end
+
+  class CLI
+    def initialize
+      credentials = load_credentials
+      Client.credentials(credentials['username'], credentials['password'])
+    end
+
+    def execute(command_name, args, options={})
+      command = commands[command_name]
+      if command
+        begin
+          command.new.execute(args, options)
+        rescue DNSimple::Error => e
+          puts "An error occurred: #{e.message}"
+        rescue RuntimeError => e
+          puts "An error occurred: #{e.message}"
+        end
+      else
+        raise CommandNotFound, "Unknown command: #{command_name}"
+      end
+    end
+
+    def commands
+      {
+        'create' => DNSimple::Commands::CreateDomain,
+        'describe' => DNSimple::Commands::DescribeDomain,
+        'list' => DNSimple::Commands::ListDomains,
+        'delete' => DNSimple::Commands::DeleteDomain,
+        'clear' => DNSimple::Commands::ClearDomain,
+        'apply' => DNSimple::Commands::ApplyTemplate,
+        
+        'record:create' => DNSimple::Commands::CreateRecord,
+        'record:list' => DNSimple::Commands::ListRecords,
+        'record:delete' => DNSimple::Commands::DeleteRecord,
+      }
+    end
+
+    private
+    def load_credentials
+      YAML.load(File.new(File.expand_path('~/.dnsimple')))
+    end
+  end
+end
+
+require 'dnsimple/commands/create_domain'
+require 'dnsimple/commands/describe_domain'
+require 'dnsimple/commands/list_domains'
+require 'dnsimple/commands/delete_domain'
+require 'dnsimple/commands/clear_domain'
+require 'dnsimple/commands/apply_template'
+
+require 'dnsimple/commands/create_record'
+require 'dnsimple/commands/list_records'
+require 'dnsimple/commands/delete_record'

data/lib/dnsimple/client.rb

@@ -0,0 +1,34 @@
+module DNSimple
+  class Client
+    def self.debug?
+      @debug
+    end
+    def self.debug=(debug)
+      @debug = debug
+    end
+
+    def self.username=(username)
+      self.credentials[:username] = username
+    end
+
+    def self.password=(password)
+      self.credentials[:password] = password
+    end
+
+    def self.credentials(username=nil, password=nil)
+      @credentials ||= {}
+      @credentials = {:username => username, :password => password} if username && password
+      @credentials
+    end
+
+    def self.base_uri(site=nil) 
+      self.base_uri = site if site
+      @@base_uri ||= "http://localhost:3000"
+    end
+
+    def self.base_uri=(base_uri)
+      @@base_uri = base_uri.gsub(/\/$/, '')
+      puts "Using #{@@base_uri}"
+    end
+  end
+end

data/lib/dnsimple/commands/apply_template.rb

@@ -0,0 +1,15 @@
+module DNSimple
+  module Commands
+    class ApplyTemplate
+      def execute(args, options={})
+        domain_name = args.shift
+        template_name = args.shift
+
+        domain = Domain.find(domain_name)
+        domain.apply(template_name)
+
+        puts "Applied template #{template_name} to #{domain.name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/clear_domain.rb

@@ -0,0 +1,16 @@
+module DNSimple
+  module Commands
+    class ClearDomain
+      def execute(args, options={})
+        name = args.shift
+
+        records = Record.all(name)
+        records.each do |record|
+          record.delete
+        end
+
+        puts "Deleted #{records.length} records from #{name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/create_domain.rb

@@ -0,0 +1,16 @@
+module DNSimple
+  module Commands
+    class CreateDomain
+      def execute(args, options={})
+        name = args.shift
+        domain = Domain.create(name) 
+        puts "Created #{domain.name}"
+
+        if template = options.delete(:template)
+          domain.apply(template)
+          puts "Applied template #{template} to #{domain.name}"
+        end
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/create_record.rb

@@ -0,0 +1,18 @@
+module DNSimple
+  module Commands
+    class CreateRecord
+      def execute(args, options={})
+        name = args.shift
+        record_name = args.shift
+        record_type = args.shift
+        content = args.shift
+        ttl = args.shift
+        
+        domain = Domain.find(name)
+        record = Record.create(domain.name, record_name, record_type, content, :ttl => ttl, :prio => options[:prio])
+        
+        puts "Created #{record.record_type} record for #{domain.name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/delete_domain.rb

@@ -0,0 +1,14 @@
+module DNSimple
+  module Commands
+    class DeleteDomain
+      def execute(args, options={})
+        name_or_id = args.shift
+
+        domain = Domain.find(name_or_id)
+        domain.delete
+
+        puts "Deleted #{domain.name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/delete_record.rb

@@ -0,0 +1,16 @@
+module DNSimple
+  module Commands
+    class DeleteRecord
+      def execute(args, options={})
+        domain_name = args.shift
+        id = args.shift
+
+        domain = Domain.find(domain_name)
+        record = Record.find(domain.name, id)
+        record.delete
+
+        puts "Deleted #{record.id} from #{domain.name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/describe_domain.rb

@@ -0,0 +1,14 @@
+module DNSimple
+  module Commands
+    class DescribeDomain
+      def execute(args, options={})
+        name = args.shift
+        domain = Domain.find(name)
+        puts "Domain #{domain.name}:"
+        puts "\tID: #{domain.id}"
+        puts "\tCreated: #{domain.created_at}"
+        puts "\tName Server Status: #{domain.name_server_status}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/list_domains.rb

@@ -0,0 +1,14 @@
+module DNSimple
+  module Commands
+    class ListDomains
+      def execute(args, options={})
+        puts "Base URI: #{Domain.base_uri}"
+        domains = Domain.all
+        puts "Found #{domains.length} domains:"
+        domains.each do |domain|
+          puts "\t#{domain.name}"
+        end
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/list_records.rb

@@ -0,0 +1,17 @@
+module DNSimple
+  module Commands
+    class ListRecords
+      def execute(args, options={})
+        domain_name = args.shift
+        records = Record.all(domain_name)
+        puts "Found #{records.length} records for #{domain_name}"
+        records.each do |record|
+          extra = ["ttl:#{record.ttl}", "id:#{record.id}"]
+          extra << "prio:#{record.prio}" if record.record_type == "MX"
+          extra = "(#{extra.join(', ')})"
+          puts "\t#{record.name}.#{record.domain.name} (#{record.record_type})-> #{record.content} #{extra}"
+        end
+      end
+    end
+  end
+end

data/lib/dnsimple/domain.rb

@@ -0,0 +1,100 @@
+module DNSimple #:nodoc:
+  # Class representing a single domain in DNSimple.
+  class Domain
+    include HTTParty
+
+    # The domain ID in DNSimple
+    attr_accessor :id
+    
+    # The domain name
+    attr_accessor :name
+    
+    # When the domain was created in DNSimple
+    attr_accessor :created_at
+    
+    # When the domain was last update in DNSimple
+    attr_accessor :updated_at
+
+    # The current known name server status
+    attr_accessor :name_server_status
+
+    #:nodoc:
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      end
+    end
+
+    # Delete the domain from DNSimple. WARNING: this cannot
+    # be undone.
+    def delete(options={})
+      options.merge!({:basic_auth => Client.credentials})
+      self.class.delete("#{Client.base_uri}/domains/#{id}.json", options)
+    end
+    alias :destroy :delete
+
+    def apply(template_name, options={})
+      template = DNSimple::Template.find(template_name)
+      options.merge!({:basic_auth => Client.credentials})
+      self.class.post("#{Client.base_uri}/domains/#{id}/templates/#{template.id}/apply", options)
+    end
+
+    # Create the domain with the given name in DNSimple. This
+    # method returns a Domain instance if the name is created
+    # and raises 
+    def self.create(name, options={})
+      domain_hash = {:name => name}
+      
+      options.merge!({:query => {:domain => domain_hash}})
+      options.merge!({:basic_auth => Client.credentials})
+
+      response = self.post("#{Client.base_uri}/domains.json", options)
+      
+      pp response if Client.debug?
+      
+      case response.code
+      when 201
+        return Domain.new(response["domain"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise DNSimple::Error.new(name, response["errors"])
+      end
+    end
+
+    def self.find(id_or_name, options={})
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/domains/#{id_or_name}.json", options)
+      
+      pp response if Client.debug?
+      
+      case response.code
+      when 200
+        return Domain.new(response["domain"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      when 404
+        raise RuntimeError, "Could not find domain #{id_or_name}"
+      else
+        raise DNSimple::Error.new(id_or_name, response["errors"])
+      end
+    end
+
+    def self.all(options={})
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/domains.json", options)
+      
+      pp response if Client.debug?
+
+      case response.code
+      when 200
+        response.map { |r| Domain.new(r["domain"]) }
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+  end
+end

data/lib/dnsimple/error.rb

@@ -0,0 +1,9 @@
+module DNSimple
+  class Error < StandardError
+    def initialize(domain, messages)
+      @domain = domain
+      @messages = messages
+      super "An error occurred: #{messages.join('. ')}"
+    end
+  end
+end

data/lib/dnsimple/record.rb

@@ -0,0 +1,94 @@
+module DNSimple
+  class Record
+    include HTTParty
+
+    attr_accessor :id
+
+    attr_accessor :domain
+
+    attr_accessor :name
+
+    attr_accessor :content
+
+    attr_accessor :record_type
+
+    attr_accessor :ttl
+
+    attr_accessor :prio
+
+    #:nodoc:
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      end
+    end
+    
+    def delete(options={})
+      options.merge!({:basic_auth => Client.credentials})
+      self.class.delete("#{Client.base_uri}/domains/#{domain.id}/records/#{id}.json", options)
+    end
+    alias :destroy :delete
+
+    def self.create(domain_name, name, record_type, content, options={})
+      domain = Domain.find(domain_name)
+      
+      record_hash = {:name => name, :record_type => record_type, :content => content}
+      record_hash[:ttl] = options.delete(:ttl) || 3600
+      record_hash[:prio] = options.delete(:prio) || ''
+
+      options.merge!({:query => {:record => record_hash}})
+      options.merge!({:basic_auth => Client.credentials})
+
+      response = self.post("#{Client.base_uri}/domains/#{domain.id}/records.json", options) 
+
+      pp response if Client.debug?
+
+      case response.code
+      when 201
+        return Record.new({:domain => domain}.merge(response["record"]))
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise DNSimple::Error.new("#{name}.#{domain_name}", response["errors"])
+      end
+    end
+
+    def self.find(domain_name, id, options={})
+      domain = Domain.find(domain_name)
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/domains/#{domain.id}/records/#{id}", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 200
+        return Record.new({:domain => domain}.merge(response["record"]))
+      when 401
+        raise RuntimeError, "Authentication failed"
+      when 404
+        raise RuntimeError, "Could not find record #{id} for domain #{domain_name}"
+      else
+        raise DNSimple::Error.new("#{domain_name}/#{id}", response["errors"])
+      end
+    end
+
+    def self.all(domain_name, options={})
+      domain = Domain.find(domain_name)
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/domains/#{domain.id}/records.json", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 200
+        response.map { |r| Record.new({:domain => domain}.merge(r["record"])) }
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+
+  end
+end

data/lib/dnsimple/template.rb

@@ -0,0 +1,43 @@
+module DNSimple
+  class Template
+    include HTTParty
+
+    # The template ID in DNSimple
+    attr_accessor :id
+    
+    # The template name
+    attr_accessor :name
+
+    # The template short name
+    attr_accessor :short_name
+
+    # The template description
+    attr_accessor :description
+
+    #:nodoc:
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      end
+    end
+
+    def self.find(id_or_short_name, options={})
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/templates/#{id_or_short_name}.json", options)
+      
+      pp response if Client.debug?
+      
+      case response.code
+      when 200
+        return Template.new(response["dns_template"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      when 404
+        raise RuntimeError, "Could not find template #{id_or_short_name}"
+      else
+        raise DNSimple::Error.new(id_or_short_name, response["errors"])
+      end
+    end
+  end
+end

data/spec/README

@@ -0,0 +1,6 @@
+Before running the DNSimple Ruby Client specifications, you must create a file in your home directory called .dnsimple.localhost and include the following:
+
+username: YOUR_USERNAME
+password: YOUR_PASSWORD
+
+

data/spec/domain_spec.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe DNSimple::Domain do
+
+  describe "a new domain" do
+    before do
+      @domain = DNSimple::Domain.create("testdomain.com")
+    end
+    after do
+      @domain.delete
+    end
+    it "has specific attributes" do 
+      @domain.name.should eql("testdomain.com")
+      @domain.id.should_not be_nil
+    end
+    it "can be found by id" do
+      domain = DNSimple::Domain.find(@domain.id)
+      domain.name.should eql("testdomain.com")
+      domain.id.should_not be_nil
+    end
+    it "can be found by name" do
+      domain = DNSimple::Domain.find(@domain.name)
+      domain.name.should eql("testdomain.com")
+      domain.id.should_not be_nil
+    end
+  end
+
+  describe ".all" do
+    before do
+      @domains = []
+      3.times do |n|
+        @domains << DNSimple::Domain.create("testdomain#{n}.com")
+      end
+    end
+    after do
+      @domains.each { |d| d.destroy }
+    end
+    it "returns a list of domains" do
+      domains = DNSimple::Domain.all
+      domains.map { |d| d.name }.should include(*@domains.map { |d| d.name })
+    end
+  end
+
+  describe "applying templates" do
+    before do
+      @domain = DNSimple::Domain.create("testdomain.com")
+    end
+    after do
+      @domain.delete
+    end
+    it "applies a named template" do
+      DNSimple::Record.all(@domain.name).should be_empty
+      @domain.apply("googleapps")
+      DNSimple::Record.all(@domain.name).should_not be_empty
+    end
+  end
+end

data/spec/record_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe DNSimple::Record do
+  before do
+    @domain = DNSimple::Domain.create("testdomain.com")
+  end
+
+  after do
+    @domain.delete
+  end
+
+  describe "a new record" do
+    before do
+      @record = DNSimple::Record.create(@domain.name, "", "A", "1.2.3.4", :ttl => 600)
+    end
+
+    it "has specific attributes" do 
+      @record.name.should eql("")
+      @record.record_type.should eql("A")
+      @record.content.should eql("1.2.3.4")
+      @record.ttl.should eql(600)
+      @record.id.should_not be_nil
+    end
+    it "can be found by id" do
+      record = DNSimple::Record.find(@domain.name, @record.id)
+      record.name.should eql("")
+      record.record_type.should eql("A")
+      record.content.should eql("1.2.3.4")
+      record.ttl.should eql(600)
+      record.id.should_not be_nil
+    end
+  end
+
+  describe ".all" do
+    before do
+      @records = []
+      
+      @records << DNSimple::Record.create("testdomain.com", "", "A", "4.5.6.7")
+      @records << DNSimple::Record.create("testdomain.com", "www", "CNAME", "testdomain.com")
+      @records << DNSimple::Record.create("testdomain.com", "", "MX", "mail.foo.com", :prio => 10)
+    end
+    
+    it "returns a list of records" do
+      records = DNSimple::Record.all(@domain.name)
+      records.should_not be_empty
+      records.length.should eql(@records.length)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'lib/dnsimple'
+
+config = YAML.load(File.new(File.expand_path('~/.dnsimple.localhost')))
+
+DNSimple::Client.base_uri = config['site'] || "http://localhost:3000/" 
+DNSimple::Client.username = config['username']
+DNSimple::Client.password = config['password'] 

data/spec/template_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe DNSimple::Template do
+  describe "a template" do
+    it "can be found by name" do
+      template = DNSimple::Template.find('googleapps')
+      template.id.should_not be_nil
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: dnsimple-ruby
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Anthony Eden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-10 00:00:00 -10:00
+default_executable: 
+dependencies: []
+
+description: A ruby wrapper for the DNSimple API that also includes a command-line client.
+email: anthony.eden@dnsimple.com
+executables: 
+- dnsimple
+- dnsimple.rb
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- VERSION
+- bin/dnsimple
+- bin/dnsimple.rb
+- lib/dnsimple.rb
+- lib/dnsimple/cli.rb
+- lib/dnsimple/client.rb
+- lib/dnsimple/commands/apply_template.rb
+- lib/dnsimple/commands/clear_domain.rb
+- lib/dnsimple/commands/create_domain.rb
+- lib/dnsimple/commands/create_record.rb
+- lib/dnsimple/commands/delete_domain.rb
+- lib/dnsimple/commands/delete_record.rb
+- lib/dnsimple/commands/describe_domain.rb
+- lib/dnsimple/commands/list_domains.rb
+- lib/dnsimple/commands/list_records.rb
+- lib/dnsimple/domain.rb
+- lib/dnsimple/error.rb
+- lib/dnsimple/record.rb
+- lib/dnsimple/template.rb
+- spec/README
+- spec/domain_spec.rb
+- spec/record_spec.rb
+- spec/spec_helper.rb
+- spec/template_spec.rb
+has_rdoc: true
+homepage: http://github.com/aetrion/dnsimple-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A ruby wrapper for the DNSimple API
+test_files: 
+- spec/domain_spec.rb
+- spec/record_spec.rb
+- spec/spec_helper.rb
+- spec/template_spec.rb