chef-provisioning-vsphere 0.4.2

data/lib/chef/provisioning/vsphere_driver/vsphere_url.rb

@@ -0,0 +1,31 @@
+require 'uri'
+
+module URI
+	class VsphereUrl < Generic
+		DEFAULT_PORT = 443
+		DEFAULT_PATH = '/sdk'
+
+		def self.from_config(options)
+			URI("vsphere://#{options[:host]}:#{options[:port]}#{options[:path]}?use_ssl=#{options[:use_ssl]}&insecure=#{options[:insecure]}")
+		end
+
+		def use_ssl
+			if query
+				ssl_query = query.split('&').each.select{|q| q.start_with?('use_ssl=')}.first
+				ssl_query == 'use_ssl=true'
+			else
+				true
+			end
+		end
+
+		def insecure
+			if query
+				insecure_query = query.split('&').each.select{|q| q.start_with?('insecure=')}.first
+				insecure_query == 'insecure=true'
+			else
+				false
+			end
+		end
+	end
+	@@schemes['VSPHERE'] = VsphereUrl
+end

data/lib/kitchen/driver/vsphere.rb

@@ -0,0 +1,85 @@
+require 'json'
+require 'kitchen'
+require 'chef/provisioning/vsphere_driver'
+require 'chef/provisioning/machine_spec'
+
+module Kitchen
+  module Driver
+    class Vsphere < Kitchen::Driver::Base
+
+      default_config :machine_options,
+        :start_timeout => 600,
+        :create_timeout => 600,
+        :ready_timeout => 90,
+        :bootstrap_options => {
+          :use_linked_clone => true,
+          :ssh => {
+            :user => 'root',
+            :paranoid => false,
+            :port => 22
+          },
+          :convergence_options => {},
+          :customization_spec => {
+            :domain => 'local'
+          }
+        }
+
+      def create(state)
+        config[:server_name] ||= "kitchen-#{SecureRandom.hex(4)}"
+        state[:username] = config[:machine_options][:bootstrap_options][:ssh][:user]
+        state[:password] = config[:machine_options][:bootstrap_options][:ssh][:password]
+        
+        machine = with_provisioning_driver(config[:server_name]) do | action_handler, driver, machine_spec|
+          driver.allocate_machine(action_handler, machine_spec, config[:machine_options])
+          driver.ready_machine(action_handler, machine_spec, config[:machine_options])
+          state[:server_id] = machine_spec.location['server_id']
+          state[:hostname] = machine_spec.location['ipaddress']
+          state[:vsphere_name] = config[:server_name]
+        end
+
+        node_dir = File.join(instance.verifier[:test_base_path], "nodes")
+        Dir.mkdir(node_dir) unless Dir.exist?(node_dir)
+        node_file = File.join(node_dir, "#{instance.suite.name}.json")
+        node = {
+          :id => instance.suite.name,
+          :automatic => {
+            :ipaddress => state[:hostname]
+          }
+        }
+        File.open(node_file, 'w') do |out|
+          out << JSON.pretty_generate(node)
+        end
+
+      end
+
+      def destroy(state)
+        return if state[:server_id].nil?
+
+        with_provisioning_driver(state[:vsphere_name]) do | action_handler, driver, machine_spec|
+          machine_spec.location = { 'driver_url' => driver.driver_url,
+                        'server_id' => state[:server_id]}
+          driver.destroy_machine(action_handler, machine_spec, config[:machine_options])
+        end
+
+        state.delete(:server_id)
+        state.delete(:hostname)
+        state.delete(:vsphere_name)
+
+        node_file = File.join(instance.verifier[:test_base_path], "nodes/#{instance.suite.name}.json")
+        File.delete(node_file) if File.exist?(node_file)
+      end
+
+      def with_provisioning_driver(name, &block)
+        Cheffish.honor_local_mode do
+          chef_server = Cheffish.default_chef_server
+          config[:machine_options][:convergence_options] = {:chef_server => chef_server}
+          machine_spec = Chef::Provisioning.chef_managed_entry_store(chef_server).new_entry(:machine, name)
+          driver = Chef::Provisioning.driver_for_url("vsphere://#{config[:driver_options][:host]}", config)
+          action_handler = Chef::Provisioning::ActionHandler.new
+          block.call(action_handler, driver, machine_spec)
+        end
+      end
+
+    end
+  end
+end

data/spec/integration_tests/.gitignore

@@ -0,0 +1 @@
+config.rb

data/spec/integration_tests/vsphere_driver_spec.rb

@@ -0,0 +1,147 @@
+require 'chef/provisioning/vsphere_driver'
+require 'chef/provisioning/machine_spec'
+
+	# A file named config.rb in the same directory as this spec file 
+	# must exist containing the driver options to use for the test.
+	# Here is an example:
+	# {
+	#   :driver_options => { 
+	#   	:host => '213.45.67.88',
+	#   	:user => 'vmapi',
+	#   	:password => 'SuperSecureP@ssw0rd',
+	#   	:insecure => true
+	#   },
+	#   :machine_options => { 
+	# 		:start_timeout => 600, 
+ #            :create_timeout => 600, 	  	
+ #            :bootstrap_options => {
+	#   		:datacenter => 'QA1',
+	#   		:template_name => 'UBUNTU-12-64-TEMPLATE',
+	#   		:vm_folder => 'DLAB',
+	#   		:num_cpus => 2,
+	#   		:network_name => 'vlan152_172.21.152',
+	#   		:memory_mb => 4096,
+	#   		:resource_pool => 'CLSTR02/DLAB',
+	# 	  	:ssh => {
+	# 	  		:user => 'root',
+	# 	  		:password => 'SuperSecureP@ssw0rd',
+	# 	  		:paranoid => false,
+	# 	  		:port => 22
+	# 	  	},
+	# 	  	:convergence_options => {}
+	#   	}
+	#   }
+	# }
+
+describe "vsphere_driver" do
+    include ChefProvisioningVsphere::Helpers
+
+	before :all do
+		@vm_name = "cmvd-test-#{SecureRandom.hex}"
+		@metal_config = eval File.read(File.expand_path('../config.rb', __FILE__))
+		Cheffish.honor_local_mode do
+			chef_server = Cheffish.default_chef_server
+			@machine_spec = Chef::Provisioning.chef_managed_entry_store(chef_server).new_entry(:machine, @vm_name)
+			@driver = Chef::Provisioning.driver_for_url("vsphere://#{@metal_config[:driver_options][:host]}", @metal_config)
+			action_handler = Chef::Provisioning::ActionHandler.new
+			@driver.allocate_machine(action_handler, @machine_spec, @metal_config[:machine_options])
+			@metal_config[:machine_options][:convergence_options] = {:chef_server => chef_server}
+			machine = @driver.ready_machine(action_handler, @machine_spec, @metal_config[:machine_options])
+			@server_id = @machine_spec.location['server_id']
+			@connection = vim(@metal_config[:driver_options])
+			@vm = find_vm_by_id(@server_id, @connection)
+		end
+	end
+
+
+    context 'when allocating a machine' do
+
+		it "adds machine to the correct folder" do
+			expect(@vm.parent.name).to eq(@metal_config[:machine_options][:bootstrap_options][:vm_folder])
+		end
+		it "has a matching id with the machine_spec" do
+			expect(@vm.config.instanceUuid).to eq(@machine_spec.location['server_id'])
+		end
+		it "has the correct name" do
+	      	now = Time.now.utc
+	      	trimmed_name = @vm.config.guestId.start_with?('win') ? @vm_name.byteslice(0,15) : @vm_name
+	      	expected_name="#{trimmed_name}.#{@metal_config[:machine_options][:bootstrap_options][:customization_spec][:domain]}"
+	        until (Time.now.utc - now) > 30 || (@vm.guest.hostName == expected_name) do
+	          print "."
+	          sleep 5
+	        end
+			expect(@vm.guest.hostName).to eq(expected_name)
+		end
+		it "has the correct number of CPUs" do
+			expect(@vm.config.hardware.numCPU).to eq(@metal_config[:machine_options][:bootstrap_options][:num_cpus])
+		end
+		it "has the correct amount of memory" do
+			expect(@vm.config.hardware.memoryMB).to eq(@metal_config[:machine_options][:bootstrap_options][:memory_mb])
+		end
+		it "is on the correct networks" do
+			expect(@vm.network.map {|n| n.name}).to include(@metal_config[:machine_options][:bootstrap_options][:network_name][0])
+			expect(@vm.network.map {|n| n.name}).to include(@metal_config[:machine_options][:bootstrap_options][:network_name][1])
+		end
+		it "is on the correct datastore" do
+			expect(@vm.datastore[0].name).to eq(@metal_config[:machine_options][:bootstrap_options][:datastore])
+		end
+		it "is in the correct resource pool" do
+			if @metal_config[:machine_options][:bootstrap_options].has_key?(:resource_pool)
+				expect(@vm.resourcePool.name).to eq(@metal_config[:machine_options][:bootstrap_options][:resource_pool].split('/')[1])
+			end
+		end
+		it "is in the correct host" do
+			if @metal_config[:machine_options][:bootstrap_options].has_key?(:host)
+				expect(@vm.runtime.host.name).to eq(@metal_config[:machine_options][:bootstrap_options][:host].split('/')[1])
+			end
+		end
+		it "is in the correct cluster" do
+			if @metal_config[:machine_options][:bootstrap_options].has_key?(:resource_pool)
+				expect(@vm.resourcePool.owner.name).to eq(@metal_config[:machine_options][:bootstrap_options][:resource_pool].split('/')[0])
+			end
+		end
+		it "is in the correct datacenter" do
+			expect(@connection.serviceInstance.find_datacenter(@metal_config[:machine_options][:bootstrap_options][:datacenter]).find_vm("#{@vm.parent.name}/#{@vm_name}")).not_to eq(nil)
+		end
+		it "has an added disk of the correct size" do
+			disk_count = @vm.disks.count
+			expect(@vm.disks[disk_count-1].capacityInKB).to eq(@metal_config[:machine_options][:bootstrap_options][:additional_disk_size_gb] * 1024 * 1024)
+		end
+		it "has hot add cpu enabled" do
+			expect(@vm.config.cpuHotAddEnabled).to eq(true)
+		end
+		it "has hot remove cpu enabled" do
+			expect(@vm.config.cpuHotRemoveEnabled).to eq(true)
+		end
+		it "has hot add memory enabled" do
+			expect(@vm.config.memoryHotAddEnabled).to eq(true)
+		end		
+		it "has the correct IP address" do
+	      if @vm.guest.toolsRunningStatus != "guestToolsRunning"
+	      	now = Time.now.utc
+	        until (Time.now.utc - now) > 30 || (@vm.guest.toolsRunningStatus == "guestToolsRunning" && @vm.guest.net.count == 2 && @vm.guest.net[1].ipAddress[1] == @metal_config[:machine_options][:bootstrap_options][:customization_spec][:ipsettings][:ip]) do
+	          print "."
+	          sleep 5
+	        end
+	      end
+			expect(@vm.guest.net.map { |net| net.ipAddress}.flatten).to include(@metal_config[:machine_options][:bootstrap_options][:customization_spec][:ipsettings][:ip])
+		end
+    end
+
+	context "destroy_machine" do
+
+		it "removes the machine" do
+			Cheffish.honor_local_mode do
+				chef_server = Cheffish.default_chef_server
+				driver = Chef::Provisioning.driver_for_url("vsphere://#{@metal_config[:driver_options][:host]}", @metal_config)
+				action_handler = Chef::Provisioning::ActionHandler.new
+				machine_spec = Chef::Provisioning.chef_managed_entry_store(chef_server).new_entry(:machine, @vm_name)
+				machine_spec.location = { 'driver_url' => driver.driver_url,
+										  'server_id' => @server_id}
+				driver.destroy_machine(action_handler, machine_spec, @metal_config[:machine_options])
+			end
+			vm = find_vm_by_id(@server_id, @connection)
+			expect(vm).to eq(nil)
+		end
+	end
+end

data/spec/unit_tests/VsphereDriver_spec.rb

@@ -0,0 +1,206 @@
+require 'chef/provisioning/vsphere_driver'
+
+describe "canonicalize_url" do
+
+	context "when config does not include the properties included in the url" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>'
+		  },
+		  :machine_options => { 
+		  	:ssh => {
+		  		:password => '<password>',
+		  		:paranoid => false
+		  	},
+		  	:bootstrap_options => {
+		  		:datacenter => 'QA1',
+		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
+		  		:vm_folder => 'DLAB',
+		  		:num_cpus => 2,
+		  		:memory_mb => 4096,
+		  		:resource_pool => 'CLSTR02/DLAB'
+		  	}
+		  },
+		  :log_level => :debug
+		}
+
+		let(:results) {
+			ChefProvisioningVsphere::VsphereDriver.canonicalize_url('vsphere://3.3.3.3:999/crazyapi?use_ssl=false&insecure=true', metal_config)
+		}
+
+		it "populates the config with correct host from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:host]).to eq('3.3.3.3')
+		end
+		it "populates the config with correct port from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:port]).to eq(999)
+		end
+		it "populates the config with correct path from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:path]).to eq('/crazyapi')
+		end
+		it "populates the config with correct use_ssl setting from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:use_ssl]).to eq(false)
+		end
+		it "populates the config with correct insecure setting from the driver url" do
+			expect(results[1][:driver_options][:connect_options][:insecure]).to eq(true)
+		end
+	end
+
+	context "when config keys are stringified" do
+		metal_config = {
+		  'driver_options' => { 
+		  	'user' => 'vmapi',
+		  	'password' => '<password>'
+		  },
+		  'machine_options' => { 
+		  	'ssh' => {
+		  		'password' => '<password>'
+		  	},
+		  	'bootstrap_options' => {
+		  		'datacenter' => 'QA1'
+		  	}
+		  }
+		 }
+
+		let(:results) {
+			ChefProvisioningVsphere::VsphereDriver.canonicalize_url('vsphere://3.3.3.3:999/crazyapi?use_ssl=false&insecure=true', metal_config)
+		}
+
+		it "will symbolize user" do
+			expect(results[1][:driver_options][:connect_options][:user]).to eq('vmapi')
+		end
+		it "will symbolize password" do
+			expect(results[1][:driver_options][:connect_options][:password]).to eq('<password>')
+		end
+		it "will symbolize ssh password" do
+			expect(results[1][:machine_options][:ssh][:password]).to eq('<password>')
+		end
+		it "will symbolize ssh bootstrap options" do
+			expect(results[1][:machine_options][:bootstrap_options][:datacenter]).to eq('QA1')
+		end
+	end
+
+	context "when no url is in the config" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>',
+		  	:host => '4.4.4.4',
+		  	:port => 888,
+		  	:path => '/yoda',
+		  	:use_ssl => 'false',
+		  	:insecure => 'true'
+		  },
+		  :machine_options => { 
+		  	:ssh => {
+		  		:password => '<password>',
+		  		:paranoid => false
+		  	},
+		  	:bootstrap_options => {
+		  		:datacenter => 'QA1',
+		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
+		  		:vm_folder => 'DLAB',
+		  		:num_cpus => 2,
+		  		:memory_mb => 4096,
+		  		:resource_pool => 'CLSTR02/DLAB'
+		  	}
+		  },
+		  :log_level => :debug
+		}
+
+		let(:results) {
+			ChefProvisioningVsphere::VsphereDriver.canonicalize_url(nil, metal_config)
+		}
+
+		it "creates the correct driver url from config settings" do
+			expect(results[0]).to eq('vsphere://4.4.4.4:888/yoda?use_ssl=false&insecure=true')
+		end
+	end
+
+	context "when no url is in the config and config is missing defaulted values" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>',
+		  	:host => '4.4.4.4'
+		  },
+		  :machine_options => { 
+		  	:bootstrap_options => {
+		  		:datacenter => 'QA1',
+		  		:template_name => 'UBUNTU-12-64-TEMPLATE',
+		  		:vm_folder => 'DLAB',
+		  		:num_cpus => 2,
+		  		:memory_mb => 4096,
+		  		:resource_pool => 'CLSTR02/DLAB',
+			  	:ssh => {
+			  		:password => '<password>',
+			  		:paranoid => false
+			  	}
+		  	}
+		  },
+		  :log_level => :debug
+		}
+
+		let(:results) {
+			ChefProvisioningVsphere::VsphereDriver.canonicalize_url(nil, metal_config)
+		}
+
+		it "creates the correct driver url from default settings" do
+			expect(results[0]).to eq('vsphere://4.4.4.4/sdk?use_ssl=true&insecure=false')
+		end
+		it "populates the config with correct port from default settings" do
+			expect(results[1][:driver_options][:connect_options][:port]).to eq(443)
+		end
+		it "populates the config with correct path from default settings" do
+			expect(results[1][:driver_options][:connect_options][:path]).to eq('/sdk')
+		end
+		it "populates the config with correct use_ssl setting from default settings" do
+			expect(results[1][:driver_options][:connect_options][:use_ssl]).to eq(true)
+		end
+		it "populates the config with correct insecure setting from default settings" do
+			expect(results[1][:driver_options][:connect_options][:insecure]).to eq(false)
+		end
+		it "populates the config with correct ssh port from default settings" do
+			expect(results[1][:machine_options][:bootstrap_options][:ssh][:port]).to eq(22)
+		end
+	end
+
+	context "when missing host" do
+		metal_config = {
+		  :driver_options => { 
+		  	:user => 'vmapi',
+		  	:password => '<password>',
+		  }
+		}
+
+		it "should raise an error" do
+			expect{ChefProvisioningVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
+		end
+	end
+
+	context "when missing user" do
+		metal_config = {
+		  :driver_options => { 
+		  	:host => 'host',
+		  	:password => '<password>',
+		  }
+		}
+
+		it "should raise an error" do
+			expect{ChefProvisioningVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
+		end
+	end
+
+	context "when missing password" do
+		metal_config = {
+		  :driver_options => { 
+		  	:host => 'host',
+		  	:user => 'user',
+		  }
+		}
+
+		it "should raise an error" do
+			expect{ChefProvisioningVsphere::VsphereDriver.canonicalize_url(nil,metal_config)}.to raise_error(RuntimeError)
+		end
+	end	
+end