fog 0.10.0 → 0.11.0

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

@@ -0,0 +1,53 @@
+require 'fog/core/collection'
+require 'fog/dns/models/dynect/record'
+
+module Fog
+  module DNS
+    class Dynect
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::DNS::Dynect::Record
+
+        def all
+          requires :zone
+          data = []
+          connection.get_node_list(zone.domain).body['data'].each do |fqdn|
+            records = connection.get_record('ANY', zone.domain, fqdn).body['data']
+
+            # data in format ['/REST/xRecord/domain/fqdn/identity]
+            records.map! do |record|
+              tokens = record.split('/')
+              {
+                :identity => tokens.last,
+                :fqdn     => fqdn,
+                :type     => tokens[2][0...-6] # everything before 'Record'
+              }
+            end
+
+            data.concat(records)
+          end
+
+          # leave out the default, read only records
+          data = data.reject {|record| ['NS', 'SOA'].include?(record[:type])}
+
+          load(data)
+        end
+
+        def get(record_id)
+          # FIXME: can this be done more efficiently?
+          all.detect {|record| record.identity == record_id}
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'fog/core/model'
+require 'fog/dns/models/dynect/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={})
+          self.ttl  ||= 3600
+          super
+        end
+
+        def destroy
+          requires :domain
+          connection.delete_zone(domain)
+          true
+        end
+
+        undef_method :domain=
+        def domain=(new_domain)
+          attributes[:domain] = new_domain.split('/').last
+        end
+
+        def publish
+          requires :identity
+          data = connection.put_zone(identity, :publish => true)
+          true
+        end
+
+        def records
+          @records ||= Fog::DNS::Dynect::Records.new(:zone => self, :connection => connection)
+        end
+
+        def nameservers
+          raise 'nameservers Not Implemented'
+        end
+
+        def save
+          requires :domain, :email, :ttl
+          data = connection.post_zone(email, ttl, domain).body['data']
+          merge_attributes(data)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+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,
+            :method   => :delete,
+            :path     => ["#{type.to_s.upcase}Record", zone, fqdn, record_id].join('/')
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,23 @@
+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 = {})
+          request(
+            :expects  => 200,
+            :method   => :get,
+            :path     => ['NodeList', zone, options['fqdn']].compact.join('/')
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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,
+            :method   => :get,
+            :path     => ["#{type.to_s.upcase}Record", zone, fqdn, options['record_id']].compact.join('/')
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+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,
+            :method   => :get,
+            :path     => ['Zone', options['zone']].compact.join('/')
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Create 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
+        # * rdata<~Hash> - rdata for record
+        # * options<~Hash>: (options vary by type, listing below includes common parameters)
+        #   * ttl<~Integer> - ttl for the record, defaults to zone ttl
+
+        def post_record(type, zone, fqdn, rdata, options = {})
+          options.merge!('rdata' => rdata)
+          request(
+            :body     => MultiJson.encode(options),
+            :expects  => 200,
+            :method   => :post,
+            :path     => ["#{type.to_s.upcase}Record", zone, fqdn].join('/')
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        def post_session
+          request(
+            :expects  => 200,
+            :method   => :post,
+            :path     => "Session",
+            :body     => MultiJson.encode({
+              :customer_name  => @dynect_customer,
+              :user_name      => @dynect_username,
+              :password       => @dynect_password
+            })
+          )
+        end
+      end
+
+      class Mock
+
+        def post_session
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'API-Version' => '2.3.1',
+            'Auth-Token' => 'thetoken=='
+          }
+          response
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Create a zone
+        #
+        # ==== Parameters
+        # * rname<~String> - administrative contact
+        # * ttl<~Integer> - time to live (in seconds) for records in this zone
+        # * zone<~String> - name of zone to host
+        # * options<~Hash>:
+        #   * serial_style<~String> - style of serial number, in ['day', 'epoch', 'increment', 'minute']. Defaults to increment
+
+        def post_zone(rname, ttl, zone, options = {})
+          body = MultiJson.encode({
+            :rname  => rname,
+            :token  => auth_token,
+            :ttl    => ttl
+          }.merge!(options))
+
+          request(
+            :body     => body,
+            :expects  => 200,
+            :method   => :post,
+            :path     => 'Zone/' << zone
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Update a zone
+        #
+        # ==== Parameters
+        # * zone<~String> - name or id of zone
+        # * options<~Hash>:
+        #   * freeze<~Boolean> - causes zone to become frozen
+        #   * publish<~Boolean> - causes all pending changes to be pushed to nameservers
+        #   * thaw<~Boolean> - causes zone to cease being frozen
+
+        def put_zone(zone, options = {})
+          request(
+            :body     => MultiJson.encode(options),
+            :expects  => 200,
+            :method   => :put,
+            :path     => 'Zone/' << zone
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/dns/zerigo.rb

@@ -3,7 +3,7 @@ module Fog
     class Zerigo < Fog::Service
 
       requires :zerigo_email, :zerigo_token
-      recognizes :timeout, :persistent
+      recognizes :host, :persistent, :port, :scheme, :timeout
 
       model_path 'fog/dns/models/zerigo'
       model       :record

data/lib/fog/providers.rb

@@ -11,6 +11,7 @@ require 'fog/providers/bluebox'
 require 'fog/providers/brightbox'
 require 'fog/providers/dnsimple'
 require 'fog/providers/dnsmadeeasy'
+require 'fog/providers/dynect'
 require 'fog/providers/ecloud'
 require 'fog/providers/go_grid'
 require 'fog/providers/google'

data/lib/fog/providers/dynect.rb

@@ -0,0 +1,14 @@
+require 'nokogiri'
+
+require 'fog/core'
+require 'fog/core/parser'
+
+module Fog
+  module Dynect
+
+    extend Fog::Provider
+
+    service(:dns, 'dns/dynect')
+
+  end
+end

data/lib/fog/providers/rackspace.rb

@@ -8,6 +8,7 @@ module Fog
     service(:cdn,     'cdn/rackspace')
     service(:compute, 'compute/rackspace')
     service(:storage, 'storage/rackspace')
+    service(:load_balancers, 'rackspace/load_balancers')
 
     def self.authenticate(options)
       rackspace_auth_url = options[:rackspace_auth_url] || "auth.api.rackspacecloud.com"

data/lib/fog/rackspace/load_balancers.rb

@@ -0,0 +1,179 @@
+module Fog
+  module Rackspace
+    class LoadBalancers < Fog::Service
+
+      class ServiceError < Fog::Errors::Error
+        attr_reader :response_data
+
+        def self.slurp(error)
+          if error.response.body.empty?
+            data = nil
+            message = nil
+          else
+            data = MultiJson.decode(error.response.body)
+            message = data['message']
+          end
+
+          new_error = super(error, message)
+          new_error.instance_variable_set(:@response_data, data)
+          new_error
+        end
+      end
+
+      class InternalServerError < ServiceError; end
+
+      class BadRequest < ServiceError
+        #TODO - Need to find a bette way to print out these validation errors when they are thrown
+        attr_reader :validation_errors
+
+        def self.slurp(error)
+          new_error = super(error)
+          unless new_error.response_data.nil?
+            new_error.instance_variable_set(:@validation_errors, new_error.response_data['validationErrors'])
+          end
+          new_error
+        end
+      end
+
+      DFW_ENDPOINT = 'https://dfw.loadbalancers.api.rackspacecloud.com/v1.0/'
+      ORD_ENDPOINT = 'https://ord.loadbalancers.api.rackspacecloud.com/v1.0/'
+      LON_ENDPOINT = 'https://lon.loadbalancers.api.rackspacecloud.com/v1.0/'
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url
+      recognizes :rackspace_auth_token
+
+      model_path 'fog/rackspace/models/load_balancers'
+      collection :load_balancers
+      model :load_balancer
+      collection :nodes
+      model :node
+      collection :virtual_ips
+      model :virtual_ip
+      collection :access_rules
+      model :access_rule
+
+      request_path 'fog/rackspace/requests/load_balancers'
+      request :create_load_balancer
+      request :get_load_balancer
+      request :list_load_balancers
+      request :update_load_balancer
+      request :delete_load_balancer
+      request :create_node
+      request :list_nodes
+      request :get_node
+      request :update_node
+      request :delete_node
+      request :delete_nodes
+      request :create_virtual_ip
+      request :list_virtual_ips
+      request :delete_virtual_ip
+      request :list_protocols
+      request :list_algorithms
+      request :get_connection_logging
+      request :set_connection_logging
+      request :create_access_rule
+      request :list_access_rules
+      request :delete_access_rule
+      request :delete_all_access_rules
+      request :get_session_persistence
+      request :set_session_persistence
+      request :remove_session_persistence
+      request :get_connection_throttling
+      request :remove_connection_throttling
+      request :set_connection_throttling
+      request :get_monitor
+      request :set_monitor
+      request :remove_monitor
+      request :get_usage
+      request :get_load_balancer_usage
+
+      module Shared
+
+        def algorithms
+          list_algorithms.body['algorithms'].collect { |i| i['name'] }
+        end
+
+        def protocols
+          list_protocols.body['protocols']
+        end
+
+        def usage(options = {})
+          get_usage(options).body
+        end
+
+      end
+
+      class Mock
+        include Shared
+
+        def initialize(options={})
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+        end
+
+      end
+
+      class Real
+        include Shared
+
+        def initialize(options={})
+          require 'multi_json'
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @rackspace_must_reauthenticate = false
+          uri = URI.parse(options[:rackspace_lb_endpoint] || DFW_ENDPOINT)
+          @host = uri.host
+          @path = uri.path
+          @port = uri.port
+          @scheme = uri.scheme
+
+          authenticate
+
+          @connection = Fog::Connection.new(uri.to_s, options[:persistent])
+        end
+
+        def request(params)
+          #TODO - Unify code with other rackspace services
+          begin
+            response = @connection.request(params.merge!({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}"
+            }))
+          rescue Excon::Errors::NotFound => error
+            raise NotFound.slurp error
+          rescue Excon::Errors::BadRequest => error
+            raise BadRequest.slurp error
+          rescue Excon::Errors::InternalServerError => error
+            raise InternalServerError.slurp error
+          rescue Excon::Errors::HTTPStatusError => error
+            raise ServiceError.slurp error
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+        def authenticate
+          options = {
+            :rackspace_api_key  => @rackspace_api_key,
+            :rackspace_username => @rackspace_username,
+            :rackspace_auth_url => @rackspace_auth_url
+          }
+          credentials = Fog::Rackspace.authenticate(options)
+          @auth_token = credentials['X-Auth-Token']
+          account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1]
+          @path = "#{@path}/#{account_id}"
+        end
+
+      end
+    end
+  end
+end