chef-provisioning-oneview 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9d6fc4eeb70e68a685026500dd2f1b740bc2258
+  data.tar.gz: a6b1a761bbfda4d5a7df5254992eb7da07f7bc0a
+SHA512:
+  metadata.gz: 1998337d50d17e87c542b76cf73974f2caf0403e12e5535bb4cb648edbb846bcece9fff6017a48b527771477c81d2f12b4ad3be67d7b544c3e0a9263cd20b47f
+  data.tar.gz: 92a234a482898954435ce47c131a62ba8d71ad0c7b1f9c3514e6ccdd4d0ce6f0de59af4c0e2ccfd951b9167b2197aa699a53e2c8797fd329b341365a7ada8aa9

data/LICENSE

@@ -0,0 +1,9 @@
+© Copyright 2015 Hewlett Packard Enterprise Development LP
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and limitations under the License.

data/README.md

@@ -0,0 +1,149 @@
+# chef-provisioning-oneview
+Chef Provisioning driver for HP OneView
+
+Currently supports OneView v1.2.0 and ICsp v7.4.0
+
+# Installation
+
+- Require the gem in your Gemfile: `gem 'chef-provisioning-oneview'`
+  
+  Then run `$ bundle install`
+- Or run the command:
+  
+  ```ruby
+  $ gem install chef-provisioning-oneview
+  ```
+
+
+
+# Prerequisites
+- Set up your `knife.rb` file with the information the driver needs to connect to OneView and Insight Control Server Provisioning
+  
+  ```ruby
+  # (knife.rb)
+  # (in addition to all the normal stuff like node_name, client_key, validation_client_name, validation_key, chef_server_url, etc.)
+  knife[:oneview_url]        = 'https://my-oneview.my-domain.com'
+  knife[:oneview_username]   = 'Administrator'
+  knife[:oneview_password]   = 'password123'
+  knife[:oneview_ignore_ssl] = true # For self-signed certs
+  
+  knife[:icsp_url]           = 'https://my-icsp.my-domain.com'
+  knife[:icsp_username]      = 'Administrator'
+  knife[:icsp_password]      = 'password123'
+  knife[:icsp_ignore_ssl]    = true # For self-signed certs
+  
+  knife[:node_root_password] = 'password123'
+  
+  # If your Chef server has self-signed certs:
+  verify_api_cert              false
+  ssl_verify_mode              :verify_none
+  ```
+
+- Your OneView, Insight Controll Server Provisioning(ICSP), and Chef server must be trusted by your certificate stores. See [examples/ssl_issues.md](examples/ssl_issues.md) for more info on how to do this.
+- Your OneView and ICSP servers must be set up beforehand. Unfortunately, this driver doesn't do that for you too. See the wiki pages [OneView Configuration](https://github.com/HewlettPackard/chef-provisioning-oneview/wiki/OneView-Configuration) and [ICsp Configuration](https://github.com/HewlettPackard/chef-provisioning-oneview/wiki/ICsp-Configuration) for details about how to set them up.
+
+# Usage
+
+Example recipe:
+```ruby
+require 'chef/provisioning'
+
+with_driver 'oneview'
+
+with_chef_server "https://my-chef.my-domain.com/organizations/my-org",
+  :client_name => Chef::Config[:node_name],          # NOTE: This must have node & client creation privileges (ie admin group)
+  :signing_key_filename => Chef::Config[:client_key] # NOTE: This must have node & client creation privileges (ie admin group)
+
+machine 'web01' do
+  recipe 'my_server_cookbook::default'
+
+  machine_options :driver_options => {
+      :server_template => 'Web Server Template',
+      :os_build => 'CHEF-RHEL-6.5-x64',
+      :host_name => 'chef-web01',
+      :ip_address => 'xx.xx.xx.xx', # For bootstrapping only.
+      
+      :domainType => 'workgroup',
+      :domainName => 'sub.domain.com',
+      :mask => '255.255.255.0', # Can set here or in individual connections below
+      :dhcp => false,
+      :gateway =>  'xx.xx.xx.1',
+      :dns => 'xx.xx.xx.xx,xx.xx.xx.xx,xx.xx.xx.xx',
+      :connections => {
+        #1 => { ... } (Reserved for PXE on our setup)
+        2 => {
+          :ip4Address => 'xx.xx.xx.xx',
+          :mask => '255.255.254.0', # Optional. Overrides mask property above
+          :dhcp => false            # Optional. Overrides dhcp property above
+          :gateway => 'xx.xx.xx.1'  # Optional. Overrides gateway property above
+          :dns => 'xx.xx.xx.xx'     # Optional. Overrides dns property above
+        }
+      },
+      :custom_attributes => {
+        :chefCert => 'ssh-rsa AA...' # Optional
+      }
+    },
+    :transport_options => {
+      :user => 'root', # Optional. Defaults to 'root'
+      :ssh_options => {
+        :password => Chef::Config.knife[:node_root_password]
+      }
+    },
+    :convergence_options => {
+      :ssl_verify_mode => :verify_none, # Optional. For Chef servers with self-signed certs
+      :bootstrap_proxy => 'http://proxy.domain.com:8080' # Optional
+    }
+
+  chef_environment '_default'
+  converge true
+end
+```
+
+See https://github.com/chef/chef-provisioning-ssh for more transport_options.
+
+### Custom Attributes
+Insided the custom attributes hash, you can specify any data that you would like to pass into your ICsp build plan scripts or configuration files. For example, to specify a list of trusted public keys to be placed into the node's .ssh/authorized_keys file, add a custom attribute to the machine resource definition:
+
+```ruby
+:custom_attributes => {
+  :chefCert => 'ssh-rsa AA...'
+}
+```
+
+Then create/modify a custom build script in ICsp that will do something with this data. To access it, use the format: `@variable_name@` or `@variable_name:default_value@`. For our example, we could do something like:
+
+```bash
+#!/bin/bash
+authorized_keys = @chefCert@
+if [ -n "$authorized_keys"]; then
+  echo -e "$authorized_keys" > /mnt/sysimage/root/.ssh/authorized_keys
+fi
+```
+
+### Behind a proxy
+Add `:bootstrap_proxy => 'http://proxy.domain.com:8080'` to your convergence_options hash.
+Also, make sure your OS build plans set up the proxy configuration in a post OS install script.
+
+
+# Doing a test run
+This repo contains everything you need to get started, including example recipes and knife configuration files. See the README in the [examples](examples/) directory for how to begin provisioning.
+
+
+# Contributing
+You know the drill. Fork it, branch it, change it, commit it, pull-request it. We're passionate about improving this driver, and glad to accept help to make it better.
+
+### Building the Gem
+To build this gem, run `$ rake build` or `gem build chef-provisioning-oneview.gemspec`.
+
+Then once it's built you can install it by running `$ rake install` or `$ gem install ./chef-provisioning-oneview-<VERSION>.gem`.
+
+### Testing
+- RuboCop: `$ rake rubocop` or `$ rubocop .`
+- Rspec: `$ rake spec` or `$ rspec`
+- Both: Run `$ rake test` to run both RuboCop and Rspec tests.
+
+# Authors
+ - Jared Smartt - [@jsmartt](https://github.com/jsmartt)
+ - Gunjan Kamle - [@kgunjan](https://github.com/kgunjan)
+ - Matthew Frahry - [@mbfrahry](https://github.com/mbfrahry)
+ - Andy Claiborne - [@veloandy](https://github.com/veloandy)

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+RuboCop::RakeTask.new
+
+desc 'Runs rubocop and rspec'
+task :test do
+  Rake::Task[:rubocop].invoke
+  Rake::Task[:spec].invoke
+end

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

@@ -0,0 +1,3 @@
+require 'chef/provisioning/oneview_driver'
+
+Chef::Provisioning.register_driver_class('oneview', Chef::Provisioning::OneViewDriver)

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

@@ -0,0 +1,467 @@
+require_relative 'v1.20/api'
+require_relative 'v2.0/api'
+
+module OneViewAPI
+  private
+
+  include OneViewAPIv1_20
+  include OneViewAPIv2_0
+
+  # API calls for OneView and ICSP
+  def rest_api(host, type, path, options = {})
+    disable_ssl = false
+    case host
+    when 'icsp', :icsp
+      uri = URI.parse(URI.escape(@icsp_base_url + path))
+      options['X-API-Version'] ||= @icsp_api_version unless [:put, 'put'].include?(type.downcase)
+      options['auth'] ||= @icsp_key
+      disable_ssl = true if @icsp_disable_ssl
+    when 'oneview', :oneview
+      uri = URI.parse(URI.escape(@oneview_base_url + path))
+      options['X-API-Version'] ||= @oneview_api_version
+      options['auth'] ||= @oneview_key
+      disable_ssl = true if @oneview_disable_ssl
+    else
+      fail "Invalid rest host: #{host}"
+    end
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == 'https'
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE if disable_ssl
+
+    case type.downcase
+    when 'get', :get
+      request = Net::HTTP::Get.new(uri.request_uri)
+    when 'post', :post
+      request = Net::HTTP::Post.new(uri.request_uri)
+    when 'put', :put
+      request = Net::HTTP::Put.new(uri.request_uri)
+    when 'delete', :delete
+      request = Net::HTTP::Delete.new(uri.request_uri)
+    else
+      fail "Invalid rest call: #{type}"
+    end
+    options['Content-Type'] ||= 'application/json'
+    options.delete('Content-Type')  if [:none, 'none', nil].include?(options['Content-Type'])
+    options.delete('X-API-Version') if [:none, 'none', nil].include?(options['X-API-Version'])
+    options.delete('auth')          if [:none, 'none', nil].include?(options['auth'])
+    options.each do |key, val|
+      if key.downcase == 'body'
+        request.body = val.to_json rescue val
+      else
+        request[key] = val
+      end
+    end
+
+    response = http.request(request)
+    JSON.parse(response.body) rescue response
+  end
+
+  def get_oneview_api_version
+    begin
+      version = rest_api(:oneview, :get, '/rest/version', { 'Content-Type' => :none, 'X-API-Version' => :none, 'auth' => :none })['currentVersion']
+      fail "Couldn't get API version" unless version
+      if version.class != Fixnum
+        version = version.to_i
+        fail 'API version type mismatch' if !version > 0
+      end
+    rescue
+      puts 'Failed to get OneView API version. Setting to default (120)'
+      version = 120
+    end
+    version
+  end
+
+  def get_icsp_api_version
+    begin
+      version = rest_api(:icsp, :get, '/rest/version', { 'Content-Type' => :none, 'X-API-Version' => :none, 'auth' => :none })['currentVersion']
+      fail "Couldn't get API version" unless version
+      if version.class != Fixnum
+        version = version.to_i
+        fail 'API version type mismatch' if !version > 0
+      end
+    rescue
+      puts 'Failed to get ICSP API version. Setting to default (102)'
+      version = 102
+    end
+    version
+  end
+
+  # Login functions
+  def auth_tokens
+    @icsp_key  ||= login_to_icsp
+    @oneview_key ||= login_to_oneview
+    { 'icsp_key' => @icsp_key, 'oneview_key' => @oneview_key }
+  end
+
+  def login_to_icsp
+    path = '/rest/login-sessions'
+    options = {
+      'body' => {
+        'userName' => @icsp_username,
+        'password' => @icsp_password,
+        'authLoginDomain' => 'LOCAL'
+      }
+    }
+    response = rest_api(:icsp, :post, path, options)
+    return response['sessionID'] if response['sessionID']
+    fail("\nERROR! Couldn't log into OneView server at #{@oneview_base_url}. Response:\n#{response}")
+  end
+
+  def login_to_oneview
+    path = '/rest/login-sessions'
+    options = {
+      'body' => {
+        'userName' => @oneview_username,
+        'password' => @oneview_password,
+        'authLoginDomain' => 'LOCAL'
+      }
+    }
+    response = rest_api(:oneview, :post, path, options)
+    return response['sessionID'] if response['sessionID']
+    fail("\nERROR! Couldn't log into OneView server at #{@oneview_base_url}. Response:\n#{response}")
+  end
+
+
+  def get_oneview_profile_by_sn(serialNumber)
+    matching_profiles = rest_api(:oneview, :get, "/rest/server-profiles?filter=serialNumber matches '#{serialNumber}'&sort=name:asc")
+    return matching_profiles['members'].first if matching_profiles['count'] > 0
+    nil
+  end
+
+  def get_icsp_server_by_sn(serialNumber)
+    search_result = rest_api(:icsp, :get,
+      "/rest/index/resources?category=osdserver&query='osdServerSerialNumber:\"#{serial_number}\"'")['members'] rescue nil
+    if search_result && search_result.size == 1 && search_result.first['attributes']['osdServerSerialNumber'] == serial_number
+      my_server = search_result.first
+    end
+    unless my_server && my_server['uri']
+      os_deployment_servers = rest_api(:icsp, :get, '/rest/os-deployment-servers')
+      # Pick the relevant os deployment server from icsp
+      my_server = nil
+      os_deployment_servers['members'].each do |server|
+        if server['serialNumber'] == serialNumber
+          my_server = server
+          break
+        end
+      end
+    end
+    my_server
+  end
+
+
+  def power_on(action_handler, machine_spec, hardware_uri = nil)
+    set_power_state(action_handler, machine_spec, 'on', hardware_uri)
+  end
+
+  def power_off(action_handler, machine_spec, hardware_uri = nil)
+    set_power_state(action_handler, machine_spec, 'off', hardware_uri)
+  end
+
+  def set_power_state(action_handler, machine_spec, state, hardware_uri = nil)
+    case state
+    when :on, 'on', true
+      state = 'on'
+    when :off, 'off', false
+      state = 'off'
+    else fail "Invalid power state #{state}"
+    end
+
+    if hardware_uri.nil?
+      profile = get_oneview_profile_by_sn(machine_spec.reference['serial_number'])
+      hardware_uri = profile['serverHardwareUri']
+    end
+
+    hardware_info = rest_api(:oneview, :get, hardware_uri)
+    unless hardware_info['powerState'].downcase == state
+      action_handler.perform_action "Power #{state} server #{hardware_info['name']} for #{machine_spec.name}" do
+        action_handler.report_progress "INFO: Powering #{state} server #{hardware_info['name']} for #{machine_spec.name}"
+        task = rest_api(:oneview, :put, "#{hardware_uri}/powerState", { 'body' => { 'powerState' => state.capitalize, 'powerControl' => 'MomentaryPress' } })
+        task_uri = task['uri']
+        60.times do # Wait for up to 10 minutes
+          task = rest_api(:oneview, :get, task_uri)
+          break if task['taskState'].downcase == 'completed'
+          print '.'
+          sleep 10
+        end
+        fail "Powering #{state} machine #{machine_spec.name} failed!" unless task['taskState'].downcase == 'completed'
+      end
+    end
+    hardware_uri
+  end
+
+  #  Chef oneview provisioning
+  def create_machine(action_handler, machine_spec, machine_options)
+    host_name = machine_options[:driver_options][:host_name]
+    server_template = machine_options[:driver_options][:server_template]
+
+    auth_tokens # Login (to both ICSP and OneView)
+
+    # Check if profile exists first
+    matching_profiles = rest_api(:oneview, :get, "/rest/server-profiles?filter=name matches '#{host_name}'&sort=name:asc")
+
+    if matching_profiles['count'] > 0
+      profile = matching_profiles['members'].first
+      power_on(action_handler, machine_spec, profile['serverHardwareUri']) # Make sure server is started
+      return profile
+    end
+
+
+    #  Get HPOVProfile by name (to see if it already exists)
+    #  For 120 verion of Oneview , we are going to retrive a predefined unassociated server profile
+    templates = rest_api(:oneview, :get, "/rest/server-profiles?filter=name matches '#{server_template}'&sort=name:asc")
+    unless templates['members'] && templates['members'].count > 0
+      fail "Template '#{server_template}' not found! Please match the template name with one that exists on OneView."
+    end
+
+    template_uri             = templates['members'].first['uri']
+    server_hardware_type_uri = templates['members'].first['serverHardwareTypeUri']
+    enclosure_group_uri      = templates['members'].first['enclosureGroupUri']
+
+    # Get availabe (and compatible) HP OV server blades. Take first one.
+    blades = rest_api(:oneview, :get, "/rest/server-hardware?sort=name:asc&filter=serverHardwareTypeUri='#{server_hardware_type_uri}'&filter=serverGroupUri='#{enclosure_group_uri}'")
+    fail 'Error! No available blades that are compatible with the server profile!' unless blades['count'] > 0
+    chosen_blade = nil
+    blades['members'].each do |member|
+      if member['state'] != 'ProfileApplied' &&  member['state'] != 'ApplyingProfile'
+        chosen_blade = member
+        break
+      end
+    end
+    if chosen_blade.nil? # TODO
+      # Every bay is full and no more machines can be allocated
+      fail 'No more blades are available for provisioning!'
+    end
+
+    power_off(action_handler, machine_spec, chosen_blade['uri'])
+    # New-HPOVProfileFromTemplate
+    # Create new profile instance from template
+    action_handler.perform_action "Initialize creation of server template for #{machine_spec.name}" do
+      action_handler.report_progress "INFO: Initializing creation of server template for #{machine_spec.name}"
+
+      new_template_profile = rest_api(:oneview, :get, "#{template_uri}")
+
+      # Take response, add name & hardware uri, and post back to /rest/server-profiles
+      new_template_profile['name'] = host_name
+      new_template_profile['uri'] = nil
+      new_template_profile['serialNumber'] = nil
+      new_template_profile['uuid'] = nil
+      new_template_profile['connections'].each do |c|
+        c['wwnn'] = nil
+        c['wwpn'] = nil
+        c['mac']  = nil
+      end
+
+      new_template_profile['serverHardwareUri'] = chosen_blade['uri']
+      task = rest_api(:oneview, :post, '/rest/server-profiles', { 'body' => new_template_profile })
+      task_uri = task['uri']
+      # Poll task resource to see when profile has finished being applied
+      60.times do # Wait for up to 5 min
+        matching_profiles = rest_api(:oneview, :get, "/rest/server-profiles?filter=name matches '#{host_name}'&sort=name:asc")
+        break if matching_profiles['count'] > 0
+        print '.'
+        sleep 5
+      end
+      unless matching_profiles['count'] > 0
+        task = rest_api(:oneview, :get, task_uri)
+        fail "Server template coudln't be applied! #{task['taskStatus']}. #{task['taskErrors'].first['message']}"
+      end
+    end
+    matching_profiles['members'].first
+  end
+
+
+  # Use ICSP to install OS
+  def customize_machine(action_handler, machine_spec, machine_options, profile)
+    auth_tokens # Login (to both ICSP and OneView)
+
+    # Wait for server profile to finish building
+    unless profile['state'] == 'Normal'
+      action_handler.perform_action "Wait for #{machine_spec.name} server to start and profile to be applied" do
+        action_handler.report_progress "INFO: Waiting for #{machine_spec.name} server to start and profile to be applied"
+        task_uri = profile['taskUri']
+        build_server_template_task = rest_api(:oneview, :get, task_uri)
+        # Poll task resource to see when profile has finished being applied
+        240.times do # Wait for up to 40 min
+          build_server_template_task = rest_api(:oneview, :get, task_uri)
+          break if build_server_template_task['taskState'].downcase == 'completed'
+          if build_server_template_task['taskState'].downcase == 'error'
+            server_template = machine_options[:driver_options][:server_template]
+            fail "Error creating server profile from template #{server_template}: #{build_server_template_task['taskErrors'].first['message']}"
+          end
+          print '.'
+          sleep 10
+        end
+        fail 'Timed out waiting for server to start and profile to be applied' unless build_server_template_task['taskState'].downcase == 'completed'
+      end
+      profile = get_oneview_profile_by_sn(machine_spec.reference['serial_number']) # Refresh profile
+      fail "Server profile state '#{profile['state']}' not 'Normal'" unless profile['state'] == 'Normal'
+    end
+
+    # Make sure server is started
+    power_on(action_handler, machine_spec, profile['serverHardwareUri'])
+
+    # Get ICSP servers to poll and wait until server PXE complete (to make sure ICSP is available).
+    my_server = nil
+    action_handler.perform_action "Wait for #{machine_spec.name} to boot" do
+      action_handler.report_progress "INFO: Waiting for #{machine_spec.name} to PXE boot. This may take a while..."
+      360.times do # Wait for up to 1 hr
+        os_deployment_servers = rest_api(:icsp, :get, '/rest/os-deployment-servers')
+
+        # TODO: Maybe check for opswLifecycle = 'UNPROVISIONED' instead of serialNumber existance
+        os_deployment_servers['members'].each do |server|
+          if server['serialNumber'] == profile['serialNumber']
+            my_server = server
+            break
+          end
+        end
+        break if !my_server.nil?
+        print '.'
+        sleep 10
+      end
+      fail "Timeout waiting for server #{machine_spec.name} to register with ICSP" if my_server.nil?
+    end
+
+    # Consume any custom attributes that were specified
+    if machine_options[:driver_options][:custom_attributes]
+      curr_server = rest_api(:icsp, :get, my_server['uri'])
+      machine_options[:driver_options][:custom_attributes].each do |key, val|
+        curr_server['customAttributes'].push({
+          'values' => [{ 'scope' => 'server',  'value' => val.to_s }],
+          'key' => key.to_s
+        })
+      end
+      options = { 'body' => curr_server }
+      rest_api(:icsp, :put, my_server['uri'], options)
+    end
+
+    # Run OS install on a server
+    unless my_server['opswLifecycle'] == 'MANAGED' # Skip if already in MANAGED state
+      os_build = machine_options[:driver_options][:os_build]
+      action_handler.perform_action "Install OS: #{os_build} on #{machine_spec.name}" do
+        action_handler.report_progress "INFO: Installing OS: #{os_build} on #{machine_spec.name}"
+        # Get os-deployment-build-plans
+        build_plan_uri = nil
+        os_deployment_build_plans = rest_api(:icsp, :get, '/rest/os-deployment-build-plans')
+        os_deployment_build_plans['members'].each do |bp|
+          if bp['name'] == os_build
+            build_plan_uri = bp['uri']
+            break
+          end
+        end
+        fail "OS build plan #{os_build} not found!" if build_plan_uri.nil?
+
+        # Do the OS deployment
+        options = { 'body' => {
+          'osbpUris' => [build_plan_uri],
+          'serverData' => [{ 'serverUri' => my_server['uri'] }]
+        } }
+        os_deployment_task = rest_api(:icsp, :post, '/rest/os-deployment-jobs/?force=true', options)
+        os_deployment_task_uri = os_deployment_task['uri']
+        720.times do # Wait for up to 2 hr
+          os_deployment_task = rest_api(:icsp, :get, os_deployment_task_uri, options) # TODO: Need options?
+          break if os_deployment_task['running'] == 'false'
+          print '.'
+          sleep 10
+        end
+        unless os_deployment_task['state'] == 'STATUS_SUCCESS'
+          fail "Error running OS build plan #{os_build}: #{os_deployment_task['jobResult'].first['jobMessage']}\n#{os_deployment_task['jobResult'].first['jobResultErrorDetails']}"
+        end
+      end
+    end
+
+    # Perform network personalization
+    action_handler.perform_action "Perform network personalization on #{machine_spec.name}" do
+      action_handler.report_progress "INFO: Performing network personalization on #{machine_spec.name}"
+      nics = []
+      if machine_options[:driver_options][:connections]
+        machine_options[:driver_options][:connections].each do |id, data|
+          c = data
+          c[:macAddress]   = profile['connections'].select {|x| x['id'] == id}.first['mac']
+          c[:mask]       ||= machine_options[:driver_options][:mask]
+          c[:dhcp]       ||= machine_options[:driver_options][:dhcp] || false
+          c[:gateway]    ||= machine_options[:driver_options][:gateway]
+          c[:dns]        ||= machine_options[:driver_options][:dns]
+          c[:ip4Address] ||= machine_options[:driver_options][:ip_address]
+          nics.push c
+        end
+      end
+      options = { 'body' => [{
+        'serverUri' => my_server['uri'],
+        'personalityData' => {
+          'hostName'   => machine_options[:driver_options][:host_name],
+          'domainType' => machine_options[:driver_options][:domainType],
+          'domainName' => machine_options[:driver_options][:domainName],
+          'nics'       => nics
+        }
+      }] }
+      network_personalization_task = rest_api(:icsp, :put, '/rest/os-deployment-apxs/personalizeserver', options)
+      network_personalization_task_uri = network_personalization_task['uri']
+      60.times do # Wait for up to 10 min
+        network_personalization_task = rest_api(:icsp, :get, network_personalization_task_uri, options)
+        break if network_personalization_task['running'] == 'false'
+        print '.'
+        sleep 10
+      end
+      unless network_personalization_task['state'] == 'STATUS_SUCCESS'
+        fail "Error performing network personalization: #{network_personalization_task['jobResult'].first['jobResultLogDetails']}\n#{network_personalization_task['jobResult'].first['jobResultErrorDetails']}"
+      end
+    end
+    #   Get all, search for yours.  If not there or if it's in uninitialized state, pull again
+    my_server_uri = my_server['uri']
+    30.times do # Wait for up to 5 min
+      my_server = rest_api(:icsp, :get, my_server_uri)
+      break if my_server['opswLifecycle'] == 'MANAGED'
+      print '.'
+      sleep 10
+    end
+
+    fail "Timeout waiting for server #{machine_spec.name} to finish network personalization" if my_server['opswLifecycle'] != 'MANAGED'
+    my_server
+  end
+
+
+  def destroy_icsp_server(action_handler, machine_spec)
+    my_server = get_icsp_server_by_sn(machine_spec.reference['serial_number'])
+    return false if my_server.nil? || my_server['uri'].nil?
+
+    action_handler.perform_action "Delete server #{machine_spec.name} from ICSP" do
+      task = rest_api(:icsp, :delete, my_server['uri']) # TODO: This returns nil instead of task info
+
+      if task['uri']
+        task_uri = task['uri']
+        90.times do # Wait for up to 15 minutes
+          task = rest_api(:icsp, :get, task_uri)
+          break if task['taskState'].downcase == 'completed'
+          print '.'
+          sleep 10
+        end
+        fail "Deleting os deployment server #{machine_spec.name} at icsp failed!" unless task['taskState'].downcase == 'completed'
+      end
+    end
+  end
+
+
+  def destroy_oneview_profile(action_handler, machine_spec, profile = nil)
+    profile ||= get_oneview_profile_by_sn(machine_spec.reference['serial_number'])
+
+    hardware_info = rest_api(:oneview, :get, profile['serverHardwareUri'])
+    if hardware_info.nil?
+      action_handler.report_progress "INFO: #{machine_spec.name} is already deleted."
+    else
+      action_handler.perform_action "Delete server #{machine_spec.name} from oneview" do
+        action_handler.report_progress "INFO: Deleting server profile #{machine_spec.name}"
+        task = rest_api(:oneview, :Delete, "#{profile['uri']}")
+        task_uri = task['uri']
+
+        60.times do # Wait for up to 10 minutes
+          task = rest_api(:oneview, :get, task_uri)
+          break if task['taskState'].downcase == 'completed'
+          print '.'
+          sleep 10
+        end
+        fail "Deleting server profile #{machine_spec.name} failed!" unless task['taskState'].downcase == 'completed'
+      end
+    end
+  end
+end