chef-provisioning-oneview 1.2.1 → 1.3.0

data/lib/chef/provisioning/customize_machine.rb

@@ -1,64 +1,66 @@
-module CustomizeMachine
-  private
+module OneviewChefProvisioningDriver
+  # Handles OS install and network configuration
+  module CustomizeMachine
+    # Use ICSP to install OS
+    def customize_machine(action_handler, machine_spec, machine_options, profile)
+      machine_name = machine_spec.name
+      # Wait for server profile to finish building
+      wait_for_profile(action_handler, machine_name, profile)
+      profile.refresh
 
-  # Use ICSP to install OS
-  def customize_machine(action_handler, machine_spec, machine_options, profile)
-    # Wait for server profile to finish building
-    wait_for_profile(action_handler, machine_spec, machine_options, profile)
+      # Configure SAN storage (if applicable)
+      enable_boot_from_san(action_handler, machine_name, profile) unless machine_spec.reference['network_personalitation_finished']
 
-    # Configure SAN storage (if applicable)
-    enable_boot_from_san(action_handler, machine_spec, profile) unless machine_spec.reference['network_personalitation_finished']
+      # Make sure server is started
+      profile.get_server_hardware.power_on
 
-    # Make sure server is started
-    power_on(action_handler, machine_spec, profile['serverHardwareUri'])
+      return if @icsp_ignore == true
 
-    # 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 into HP Intelligent Provisioning" do
-      action_handler.report_progress "INFO: Waiting for #{machine_spec.name} to PXE boot into HP Intelligent Provisioning"
-      360.times do # Wait for up to 1 hr
-        my_server = get_icsp_server_by_sn(profile['serialNumber'])
-        break if !my_server.nil?
-        print '.'
-        sleep 10
+      # 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_name} to boot into HP Intelligent Provisioning" do
+        action_handler.report_progress "INFO: Waiting for #{machine_name} to PXE boot into HP Intelligent Provisioning"
+        360.times do # Wait for up to 1 hr
+          my_server = get_icsp_server_by_sn(profile['serialNumber'])
+          break unless my_server.nil?
+          print '.'
+          sleep 10
+        end
+        raise "Timeout waiting for server #{machine_name} to register with ICSP" if my_server.nil?
       end
-      raise "Timeout waiting for server #{machine_spec.name} to register with ICSP" if my_server.nil?
-    end
 
-    icsp_configure_nic_teams(machine_options, profile)
+      icsp_configure_nic_teams(machine_options, profile)
 
-    icsp_set_custom_attributes(machine_options, my_server)
+      icsp_set_custom_attributes(machine_options, my_server)
 
-    icsp_run_os_install(action_handler, machine_spec, machine_options, my_server, profile)
+      icsp_run_os_install(action_handler, machine_spec, machine_options, my_server, profile)
 
-    # Customize networking
-    if !machine_spec.reference['network_personalitation_finished'] || machine_options[:driver_options][:force_network_update]
+      # Customize networking
+      if !machine_spec.reference['network_personalitation_finished'] || machine_options[:driver_options][:force_network_update]
 
-      icsp_configure_networking(action_handler, machine_spec, machine_options, my_server, profile)
+        icsp_configure_networking(action_handler, machine_spec, machine_options, my_server, profile)
 
-      # Switch deploy networks to post-deploy networks if specified
-      if machine_options[:driver_options][:connections]
-        available_networks = rest_api(:oneview, :get, "/rest/server-profiles/available-networks?serverHardwareTypeUri=#{profile['serverHardwareTypeUri']}&enclosureGroupUri=#{profile['enclosureGroupUri']}")
-        machine_options[:driver_options][:connections].each do |id, data|
-          next unless data && data[:net] && data[:deployNet]
-          action_handler.report_progress "INFO: Performing network flipping on #{machine_spec.name}, connection #{id}"
-          deploy_network = available_networks['ethernetNetworks'].find {|n| n['name'] == data[:deployNet] }
-          new_network = available_networks['ethernetNetworks'].find {|n| n['name'] == data[:net] }
-          raise "Failed to perform network flipping on #{machine_spec.name}, connection #{id}. '#{data[:net]}' network not found" if new_network.nil?
-          raise "Failed to perform network flipping on #{machine_spec.name}, connection #{id}. '#{data[:deployNet]}' network not found" if deploy_network.nil?
-          profile = get_oneview_profile_by_sn(machine_spec.reference['serial_number'])
-          profile['connections'].find {|c| c['networkUri'] == deploy_network['uri'] }['networkUri'] = new_network['uri']
-          options = { 'body' => profile }
-          task = rest_api(:oneview, :put, profile['uri'], options)
-          raise "Failed to perform network flipping on #{machine_spec.name}. Details: #{task['message'] || task}" unless task['uri']
-          task = oneview_wait_for(task['uri']) # Wait up to 10 min
-          raise "Timed out waiting for network flipping on #{machine_spec.name}" if task == false
-          raise "Error performing network flip on #{machine_spec.name}. Response: #{task}" unless task == true
+        # Switch deploy networks to post-deploy networks if specified
+        if machine_options[:driver_options][:connections]
+          available_networks = profile.available_networks
+          machine_options[:driver_options][:connections].each do |id, data|
+            next unless data && data[:net] && data[:deployNet]
+            action_handler.perform_action "Perform network flipping on #{machine_name}, connection #{id}" do
+              action_handler.report_progress "INFO: Performing network flipping on #{machine_name}, connection #{id}"
+              deploy_network = available_networks['ethernetNetworks'].find { |n| n['name'] == data[:deployNet] }
+              new_network = available_networks['ethernetNetworks'].find { |n| n['name'] == data[:net] }
+              raise "Failed to perform network flipping on #{machine_name}, connection #{id}. '#{data[:net]}' network not found" if new_network.nil?
+              raise "Failed to perform network flipping on #{machine_name}, connection #{id}. '#{data[:deployNet]}' network not found" if deploy_network.nil?
+              profile.refresh
+              profile['connections'].find { |c| c['networkUri'] == deploy_network['uri'] }['networkUri'] = new_network['uri']
+              profile.update
+            end
+          end
         end
+        machine_spec.reference['network_personalitation_finished'] = true
       end
-      machine_spec.reference['network_personalitation_finished'] = true
-    end
 
-    my_server = rest_api(:icsp, :get, my_server['uri'])
+      my_server = rest_api(:icsp, :get, my_server['uri'])
+    end
   end
 end

data/lib/chef/provisioning/helpers.rb

@@ -0,0 +1,18 @@
+require_relative 'create_machine'
+require_relative 'customize_machine'
+require_relative 'oneview/oneview_helper'
+require_relative 'oneview/san_storage'
+require_relative 'icsp/icsp_helper'
+
+module OneviewChefProvisioningDriver
+  # Module that just includes all other helper modules
+  module Helpers
+    include CreateMachine # Handles allocation of OneView ServerProfile
+    include CustomizeMachine # Handles OS install and network configuration
+
+    include OneViewHelper # Helpers for OneView actions
+    include OneViewSanStorage # Helpers for OneView SAN storage actions
+
+    include IcspHelper # Helpers for ICSP actions
+  end
+end

data/lib/chef/provisioning/icsp/api_v104.rb

@@ -1,3 +1,4 @@
+# Helper module for ICSP v104 API requests
 module ICspAPIv104
   # Parse and clean connection data for api call
   def icsp_v104_parse_connection(machine_options, c)
@@ -11,14 +12,14 @@ module ICspAPIv104
     c[:dnsServers]    = nil if c[:dnsServers] == :none
     c[:dnsServers]    = c[:dnsServers].split(',') if c[:dnsServers].class == String
     c[:staticNetworks] ||= ["#{c[:ip4Address]}/#{c[:mask] || machine_options[:driver_options][:mask] || '24'}"] if c[:ip4Address]
-    c.keep_if {|k, _v| allowed_keys.include? k.to_s }
+    c.keep_if { |k, _v| allowed_keys.include? k.to_s }
   end
 
   # Parse and clean personality_data data for api call
   def icsp_v104_build_personality_data(machine_options, nics)
     allowed_keys = %w(hostname domain workgroup)
     personality_data = Marshal.load(Marshal.dump(machine_options[:driver_options])) || {}
-    personality_data.keep_if {|k, _v| allowed_keys.include? k.to_s }
+    personality_data.keep_if { |k, _v| allowed_keys.include? k.to_s }
     personality_data['hostname'] ||= machine_options[:driver_options][:host_name]
     personality_data['domain']   ||= machine_options[:driver_options][:domainName]
     personality_data['interfaces'] = nics

data/lib/chef/provisioning/icsp/icsp_helper.rb

@@ -0,0 +1,288 @@
+require_relative 'rest'
+require_relative 'api_v104'
+
+module OneviewChefProvisioningDriver
+  # Helpers for ICSP actions
+  module IcspHelper
+    include RestAPI
+    include ICspAPIv104
+
+    def get_icsp_api_version
+      begin
+        version = rest_api(:icsp, :get, '/rest/version', 'Content-Type' => :none, 'X-API-Version' => :none, 'auth' => :none)['currentVersion']
+        raise "Couldn't get API version" unless version
+        if version.class != Fixnum
+          version = version.to_i
+          raise '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
+
+    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']
+      raise("\nERROR! Couldn't log into ICSP server at #{@icsp_base_url}. Response:\n#{response}")
+    end
+
+    def get_icsp_server_by_sn(serial_number)
+      raise 'Must specify a serialNumber!' if serial_number.nil? || serial_number.empty?
+      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_uri = search_result.first['uri']
+        my_server = rest_api(:icsp, :get, my_server_uri)
+      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'] == serial_number
+            my_server = server
+            break
+          end
+        end
+      end
+      my_server
+    end
+
+    def icsp_wait_for(task_uri, wait_iterations = 60, sleep_seconds = 10)
+      raise 'Must specify a task_uri!' if task_uri.nil? || task_uri.empty?
+      wait_iterations.times do
+        task = rest_api(:icsp, :get, task_uri)
+        if task['taskState']
+          case task['taskState'].downcase
+          when 'completed'
+            return true
+          when 'error', 'killed', 'terminated'
+            return task
+          end
+        elsif task['running'] == 'false' && task['jobResult']
+          if task['state'] == 'STATUS_SUCCESS'
+            return true
+          else
+            return task
+          end
+        end
+        print '.'
+        sleep sleep_seconds
+      end
+      false
+    end
+
+    # Consume and set any custom attributes that were specified
+    def icsp_set_custom_attributes(machine_options, my_server)
+      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
+    end
+
+    def icsp_run_os_install(action_handler, machine_spec, machine_options, my_server, profile)
+      return if my_server['state'] == 'OK' # Skip if the OS has already been deployed
+
+      # Wait for my_server['state'] to be in MAINTENANCE mode
+      if my_server['state'] != 'MAINTENANCE'
+        action_handler.perform_action "Wait for #{machine_spec.name} to go into maintenance mode in ICsp" do
+          action_handler.report_progress "INFO: Waiting for #{machine_spec.name} to go into maintenance mode in ICsp"
+          120.times do # Wait for up to 20 min
+            my_server = get_icsp_server_by_sn(profile['serialNumber'])
+            break if my_server['state'] != 'MAINTENANCE'
+            print '.'
+            sleep 10
+          end
+          raise "Timed out waiting for #{machine_spec.name} to go into maintenance mode in ICsp. State: #{my_server['state']}" unless my_server['state'] == 'MAINTENANCE'
+        end
+      end
+
+      # Get the specified OS Build Plan(s)
+      os_builds = machine_options[:driver_options][:os_build]
+      os_builds = [os_builds] if os_builds.class == String
+      build_plan_uris = []
+      action_handler.perform_action "Get OS Build Plan(s) info for #{machine_spec.name}" do
+        action_handler.report_progress "INFO: Getting OS Build Plan(s) for #{machine_spec.name}"
+        os_builds.each do |os_build|
+          uri = "/rest/index/resources?userQuery=\"'#{os_build}'\"&category=osdbuildplan"
+          while uri
+            matching_plans = rest_api(:icsp, :get, uri)
+            raise "Search failed for OSBP '#{os_build}'. Response: #{matching_plans}" unless matching_plans['members']
+            build_plan_uri = matching_plans['members'].find { |bp| bp['name'] == os_build }['uri'] rescue nil
+            break unless build_plan_uri.nil?
+            uri = URI.unescape(matching_plans['nextPageUri']) rescue nil
+          end
+          raise "OS build plan #{os_build} not found!" if build_plan_uri.nil?
+          build_plan_uris.push build_plan_uri
+        end
+      end
+
+      # Build options for the OS deployment
+      options = {}
+      options['X-API-Version'] = 104 if @current_icsp_api_version.between?(104, 108)
+      options['body'] = {
+        'osbpUris' => build_plan_uris,
+        'serverData' => [{
+          'serverUri' => my_server['uri']
+        }]
+      }
+
+      # Do the OS deployment
+      action_handler.perform_action "Run: #{os_builds} OS Build Plan(s) on #{machine_spec.name}" do
+        action_handler.report_progress "INFO: Running: #{os_builds} OS Build Plan(s) on #{machine_spec.name}"
+        task = rest_api(:icsp, :post, '/rest/os-deployment-jobs/?force=true', options)
+        task_uri = task['uri']
+        raise "Failed to start OS Deployment Job. Details: #{task['details'] || task['message'] || task}" unless task_uri
+        task = icsp_wait_for(task_uri, 720)
+        raise "Error running OS build plan(s) #{os_builds}: #{task['jobResult'].first['jobMessage']}\n#{task['jobResult'].first['jobResultErrorDetails']}" unless task == true
+      end
+    end
+
+    def icsp_configure_networking(action_handler, machine_spec, machine_options, my_server, profile)
+      return if machine_options[:driver_options][:skip_network_configuration] == true
+      action_handler.perform_action "Configure networking on #{machine_spec.name}" do
+        action_handler.report_progress "INFO: Configuring networking on #{machine_spec.name}"
+        personality_data = icsp_build_personality_data(machine_options, profile)
+        options = {}
+        options['X-API-Version'] = 104 if @current_icsp_api_version.between?(104, 108)
+        options['body'] = {
+          'serverData' => [{
+            'serverUri' => my_server['uri'],
+            'personalityData' => personality_data
+          }]
+        }
+
+        task = rest_api(:icsp, :post, '/rest/os-deployment-jobs/?force=true', options)
+        task_uri = task['uri']
+        raise "Failed to start network personalization job. Details: #{task['details'] || task['message'] || task}" unless task_uri
+        task = icsp_wait_for(task_uri, 60) # Wait for up to 10 min
+        raise "Error running network personalization job: #{task['jobResult'].first['jobMessage']}\n#{task['jobResult'].first['jobResultErrorDetails']}" unless task == true
+
+        # Check if ICsp IP config matches machine options
+        requested_ips = []
+        machine_options[:driver_options][:connections].each do |_id, c|
+          requested_ips.push c[:ip4Address] if c[:ip4Address] && c[:dhcp] == false
+        end
+        my_server_connections = []
+        10.times do
+          my_server_connections = rest_api(:icsp, :get, my_server['uri'])['interfaces']
+          my_server_connections.each { |c| requested_ips.delete c['ipv4Addr'] }
+          break if requested_ips.empty?
+          print ','
+          sleep 10
+        end
+        puts "\nWARN: The following IPs are not visible on ICsp, so they may not have gotten configured correctly: #{requested_ips}" unless requested_ips.empty?
+
+        # Set interface data as normal node attributes
+        my_server_connections.each do |c|
+          c['oneViewId'] = profile['connections'].find { |x| x['mac'] == c['macAddr'] }['id'] rescue nil
+        end
+        machine_spec.data['normal']['icsp'] ||= {}
+        machine_spec.data['normal']['icsp']['interfaces'] = my_server_connections
+      end
+    end
+
+    # Build options for the network configuration
+    def icsp_build_personality_data(machine_options, profile)
+      nics = []
+      if machine_options[:driver_options][:connections]
+        machine_options[:driver_options][:connections].each do |id, data|
+          c = Marshal.load(Marshal.dump(data))
+          next unless c[:dhcp] || c[:dhcpv4] || c[:ip4Address] || c[:ipv6autoconfig] || c[:staticNetworks] # Invalid network or only switch networks specified
+          c.delete_if { |k, _v| k.to_s == 'bootstrap' }
+          begin
+            c[:macAddress] = profile['connections'].find { |x| x['id'] == id }['mac']
+          rescue NoMethodError
+            ids = []
+            profile['connections'].each { |x| ids.push x['id'] }
+            raise "Could not find connection id #{id} for #{profile['name']}. Available connection ids are: #{ids}. Please make sure the connection ids map to those on OneView."
+          end
+          if @current_icsp_api_version.between?(104, 108)
+            icsp_v104_parse_connection(machine_options, c)
+          else
+            c[:mask]    ||= machine_options[:driver_options][:mask]
+            c[:dhcp]    ||= false
+            c[:gateway] ||= machine_options[:driver_options][:gateway]
+            c[:dns]     ||= machine_options[:driver_options][:dns]
+          end
+          nics.push c
+        end
+      end
+
+      if @current_icsp_api_version.between?(104, 108)
+        personality_data = icsp_v104_build_personality_data(machine_options, nics)
+      else
+        personality_data = {
+          'hostName' => machine_options[:driver_options][:host_name],
+          'domainType' => machine_options[:driver_options][:domainType],
+          'domainName' => machine_options[:driver_options][:domainName],
+          'nics' => nics
+        }
+      end
+      personality_data
+    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'].casecmp('completed') == 0
+            print '.'
+            sleep 10
+          end
+          raise "Deleting os deployment server #{machine_spec.name} at icsp failed!" unless task['taskState'].casecmp('completed') == 0
+        end
+      end
+    end
+
+    # Sets ICSP custom attributes to enable nic teaming
+    def icsp_configure_nic_teams(machine_options, profile)
+      return false if machine_options[:driver_options][:connections].nil?
+      teams = {}
+
+      machine_options[:driver_options][:connections].each do |id, options|
+        next unless options.is_a?(Hash) && options[:team]
+        raise "#{options[:team]}: Team names must not include hyphens" if options[:team].to_s.include?('-')
+        teams[options[:team].to_s] ||= []
+        begin
+          mac = profile['connections'].find { |x| x['id'] == id }['mac']
+          teams[options[:team].to_s].push mac
+        rescue NoMethodError
+          ids = []
+          profile['connections'].each { |x| ids.push x['id'] }
+          raise "Failed to configure nic teams: Could not find connection id #{id} for #{profile['name']}. Available connection ids are: #{ids}. Please make sure the connection ids map to those on OneView."
+        end
+      end
+      team_strings = []
+      teams.each do |name, macs|
+        raise "Team '#{name}' must have at least 2 associated connections to form a NIC team" unless macs.size >= 2
+        team_strings.push "#{name}-#{macs.join(',')}"
+      end
+      machine_options[:driver_options][:custom_attributes] ||= {}
+      machine_options[:driver_options][:custom_attributes][:teams] = team_strings.join('|')
+    end
+  end
+end

data/lib/chef/provisioning/icsp/rest.rb

@@ -0,0 +1,50 @@
+module OneviewChefProvisioningDriver
+  # Helpers for REST API calls
+  module RestAPI
+    # 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
+      else
+        raise "Invalid rest host: #{host}"
+      end
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = @icsp_timeout if @icsp_timeout # timeout for a request
+      http.open_timeout = @icsp_timeout if @icsp_timeout # timeout for a connection
+      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
+        raise "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.casecmp('body') == 0
+          request.body = val.to_json rescue val
+        else
+          request[key] = val
+        end
+      end
+
+      response = http.request(request)
+      JSON.parse(response.body) rescue response
+    end
+  end
+end