fog 0.5.2 → 0.5.3

data/lib/fog/storage/google.rb

@@ -202,7 +202,10 @@ module Fog
           @host = options[:host] || 'commondatastorage.googleapis.com'
           @port   = options[:port]      || 443
           @scheme = options[:scheme]    || 'https'
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent] || true)
+          unless options.has_key?(:persistent)
+            options[:persistent] = true
+          end
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
         end
 
         def reload

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

@@ -35,6 +35,22 @@ module Fog
             end
           end
 
+          # disables monitoring for this service
+          def disable_monitor
+            if self.monitor and self.monitor[:type] == "Disabled"
+              raise RuntimeError.new("Monitoring already disabled")
+            else
+              self.monitor = {:type => "Disabled", :is_enabled => "true"}
+              self.save
+            end
+          end
+
+          # enable default ping monitoring, use monitor= for more exotic forms (ECV & HTTP)
+          def enable_ping_monitor
+            self.monitor = nil
+            self.save
+          end
+
           def monitor=(new_monitor = {})
             if new_monitor.nil? || new_monitor.empty?
               attributes[:monitor] = nil
@@ -43,7 +59,13 @@ module Fog
               attributes[:monitor][:type] = new_monitor[:MonitorType] || new_monitor[:type]
               attributes[:monitor][:url_send_string] = new_monitor[:UrlSendString] || new_monitor[:url_send_string]
               attributes[:monitor][:http_headers] = new_monitor[:HttpHeader] || new_monitor[:http_headers]
-              attributes[:monitor][:http_headers] = attributes[:monitor][:http_headers].split("\n") unless attributes[:monitor][:http_headers].is_a?(Array)
+              if attributes[:monitor][:http_headers]
+                if attributes[:monitor][:http_headers].is_a?(String)
+                  attributes[:monitor][:http_headers] = attributes[:monitor][:http_headers].split("\n")
+                else
+                  attributes[:monitor][:http_headers] = attributes[:monitor][:http_headers]
+                end
+              end
               attributes[:monitor][:receive_string] = new_monitor[:ReceiveString] || new_monitor[:receive_string]
               attributes[:monitor][:interval] = new_monitor[:Interval] || new_monitor[:interval]
               attributes[:monitor][:response_timeout] = new_monitor[:ResponseTimeOut] || new_monitor[:response_timeout]

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

@@ -5,18 +5,26 @@ module Fog
         module Shared
           def validate_internet_service_monitor(monitor)
             #FIXME: Refactor this type of function into something generic
-            required_opts = [:type, :url_send_string, :http_headers, :receive_string, :is_enabled]
+            unless ['Disabled','HTTP','ECV'].include?(monitor[:type])
+              raise ArgumentError.new("Supported monitor types are: ECV & HTTP")
+            end
+
+            required_opts = case monitor[:type]
+                            when "Disabled"
+                              [:type, :is_enabled]
+                            else
+                              [:type, :url_send_string, :http_headers, :receive_string, :is_enabled]
+                            end
 
             unless required_opts.all? { |opt| monitor.keys.include?(opt) && monitor[opt] }
               raise ArgumentError.new("Required Monitor data missing: #{(required_opts - monitor.keys).map(&:inspect).join(", ")}")
             end
 
-            unless ['HTTP','ECV'].include?(monitor[:type])
-              raise ArgumentError.new("Supported monitor types are: ECV & HTTP")
-            end
-
-            unless monitor[:http_headers].is_a?(Array) || monitor[:http_headers].is_a?(String)
-              raise ArgumentError.new("Monitor :http_headers must be a String or Array")
+            case monitor[:type]
+              when "HTTP", "ECV"
+                unless monitor[:http_headers].is_a?(Array) || monitor[:http_headers].is_a?(String)
+                  raise ArgumentError.new("Monitor :http_headers must be a String or Array")
+                end
             end
 
             unless [true, false, "true", "false"].include?(monitor[:is_enabled])
@@ -33,6 +41,28 @@ module Fog
               raise ArgumentError.new("Required Internet Service data missing: #{(required_opts - service_data.keys).map(&:inspect).join(", ")}")
             end
           end
+
+          def ensure_monitor_defaults!(monitor)
+            if monitor[:http_headers].is_a?(String)
+              monitor[:http_headers] = [ monitor[:http_headers] ]
+            end
+
+            unless monitor[:retries]
+              monitor[:retries] = 3
+            end
+
+            unless monitor[:response_timeout]
+              monitor[:response_timeout] = 2
+            end
+
+            unless monitor[:down_time]
+              monitor[:down_time] = 30
+            end
+
+            unless monitor[:interval]
+              monitor[:interval] = 5
+            end
+          end
         end
 
         class Real
@@ -75,38 +105,20 @@ module Fog
           def generate_monitor_section(builder, monitor)
             builder.Monitor {
               builder.MonitorType(monitor[:type])
-              builder.UrlSendString(monitor[:url_send_string])
-              builder.HttpHeader(monitor[:http_headers].join("\n"))
-              builder.ReceiveString(monitor[:receive_string])
-              builder.Interval(monitor[:interval])
-              builder.ResponseTimeOut(monitor[:response_timeout])
-              builder.DownTime(monitor[:downtime])
-              builder.Retries(monitor[:retries])
+              case monitor[:type]
+              when "ECV","HTTP"
+                builder.UrlSendString(monitor[:url_send_string])
+                builder.HttpHeader(monitor[:http_headers].join("\n"))
+                builder.ReceiveString(monitor[:receive_string])
+                builder.Interval(monitor[:interval])
+                builder.ResponseTimeOut(monitor[:response_timeout])
+                builder.DownTime(monitor[:downtime])
+                builder.Retries(monitor[:retries])
+              end
               builder.IsEnabled(monitor[:is_enabled])
             }
           end
 
-          def ensure_monitor_defaults!(monitor)
-            if monitor[:http_headers].is_a?(String)
-              monitor[:http_headers] = [ monitor[:http_headers] ]
-            end
-
-            unless monitor[:retries]
-              monitor[:retries] = 3
-            end
-
-            unless monitor[:response_timeout]
-              monitor[:response_timeout] = 2
-            end
-
-            unless monitor[:down_time]
-              monitor[:down_time] = 30
-            end
-
-            unless monitor[:interval]
-              monitor[:interval] = 5
-            end
-          end
         end
 
         class Mock

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

@@ -80,6 +80,11 @@ module Fog
 
             validate_internet_service_data(service_data, true)
 
+            if monitor = service_data[:monitor]
+              validate_internet_service_monitor(monitor)
+              ensure_monitor_defaults!(monitor)
+            end
+
             validate_public_ip_address_data(ip_address_data)
 
             internet_service_uri = ensure_unparsed(internet_service_uri)

data/spec/vcloud/models/vdc_spec.rb

@@ -6,24 +6,24 @@ if Fog.mocking?
     describe :class do
       subject { Fog::Vcloud::Vdc }
 
-      it { should have_identity :href }
+      it { should have_identity(:href) }
 
-      it { should have_only_these_attributes [:href, :name, :type, :description, :other_links, :compute_capacity, :storage_capacity, :available_networks,
-                                              :resource_entities, :enabled, :vm_quota, :nic_quota, :network_quota, :allocation_model] }
+      it { should have_only_these_attributes([:href, :name, :type, :description, :other_links, :compute_capacity, :storage_capacity, :available_networks,
+                                              :resource_entities, :enabled, :vm_quota, :nic_quota, :network_quota, :allocation_model]) }
     end
 
     context "with no uri" do
 
       subject { Fog::Vcloud::Vdc.new() }
 
-      it { should have_all_attributes_be_nil }
+      it { should(have_all_attributes_be_nil) }
 
     end
 
     context "as a collection member" do
       subject { @vcloud.vdcs[0].reload }
 
-      it { should be_an_instance_of Fog::Vcloud::Vdc }
+      it { should be_an_instance_of(Fog::Vcloud::Vdc) }
 
       its(:href)                  { should == @mock_vdc.href }
       its(:identity)              { should == @mock_vdc.href }
@@ -32,12 +32,12 @@ if Fog.mocking?
       its(:resource_entities)     { should have(3).items }
       its(:available_networks)    { should have(2).items }
 
-      its(:compute_capacity)      { should be_an_instance_of Hash }
+      its(:compute_capacity)      { should be_an_instance_of(Hash) }
       its(:compute_capacity)      { should == {:Cpu =>
                                                 {:Units => "Mhz", :Allocated => @mock_vdc.cpu_allocated.to_s, :Limit => @mock_vdc.cpu_allocated.to_s},
                                                :Memory =>
                                                 {:Units => "MB", :Allocated => @mock_vdc.memory_allocated.to_s, :Limit => @mock_vdc.memory_allocated.to_s}} }
-      its(:storage_capacity)      { should be_an_instance_of Hash }
+      its(:storage_capacity)      { should be_an_instance_of(Hash) }
       its(:storage_capacity)      { should == {:Limit => @mock_vdc.storage_allocated.to_s, :Units=>"MB", :Allocated => @mock_vdc.storage_allocated.to_s} }
 
       its(:vm_quota)              { should == "0" }
@@ -48,5 +48,4 @@ if Fog.mocking?
 
     end
   end
-else
 end

data/spec/vcloud/requests/get_network_spec.rb

@@ -4,7 +4,7 @@ if Fog.mocking?
   describe Fog::Vcloud, :type => :mock_vcloud_request do
     subject { @vcloud }
 
-    it { should respond_to :get_network }
+    it { should respond_to(:get_network) }
 
     describe :get_network, :type => :vcloud_request do
       context "with a valid network uri" do
@@ -12,7 +12,7 @@ if Fog.mocking?
         subject { @network }
 
         it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
+        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.network+xml") }
 
         describe :body do
           subject { @network.body }
@@ -20,19 +20,19 @@ if Fog.mocking?
           it { should have(9).keys }
 
           it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-          it { should have_key_with_value :type, "application/vnd.vmware.vcloud.network+xml" }
-          it { should have_key_with_value :Features, {:FenceMode => "isolated"} }
-          it { should have_key_with_value :Description, @mock_network.name }
-          it { should have_key_with_value :href, @mock_network.href }
-          it { should have_key_with_value :name, @mock_network.name }
-          it { should have_key_with_value :Configuration, {:Gateway => @mock_network.gateway,
+          it { should have_key_with_value(:type, "application/vnd.vmware.vcloud.network+xml") }
+          it { should have_key_with_value(:Features, {:FenceMode => "isolated"}) }
+          it { should have_key_with_value(:Description, @mock_network.name) }
+          it { should have_key_with_value(:href, @mock_network.href) }
+          it { should have_key_with_value(:name, @mock_network.name) }
+          it { should have_key_with_value(:Configuration, {:Gateway => @mock_network.gateway,
                                                            :Netmask => @mock_network.netmask,
-                                                           :Dns => @mock_network.dns } }
+                                                           :Dns => @mock_network.dns }) }
         end
       end
       context "with a network uri that doesn't exist" do
         subject { lambda { @vcloud.get_network(URI.parse('https://www.fakey.com/api/v0.8/network/999')) } }
-        it_should_behave_like "a request for a resource that doesn't exist"
+        it_should_behave_like("a request for a resource that doesn't exist")
       end
     end
   end

data/spec/vcloud/requests/get_organization_spec.rb

@@ -4,7 +4,7 @@ if Fog.mocking?
   describe Fog::Vcloud, :type => :mock_vcloud_request do
     subject { @vcloud }
 
-    it { should respond_to :get_organization }
+    it { should respond_to(:get_organization) }
 
     describe "#get_organization" do
       context "with a valid organization uri" do
@@ -12,7 +12,7 @@ if Fog.mocking?
         subject { @organization }
 
         it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.org+xml" }
+        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.org+xml") }
 
         describe "#body" do
           subject { @organization.body }
@@ -23,9 +23,9 @@ if Fog.mocking?
           it { should have(6).keys }
 
           it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-          it { should have_key_with_value :href, @mock_organization.href }
-          it { should have_key_with_value :name, @mock_organization.name }
-          it { should have_key_with_array :Link, @mock_organization.vdcs.map { |vdc|
+          it { should have_key_with_value(:href, @mock_organization.href)}
+          it { should have_key_with_value(:name, @mock_organization.name) }
+          it { should have_key_with_array(:Link, @mock_organization.vdcs.map { |vdc|
                                                  [{ :type => "application/vnd.vmware.vcloud.vdc+xml",
                                                     :href => vdc.href,
                                                     :name => vdc.name,
@@ -38,16 +38,15 @@ if Fog.mocking?
                                                     :href => vdc.task_list.href,
                                                     :name => vdc.task_list.name,
                                                     :rel => "down" }]
-                                                  }.flatten }
+                                                  }.flatten) }
 
         end
       end
       context "with an organization uri that doesn't exist" do
         subject { lambda { @vcloud.get_organization(URI.parse('https://www.fakey.com/api/v0.8/org/999')) } }
-        it_should_behave_like "a request for a resource that doesn't exist"
+        it_should_behave_like("a request for a resource that doesn't exist")
       end
     end
   end
-else
 end
 

data/spec/vcloud/requests/get_vdc_spec.rb

@@ -8,7 +8,7 @@ if Fog.mocking?
   describe Fog::Vcloud, :type => :mock_vcloud_request do
     subject { @vcloud }
 
-    it { should respond_to :get_vdc }
+    it { should respond_to(:get_vdc) }
 
     describe :get_vdc, :type => :vcloud_request do
       context "with a valid vdc uri" do
@@ -16,14 +16,14 @@ if Fog.mocking?
         subject { @vdc }
 
         it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.vdc+xml" }
+        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.vdc+xml") }
 
         describe :body do
           subject { @vdc.body }
 
           it { should have(16).items }
 
-          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
+          it_should_behave_like("it has the standard vcloud v0.8 xmlns attributes")   # 3 keys
 
           its(:name)            { should == @mock_vdc.name }
           its(:href)            { should == @mock_vdc.href }
@@ -53,11 +53,10 @@ if Fog.mocking?
       end
       context "with a vdc uri that doesn't exist" do
         subject { lambda { @vcloud.get_vdc(URI.parse('https://www.fakey.com/api/v0.8/vdc/999')) } }
-        it_should_behave_like "a request for a resource that doesn't exist"
+        it_should_behave_like("a request for a resource that doesn't exist")
       end
     end
   end
-else
 end
 
 

data/spec/vcloud/requests/get_versions_spec.rb

@@ -4,7 +4,7 @@ shared_examples_for "real or mock get_versions requests" do
 
   subject { @vcloud }
 
-  it { should respond_to :get_versions }
+  it { should respond_to(:get_versions) }
 
   describe "#get_versions" do
     subject { @vcloud.get_versions( @vcloud.versions_uri ) }
@@ -29,7 +29,7 @@ shared_examples_for "real or mock get_versions requests" do
             version_info.should include(:LoginUrl)
             version_info[:LoginUrl].should be_a_url
             version_info.should include(:Version)
-            version_info[:Version].should be_an_instance_of String
+            version_info[:Version].should be_an_instance_of(String)
           end
         }
       end

data/spec/vcloud/spec_helper.rb

@@ -30,34 +30,38 @@ def arrayify(item)
   item.is_a?(Array) ? item : [ item ]
 end
 
+def ecloud_disabled_default_monitor
+  {:url_send_string=>nil, :receive_string=>nil, :response_timeout=>2, :retries=>3, :is_enabled=>"true", :down_time=>30, :type=>"Disabled", :http_headers=>nil, :interval=>5, :downtime=>nil}
+end
+
 shared_examples_for "all responses" do
-  it { should be_an_instance_of Excon::Response }
-  it { should respond_to :body }
-  it { should respond_to :headers }
+  it { should be_an_instance_of(Excon::Response) }
+  it { should respond_to(:body) }
+  it { should respond_to(:headers) }
   it { should have_at_least(1).body }
   it { should have_at_least(0).headers }
-  its(:body) { should be_an_instance_of Hash }
-  its(:headers) { should be_an_instance_of Hash }
+  its(:body) { should be_an_instance_of(Hash) }
+  its(:headers) { should be_an_instance_of(Hash) }
 end
 
 shared_examples_for "all delete responses" do
-  it { should be_an_instance_of Excon::Response }
-  it { should respond_to :body }
-  it { should respond_to :headers }
-  its(:headers) { should be_an_instance_of Hash }
+  it { should be_an_instance_of(Excon::Response) }
+  it { should respond_to(:body) }
+  it { should respond_to(:headers) }
+  its(:headers) { should be_an_instance_of(Hash) }
 end
 
 shared_examples_for "it has a Content-Type header" do
-  its(:headers) { should include "Content-Type" }
+  its(:headers) { should include("Content-Type") }
 end
 
 shared_examples_for "all rel=down vcloud links" do
-  it { should be_an_instance_of Struct::VcloudLink }
+  it { should be_an_instance_of(Struct::VcloudLink) }
   specify { subject.rel.should == "down" }
 end
 
 shared_examples_for "all vcloud links w/o a rel" do
-  it { should be_an_instance_of Struct::VcloudLink }
+  it { should be_an_instance_of(Struct::VcloudLink) }
   specify { subject.rel.should == nil }
 end
 
@@ -91,21 +95,21 @@ end
 
 shared_examples_for "all login requests" do
 
-  it { should respond_to :login }
+  it { should respond_to(:login) }
 
   describe "#login" do
     before { @login = @vcloud.login }
     subject { @login }
 
-    it_should_behave_like "all responses"
+    it_should_behave_like("all responses")
 
-    its(:headers) { should include "Set-Cookie" }
+    its(:headers) { should include("Set-Cookie") }
 
     describe "#body" do
       subject { @login.body }
 
       it { should have(4).items }
-      it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
+      it_should_behave_like("it has the standard vcloud v0.8 xmlns attributes")   # 3 keys
       it { should include(:Org) }
 
       describe ":Org" do
@@ -114,11 +118,11 @@ shared_examples_for "all login requests" do
         specify do
           subject.each do |org|
             org.should include(:type)
-            org[:type].should be_of_type "application/vnd.vmware.vcloud.org+xml"
+            org[:type].should be_of_type("application/vnd.vmware.vcloud.org+xml")
             org.should include(:name)
-            org[:name].should be_an_instance_of String
+            org[:name].should be_an_instance_of(String)
             org.should include(:href)
-            org[:href].should be_a_url
+            org[:href].should(be_a_url)
           end
         end
       end
@@ -139,17 +143,17 @@ shared_examples_for "it has the proper xmlns_xsd" do
 end
 
 shared_examples_for "it has the standard xmlns attributes" do
-  it_should_behave_like "it has the proper xmlns_xsi"
-  it_should_behave_like "it has the proper xmlns_xsd"
+  it_should_behave_like("it has the proper xmlns_xsi")
+  it_should_behave_like("it has the proper xmlns_xsd")
 end
 
 shared_examples_for "it has the standard vcloud v0.8 xmlns attributes" do
-  it_should_behave_like "it has a vcloud v0.8 xmlns"
-  it_should_behave_like "it has the standard xmlns attributes"
+  it_should_behave_like("it has a vcloud v0.8 xmlns")
+  it_should_behave_like("it has the standard xmlns attributes")
 end
 
 shared_examples_for "a request for a resource that doesn't exist" do
-  it { should raise_error Excon::Errors::Unauthorized }
+  it { should raise_error(Excon::Errors::Unauthorized) }
 end
 
 shared_examples_for "a vdc catalog link" do
@@ -159,8 +163,8 @@ shared_examples_for "a vdc catalog link" do
 end
 
 shared_examples_for "a tmrk network link" do
-  it_should_behave_like "all vcloud links w/o a rel"
-  it_should_behave_like "all vcloud network types"
+  it_should_behave_like("all vcloud links w/o a rel")
+  it_should_behave_like("all vcloud network types")
 end
 
 shared_examples_for "the mocked tmrk network links" do
@@ -186,22 +190,22 @@ shared_examples_for "the mocked tmrk resource entity links" do
 
   describe "[0]" do
     subject { @vdc.body.resource_entities[0] }
-    it_should_behave_like "a vapp type"
-    it_should_behave_like "all vcloud links w/o a rel"
+    it_should_behave_like("a vapp type")
+    it_should_behave_like("all vcloud links w/o a rel")
     its(:href) { should == URI.parse(@mock_vdc[:vms][0][:href]) }
     its(:name) { should == @mock_vdc[:vms][0][:name] }
   end
   describe "[1]" do
     subject { @vdc.body.resource_entities[1] }
-    it_should_behave_like "a vapp type"
-    it_should_behave_like "all vcloud links w/o a rel"
+    it_should_behave_like("a vapp type")
+    it_should_behave_like("all vcloud links w/o a rel")
     its(:href) { should == URI.parse(@mock_vdc[:vms][1][:href]) }
     its(:name) { should == @mock_vdc[:vms][1][:name] }
   end
   describe "[2]" do
     subject { @vdc.body.resource_entities[2] }
-    it_should_behave_like "a vapp type"
-    it_should_behave_like "all vcloud links w/o a rel"
+    it_should_behave_like("a vapp type")
+    it_should_behave_like("all vcloud links w/o a rel")
     its(:href) { should == URI.parse(@mock_vdc[:vms][2][:href]) }
     its(:name) { should == @mock_vdc[:vms][2][:name] }
   end