fog 1.41.0 → 2.3.0

data/lib/fog/zerigo/dns.rb

@@ -1,114 +0,0 @@
-require 'fog/zerigo/core'
-
-module Fog
-  module DNS
-    class Zerigo < Fog::Service
-      requires :zerigo_email, :zerigo_token
-      recognizes :host, :persistent, :port, :scheme, :timeout
-
-      model_path 'fog/zerigo/models/dns'
-      model       :record
-      collection  :records
-      model       :zone
-      collection  :zones
-
-      request_path 'fog/zerigo/requests/dns'
-      request :count_hosts
-      request :count_zones
-      request :create_host
-      request :create_zone
-      request :delete_host
-      request :delete_zone
-      request :find_hosts
-      request :get_host
-      request :get_zone
-      request :get_zone_stats
-      request :list_zones
-      request :list_hosts
-      request :update_host
-      request :update_zone
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = key == :zones ? [] : {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @zerigo_email = options[:zerigo_email]
-          @zerigo_token = options[:zerigo_token]
-        end
-
-        def data
-          self.class.data
-        end
-
-        def reset_data
-          self.class.reset
-        end
-
-        def find_by_zone_id(zone_id)
-          self.data[:zones].find { |z| z['id'] == zone_id }
-        end
-
-        def find_by_domain(domain)
-          self.data[:zones].find { |z| z['domain'] == domain }
-        end
-
-        def find_host(host_id)
-          self.data[:zones].map { |z| z['hosts'].find { |h| h['id'] == host_id } }.compact.first
-        end
-      end
-
-      class Real
-        def initialize(options={})
-
-          @zerigo_email  = options[:zerigo_email]
-          @zerigo_token  = options[:zerigo_token]
-          @connection_options = options[:connection_options] || {}
-          @host       = options[:host]        || "ns.zerigo.com"
-          @persistent = options[:persistent]  || false
-          @port       = options[:port]        || 80
-          @scheme     = options[:scheme]      || 'http'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-          key= "#{@zerigo_email}:#{@zerigo_token}"
-          params[:headers].merge!({
-            'Authorization' => "Basic #{Base64.encode64(key).delete("\r\n")}"
-          })
-          case params[:method]
-          when 'DELETE', 'GET', 'HEAD'
-            params[:headers]['Accept'] = 'application/xml'
-          when 'POST', 'PUT'
-            params[:headers]['Content-Type'] = 'application/xml'
-          end
-
-          begin
-            response = @connection.request(params)
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::DNS::Zerigo::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/models/dns/record.rb

@@ -1,66 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Record < Fog::Model
-        extend Fog::Deprecation
-        deprecate :ip, :value
-        deprecate :ip=, :value=
-
-        identity :id
-
-        attribute :created_at,  :aliases => 'created-at'
-        attribute :value,       :aliases => 'data'
-        attribute :domain,      :aliases => 'fqdn'
-        attribute :name,        :aliases => 'hostname'
-        attribute :description, :aliases => 'notes'
-        attribute :priority
-        attribute :ttl
-        attribute :type,        :aliases => 'host-type'
-        attribute :updated_at,  :aliases => 'updated-at'
-        attribute :zone_id,     :aliases => 'zone-id'
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :identity
-          service.delete_host(identity)
-          true
-        end
-
-        def zone
-          @zone
-        end
-
-        def save
-          requires :zone, :type, :value
-          options = {}
-          options[:hostname]  = name if name
-          options[:notes]     = description if description
-          options[:priority]  = priority if priority
-          options[:ttl]       = ttl if ttl
-
-          if persisted?
-            options[:host_type] = type
-            options[:data]      = value
-            service.update_host(identity, options)
-          else
-            data = service.create_host(@zone.id, type, value, options)
-            merge_attributes(data.body)
-          end
-
-          true
-        end
-
-        private
-
-        def zone=(new_zone)
-          @zone = new_zone
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-require 'fog/core/collection'
-require 'fog/zerigo/models/dns/record'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Records < Fog::Collection
-        attribute :zone
-
-        model Fog::DNS::Zerigo::Record
-
-        # List all domains
-        # @param [Hash] options Options to pass to the underlying API call
-        # @option options [String] :fqdn search for the given fqdn
-        def all(options = {})
-          requires :zone
-          if options[:fqdn]
-            hosts = service.find_hosts(options[:fqdn], zone.id).body['hosts']
-            load(hosts)
-          else
-            parent = zone.collection.get(zone.identity)
-            if parent
-              merge_attributes(parent.records.attributes)
-              load(parent.records.map {|record| record.attributes})
-            else
-              nil
-            end
-          end
-        end
-
-        def get(record_id)
-          data = service.get_host(record_id).body
-          new(data)
-        rescue Fog::Service::NotFound
-          nil
-        end
-
-        def new(attributes = {})
-          requires :zone
-          super({ :zone => zone }.merge!(attributes))
-        end
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-require 'fog/core/model'
-require 'fog/zerigo/models/dns/records'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Zone < Fog::Model
-        identity :id
-
-        attribute :created_at,  :aliases => 'created-at'
-        attribute :domain
-        attribute :ttl,         :aliases => 'default-ttl'
-        attribute :type,        :aliases => 'ns-type'
-        attribute :updated_at,  :aliases => 'updated-at'
-
-        # <custom-nameservers>ns1.example.com,ns2.example.com</custom-nameservers>
-        # <custom-ns type="boolean">true</custom-ns>
-        # <hostmaster>dnsadmin@example.com</hostmaster>
-        # <notes nil="true"/>
-        # <ns1 nil="true"/>
-        # <nx-ttl nil="true"></nx-ttl>
-        # <slave-nameservers nil="true"/>
-        # <tag-list>one two</tag-list>
-        # <hosts-count>1</hosts-count>
-
-        def initialize(attributes={})
-          self.type ||= 'pri_sec'
-          super
-        end
-
-        def destroy
-          requires :identity
-          service.delete_zone(identity)
-          true
-        end
-
-        def records
-          @records ||= begin
-            Fog::DNS::Zerigo::Records.new(
-              :zone       => self,
-              :service => service
-            )
-          end
-        end
-
-        def nameservers
-          [
-            'a.ns.zerigo.net',
-            'b.ns.zerigo.net',
-            'c.ns.zerigo.net',
-            'd.ns.zerigo.net',
-            'e.ns.zerigo.net'
-          ]
-        end
-
-        def save
-          self.ttl ||= 3600
-          requires :domain, :type, :ttl
-          options = {}
-          # * options<~Hash> - optional paramaters
-          #   * ns1<~String> - required if ns_type == sec
-          #   * nx_ttl<~Integer> -
-          #   * slave_nameservers<~String> - required if ns_type == pri
-          #   * axfr_ips<~String> - comma-separated list of IPs or IP blocks allowed to perform AXFRs
-          #   * custom_nameservers<~String> - comma-separated list of custom nameservers
-          #   * custom_ns<~String> - indicates if vanity (custom) nameservers are enabled for this domain
-          #   * hostmaster<~String> - email of the DNS administrator or hostmaster
-          #   * notes<~String> - notes about the domain
-          #   * restrict_axfr<~String> - indicates if AXFR transfers should be restricted to IPs in axfr-ips
-          #   * tag_list<~String> - List of all tags associated with this domain
-          data = unless identity
-            service.create_zone(domain, ttl, type, options)
-          else
-            options[:default_ttl] = ttl
-            options[:ns_type]     = type
-            service.update_zone(identity, options)
-          end
-          merge_attributes(data.body)
-          true
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'fog/core/collection'
-require 'fog/zerigo/models/dns/zone'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Zones < Fog::Collection
-        model Fog::DNS::Zerigo::Zone
-
-        def all(options = {})
-          data = service.list_zones(options).body['zones']
-          load(data)
-        end
-
-        def get(zone_id_or_domain)
-          data = service.get_zone(zone_id_or_domain).body
-          zone = new(data)
-          zone.records.load(data['hosts'])
-          zone
-        rescue Fog::Service::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/count_hosts.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CountHosts < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'count'
-              @response[name] = value.to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/count_zones.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CountZones < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'count'
-              @response[name] = value.to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/create_host.rb

@@ -1,24 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CreateHost < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'zone-id'
-              @response[name] = value.to_i
-            when 'priority', 'ttl'
-              @response[name] = value.to_i if value
-            when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/create_zone.rb

@@ -1,22 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CreateZone < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'default-ttl', 'id', 'nx-ttl', 'hosts-count'
-              @response[name] = value.to_i
-            when 'created-at', 'custom-nameservers', 'custom-ns', 'domain', 'hostmaster', 'notes', 'ns1', 'ns-type', 'slave-nameservers', 'tag-list', 'updated-at', 'hosts', 'axfr-ips', 'restrict-axfr'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/find_hosts.rb

@@ -1,28 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class FindHosts < Fog::Parsers::Base
-          def reset
-            @host = {}
-            @response = { 'hosts' => [] }
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'zone-id'
-              @host[name] = value.to_i
-            when 'priority', 'ttl'
-              @host[name] = value.to_i if value
-            when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-              @host[name] = value
-            when 'host'
-              @response['hosts'] << @host
-              @host = {}
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/get_host.rb

@@ -1,24 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class GetHost < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'zone-id'
-              @response[name] = value.to_i
-            when 'priority', 'ttl'
-              @response[name] = value.to_i if value
-            when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/get_zone.rb

@@ -1,53 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class GetZone < Fog::Parsers::Base
-          def reset
-            @host = {}
-            @hosts = []
-            @response = {}
-            @in_hosts = false
-          end
-
-          def start_element(name, attrs = [])
-            super(name, attrs)
-            #look out for start of <hosts> section
-            #needed as some of the tags have the same name as the parent <zone> section
-            if name == 'hosts'
-              @in_hosts= true
-            end
-          end
-
-          def end_element(name)
-            if (@in_hosts)
-              #in hosts part of response
-              case name
-              when 'id', 'zone-id'
-                @host[name] = value.to_i
-              when 'priority', 'ttl'
-                @host[name] = value.to_i if value
-              when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-                @host[name] = value
-              when 'host'
-                @hosts << @host
-                @host = {}
-              when 'hosts'
-                @response[name] = @hosts
-                @in_hosts = false
-              end
-            else
-              #in zone part of data
-              case name
-              when 'default-ttl', 'id', 'nx-ttl', 'hosts-count'
-                @response[name] = value.to_i
-              when 'created-at', 'custom-nameservers', 'custom-ns', 'domain', 'hostmaster', 'notes', 'ns1', 'ns-type', 'slave-nameservers', 'tag-list', 'updated-at', 'hosts', 'axfr-ips', 'restrict-axfr'
-                @response[name] = value
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/get_zone_stats.rb

@@ -1,22 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class GetZoneStats < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'queries'
-              @response[name] = value.to_i
-            when 'domain', 'period-begin', 'period-end'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/list_hosts.rb

@@ -1,28 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class ListHosts < Fog::Parsers::Base
-          def reset
-            @host = {}
-            @response = { 'hosts' => [] }
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'zone-id'
-              @host[name] = value.to_i
-            when 'priority', 'ttl'
-              @host[name] = value.to_i if value
-            when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-              @host[name] = value
-            when 'host'
-              @response['hosts'] << @host
-              @host = {}
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/list_zones.rb

@@ -1,26 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class ListZones < Fog::Parsers::Base
-          def reset
-            @zone = {}
-            @response = { 'zones' => [] }
-          end
-
-          def end_element(name)
-            case name
-            when 'default-ttl', 'id', 'nx-ttl', 'hosts-count'
-              @zone[name] = value.to_i
-            when 'created-at', 'custom-nameservers', 'custom-ns', 'domain', 'hostmaster', 'notes', 'ns1', 'ns-type', 'slave-nameservers', 'tag-list', 'updated-at', 'hosts', 'axfr-ips', 'restrict-axfr'
-              @zone[name] = value
-            when 'zone'
-              @response['zones'] << @zone
-              @zone = {}
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/requests/dns/count_hosts.rb

@@ -1,45 +0,0 @@
-module Fog
-  module DNS
-    class Zerigo
-      class Real
-        require 'fog/zerigo/parsers/dns/count_hosts'
-
-        # total number of hosts available for the specified zone. It is the same value as provided
-        # in the X-Query-Count header in the list_hosts API method
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>
-        #     * 'count'<~Integer>
-        #   * 'status'<~Integer> - 200 indicates success
-        def count_hosts(zone_id)
-          request(
-            :expects  => 200,
-            :method   => 'GET',
-            :parser   => Fog::Parsers::DNS::Zerigo::CountHosts.new,
-            :path     => "/api/1.1/zones/#{zone_id}/hosts/count.xml"
-          )
-        end
-      end
-
-      class Mock # :nodoc:all
-        def count_hosts(zone_id)
-          zone = find_by_zone_id(zone_id)
-
-          response = Excon::Response.new
-
-          if zone
-            response.status = 200
-            response.body = {
-              'count' => zone['hosts'].size
-            }
-          else
-            response.status = 404
-          end
-
-          response
-        end
-      end
-    end
-  end
-end