fog 1.7.0 → 1.8.0

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

@@ -1,97 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-
-      module Shared
-        private
-        def vm_create_check_options(options)
-          options = { 'force' => false }.merge(options)
-          required_options = %w{ path name cluster }
-          required_options.each do |param|
-            raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
-          end
-          # 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_create 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.datacenters.join(",")} are accessible."
-          end
-          options
-        end
-      end
-
-      class Real
-        include Shared
-        def vm_create(options = {})
-          # Option handling
-          options = vm_create_check_options(options)
-          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
-          dc_name = path_elements.shift
-          vm_cfg = {
-            :name                => options['name'],
-            :guestId             => options['guest_id'] ? options['guest_id'] : 'otherGuest',
-            :files               => { :vmPathName => "[#{options['datastore']}]" },
-            :numCPUs             => options['num_cpus'] ? options['num_cpus'] : 1 ,
-            :memoryMB            => options['memory'] ? options['memory'] : 512,
-            :memoryHotAddEnabled => options['memory_hot_add_enabled'] ? options['memory_hot_add_enabled'] : 0,
-            :cpuHotAddEnabled    => options['cpu_hot_add_enabled'] ? options['cpu_hot_add_enabled'] : 0,
-            :deviceChange        => options['device_array'].class == Array ? options['device_array'] : nil,
-            :extraConfig         => options['extra_config'].class == Array ? options['extra_config'] : nil,
-          }
-          self.datacenters
-          dc = @datacenters[dc_name]
-          vm_folder = dc.vmFolder
-          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
-            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
-          clusters = dc.hostFolder.children
-          build_cluster=''
-          clusters.each { |my_cluster|
-            if "#{my_cluster.name}" == "#{options['cluster']}"
-              build_cluster=my_cluster
-            end
-          }
-          resource_pool = build_cluster.resourcePool
-          task=folder.CreateVM_Task(:config => vm_cfg, :pool => resource_pool)
-          if options['wait'] then
-            new_vm = task.wait_for_completion
-          else
-            tries = 0
-            new_vm = begin
-              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
-          end
-          {
-            '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
-      end
-      class Mock
-        include Shared
-        def vm_create(options = {})
-          # Option handling
-          options = vm_create_check_options(options)
-          {
-            'vm_ref'   => 'vm-123',
-            'task_ref' => 'task-1234'
-          }
-        end
-      end
-    end
-  end
-end

data/tests/vsphere/requests/compute/find_vm_by_ref_tests.rb

@@ -1,26 +0,0 @@
-Shindo.tests('Fog::Compute[:vsphere] | find_vm_by_ref request', ['vsphere']) do
-
-  compute = Fog::Compute[:vsphere]
-
-  tests("When missing arguments") do
-    raises(ArgumentError, "Should raise ArgumentError when missing :vm_ref") do
-      compute.find_vm_by_ref
-    end
-    raises(Fog::Compute::Vsphere::NotFound, "Should raise Fog::Compute::Vsphere::NotFound when the vm does not exist") do
-      compute.find_vm_by_ref('vm_ref' => 'vm-000')
-    end
-  end
-
-  # centos56gm is a template
-  existing_vms = { 'vm-715' => 'jefftest', 'vm-698' => 'centos56gm' }
-
-  tests("When looking for existing VM's the response") do
-    existing_vms.each do |ref,name|
-      response = compute.find_vm_by_ref('vm_ref' => ref)
-      test("should be a kind of Hash") { response.kind_of? Hash }
-      test("should have virtual_machine key") { response.has_key? 'virtual_machine' }
-      returns(name, "#{ref} should return #{name}") { response['virtual_machine']['name'] }
-    end
-  end
-
-end

data/tests/vsphere/requests/compute/vm_create_tests.rb

@@ -1,20 +0,0 @@
-Shindo.tests("Fog::Compute[:vsphere] | vm_create request", 'vsphere') do
-  #require 'guid'
-  path = "/Datacenters/Solutions"
-  compute = Fog::Compute[:vsphere]
-
-  tests("The return value should") do
-    response = compute.vm_create('path' => path, 'name' => 'fog_test_vm', 'cluster' => 'cluster01')
-    test("be a kind of Hash") { response.kind_of? Hash }
-    %w{ vm_ref task_ref }.each do |key|
-      test("have a #{key} key") { response.has_key? key }
-    end
-  end
-  tests("When invalid input is presented") do
-    raises(ArgumentError, 'it should raise ArgumentError') { compute.vm_create(:foo => 1) }
-    raises(Fog::Compute::Vsphere::NotFound, 'it should raise Fog::Compute::Vsphere::NotFound when the UUID is not a string') do
-      pending # require 'guid'
-      compute.vm_create('instance_uuid' => Guid.from_s(template), 'name' => 'jefftestfoo')
-    end
-  end
-end