class Kitchen::Driver::Vsphere

vSphere kitchen class extends the Kitchen::Driver::Base

Public Instance Methods

chef_server() click to toggle source

Uses either a remote Chef server or Chef Zero

# File lib/kitchen/driver/vsphere.rb, line 100
def chef_server
  unless @@chef_zero_server
    vsphere_mutex.synchronize do
      unless @@chef_zero_server
        Chef::Config.local_mode = true
        Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
        require "chef/local_mode"
        Chef::LocalMode.setup_server_connectivity
        @@chef_zero_server = true
      end
    end
  end

  Cheffish.default_chef_server
end
create(state) click to toggle source

Creates VM on the vSphere cluster

@param [Object] state Uses state of the machine from Chef provisioning.

# File lib/kitchen/driver/vsphere.rb, line 41
def create(state)
  state[:vsphere_name] ||= config[:vsphere_name]
  state[:username] = config[:machine_options][:bootstrap_options][:ssh][:user]
  state[:password] = config[:machine_options][:bootstrap_options][:ssh][:password]
  config[:server_name] = state[:vsphere_name]

  with_provisioning_driver(state) do |action_handler, driver, machine_spec|
    begin
      driver.allocate_machine(action_handler, machine_spec, config[:machine_options])
      driver.ready_machine(action_handler, machine_spec, config[:machine_options])
    rescue
      raise
    ensure
      if machine_spec
        if machine_spec.location
          state[:server_id] = machine_spec.location["server_id"]
          state[:hostname] = machine_spec.location["ipaddress"]
        end
        machine_spec.save(action_handler)
      end
    end
  end
end
destroy(state) click to toggle source

Destroys VM on the vSphere cluster

@param [Object] state Uses state of the machine from Chef provisioning.

# File lib/kitchen/driver/vsphere.rb, line 68
def destroy(state)
  return if state[:server_id].nil?

  with_provisioning_driver(state) 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)
end
vsphere_mutex() click to toggle source

Creates a new mutex object for Kitchen

# File lib/kitchen/driver/vsphere.rb, line 118
def vsphere_mutex
  @@vsphere_mutex ||= begin
    Kitchen.mutex.synchronize do
      instance.class.mutexes ||= {}
      instance.class.mutexes[self.class] = Mutex.new
    end

    instance.class.mutexes[self.class]
  end
end
with_provisioning_driver(state) { |action_handler, driver, machine_spec| ... } click to toggle source

Leverages the chef provisioning driver options

@param [Object] state Uses state of the machine from Chef provisioning.

# File lib/kitchen/driver/vsphere.rb, line 85
def with_provisioning_driver(state)
  config[:machine_options][:convergence_options] = { chef_server: chef_server }
  machine_spec = Chef::Provisioning.chef_managed_entry_store(chef_server).get(:machine, state[:vsphere_name])
  if machine_spec.nil?
    machine_spec = Chef::Provisioning.chef_managed_entry_store(chef_server)
                                     .new_entry(:machine, state[:vsphere_name])
  end
  url = URI::VsphereUrl.from_config(@config[:driver_options]).to_s
  driver = Chef::Provisioning.driver_for_url(url, config)
  action_handler = Chef::Provisioning::ActionHandler.new
  yield(action_handler, driver, machine_spec)
end