chef-provisioning-oneview 1.2.1 → 1.3.0

data/lib/chef/provisioning/oneview/oneview_helper.rb

@@ -0,0 +1,53 @@
+module OneviewChefProvisioningDriver
+  # Helpers for OneView actions
+  module OneViewHelper
+    # Create new Profile from template or server profile
+    # @return [OneviewSDK::ServerProfile] server profile
+    def profile_from_template(template_name, profile_name)
+      raise 'Template name missing! Please set machine_options[:driver_options][:server_template]' unless template_name
+      if @ov.api_version >= 200
+        # Look for Server Profile Template (OneView 2.0 or higher)
+        template = OneviewSDK::ServerProfileTemplate.find_by(@ov, name: template_name).first
+        return template.new_profile(profile_name) if template
+      end
+
+      # Look for Server Profile as second option
+      profile = OneviewSDK::ServerProfile.find_by(@ov, name: template_name).first
+      raise "Template '#{template_name}' not found! Please match the template name with one that exists on OneView." unless profile
+      profile['name'] = profile_name
+
+      # Remove unwanted fields
+      %w(uri serialNumber uuid taskUri enclosureBay enclosureUri).each { |key| profile.data.delete(key) }
+      profile['connections'].each do |c|
+        %w(wwnn wwpn mac deploymentStatus interconnectUri wwpnType macType).each { |key| c[key] = nil }
+      end
+      profile
+    end
+
+    # Get an available hardware for a template. If a specific location is requested, find it
+    # @return [OneviewSDK::ServerHardware]
+    def available_hardware_for_profile(profile, location = nil)
+      Chef::Log.debug "Specific hardware requested: #{location}" if location
+      hw_list = profile.get_available_hardware
+      raise 'Error! No available blades that are compatible with the server template!' if hw_list.empty?
+      if location
+        chosen_blade = hw_list.find { |h| h['name'] == location }
+        return chosen_blade if chosen_blade
+        raise "Specified hardware '#{location}' doesn't exist or doesn't match the given template"
+      end
+      hw_list.first # If no location is specified, return the first matching HW
+    end
+
+    # Wait for the profile to finish being applied
+    # @return [TrueClass, FalseClass]
+    def wait_for_profile(action_handler, machine_name, profile)
+      return true if profile['state'] == 'Normal'
+      action_handler.perform_action "Apply profile '#{profile['name']}' for machine '#{machine_name}'" do
+        action_handler.report_progress "INFO: Applying profile '#{profile['name']}' for machine '#{machine_name}'"
+        @ov.wait_for(profile['taskUri'])
+      end
+      profile.refresh
+      raise "Server profile state '#{profile['state']}' not 'Normal'" unless profile['state'] == 'Normal'
+    end
+  end
+end

data/lib/chef/provisioning/oneview/san_storage.rb

@@ -1,91 +1,91 @@
-# Methods for configuring SAN storage on OneView
-module OneViewSanStorage
-  def fill_volume_details(v)
-    details = rest_api(:oneview, :get, v['volumeUri'])
-    v['volumeName'] = details['name']
-    v['permanent'] = details['isPermanent']
-    v['volumeShareable'] = details['shareable']
-    v['volumeProvisionType'] = details['provisionType']
-    v['volumeProvisionedCapacityBytes'] = details['provisionedCapacity']
-    v['volumeDescription'] = details['description']
-    v
-  end
+module OneviewChefProvisioningDriver
+  # Methods for configuring SAN storage on OneView
+  module OneViewSanStorage
+    def fill_volume_details(v)
+      response = @ov.rest_get(v['volumeUri'])
+      details = @ov.response_handler(response)
+      v['volumeName'] = details['name']
+      v['permanent'] = details['isPermanent']
+      v['volumeShareable'] = details['shareable']
+      v['volumeProvisionType'] = details['provisionType']
+      v['volumeProvisionedCapacityBytes'] = details['provisionedCapacity']
+      v['volumeDescription'] = details['description']
+      v
+    end
 
-  # Prepare profile for SAN storage
-  def update_san_info(machine_spec, profile)
-    san_storage = profile['sanStorage']
-    return profile unless san_storage && !san_storage['volumeAttachments'].empty?
+    # Prepare profile for SAN storage
+    def update_san_info(machine_name, profile)
+      san_storage = profile['sanStorage']
+      return profile unless san_storage && !san_storage['volumeAttachments'].empty?
 
-    # Sanitize old SAN entries and fill in details
-    boot_vols = []
-    san_storage['volumeAttachments'].each do |v|
-      fill_volume_details(v) unless profile['serverProfileTemplateUri']
-      raise "#{machine_spec.name}: Should know if volume is sharable:\n#{v}" unless v.key?('volumeShareable')
+      # Sanitize old SAN entries and fill in details
+      boot_vols = []
+      san_storage['volumeAttachments'].each do |v|
+        fill_volume_details(v) unless profile['serverProfileTemplateUri']
+        raise "#{machine_name}: Should know if volume is sharable:\n#{v}" unless v.key?('volumeShareable')
 
-      # Match boot disks by name
-      boot_vols.push(v['volumeName']) if v['volumeName'] =~ /^boot/i
-      v['volumeName'] += " #{profile['name']}" unless v['volumeShareable'] # Append profile name to volume name
+        # Match boot disks by name
+        boot_vols.push(v['volumeName']) if v['volumeName'] =~ /^boot/i
+        v['volumeName'] += " #{profile['name']}" unless v['volumeShareable'] # Append profile name to volume name
 
-      unless profile['serverProfileTemplateUri'] # Only needed when coppied from profile
+        next if profile['serverProfileTemplateUri'] # Only needed when coppied from profile
         v['state'] = nil
         v['status'] = nil
         v['storagePaths'].each { |s| s['status'] = nil }
 
-        unless v['volumeShareable']
-          # It is private in the profile, so we will clone it
-          v['volumeUri'] = nil
+        next if v['volumeShareable']
+        # It is private in the profile, so we will clone it
+        v['volumeUri'] = nil
 
-          # Assumes all cloned volumes are non-permanet. Might want some global config to control this
-          v['permanent'] = false
-          v['lun'] = nil if v['lunType'].casecmp('auto') == 0
-        end
+        # Assumes all cloned volumes are non-permanet. Might want some global config to control this
+        v['permanent'] = false
+        v['lun'] = nil if v['lunType'].casecmp('auto') == 0
       end
+      raise "#{machine_name}: There should only be 1 SAN boot volume. Boot volumes: #{boot_vols}" if boot_vols.size > 1
+      profile
     end
-    raise "#{machine_spec.name}: There should only be 1 SAN boot volume. Boot volumes: #{boot_vols}" if boot_vols.size > 1
-    profile
-  end
 
-  # Make sure connections for SAN boot volumes are configured to boot from the correct SAN volume
-  def enable_boot_from_san(action_handler, machine_spec, profile)
-    return false if profile['connections'].nil? || profile['connections'].empty?
+    # Make sure connections for SAN boot volumes are configured to boot from the correct SAN volume
+    # @return false if no connections are available to configure
+    def enable_boot_from_san(action_handler, machine_name, profile)
+      return false if profile['connections'].nil? || profile['connections'].empty?
 
-    # If there is a san volume we might need to update boot connections
-    update_needed = false
-    profile['sanStorage']['volumeAttachments'].each do |v|
-      vol_details = rest_api(:oneview, :get, v['volumeUri'])
-      next unless vol_details['name'] =~ /^boot/i
-      # Find the enabled path(s), get target wwpn, and then update connection, setting boot targets
-      v['storagePaths'].each do |s|
-        next if !s['isEnabled'] || s['storageTargets'].nil? || s['storageTargets'].empty?
-        connection = profile['connections'].find { |c| c['id'] == s['connectionId'] }
-        raise "#{machine_spec.name}: Connection #{s['connectionId']} not found! Check SAN settings" unless connection
-        if connection['boot'].nil? || connection['boot']['priority'] == 'NotBootable'
-          msg = "#{machine_spec.name}: Connection #{s['connectionId']} is labeled for boot, but the connection is not marked as bootable."
-          raise "#{msg} Set the connection boot target to Primary or Secondary"
-        end
-        target = {}
-        target['arrayWwpn'] = s['storageTargets'].first.delete(':')
-        target['lun'] = v['lun']
-        unless connection['boot']['targets'] && connection['boot']['targets'].first &&
-               connection['boot']['targets'].first['arrayWwpn'] == target['arrayWwpn'] &&
-               connection['boot']['targets'].first['lun'] == target['lun']
+      # If there is a san volume we might need to update boot connections
+      update_needed = false
+      profile['sanStorage']['volumeAttachments'].each do |v|
+        response = @ov.rest_get(v['volumeUri'])
+        vol_details = @ov.response_handler(response)
+        next unless vol_details['name'] =~ /^boot/i
+        # Find the enabled path(s), get target wwpn, and then update connection, setting boot targets
+        v['storagePaths'].each do |s|
+          next if !s['isEnabled'] || s['storageTargets'].nil? || s['storageTargets'].empty?
+          connection = profile['connections'].find { |c| c['id'] == s['connectionId'] }
+          raise "#{machine_name}: Connection #{s['connectionId']} not found! Check SAN settings" unless connection
+          if connection['boot'].nil? || connection['boot']['priority'] == 'NotBootable'
+            msg = "#{machine_name}: Connection #{s['connectionId']} is labeled for boot, but the connection is not marked as bootable."
+            raise "#{msg} Set the connection boot target to Primary or Secondary"
+          end
+          target = {}
+          target['arrayWwpn'] = s['storageTargets'].first.delete(':')
+          target['lun'] = v['lun']
+          unchanged = connection['boot']['targets'] && connection['boot']['targets'].first &&
+                      connection['boot']['targets'].first['arrayWwpn'] == target['arrayWwpn'] &&
+                      connection['boot']['targets'].first['lun'] == target['lun']
+          next if unchanged
           connection['boot']['targets'] = [target]
           update_needed = true
         end
       end
-    end
 
-    if update_needed
-      action_handler.perform_action "Enable SAN-bootable connections for #{machine_spec.name}" do
-        action_handler.report_progress "INFO: Enabling SAN-bootable connections for #{machine_spec.name}"
-        power_off(action_handler, machine_spec, profile['serverHardwareUri'])
-        task = rest_api(:oneview, :put, profile['uri'], { 'body' => profile })
-        task = oneview_wait_for(task['uri'], 90) # Wait for up to 15 min for profile to be updated
-        raise "Timed out waiting for enabling SAN-bootable connections on #{machine_spec.name}" if task == false
-        raise "Error enabling SAN-bootable connections on #{machine_spec.name}. Response: #{task}" unless task == true
+      if update_needed
+        action_handler.perform_action "Enable SAN-bootable connections for #{machine_name}" do
+          action_handler.report_progress "INFO: Enabling SAN-bootable connections for #{machine_name}"
+          profile.get_server_hardware.power_off
+          profile.update
+        end
+        profile.refresh
       end
-      profile = rest_api(:oneview, :get, profile['uri'])
+      profile # Return profile
     end
-    profile # Return profile
   end
 end

data/lib/chef/provisioning/oneview_driver.rb

@@ -6,90 +6,91 @@ require 'chef/provisioning/driver'
 require 'chef/provisioning/transport/ssh'
 require 'chef/provisioning/machine/unix_machine'
 require 'json'
+require 'oneview-sdk'
 require_relative 'driver_init/oneview'
 require_relative 'version'
-require_relative 'rest'
-require_relative 'create_machine'
-require_relative 'customize_machine'
-require_relative 'oneview/oneview_api'
-require_relative 'icsp/icsp_api'
+require_relative 'helpers'
 
 module Chef::Provisioning
+  # Provisioning driver for HPE OneView
   class OneViewDriver < Chef::Provisioning::Driver
-    include CreateMachine
-    include CustomizeMachine
-    include RestAPI
-    include OneViewAPI
-    include ICspAPI
-
+    include OneviewChefProvisioningDriver::Helpers
 
     def self.canonicalize_url(url, config)
       _scheme, oneview_url = url.split(':', 2)
-      if oneview_url.nil? || oneview_url == ''
-        oneview_url = config[:knife][:oneview_url]
-      end
-      raise 'Must set the knife[:oneview_url] attribute!' if oneview_url.nil? || oneview_url.empty?
-      'oneview:' + oneview_url
+      oneview_url ||= config[:driver_options][:oneview][:url] rescue nil
+      oneview_url ||= config[:knife][:oneview_url] rescue nil
+      oneview_url ||= ENV['ONEVIEWSDK_URL']
+      raise 'Must set the oneview driver url! See docs for more info' if oneview_url.nil? || oneview_url.empty?
+      "oneview:#{oneview_url}"
     end
 
-    def self.from_url(oneview_url, config)
-      OneViewDriver.new(oneview_url, config)
+    def self.from_url(url, config)
+      OneViewDriver.new(url, config)
     end
 
-    def initialize(canonical_url, config)
-      super(canonical_url, config)
-
-      @oneview_base_url    = config[:knife][:oneview_url]
-      @oneview_username    = config[:knife][:oneview_username]
-      @oneview_password    = config[:knife][:oneview_password]
-      @oneview_disable_ssl = config[:knife][:oneview_ignore_ssl]
-      @api_timeout         = config[:knife][:oneview_timeout] || 10 # Default timeout: 10 seconds
-      raise 'Must set knife[:oneview_url] attribute!'      if @oneview_base_url.nil? || @oneview_base_url.empty?
-      raise 'Must set knife[:oneview_username] attribute!' if @oneview_username.nil? || @oneview_username.empty?
-      raise 'Must set knife[:oneview_password] attribute!' if @oneview_password.nil? || @oneview_password.empty?
-      @oneview_api_version = 120 # Use this version for all calls that don't override it
-      @current_oneview_api_version = get_oneview_api_version
-      Chef::Log.debug("Logging into OneView at #{@oneview_base_url}")
-      @oneview_key         = login_to_oneview
-
-      @icsp_base_url       = config[:knife][:icsp_url]
-      @icsp_username       = config[:knife][:icsp_username]
-      @icsp_password       = config[:knife][:icsp_password]
-      @icsp_disable_ssl    = config[:knife][:icsp_ignore_ssl]
+    def initialize(url, config)
+      _scheme, oneview_url = url.split(':', 2)
+      super(url, config)
+
+      ov_config = config[:driver_options][:oneview] || {} rescue {}
+      ov_config = Hash[ov_config.map { |k, v| [k.to_sym, v] }] # Convert string keys to symbols
+
+      ov_config[:url] = oneview_url
+      ov_config[:user] ||= config[:knife][:oneview_username] || ENV['ONEVIEWSDK_USER']
+      ov_config[:password] ||= config[:knife][:oneview_password] || ENV['ONEVIEWSDK_PASSWORD']
+      ov_config[:token] ||= config[:knife][:oneview_token] || ENV['ONEVIEWSDK_TOKEN']
+      ov_config[:ssl_enabled] = false if ov_config[:ssl_enabled] == false || (ov_config[:ssl_enabled].nil? && config[:knife][:oneview_ignore_ssl])
+      ov_config[:timeout] ||= config[:knife][:oneview_timeout] if config[:knife][:oneview_timeout]
+      ov_config[:print_wait_dots] = true if ov_config[:print_wait_dots].nil?
+      ov_config[:logger] = Chef::Log
+      @ov = OneviewSDK::Client.new(ov_config) # OneView client object
+
+      icsp_config = config[:driver_options][:icsp] || {} rescue {}
+
+      @icsp_base_url       = icsp_config[:url] || config[:knife][:icsp_url]
+      @icsp_username       = icsp_config[:user] || config[:knife][:icsp_username]
+      @icsp_password       = icsp_config[:password] || config[:knife][:icsp_password]
+      @icsp_disable_ssl    = false
+      @icsp_disable_ssl    = true if icsp_config[:ssl_enabled] == false || config[:knife][:icsp_ignore_ssl] == true
       @icsp_api_version    = 102 # Use this version for all calls that don't override it
+      @icsp_timeout        = icsp_config[:timeout] || config[:knife][:icsp_timeout]
 
-      Chef::Log.warn 'knife[:icsp_url] not set in knife.rb!'      if @icsp_base_url.nil?
-      Chef::Log.warn 'knife[:icsp_username] not set in knife.rb!' if @icsp_username.nil?
-      Chef::Log.warn 'knife[:icsp_password] not set in knife.rb!' if @icsp_password.nil?
+      Chef::Log.warn 'ICSP url not set! ICSP will be ignored'      if @icsp_base_url.nil?
+      Chef::Log.warn 'ICSP user not set! ICSP will be ignored'     if @icsp_username.nil?
+      Chef::Log.warn 'ICSP password not set! ICSP will be ignored' if @icsp_password.nil?
 
       @icsp_ignore = @icsp_base_url.nil? || @icsp_username.nil? || @icsp_password.nil?
       # If the config is not specified, skip ICSP
-      unless @icsp_ignore
-        Chef::Log.debug("Logging into ICSP at #{@icsp_base_url}")
-        @current_icsp_api_version = get_icsp_api_version
-        @icsp_key = login_to_icsp
-      end
+      return if @icsp_ignore
+      Chef::Log.debug("Logging into ICSP at #{@icsp_base_url}")
+      @current_icsp_api_version = get_icsp_api_version
+      @icsp_key = login_to_icsp
     end
 
 
     def allocate_machine(action_handler, machine_spec, machine_options)
-      host_name = machine_options[:driver_options][:host_name]
+      raise 'Machine definition missing :driver_options parameter!' unless machine_options[:driver_options]
       if machine_spec.reference
-        if get_oneview_profile_by_sn(machine_spec.reference['serial_number']).nil? # It doesn't really exist
-          action_handler.report_progress "Machine #{host_name} does not really exist.  Recreating ..."
-          machine_spec.reference = nil
-        else # Update reference data
+        profile = OneviewSDK::ServerProfile.find_by(@ov, serialNumber: machine_spec.reference['serial_number']).first
+        if profile # Update reference data
           machine_spec.reference['driver_url'] = driver_url
           machine_spec.reference['driver_version'] = ONEVIEW_DRIVER_VERSION
+          # TODO: Update profile if differs from Chef and/or Template config
+          machine_spec.reference['profile_name'] = profile['name']
+        else # It doesn't really exist
+          action_handler.report_progress "Machine #{machine_spec.name} does not really exist.  Recreating ..."
+          machine_spec.reference = nil
         end
       end
-      if !machine_spec.reference
-        action_handler.perform_action "Creating server #{machine_spec.name}" do
-          profile = create_machine(action_handler, machine_spec, machine_options)
+      unless machine_spec.reference
+        action_handler.perform_action "Allocate server #{machine_spec.name}" do
+          profile = create_machine(action_handler, machine_spec.name, machine_options)
           machine_spec.reference = {
             'driver_url' => driver_url,
             'driver_version' => ONEVIEW_DRIVER_VERSION,
-            'serial_number' => profile['serialNumber']
+            'serial_number' => profile['serialNumber'],
+            'profile_name' => profile['name']
           }
         end
       end
@@ -102,37 +103,22 @@ module Chef::Provisioning
       end
     end
 
+
     def ready_machine(action_handler, machine_spec, machine_options)
-      profile = get_oneview_profile_by_sn(machine_spec.reference['serial_number'])
+      profile = OneviewSDK::ServerProfile.find_by(@ov, serialNumber: machine_spec.reference['serial_number']).first
       raise "Failed to retrieve Server Profile for #{machine_spec.name}. Serial Number used to search: #{machine_spec.reference['serial_number']}" unless profile
+      customize_machine(action_handler, machine_spec, machine_options, profile)
       if @icsp_ignore == true
-        wait_for_profile(action_handler, machine_spec, machine_options, profile)
-        Chef::Log.warn('Action converge action being used, without an ICSP configuration')
+        Chef::Log.warn("Skipping ICSP configuration for machine '#{machine_spec.name}'")
         Machine::BasicMachine.new(machine_spec, OneViewNilTransport.new, OneViewNilConvergence.new)
-      else
-        # This function takes care of installing the operating system etc. to the machine (blade)
-        customize_machine(action_handler, machine_spec, machine_options, profile)
-        # This is a provisining function and handles installing a chef-client
-        machine_for(machine_spec, machine_options) # Return the Machine object
+      else # Return a machine object that Chef can connect to (to install chef-client)
+        machine_for(machine_spec, machine_options)
       end
     end
 
 
     def machine_for(machine_spec, machine_options)
-      bootstrap_ip_address = machine_options[:driver_options][:ip_address]
-      unless bootstrap_ip_address
-        id, connection = machine_options[:driver_options][:connections].find { |_id, c| c[:bootstrap] == true }
-        raise 'Must specify a connection to use to bootstrap!' unless id && connection
-        bootstrap_ip_address = connection[:ip4Address] # For static IPs
-        unless bootstrap_ip_address # Look for dhcp address given to this connection
-          profile = get_oneview_profile_by_sn(machine_spec.reference['serial_number'])
-          my_server = get_icsp_server_by_sn(machine_spec.reference['serial_number'])
-          mac = profile['connections'].find {|x| x['id'] == id}['mac']
-          interface = my_server['interfaces'].find { |i| i['macAddr'] == mac }
-          bootstrap_ip_address = interface['ipv4Addr'] || interface['ipv6Addr']
-        end
-        bootstrap_ip_address ||= my_server['hostName'] # Fall back on hostName
-      end
+      bootstrap_ip_address = ip_from_machine(machine_spec, machine_options)
       raise 'Server IP address not specified and could not be retrieved!' unless bootstrap_ip_address
       username = machine_options[:transport_options][:user] || 'root' rescue 'root'
       default_ssh_options = {
@@ -153,39 +139,46 @@ module Chef::Provisioning
       Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport, convergence_strategy)
     end
 
-    def stop_machine(action_handler, machine_spec, _machine_options)
-      power_off(action_handler, machine_spec) if machine_spec.reference
+    def stop_machine(_action_handler, machine_spec, _machine_options)
+      return unless machine_spec.reference
+      profile = OneviewSDK::ServerProfile.find_by(@ov, serialNumber: machine_spec.reference['serial_number']).first
+      profile.get_server_hardware.power_off
     end
 
 
-    def destroy_machine(action_handler, machine_spec, _machine_options)
-      if machine_spec.reference
-        power_off(action_handler, machine_spec) # Power off server
-        destroy_icsp_server(action_handler, machine_spec) unless @icsp_ignore # Delete os deployment server from ICSP
-        destroy_oneview_profile(action_handler, machine_spec) # Delete server profile from OneView
-
-        name = machine_spec.name # Save for next steps
-
-        # Remove entry from known_hosts file(s)
-        ip_address = machine_spec.data['automatic']['ipaddress'] rescue nil
-        if ip_address
-          action_handler.perform_action "Delete entry for #{name} (#{ip_address}) from known_hosts file(s)" do
-            files = [File.expand_path('~/.ssh/known_hosts'), File.expand_path('/etc/ssh/known_hosts')]
-            files.each do |f|
-              next unless File.exist?(f)
-              begin
-                text = File.read(f)
-                text.gsub!(/#{ip_address} ssh-rsa.*(\n|\r\n)/, '')
-                File.open(f, 'w') {|file| file.puts text } if text
-              rescue  Exception => e
-                action_handler.report_progress "WARN: Failed to delete entry for #{name} (#{ip_address}) from known_hosts file: '#{f}'! "
-                puts "Error: #{e.message}"
-              end
-            end
+    def destroy_machine(action_handler, machine_spec, machine_options)
+      return unless machine_spec.reference
+      profile = OneviewSDK::ServerProfile.find_by(@ov, serialNumber: machine_spec.reference['serial_number']).first
+      if profile
+        profile.get_server_hardware.power_off
+        action_handler.perform_action "Delete server profile #{machine_spec.name}" do
+          action_handler.report_progress "INFO: Deleting server profile #{machine_spec.name}"
+          profile.delete
+        end
+      else
+        action_handler.report_progress "INFO: #{machine_spec.name} is already deleted."
+      end
+      destroy_icsp_server(action_handler, machine_spec) unless @icsp_ignore # Delete os deployment server from ICSP
+
+      name = machine_spec.name # Save for next steps
+
+      # Remove entry from known_hosts file(s)
+      ip_address = ip_from_machine(machine_spec, machine_options)
+      return unless ip_address
+      action_handler.perform_action "Delete entries for #{name} (#{ip_address}) from known_hosts file(s)" do
+        files = [File.expand_path('~/.ssh/known_hosts'), File.expand_path('/etc/ssh/known_hosts')]
+        files.each do |f|
+          next unless File.exist?(f)
+          begin
+            text = File.read(f)
+            text.gsub!(/#{ip_address} ssh-rsa.*(\n|\r\n)/, '')
+            File.open(f, 'w') { |file| file.puts text } if text
+          rescue Exception => e
+            action_handler.report_progress "WARN: Failed to delete entries for #{name} (#{ip_address}) from known_hosts file: '#{f}'! "
+            puts "Error: #{e.message}"
           end
         end
-
-      end # End if machine_spec.reference
+      end
     end # destroy_machine method end
 
 
@@ -193,6 +186,32 @@ module Chef::Provisioning
       machine_for(machine_spec, machine_options)
     end
 
+    private
+
+    def ip_from_machine(machine_spec, machine_options)
+      return machine_options[:driver_options][:ip_address] if machine_options[:driver_options][:ip_address]
+
+      id, connection = machine_options[:driver_options][:connections].find { |_id, c| c[:bootstrap] == true }
+      raise 'Must specify a connection to use to bootstrap!' unless id && connection # TODO: Try first connection anyways?
+      return connection[:ip4Address] if connection[:ip4Address] # Return static IP if set
+      # Look for dhcp address given to this connection
+      if machine_spec.data['normal']['icsp'] && machine_spec.data['normal']['icsp']['interfaces']
+        interface = machine_spec.data['normal']['icsp']['interfaces'].find { |i| i['oneViewId'] == id }
+        if interface
+          addr = interface['ipv4Addr'] || interface['ipv6Addr']
+          return addr if addr
+        end
+      end
+      profile = OneviewSDK::ServerProfile.find_by(@ov, serialNumber: machine_spec.reference['serial_number']).first
+      my_server = get_icsp_server_by_sn(machine_spec.reference['serial_number'])
+      mac = profile['connections'].find { |x| x['id'] == id }['mac']
+      interface = my_server['interfaces'].find { |i| i['macAddr'] == mac }
+      addr = interface['ipv4Addr'] || interface['ipv6Addr']
+      addr ||= my_server['hostName'] # Fall back on hostName
+      Chef::Log.warn "IP address for '#{machine_spec.name}' not specified and could not be retrieved!" unless addr
+      addr
+    end
+
   end # class end
 
   # Additional No-Op classes to nil return when a :converge is called