fog 1.1.1 → 1.1.2

data/lib/fog/vsphere/requests/compute/vm_clone.rb

@@ -6,14 +6,19 @@ module Fog
         private
         def vm_clone_check_options(options)
           options = { 'force' => false }.merge(options)
-          required_options = %w{ instance_uuid name }
+          required_options = %w{ path name }
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
           end
-          # First, figure out if there's already a VM of the same name.
-          all_virtual_machines = list_virtual_machines['virtual_machines']
-          if not options['force'] and all_virtual_machines.detect { |vm| vm['name'] == options['name'] } then
-            raise Fog::Vsphere::Errors::ServiceError, "A VM already exists with name #{options['name']}"
+          # The tap removes the leading empty string
+          path_elements = options['path'].split('/').tap { |o| o.shift }
+          first_folder = path_elements.shift
+          if first_folder != 'Datacenters' then
+            raise ArgumentError, "vm_clone path option must start with /Datacenters.  Got: #{options['path']}"
+          end
+          dc_name = path_elements.shift
+          if not self.datacenters.include? dc_name then
+            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{self.dacenters.join(",")} are accessible."
           end
           options
         end
@@ -25,23 +30,47 @@ module Fog
           # Option handling
           options = vm_clone_check_options(options)
 
-          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
+          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
 
-          # REVISIT: This will have horrible performance for large sites.
-          # Find the Managed Object reference of the template VM (Wish I could do this with the API)
-          vm_mob_ref = list_all_virtual_machine_mobs.find(notfound) do |vm|
-            convert_vm_mob_ref_to_attr_hash(vm)['instance_uuid'] == options['instance_uuid']
+          # Find the template in the folder.  This is more efficient than
+          # searching ALL VM's looking for the template.
+          # Tap gets rid of the leading empty string and "Datacenters" element
+          # and returns the array.
+          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
+          # The DC name itself.
+          template_dc = path_elements.shift
+          # If the first path element contains "vm" this denotes the vmFolder
+          # and needs to be shifted out
+          path_elements.shift if path_elements[0] = 'vm'
+          # The template name.  The remaining elements are the folders in the
+          # datacenter.
+          template_name = path_elements.pop
+          # Make sure @datacenters is populated.  We need the instances from the Hash keys.
+          self.datacenters
+          # Get the datacenter managed object from the hash
+          dc = @datacenters[template_dc]
+          # Get the VM Folder (Group) efficiently
+          vm_folder = dc.vmFolder
+          # Walk the tree resetting the folder pointer as we go
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
           end
 
-          # We need to locate the datacenter object to find the
-          # default resource pool.
-          container = vm_mob_ref.parent
-          until container.kind_of? RbVmomi::VIM::Datacenter
-            container = container.parent
-          end
-          dc = container
-          # With the Datacenter Object we can obtain the resource pool
-          resource_pool = dc.hostFolder.children.first.resourcePool
+          # Now find the template itself using the efficient find method
+          vm_mob_ref = folder.find(template_name, RbVmomi::VIM::VirtualMachine)
+
+          # Now find _a_ resource pool of the template's host (REVISIT: We need
+          # to support cloning into a specific RP)
+          esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
+          # The parent of the ESX host itself is a ComputeResource which has a resourcePool
+          resource_pool = esx_host.parent.resourcePool
+
           # Next, create a Relocation Spec instance
           relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
                                                                     :transform => options['transform'] || 'sparse')
@@ -50,27 +79,37 @@ module Fog
                                                             :powerOn  => options['power_on'] || true,
                                                             :template => false)
           task = vm_mob_ref.CloneVM_Task(:folder => vm_mob_ref.parent, :name => options['name'], :spec => clone_spec)
-          # REVISIT: The task object contains a reference to the template but does
-          # not appear to contain a reference to the newly created VM.
-          # This is a really naive way to find the managed object reference
-          # of the newly created VM.
-          tries = 0
-          new_vm = begin
-            list_virtual_machines['virtual_machines'].detect(lambda { raise Fog::Vsphere::Errors::NotFound }) do |vm|
-              vm['name'] == options['name']
-            end
-          rescue Fog::Vsphere::Errors::NotFound
-            tries += 1
-            if tries <= 10 then
-              sleep 1
-              retry
+
+          # Waiting for the VM to complete allows us to get the VirtulMachine
+          # object of the new machine when it's done.  It is HIGHLY recommended
+          # to set 'wait' => true if your app wants to wait.  Otherwise, you're
+          # going to have to reload the server model over and over which
+          # generates a lot of time consuming API calls to vmware.
+          if options['wait'] then
+            # REVISIT: It would be awesome to call a block passed to this
+            # request to notify the application how far along in the process we
+            # are.  I'm thinking of updating a progress bar, etc...
+            new_vm = task.wait_for_completion
+          else
+            tries = 0
+            new_vm = begin
+              # Try and find the new VM (folder.find is quite efficient)
+              folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+            rescue Fog::Vsphere::Errors::NotFound
+              tries += 1
+              if tries <= 10 then
+                sleep 15
+                retry
+              end
+              nil
             end
-            nil
           end
+
           # Return hash
           {
-            'vm_ref'   => new_vm ? new_vm['mo_ref'] : nil,
-            'task_ref' => task._ref
+            'vm_ref'        => new_vm ? new_vm._ref : nil,
+            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
+            'task_ref'      => task._ref
           }
         end
 
@@ -83,7 +122,7 @@ module Fog
           options = vm_clone_check_options(options)
           notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
           vm_mob_ref = list_virtual_machines['virtual_machines'].find(notfound) do |vm|
-            vm['instance_uuid'] == options['instance_uuid']
+            vm['name'] == options['path'].split("/")[-1]
           end
           {
             'vm_ref'   => 'vm-123',

data/spec/lib/fog/aws/parsers/sqs/receive_message_spec.rb

@@ -0,0 +1,58 @@
+require 'fog/core/parser'
+require 'fog/aws/parsers/sqs/receive_message'
+
+describe Fog::Parsers::AWS::SQS::ReceiveMessage do
+  let(:parser) { Fog::Parsers::AWS::SQS::ReceiveMessage.new }
+
+  let(:sent_timestamp) { 1322475007845 }
+  let(:approximate_first_receive_timestamp) { 1322494017370 }
+
+  let(:xml) do
+    <<-XML
+<?xml version="1.0"?>
+<ReceiveMessageResponse xmlns="http://queue.amazonaws.com/doc/2009-02-01/">
+  <ReceiveMessageResult>
+    <Message>
+      <MessageId>e4fbeece-7260-4106-807d-18255e43e687</MessageId>
+      <ReceiptHandle>gH2qdC6bjNtuE/U+iA5J/5HQK/lgvsTY0Vj+gFEXyRlsRL+EDf9tgjLxAW9cdutwjqgV22jyQyTgFsYV+G0oQc2posQntKVMZKqOLlrJqbKSOUnsBtkoWoD2MxyacbuDTG0q0a9yS3RpPSN4lV8RN0BrJjfoeQDRQOn/RIxtAH9H4C4NasSLODB1xJWcO/KsZYRch0IWL89a4YgP060XCxAyKYqY8O+GvNhX5d59JRAI6tO2sx9wLwytIHNlG97DDnUGb/6PNuYPmoZcvYOdfhMQgP28rdrUW3B7Pai+dqE=</ReceiptHandle>
+      <MD5OfBody>b425c09d8559b59dd989cf8c47caaf54</MD5OfBody>
+      <Body>testmessage</Body>
+      <Attribute><Name>SenderId</Name><Value>000000000000</Value></Attribute>
+      <Attribute><Name>SentTimestamp</Name><Value>#{sent_timestamp}</Value></Attribute>
+      <Attribute><Name>ApproximateReceiveCount</Name><Value>2</Value></Attribute>
+      <Attribute><Name>ApproximateFirstReceiveTimestamp</Name><Value>#{approximate_first_receive_timestamp}</Value></Attribute>
+    </Message>
+  </ReceiveMessageResult>
+  <ResponseMetadata><RequestId>72c77661-d4b5-45b9-8a82-a685c980e9dd</RequestId></ResponseMetadata>
+</ReceiveMessageResponse>
+    XML
+  end
+
+  def timestamp(attribute)
+    body = Nokogiri::XML::SAX::PushParser.new(parser)
+    body << xml
+    body.finish
+    response_body = parser.response
+    response_body['Message'].first['Attributes'][attribute].utc
+  end
+
+  it "converts SentTimestamp to the same time as a Time-like object" do
+    stamp = timestamp 'SentTimestamp'
+    stamp.year.should == 2011
+    stamp.month.should == 11
+    stamp.day.should == 28
+    stamp.hour.should == 10
+    stamp.min.should == 10
+    stamp.sec.should == 7
+  end
+
+  it "converts ApproximateFirstReceiveTimestamp to the same time as a Time-like object" do
+    stamp = timestamp 'ApproximateFirstReceiveTimestamp'
+    stamp.year.should == 2011
+    stamp.month.should == 11
+    stamp.day.should == 28
+    stamp.hour.should == 15
+    stamp.min.should == 26
+    stamp.sec.should == 57
+  end
+end

data/tests/aws/models/elb/model_tests.rb

@@ -244,6 +244,11 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       end
     end
 
+    tests('setting a new ssl certificate id') do
+      elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'HTTPS', :ssl_id => @certificate['Arn'])
+      elb.set_listener_ssl_certificate(443, @certificate['Arn'])
+    end
+
     tests('destroy') do
       elb.destroy
     end

data/tests/aws/requests/compute/instance_tests.rb

@@ -122,6 +122,25 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
     'requestId'     => String
   }
 
+  @describe_instance_status_format = {
+    'requestId' => String,
+    'instanceStatusSet' => [{
+                              'instanceId' => String,
+                              'availabilityZone' => String,
+                              'instanceState' => {
+                                'code' => Integer,
+                                'name' => String
+                              },
+                              'eventsSet' => [{
+                                                'code' => String,
+                                                'description' => String,
+                                                'notBefore' => Time,
+                                                'notAfter' => Time
+                                              }]
+                            }]
+
+  }
+
   tests('success') do
 
     @instance_id = nil
@@ -214,6 +233,10 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
       @reserved_instances
     end
 
+    tests('#describe_instance_status').formats(@describe_instance_status_format) do
+      Fog::Compute[:aws].describe_instance_status.body
+    end
+
     if Fog.mocking?
       @reserved_instance_offering_id = @reserved_instances["reservedInstancesOfferingsSet"].first["reservedInstancesOfferingId"]
       tests("#purchase_reserved_instances_offering('#{@reserved_instance_offering_id}')").formats(@purchase_reserved_instances_offering_format) do

data/tests/aws/requests/compute/security_group_tests.rb

@@ -4,6 +4,7 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
     'requestId'           => String,
     'securityGroupInfo' => [{
       'groupDescription'  => String,
+      'groupId'           => Fog::Nullable::String,
       'groupName'         => String,
       'ipPermissions'     => [{
         'fromPort'    => Integer,

data/tests/aws/requests/elb/listener_tests.rb

@@ -44,6 +44,10 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
       Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
     end
 
+    tests("#set_load_balancer_listener_ssl_certificate").formats(AWS::ELB::Formats::BASIC) do
+      Fog::AWS[:elb].set_load_balancer_listener_ssl_certificate(@load_balancer_id, 443, @certificate['Arn']).body
+    end
+
     Fog::AWS[:iam].delete_server_certificate(@key_name)
     Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
   end

data/tests/aws/requests/storage/{hash_to_acl_tests.rb → acl_utils_tests.rb}

@@ -1,6 +1,6 @@
-require 'fog/aws/requests/storage/hash_to_acl'
+require 'fog/aws/requests/storage/acl_utils'
 
-Shindo.tests('Fog::Storage::AWS | converting a hash to an ACL', [:aws]) do
+Shindo.tests('Fog::Storage::AWS | ACL utils', [:aws]) do
   tests(".hash_to_acl") do
     tests(".hash_to_acl({}) at xpath //AccessControlPolicy").returns("", "has an empty AccessControlPolicy") do
       xml = Fog::Storage::AWS.hash_to_acl({})
@@ -170,4 +170,40 @@ Shindo.tests('Fog::Storage::AWS | converting a hash to an ACL', [:aws]) do
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/URI").first.content
     end
   end
+
+  tests(".acl_to_hash") do
+    acl_xml = <<-XML
+<AccessControlPolicy>
+  <Owner>
+    <ID>2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0</ID>
+    <DisplayName>me</DisplayName>
+  </Owner>
+  <AccessControlList>
+    <Grant>
+      <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+        <ID>2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0</ID>
+        <DisplayName>me</DisplayName>
+      </Grantee>
+      <Permission>FULL_CONTROL</Permission>
+    </Grant>
+  </AccessControlList>
+</AccessControlPolicy>
+XML
+
+    tests(".acl_to_hash(#{acl_xml.inspect})").returns({
+      "Owner" => {
+        "DisplayName" => "me",
+        "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0"
+      },
+      "AccessControlList" => [{
+        "Grantee" => {
+          "DisplayName" => "me",
+          "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0"
+        },
+        "Permission" => "FULL_CONTROL"
+      }]
+    }, 'returns hash of ACL XML') do
+      Fog::Storage::AWS.acl_to_hash(acl_xml)
+    end
+  end
 end

data/tests/aws/requests/storage/bucket_tests.rb

@@ -135,8 +135,6 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
       ]
     }
     tests("#put_bucket_acl('#{@aws_bucket_name}', hash with id)").returns(acl) do
-      pending if Fog.mocking?
-
       Fog::Storage[:aws].put_bucket_acl(@aws_bucket_name, acl)
       Fog::Storage[:aws].get_bucket_acl(@aws_bucket_name).body
     end
@@ -173,7 +171,6 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
       ]
     }
     tests("#put_bucket_acl('#{@aws_bucket_name}', hash with uri)").returns(acl) do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_bucket_acl(@aws_bucket_name, acl)
       Fog::Storage[:aws].get_bucket_acl(@aws_bucket_name).body
     end

data/tests/aws/requests/storage/object_tests.rb

@@ -37,13 +37,12 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
     acl = {
       'Owner' => @aws_owner,
       'AccessControlList' => [
-        { 
+        {
           'Grantee' => @aws_owner,
-          'Permission' => "FULL_CONTROL" 
+          'Permission' => "FULL_CONTROL"
         }
       ]}
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', hash with id)").returns(acl) do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_object_acl(@directory.identity, 'fog_object', acl)
       Fog::Storage[:aws].get_object_acl(@directory.identity, 'fog_object').body
     end
@@ -77,7 +76,6 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
         }
       ]}
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', hash with uri)").returns(acl) do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_object_acl(@directory.identity, 'fog_object', acl)
       Fog::Storage[:aws].get_object_acl(@directory.identity, 'fog_object').body
     end

data/tests/aws/requests/sts/get_federation_token_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('AWS::STS | session tokens', ['aws']) do
+
+	@policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+	@federation_format = {
+		'SessionToken' => String,
+		'SecretAccessKey' => String,
+		'Expiration' => String,
+		'AccessKeyId' => String,
+		'Arn' => String,
+		'FederatedUserId' => String,
+		'PackedPolicySize' => String,
+		'RequestId'	=> String
+	}
+
+	tests("#get_federation_token('test@fog.io', #{@policy.inspect})").formats(@federation_format) do
+		pending if Fog.mocking?
+		Fog::AWS[:sts].get_federation_token("test@fog.io", @policy).body
+	end
+	
+end

data/tests/aws/requests/sts/session_token_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('AWS::STS | session tokens', ['aws']) do
+
+	@session_format = {
+		'SessionToken' => String,
+		'SecretAccessKey' => String,
+		'Expiration' => String,
+		'AccessKeyId' => String,
+		'RequestId'	=> String
+	}
+
+	tests("#get_session_token").formats(@session_format) do
+		pending if Fog.mocking?
+		Fog::AWS[:sts].get_session_token.body
+	end
+	
+end

data/tests/brightbox/requests/compute/account_tests.rb

@@ -2,20 +2,25 @@ Shindo.tests('Fog::Compute[:brightbox] | account requests', ['brightbox']) do
 
   tests('success') do
 
-    tests("#get_account").formats(Brightbox::Compute::Formats::Full::ACCOUNT) do
+    tests("#get_account") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_account
+      result = Fog::Compute[:brightbox].get_account
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT) { result }
+      test("ftp password is blanked") { result["library_ftp_password"].nil?  }
     end
 
     update_options = {:name => "Fog@#{Time.now.iso8601}"}
-    tests("#update_account(#{update_options.inspect})").formats(Brightbox::Compute::Formats::Full::ACCOUNT) do
+    tests("#update_account(#{update_options.inspect})") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].update_account(update_options)
+      result = Fog::Compute[:brightbox].update_account(update_options)
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT) { result }
     end
 
-    tests("#reset_ftp_password_account").formats(Brightbox::Compute::Formats::Full::ACCOUNT) do
+    tests("#reset_ftp_password_account") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].reset_ftp_password_account
+      result = Fog::Compute[:brightbox].reset_ftp_password_account
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT) { result }
+      test("new ftp password is visible") { ! result["library_ftp_password"].nil?  }
     end
 
   end

data/tests/brightbox/requests/compute/api_client_tests.rb

@@ -7,32 +7,43 @@ Shindo.tests('Fog::Compute[:brightbox] | api client requests', ['brightbox']) do
       :description => "Description from Fog test"
     }
 
-    tests("#create_api_client(#{create_options.inspect})").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#create_api_client(#{create_options.inspect})") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].create_api_client(create_options)
-      @api_client_id = data["id"]
-      data
+      result = Fog::Compute[:brightbox].create_api_client(create_options)
+      @api_client_id = result["id"]
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT) { result }
     end
 
-    tests("#list_api_clients").formats(Brightbox::Compute::Formats::Collection::API_CLIENTS) do
+    tests("#list_api_clients") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].list_api_clients
+      result = Fog::Compute[:brightbox].list_api_clients
+      formats(Brightbox::Compute::Formats::Collection::API_CLIENTS) { result }
     end
 
-    tests("#get_api_client('#{@api_client_id}')").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#get_api_client('#{@api_client_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_api_client(@api_client_id)
+      result = Fog::Compute[:brightbox].get_api_client(@api_client_id)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT) { result }
     end
 
     update_options = {:name => "Fog@#{Time.now.iso8601}"}
-    tests("#update_api_client('#{@api_client_id}')").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#update_api_client('#{@api_client_id}', #{update_options.inspect})") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].update_api_client(@api_client_id, update_options)
+      result = Fog::Compute[:brightbox].update_api_client(@api_client_id, update_options)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT) { result }
     end
 
-    tests("#destroy_api_client('#{@api_client_id}')").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#reset_secret_api_client('#{@api_client_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].destroy_api_client(@api_client_id)
+      result = Fog::Compute[:brightbox].reset_secret_api_client(@api_client_id)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT) { result }
+      test("new secret is visible") { ! result["secret"].nil?  }
+    end
+
+    tests("#destroy_api_client('#{@api_client_id}')") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].destroy_api_client(@api_client_id)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT) { result }
     end
 
   end