fog 0.3.31 → 0.3.32

data/lib/fog/rackspace/compute.rb

@@ -2,8 +2,8 @@ module Fog
   module Rackspace
     class Compute < Fog::Service
 
-      requires :rackspace_api_key, :rackspace_username, &inject_parameter_specs
-      recognizes :rackspace_auth_url, :persistent, &inject_parameter_specs
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :persistent
 
       model_path 'fog/rackspace/models/compute'
       model       :flavor

data/lib/fog/rackspace/storage.rb

@@ -2,8 +2,8 @@ module Fog
   module Rackspace
     class Storage < Fog::Service
 
-      requires :rackspace_api_key, :rackspace_username, &inject_parameter_specs
-      recognizes :rackspace_auth_url, :persistent, &inject_parameter_specs
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :persistent
 
       model_path 'fog/rackspace/models/storage'
       model       :directory

data/lib/fog/slicehost.rb

@@ -1,4 +1,6 @@
 require 'nokogiri'
+
+require File.join(File.dirname(__FILE__), 'core')
 require 'fog/core/parser'
 
 module Fog
@@ -8,6 +10,7 @@ module Fog
 
     service_path 'fog/slicehost'
     service :compute
+    service :dns
 
     def self.new(attributes = {})
       location = caller.first

data/lib/fog/slicehost/bin.rb

@@ -5,6 +5,8 @@ class Slicehost < Fog::Bin
       case key
       when :compute, :slices
         Fog::Slicehost::Compute
+      when :dns
+        Fog::Slicehost::DNS
       else 
         raise ArgumentError, "Unrecognized service: #{key}"
       end

data/lib/fog/slicehost/compute.rb

@@ -2,8 +2,8 @@ module Fog
   module Slicehost
     class Compute < Fog::Service
 
-      requires :slicehost_password, &inject_parameter_specs
-      recognizes :host, :port, :scheme, :persistent, &inject_parameter_specs
+      requires :slicehost_password
+      recognizes :host, :port, :scheme, :persistent
 
       model_path 'fog/slicehost/models/compute'
       model       :flavor

data/lib/fog/slicehost/dns.rb

@@ -0,0 +1,84 @@
+module Fog
+  module Slicehost
+    class DNS < Fog::Service
+
+      requires :slicehost_password
+      recognizes :host, :port, :scheme, :persistent
+
+      model_path 'fog/slicehost/models/dns'
+
+      request_path 'fog/slicehost/requests/dns'
+      request :create_record
+      request :create_zone
+      request :delete_record
+      request :delete_zone
+      request :get_record
+      request :get_records
+      request :get_zone
+      request :get_zones
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @slicehost_password = options[:slicehost_password]
+          @data = self.class.data[@slicehost_password]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          @slicehost_password = options[:slicehost_password]
+          @host   = options[:host]    || "api.slicehost.com"
+          @port   = options[:port]    || 443
+          @scheme = options[:scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params[:headers] ||= {}
+          params[:headers].merge!({
+            'Authorization' => "Basic #{Base64.encode64(@slicehost_password).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.merge!({:host => @host}))
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Slicehost::DNS::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/parsers/dns/create_record.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module Slicehost
+      module DNS
+
+        class CreateRecord < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'zone-id', 'ttl', 'id'
+              @response[name] = @value.to_i
+            when 'record-type', 'name', 'data', 'active', 'aux'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module Slicehost
+      module DNS
+
+        class CreateZone < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'ttl', 'id'
+              @response[name] = @value.to_i
+            when 'origin', 'active'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/parsers/dns/get_record.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module Slicehost
+      module DNS
+
+        class GetRecord < Fog::Parsers::Base
+
+          def reset
+            @response = { }
+          end
+
+          def end_element(name)
+            case name
+            when 'zone-id', 'ttl'
+              @response[name] = @value.to_i
+            when 'record-type', 'name', 'data', 'active', 'aux'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/parsers/dns/get_records.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Parsers
+    module Slicehost
+      module DNS
+
+        class GetRecords < Fog::Parsers::Base
+
+          def reset
+            @record = {}
+            @response = { 'records' => [] }
+          end
+
+          def end_element(name)
+            case name
+            when 'zone-id', 'ttl'
+              @record[name] = @value.to_i
+            when 'record-type', 'name', 'data', 'active', 'aux'
+              @record[name] = @value
+            when 'record'
+              @response['records'] << @record
+              @record = {}
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module Slicehost
+      module DNS
+
+        class GetZone < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'ttl', 'id'
+              @response[name] = @value.to_i
+            when 'origin', 'active'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/parsers/dns/get_zones.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Parsers
+    module Slicehost
+      module DNS
+
+        class GetZones < Fog::Parsers::Base
+
+          def reset
+            @zone = {}
+            @response = { 'zones' => [] }
+          end
+
+          def end_element(name)
+            case name
+            when 'ttl', 'id'
+              @zone[name] = @value.to_i
+            when 'active', 'origin'
+              @zone[name] = @value
+            when 'zone'
+              @response['zones'] << @zone
+              @zone = {}
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/requests/compute/create_slice.rb

@@ -5,7 +5,7 @@ module Fog
 
         require 'fog/slicehost/parsers/compute/create_slice'
 
-        # Get list of slices
+        # Create a new slice
         # ==== Parameters
         # * flavor_id<~Integer> - Id of flavor to create slice with
         # * image_id<~Integer> - Id of image to create slice with
@@ -13,7 +13,7 @@ module Fog
         #
         # ==== Returns
         # * response<~Excon::Response>:
-        #   * body<~Array>:
+        #   * body<~Hash>:
         #     * 'addresses'<~Array> - Ip addresses for the slice
         #     * 'backup-id'<~Integer> - Id of backup slice was booted from
         #     * 'bw-in'<~Integer> - Incoming bandwidth total for current billing cycle, in Gigabytes

data/lib/fog/slicehost/requests/compute/delete_slice.rb

@@ -3,26 +3,12 @@ module Fog
     class Compute
       class Real
 
-        # Get list of slices
+        # Delete a given slice
         # ==== Parameters
-        # * flavor_id<~Integer> - Id of flavor to create slice with
-        # * image_id<~Integer> - Id of image to create slice with
-        # * name<~String> - Name of slice
+        # * slice_id<~Integer> - Id of slice to delete
         #
         # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Array>:
-        #     * 'addresses'<~Array> - Ip addresses for the slice
-        #     * 'backup-id'<~Integer> - Id of backup slice was booted from
-        #     * 'bw-in'<~Integer> - Incoming bandwidth total for current billing cycle, in Gigabytes
-        #     * 'bw-out'<~Integer> - Outgoing bandwidth total for current billing cycle, in Gigabytes
-        #     * 'flavor-id'<~Integer> - Id of flavor slice was booted from
-        #     * 'id'<~Integer> - Id of the slice
-        #     * 'image-id'<~Integer> - Id of image slice was booted from
-        #     * 'name'<~String> - Name of the slice
-        #     * 'progress'<~Integer> - Progress of current action, in percentage
-        #     * 'root-password'<~String> - Root password of slice
-        #     * 'status'<~String> - Current status of the slice
+        # * response<~Excon::Response>: - HTTP status code is the return value
         def delete_slice(slice_id)
           request(
             :expects  => 200,

data/lib/fog/slicehost/requests/dns/create_record.rb

@@ -0,0 +1,61 @@
+module Fog
+  module Slicehost
+    class DNS
+      class Real
+
+        require 'fog/slicehost/parsers/dns/create_record'
+
+        # Create a new record in a DNS zone - or update an existing one
+        # ==== Parameters
+        # * record_type<~String> - type of DNS record to create (A, CNAME, etc)
+        # * zone_id<~Integer> - ID of the zone to update
+        # * name<~String> - host name this DNS record is for 
+        # * data<~String> - data for the DNS record (ie for an A record, the IP address)
+        # * options<~Hash> - extra parameters that are not mandatory
+        #   * ttl<~Integer> - time to live in seconds
+        #   * active<~String> - whether this record is active or not ('Y' or 'N')
+        #   * aux<~String> - extra data required by the record
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'name'<~String> - as above
+        #     * 'id'<~Integer> - Id of zone/domain - used in future API calls for this zone
+        #     * 'ttl'<~Integer> - as above
+        #     * 'data'<~String> - as above
+        #     * 'active'<~String> - as above
+        #     * 'aux'<~String> - as above
+        def create_record( record_type, zone_id, name, data, options = {})
+          
+          optional_tags= ''
+          options.each { |option, value|
+            case option
+            when :ttl
+              optional_tags+= "<ttl type='integer'>#{value}</ttl>"
+            when :active
+              optional_tags+= "<active>#{value}</active>"
+            when :aux
+              optional_tags+= "<aux>#{value}</aux>"
+            end
+          }
+          
+          request(
+            :body     => %Q{<?xml version="1.0" encoding="UTF-8"?><record><record_type>#{record_type}</record_type><zone_id type="integer">#{zone_id}</zone_id><name>#{name}</name><data>#{data}</data>#{optional_tags}</record>},
+            :expects  => 201,
+            :method   => 'POST',
+            :parser   => Fog::Parsers::Slicehost::DNS::CreateRecord.new,
+            :path     => 'records.xml'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_record( record_type, zone_id, name, data)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/requests/dns/create_zone.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Slicehost
+    class DNS
+      class Real
+
+        require 'fog/slicehost/parsers/dns/create_zone'
+
+        # Create a new zone for Slicehost's DNS servers to serve/host
+        # ==== Parameters
+        # * origin<~String> - domain name to host (ie example.com)
+        # * options<~Hash> - optional paramaters
+        #   * ttl<~Integer> - TimeToLive (ttl) for the domain, in seconds (> 60)
+        #   * active<~String> - whether zone is active in Slicehost DNS server - 'Y' or 'N'
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'origin'<~String> - as above
+        #     * 'id'<~Integer> - Id of zone/domain - used in future API calls
+        #     * 'ttl'<~Integer> - as above
+        #     * 'active'<~String> - as above
+        def create_zone(origin, options = {})
+
+          optional_tags= ''
+          options.each { |option, value|
+            case option
+            when :ttl
+              optional_tags+= "<ttl type='interger'>#{value}</ttl>"
+            when :active
+              optional_tags+= "<active>#{value}</active>"
+            end
+          }
+          
+          request(
+            :body     => %Q{<?xml version="1.0" encoding="UTF-8"?><zone><origin>#{origin}</origin>#{optional_tags}</zone>},
+            :expects  => 201,
+            :method   => 'POST',
+            :parser   => Fog::Parsers::Slicehost::DNS::CreateZone.new,
+            :path     => 'zones.xml'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_zone(origin, ttl, active)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end