fog 1.32.0 → 1.33.0

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

@@ -1,48 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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