dynectastic 0.2.0

data/lib/dynectastic/factories/record_factory.rb

@@ -0,0 +1,51 @@
+module Dynectastic
+  
+  class RecordFactory < Resource
+    
+    def self.record_types(*attrs)
+      attrs.each do |attr_name|
+        class_eval do
+          attr_reader :record_type
+        end
+        eval %Q[
+          def #{ attr_name }
+            @record_type = "#{ attr_name }".upcase
+            self
+          end
+        ]
+      end
+    end
+    
+    record_types :aaaa, :any, :a, :cname, :dnskey, :ds, :key, :loc, :mx, :ns, :ptr, :rp, :soa, :srv, :txt 
+    
+    def build(attributes)
+      record = Dynectastic::Record.new(session, self)
+      record.type       = record_type
+      record.attributes = attributes
+      record
+    end
+    
+    def find_by_id(id, options={})
+      build get("#{ entity_base }/#{ options[:zone] }/#{ options[:node] }/#{ id }")
+    end
+    
+    def find_all(options={})
+      records = []
+      get("#{ entity_base }/#{ options[:zone] }/#{ options[:node] }/").each do |record_url|
+        record_id = record_url.split("/").last
+        records << find_by_id(record_id, options)
+      end
+      records
+    end
+    
+    def entity_base
+      "/REST/#{ entity_name }"
+    end
+    
+    def entity_name
+      "#{ record_type }Record"
+    end
+    
+  end
+  
+end

data/lib/dynectastic/factories/zone_factory.rb

@@ -0,0 +1,58 @@
+module Dynectastic
+  
+  class ZoneFactory < Resource
+    
+    def build(attributes)
+      zone = Dynectastic::Zone.new(session, self)
+      zone.attributes = attributes
+      zone
+    end
+    
+    def find_by_name(name=nil)
+      build api_parameters_to_attributes(get("#{ entity_base }/#{ name }/"))
+    end
+    
+    def find_all
+      zones = []
+      get("#{ entity_base }/").each do |full_zone_path|
+        zone_name = full_zone_path.split('/').last
+        zones << find_by_name(zone_name)
+      end
+      zones
+    end
+    
+    def publish(name)
+      put("#{ entity_base }/#{ name }", :body => { :publish => true } )
+    end
+    
+    def freeze(name)
+      put("#{ entity_base }/#{ name }", :body => { :freeze => true } )
+    end
+    
+    def unfreeze(name)
+      put("#{ entity_base }/#{ name }", :body => { :thaw => true } )
+    end
+    
+    def destroy(name)
+      delete("#{ entity_base }/#{ name }")
+    end
+    
+    def entity_base
+      "/REST/Zone"
+    end
+    
+  private
+  
+    def api_parameters_to_attributes(api_params)
+      {
+        :name         => api_params['zone'],
+        :contact      => api_params['rname'],
+        :ttl          => api_params['ttl'],
+        :serial_style => api_params['serial_style'],
+        :type         => api_params['zone_type']
+      }
+    end
+    
+  end
+  
+end

data/lib/dynectastic/job.rb

@@ -0,0 +1,23 @@
+module Dynectastic
+  
+  class Job < Resource
+    
+    attr_reader :request, :id, :incomplete
+    
+    def initialize(request)
+      @request    = request
+      @id         = request.job_id
+      @incomplete = request.job_incomplete
+    end
+    
+    def complete?
+      not incomplete?
+    end
+    
+    def incomplete?
+      !! @incomplete
+    end
+    
+  end
+  
+end

data/lib/dynectastic/record.rb

@@ -0,0 +1,32 @@
+module Dynectastic
+  
+  class Record < Resource
+    
+    attr_accessor :zone, :node, :rdata, :ttl, :type, :record_id
+    
+    def save
+      payload = {
+        'rdata' => rdata,
+        'ttl'   => ttl
+      }
+
+      self.attributes = record_id ? update(payload) : create(payload)
+    end
+    
+  private
+  
+    def update(payload)
+      put("#{ entity_path }/#{ record_id }/", :body => payload)
+    end
+    
+    def create(payload)
+      post("#{ entity_path }/", :body => payload)
+    end
+  
+    def entity_path
+      "#{ factory.entity_base }/#{ zone }/#{ node }"
+    end
+    
+  end
+  
+end

data/lib/dynectastic/request.rb

@@ -0,0 +1,114 @@
+module Dynectastic
+  
+  class Request
+    
+    include HTTParty
+    
+    base_uri     API_URL
+    headers      "Content-Type" => "application/json"
+    #debug_output $stdout
+    
+    attr_reader :resource, :attempts, :response, :job_id, :job_incomplete
+    
+    def initialize(resource)
+      @resource = resource
+    end
+    
+    def job
+      if job_id
+        Job.new(self)
+      end
+    end
+    
+    def perform(*args)
+      method, path, options = args.shift, args.shift, args.last
+      options ||= {}
+      prepare_options(options)
+      reset_attempts
+      
+      begin
+        process_response(self.class.send(method, path, options))
+      rescue HTTParty::RedirectionTooDeep => e
+        if e.response.body.include?("/REST/Job")
+          memorize_response_data(e.response)
+          false
+        else
+          raise e
+        end
+      
+      rescue SessionBusy => e
+        if attempts_left?
+          sleep(10)
+          increment_attempts      
+          retry
+        else
+          raise e
+        end
+      end
+    end
+    
+  private
+  
+    def default_headers
+      self.class.default_options[:headers]
+    end
+    
+    def prepare_options(options)
+      if resource.session        
+        options = options.merge!(:headers => default_headers.merge({ "Auth-Token" => resource.session.token}))
+      end
+      
+      if options[:body].kind_of?(Hash)
+        options[:body] = options[:body].to_json
+      end
+    end
+    
+    def process_response(response)
+      memorize_response_data(response)
+      if response['status'] == 'success'        
+        response['data']
+      else
+        convert_dynect_messages_to_exceptions(response['msgs'])
+        response
+      end
+    end
+    
+    def convert_dynect_messages_to_exceptions(messages)
+      messages.each do |msg|
+        if msg['LVL'] == 'ERROR'
+          raise ErrorTranslator.translate_to_exception(msg)
+        end
+      end
+    end
+    
+    def memorize_response_data(response)
+      @response = response
+      
+      if response.kind_of?(Net::HTTPTemporaryRedirect)
+        @job_id = extract_job_id_from_response(response)
+        @job_incomplete = true
+      else
+        @job_id = response['job_id']
+      end
+    end
+    
+    def extract_job_id_from_response(response)
+      response.body.scan(/\/REST\/Job\/(\d+)/i).flatten.first.to_i
+    end
+    
+    def increment_attempts
+      @attempts ||= 0
+      @attempts += 1
+    end
+    
+    def reset_attempts
+      @attempts = 0
+    end
+    
+    def attempts_left?
+      @attempts < RETRIES
+    end
+    
+  end
+  
+end

data/lib/dynectastic/resource.rb

@@ -0,0 +1,44 @@
+module Dynectastic
+  
+  class Resource
+    
+    attr_reader :session, :factory
+    attr_accessor :last_request
+    
+    def initialize(session, factory=nil)
+      @session = session
+      @factory = factory
+    end
+    
+    def get(*args)
+      request(:get, *args)
+    end
+    
+    def post(*args)
+      request(:post, *args)
+    end
+    
+    def put(*args)
+      request(:put, *args)
+    end
+    
+    def delete(*args)
+      request(:delete, *args)
+    end
+    
+    def attributes=(hash)
+      hash.each_pair do |name, value|
+        instance_variable_set("@#{ name }", value)
+      end
+    end
+    
+  private
+  
+    def request(*args)
+      @last_request = Request.new(self)
+      @last_request.perform(*args)
+    end
+    
+  end
+  
+end

data/lib/dynectastic/session.rb

@@ -0,0 +1,37 @@
+module Dynectastic
+  
+  class Session < Resource
+    
+    attr_reader :token, :api_version
+    
+    def initialize(customer_name, user_name, password)
+      payload = {
+        :customer_name => customer_name,
+        :user_name     => user_name,
+        :password      => password
+      }.to_json
+      
+      response     = post(entity_base, :body => payload)
+      @token       = response['token']
+      @api_version = response['version']
+    end
+    
+    def zones
+      Dynectastic::ZoneFactory.new(self)
+    end
+    
+    def nodes
+      Dynectastic::NodeFactory.new(self)
+    end
+    
+    def records
+      Dynectastic::RecordFactory.new(self)
+    end
+    
+    def entity_base
+      "/REST/Session"
+    end
+    
+  end
+  
+end

data/lib/dynectastic/zone.rb

@@ -0,0 +1,56 @@
+module Dynectastic
+  
+  class Zone < Resource
+    
+    attr_accessor :name, :contact, :ttl, :serial, :serial_style
+    attr_reader :zone_type
+    
+    def save
+      payload = {
+        'rname'        => contact,
+        'serial_style' => serial,
+        'ttl'          => ttl
+      }
+      self.attributes = post("#{ factory.entity_base }/#{ name }", :body => payload)
+    end
+    
+    def publish
+      if factory.publish(name)
+        @published = true
+      else
+        job
+      end
+    end
+    
+    def freeze
+      if factory.freeze(name)
+        @frozen = true
+      else
+        job
+      end
+    end
+    
+    def unfreeze
+      if factory.unfreeze(name)
+        @frozen = false
+        true
+      else
+        job
+      end
+    end
+    
+    def destroy
+      factory.destroy(name)
+    end
+    
+    def published?
+      @published
+    end
+    
+    def frozen?
+      @frozen
+    end
+    
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'dynectastic'
+
+DYNECT_CUST_NAME = "xxx"
+DYNECT_USER_NAME = "xxx"
+DYNECT_USER_PASS = "xxx"
+
+class Test::Unit::TestCase
+end

data/test/test_node_factory.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestNodeFactory < Test::Unit::TestCase
+  
+  context "NodeFactory" do
+    
+    setup do
+      @dynect = Dynectastic.session(DYNECT_CUST_NAME, DYNECT_USER_NAME, DYNECT_USER_PASS)
+      @zone = @dynect.zones.build(
+        :name    => "dynectastictests.com",
+        :contact => "ilya@wildbit.com",
+        :ttl     => 1800
+      )
+      @zone.save
+
+      @record = @dynect.records.cname.build(
+        :zone => "dynectastictests.com",
+        :node => "ilya.dynectastictests.com",
+        :ttl => 0,
+        :rdata => { :cname => "something.dynectastictests.com" }
+      )
+      @record.save
+    end
+    
+    teardown do
+      @zone.destroy
+    end
+    
+    should "delete" do
+      @dynect.nodes.destroy("dynectastictests.com", "ilya.dynectastictests.com")
+    end
+    
+  end
+  
+end