fog 0.3.34 → 0.4.0

data/lib/fog/rackspace/requests/compute/list_flavors_detail.rb

@@ -25,7 +25,20 @@ module Fog
       class Mock
 
         def list_flavors_detail
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'flavors' => [
+              { 'name' => '256 server',    'id' => 1, 'ram' => 256,    'disk' => 10   },
+              { 'name' => '512 server',    'id' => 2, 'ram' => 512,    'disk' => 20   },
+              { 'name' => '1GB server',    'id' => 3, 'ram' => 1024,   'disk' => 40   },
+              { 'name' => '2GB server',    'id' => 4, 'ram' => 2048,   'disk' => 80   },
+              { 'name' => '4GB server',    'id' => 5, 'ram' => 4096,   'disk' => 160  },
+              { 'name' => '8GB server',    'id' => 6, 'ram' => 8192,   'disk' => 320  },
+              { 'name' => '15.5GB server', 'id' => 7, 'ram' => 15872,  'disk' => 620  }
+            ]
+          }
+          response
         end
 
       end

data/lib/fog/slicehost/bin.rb

@@ -26,7 +26,7 @@ class Slicehost < Fog::Bin
     end
 
     def services
-      [:compute]
+      [:compute, :dns]
     end
 
   end

data/lib/fog/slicehost/dns.rb

@@ -6,6 +6,10 @@ module Fog
       recognizes :host, :port, :scheme, :persistent
 
       model_path 'fog/slicehost/models/dns'
+      model       :record
+      collection  :records
+      model       :zone
+      collection  :zones
 
       request_path 'fog/slicehost/requests/dns'
       request :create_record

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

@@ -0,0 +1,66 @@
+require 'fog/core/model'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Record < Fog::Model
+
+        identity :id
+
+        attribute :active
+        attribute :ip,          :aliases => 'ip'
+        attribute :name
+        attribute :description, :aliases => 'aux'
+        attribute :ttl
+        attribute :type,        :aliases => 'record_type'
+        attribute :zone_id
+
+        def initialize(attributes={})
+          self.active ||= true
+          self.ttl    ||= 3600
+          super
+        end
+
+        def active=(new_active)
+          attributes[:active] = case new_active
+          when false, 'N'
+            false
+          when true, 'Y'
+            true
+          end
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_record(identity)
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :ip, :name, :type, :zone
+          options = {}
+          options[:active]  = active ? 'Y' : 'N'
+          options[:aux]     = description if description
+          options[:ttl]     = ttl if ttl
+          data = connection.create_record(type, zone.id, name, ip, options)
+          merge_attributes(data.body)
+          true
+        end
+
+        private
+        
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/dns/record'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::Slicehost::DNS::Record
+
+        def all
+          requires :zone
+          data = connection.get_records.body['records']
+          load(data).reject {|record| record.zone_id != zone.id}
+        end
+
+        def get(record_id)
+          data = connection.get_record(record_id).body
+          new(data)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'fog/core/model'
+require 'fog/slicehost/models/dns/records'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Zone < Fog::Model
+
+        identity :id
+
+        attribute :active
+        attribute :domain, :aliases => 'origin'
+        attribute :ttl
+
+        def initialize(attributes={})
+          self.active ||= true
+          self.ttl    ||= 3600
+          super
+        end
+
+        def active=(new_active)
+          attributes[:active] = case new_active
+          when false, 'N'
+            false
+          when true, 'Y'
+            true
+          end
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_zone(identity)
+          true
+        end
+
+        def records
+          @records ||= begin
+            Fog::Slicehost::DNS::Records.new(
+              :zone       => self,
+              :connection => connection
+            )
+          end
+        end
+
+        def nameservers
+          [
+            'ns1.slicehost.net',
+            'ns2.slicehost.net',
+            'ns3.slicehost.net'
+          ]
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :active, :domain, :ttl
+          options = {}
+          options[:active]  = active ? 'Y' : 'N'
+          options[:ttl]     = ttl
+          data = connection.create_zone(domain, options)
+          merge_attributes(data.body)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/dns/zone'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Zones < Fog::Collection
+
+        model Fog::Slicehost::DNS::Zone
+
+        def all
+          data = connection.get_zones.body['zones']
+          load(data)
+        end
+
+        def get(zone_id)
+          data = connection.get_zone(zone_id).body
+          new(data)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -24,8 +24,7 @@ module Fog
         #     * 'data'<~String> - as above
         #     * 'active'<~String> - as above
         #     * 'aux'<~String> - as above
-        def create_record( record_type, zone_id, name, data, options = {})
-          
+        def create_record(record_type, zone_id, name, data, options = {})
           optional_tags= ''
           options.each { |option, value|
             case option
@@ -51,7 +50,7 @@ module Fog
 
       class Mock
 
-        def create_record( record_type, zone_id, name, data)
+        def create_record(record_type, zone_id, name, data)
           Fog::Mock.not_implemented
         end
 

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

@@ -17,7 +17,7 @@ module Fog
         #     * '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
-        def get_record( record_id)
+        def get_record(record_id)
           request(
             :expects  => 200,
             :method   => 'GET',

data/lib/fog/vcloud/terremark/ecloud.rb

@@ -4,7 +4,7 @@ module Fog
       class Ecloud < Fog::Vcloud
 
         requires   :username, :password, :versions_uri
-        recognizes :version
+        recognizes :module, :version
 
         model_path 'fog/vcloud/terremark/ecloud/models'
         model :catalog_item

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

@@ -12,13 +12,18 @@ module Fog
         attribute :ip,          :aliases => 'data'
         attribute :domain,      :aliases => 'fqdn'
         attribute :name,        :aliases => 'hostname'
-        attribute :notes
+        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={})
+          self.ttl    ||= 3600
+          super
+        end
+
         def destroy
           requires :identity
           connection.delete_host(identity)
@@ -33,10 +38,16 @@ module Fog
           requires :zone, :type, :ip
           options = {}
           options[:hostname]  = name if name
-          options[:notes]     = notes if notes
+          options[:notes]     = description if description
           options[:priority]  = priority if priority
           options[:ttl]       = ttl if ttl
-          data = connection.create_host(@zone.id, type, ip, options)
+          data = unless identity
+            connection.create_host(@zone.id, type, ip, options)
+          else
+            options[:host_type] = type
+            options[:data]      = data
+            connection.update_host(identity, options)
+          end
           merge_attributes(data.body)
           true
         end

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

@@ -25,7 +25,7 @@ module Fog
         def get(record_id)
           data = connection.get_host(record_id).body
           new(data)
-        rescue Excon::Errors::NotFound
+        rescue Fog::Service::NotFound
           nil
         end
 

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

@@ -70,7 +70,13 @@ module Fog
           #   * 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 = connection.create_zone(domain, ttl, type, options)
+          data = unless identity
+            connection.create_zone(domain, ttl, type, options)
+          else
+            options[:default_ttl] = ttl
+            options[:ns_type]     = type
+            connection.update_zone(identity, options)
+          end
           merge_attributes(data.body)
           true
         end

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

@@ -19,7 +19,7 @@ module Fog
           zone = new(data)
           zone.records.load(data['hosts'])
           zone
-        rescue Excon::Errors::Forbidden
+        rescue Fog::Service::NotFound
           nil
         end
 

data/spec/spec_helper.rb

@@ -8,30 +8,6 @@ if ENV["FOG_MOCK"] == "true"
   Fog.mock!
 end
 
-def eventually(max_delay = 16, &block)
-  delays = [0]
-  delay_step = 1
-  total = 0
-  while true
-    delay = 1
-    delay_step.times do
-      delay *= 2
-    end
-    delays << delay
-    delay_step += 1
-    break if delay >= max_delay
-  end
-  delays.each do |delay|
-    begin
-      sleep(delay)
-      yield
-      break
-    rescue => error
-      raise error if delay >= max_delay
-    end
-  end
-end
-
 unless defined?(GENTOO_AMI)
   GENTOO_AMI = 'ami-5ee70037'
 end

data/tests/aws/requests/iam/helper.rb

@@ -0,0 +1,15 @@
+class AWS
+
+  module IAM
+
+    module Formats
+
+      BASIC = {
+        'RequestId' => String
+      }
+
+    end
+
+  end
+
+end

data/tests/aws/requests/simpledb/attributes_tests.rb

@@ -0,0 +1,75 @@
+Shindo.tests('AWS::SimpleDB | attributes requests', ['aws']) do
+
+  @domain_name = "fog_domain_#{Time.now.to_f.to_s.gsub('.','')}"
+
+  AWS[:sdb].create_domain(@domain_name)
+
+  tests('success') do
+
+    tests("#batch_put_attributes('#{@domain_name}', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } }).body
+    end
+
+    tests("#get_attributes('#{@domain_name}', 'a').body['Attributes']").returns({'b' => ['c']}) do
+      attributes = {}
+      Fog.wait_for {
+        attributes = AWS[:sdb].get_attributes(@domain_name, 'a').body['Attributes']
+        attributes != {}
+      }
+      attributes
+    end
+
+    tests("#get_attributes('#{@domain_name}', 'notanattribute')").succeeds do
+      AWS[:sdb].get_attributes(@domain_name, 'notanattribute')
+    end
+
+    tests("#select('select * from #{@domain_name}').body['Items']").returns({ 'a' => { 'b' => ['c'] }, 'x' => { 'y' => ['z'] } }) do
+      pending if Fog.mocking?
+      AWS[:sdb].select("select * from #{@domain_name}").body['Items']
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '1' }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '1' }).body
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body
+    end
+
+    tests("#delete_attributes('#{@domain_name}', 'a').body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].delete_attributes(@domain_name, 'a').body
+    end
+
+    tests("#delete_attributes('#{@domain_name}', 'a').body").succeeds do
+      AWS[:sdb].delete_attributes(@domain_name, 'a').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
+    end
+
+    tests("#get_attributes('notadomain', 'a')").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].get_attributes('notadomain', 'a')
+    end
+
+    tests("#put_attributes('notadomain', 'conditional', { 'version' => '1' })").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].put_attributes('notadomain', 'foo', { 'version' => '1' })
+    end
+
+    tests("#put_attributes('#{@domain_name}', 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])").raises(Excon::Errors::Conflict) do
+      AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])
+    end
+
+    tests("#delete_attributes('notadomain', 'a')").raises(Excon::Errors::BadRequest) do
+      AWS[:sdb].delete_attributes('notadomain', 'a')
+    end
+
+  end
+
+  AWS[:sdb].delete_domain(@domain_name)
+
+end