fog-dynect 0.0.1

data/lib/fog/dynect/models/dns/records.rb

@@ -0,0 +1,48 @@
+require 'fog/core/collection'
+require 'fog/dynect/models/dns/record'
+
+module Fog
+  module DNS
+    class Dynect
+      class Records < Fog::Collection
+        attribute :zone
+
+        model Fog::DNS::Dynect::Record
+
+        def all(options = {})
+          requires :zone
+          data = []
+          service.get_all_records(zone.domain, options).body['data'].each do |records|
+            (type, list) = records
+            list.each do |record|
+              data << {
+                :identity => record['record_id'],
+                :fqdn => record['fqdn'],
+                :type => record['record_type'],
+                :rdata => record['rdata']
+              }
+            end
+          end
+
+          load(data)
+        end
+
+        def get(record_id)
+          requires :zone
+
+          # there isn't a way to look up by just id
+          # must have type and domain for 'get_record' request
+          # so we pick it from the list returned by 'all'
+
+          list = all
+          list.detect {|e| e.id == record_id}
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({:zone => zone}.merge!(attributes))
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/models/dns/zone.rb

@@ -0,0 +1,56 @@
+require 'fog/core/model'
+require 'fog/dynect/models/dns/records'
+
+module Fog
+  module DNS
+    class Dynect
+      class Zone < Fog::Model
+        identity  :domain
+
+        attribute :domain,        :aliases => 'zone'
+        attribute :email,         :aliases => 'rname'
+        attribute :serial
+        attribute :serial_style
+        attribute :ttl
+        attribute :type,          :aliases => 'zone_type'
+
+        def initialize(attributes={})
+          super
+        end
+
+        def destroy
+          requires :domain
+          service.delete_zone(domain)
+          true
+        end
+
+        undef_method :domain=
+        def domain=(new_domain)
+          attributes[:domain] = new_domain.split('/').last
+        end
+
+        def publish
+          requires :identity
+          data = service.put_zone(identity, 'publish' => true)
+          true
+        end
+
+        def records
+          @records ||= Fog::DNS::Dynect::Records.new(:zone => self, :service => service)
+        end
+
+        def nameservers
+          raise 'nameservers Not Implemented'
+        end
+
+        def save
+          self.ttl ||= 3600
+          requires :domain, :email, :ttl
+          data = service.post_zone(email, ttl, domain).body['data']
+          merge_attributes(data)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/models/dns/zones.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/dynect/models/dns/zone'
+
+module Fog
+  module DNS
+    class Dynect
+      class Zones < Fog::Collection
+        model Fog::DNS::Dynect::Zone
+
+        def all
+          data = service.get_zone.body['data'].map do |zone|
+            { :domain => zone }
+          end
+          load(data)
+        end
+
+        def get(zone_id)
+          new(service.get_zone('zone' => zone_id).body['data'])
+        rescue Excon::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/delete_record.rb

@@ -0,0 +1,55 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+        # Delete a record
+        #
+        # ==== Parameters
+        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
+        # * zone<~String> - zone of record
+        # * fqdn<~String> - fqdn of record
+        # * record_id<~String> - id of record
+
+        def delete_record(type, zone, fqdn, record_id)
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :method   => :delete,
+            :path     => ["#{type.to_s.upcase}Record", zone, fqdn, record_id].join('/')
+          )
+        end
+      end
+
+      class Mock
+        def delete_record(type, zone, fqdn, record_id)
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          raise Fog::DNS::Dynect::NotFound unless zone[:records][type].find { |record| record[:fqdn] == fqdn && record[:record_id] == record_id.to_i }
+
+          zone[:records_to_delete] << {
+            :type => type,
+            :fqdn => fqdn,
+            :record_id => record_id.to_i
+          }
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "status" => "success",
+            "data" => {},
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "INFO" => "delete: Record will be deleted on zone publish",
+              "SOURCE" => "BLL",
+              "ERR_CD" => nil,
+              "LVL" => "INFO"
+            }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/delete_zone.rb

@@ -0,0 +1,41 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+        # Delete a zone
+        #
+        # ==== Parameters
+        # * zone<~String> - zone to host
+
+        def delete_zone(zone)
+          request(
+            :expects  => 200,
+            :method   => :delete,
+            :path     => "Zone/#{zone}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_zone(zone)
+          self.data[:zones].delete(zone)
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "status" => "success",
+            "data" => {},
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "ERR_CD" => '',
+              "INFO" => '',
+              "LVL" => '',
+              "SOURCE" => ''
+            }]
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/get_all_records.rb

@@ -0,0 +1,56 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+        # Get one or more node lists
+        #
+        # ==== Parameters
+        # * zone<~String> - zone to lookup node lists for
+        # * options<~Hash>
+        #   * fqdn<~String> - fully qualified domain name of node to lookup
+
+        def get_all_records(zone, options = {})
+          requested_fqdn = options['fqdn'] || options[:fqdn]
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :method   => :get,
+            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/'),
+            :query    => {'detail' => 'Y'} # return full records, instead of just resource URLs
+          )
+        end
+      end
+
+      class Mock
+        def get_all_records(zone, options = {})
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          data = [zone[:zone]]
+
+          if fqdn = options[:fqdn]
+            data = data | zone[:records].map { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
+          else
+            data = data | zone[:records].map { |type, records| records.map { |record| record[:fqdn] } }.flatten
+          end
+
+          response.body = {
+            "status" => "success",
+            "data" => data,
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "INFO" => "get_tree: Here is your zone tree",
+              "SOURCE" => "BLL",
+              "ERR_CD" => nil,
+              "LVL" => "INFO"
+            }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/get_node_list.rb

@@ -0,0 +1,55 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+        # Get one or more node lists
+        #
+        # ==== Parameters
+        # * zone<~String> - zone to lookup node lists for
+        # * options<~Hash>
+        #   * fqdn<~String> - fully qualified domain name of node to lookup
+
+        def get_node_list(zone, options = {})
+          requested_fqdn = options['fqdn'] || options[:fqdn]
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :method   => :get,
+            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/')
+          )
+        end
+      end
+
+      class Mock
+        def get_node_list(zone, options = {})
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          data = [zone[:zone]]
+
+          if fqdn = options[:fqdn]
+            data = data | zone[:records].map { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
+          else
+            data = data | zone[:records].map { |type, records| records.map { |record| record[:fqdn] } }.flatten
+          end
+
+          response.body = {
+            "status" => "success",
+            "data" => data,
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "INFO" => "get_tree: Here is your zone tree",
+              "SOURCE" => "BLL",
+              "ERR_CD" => nil,
+              "LVL" => "INFO"
+            }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/get_record.rb

@@ -0,0 +1,83 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+        # List records of a given type
+        #
+        # ==== Parameters
+        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
+        # * zone<~String> - name of zone to lookup
+        # * fqdn<~String> - name of fqdn to lookup
+        # * options<~Hash>:
+        #   * record_id<~String> - id of record
+
+        def get_record(type, zone, fqdn, options = {})
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :method   => :get,
+            :path     => ["#{type.to_s.upcase}Record", zone, fqdn, options['record_id']].compact.join('/')
+          )
+        end
+      end
+
+      class Mock
+        def get_record(type, zone, fqdn, options = {})
+          raise ArgumentError unless [
+            'AAAA', 'ANY', 'A', 'CNAME',
+            'DHCID', 'DNAME', 'DNSKEY',
+            'DS', 'KEY', 'LOC', 'MX',
+            'NSA', 'NS', 'PTR', 'PX',
+            'RP', 'SOA', 'SPF', 'SRV',
+            'SSHFP', 'TXT'
+          ].include? type
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          if record_id = options['record_id']
+            raise Fog::DNS::Dynect::NotFound unless record = zone[:records][type].find { |record| record[:record_id] == record_id.to_i }
+            response.body = {
+              "status" => "success",
+              "data" => {
+                "zone" => record[:zone][:zone],
+                "ttl" => record[:ttl],
+                "fqdn" => record[:fqdn],
+                "record_type" => type,
+                "rdata" => record[:rdata],
+                "record_id" => record[:record_id]
+              },
+              "job_id" => Fog::Dynect::Mock.job_id,
+              "msgs" => [{
+                "INFO" => "get: Found the record",
+                "SOURCE" => "API-B",
+                "ERR_CD" => nil,
+                "LVL" => "INFO"
+              }]
+            }
+          else
+            records = if type == "ANY"
+                        zone[:records].values.flatten.select { |record| record[:fqdn] == fqdn }
+                      else
+                        zone[:records][type].select { |record| record[:fqdn] == fqdn }
+                      end
+            response.body = {
+              "status" => "success",
+              "data" => records.map { |record| "/REST/#{record[:type]}Record/#{record[:zone][:zone]}/#{record[:fqdn]}/#{record[:record_id]}" },
+              "job_id" => Fog::Dynect::Mock.job_id,
+              "msgs" => [{
+                "INFO" => "detail: Found #{records.size} record",
+                "SOURCE" => "BLL",
+                "ERR_CD" => nil,
+                "LVL" => "INFO"
+              }]
+            }
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/get_zone.rb

@@ -0,0 +1,57 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+        # Get one or more zones
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * zone<~String> - name of zone to lookup, or omit to return list of zones
+
+        def get_zone(options = {})
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :method   => :get,
+            :path     => ['Zone', options['zone']].compact.join('/')
+          )
+        end
+      end
+
+      class Mock
+        def get_zone(options = {})
+          if options['zone']
+            raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][options['zone']]
+            data = {
+              "zone_type" => zone[:zone_type],
+              "serial_style" => zone[:serial_style],
+              "serial" => zone[:serial],
+              "zone" => zone[:zone]
+            }
+            info = "get: Your zone, #{zone[:zone]}"
+          else
+            data = self.data[:zones].map { |zone, data| "/REST/Zone/#{zone}/" }
+            info = "get: Your #{data.size} zones"
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "status" => "success",
+            "data" => data,
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "INFO" => info,
+              "SOURCE" => "BLL",
+              "ERR_CD" => nil,
+              "LVL" => "INFO"
+            }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end