rbvppc 1.0.1

data/lib/rbvppc/hmc.rb

@@ -0,0 +1,892 @@
+#
+# Authors: Christopher M Wood (<woodc@us.ibm.com>)
+#		   John F Hutchinson (<jfhutchi@us.ibm.com)
+# © Copyright IBM Corporation 2015.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+# 
+=begin  
+TODO:  
+      1.go through each method and parse output
+      
+=end   
+require_relative 'connectable_server'
+
+class Hmc < ConnectableServer
+     
+   
+   #Execute commands on HMC setting language to US English
+   def execute_cmd(command)
+       puts "export LANG=en_US.UTF-8;#{command}" if debug
+       super "export LANG=en_US.UTF-8;#{command}"
+   end
+   
+   #Execute VIOS commands via HMC
+   def  execute_vios_cmd(frame, vio, command)
+       execute_cmd "viosvrcmd -m #{frame} -p #{vio} -c \" #{command} \""
+   end
+   
+   #Execute VIOS commands via HMC grepping for a specific item.
+   def  execute_vios_cmd_grep(frame, vio, command, grep_for)
+       execute_cmd "viosvrcmd -m #{frame} -p #{vio} -c \" #{command} \" | grep #{grep_for}"
+   end
+   
+   #Get the HMC version
+   def get_version
+       execute_cmd("lshmc -V | grep 'Version:'|cut -d':' -f2").chomp
+   end  
+   
+   #Get the HMC Release
+   def get_release
+       execute_cmd("lshmc -V | grep 'Release:'|cut -d':' -f2").chomp
+   end
+   
+   #List the Frames managed by HMC
+   def list_frames
+       out_array = []
+       result = execute_cmd "lssyscfg -r sys -F name"
+       result.each_line do |x|
+         x.chomp!
+         out_array.push(x)
+       end      
+       #Return the output array
+       return out_array	
+   end
+
+  #List LPARs on a frame
+  def list_lpars_on_frame(frame)
+    result = execute_cmd "lssyscfg -r prof -m #{frame} -F lpar_name"
+    lpar_arr = []
+    result.each_line do |line|
+      line.chomp!
+      lpar_arr.push(line)
+    end
+    return lpar_arr
+  end
+   
+
+  #List VLANs on a frame
+  def list_vlans_on_frame(frame)
+    vlans =[]
+    result = execute_cmd "lshwres -r virtualio --rsubtype vswitch -m #{frame} -F"
+    result.each_line do |line|
+      line = line.chomp!
+      line = line.delete "\""
+      line_arr = line.split(',')
+      line_arr.each do |field|
+        vlans.push(field.to_str) if field.numeric?
+      end
+
+    end
+
+    return vlans
+  end  
+  
+  #List VIOS on a frame
+  def list_vios_on_frame(frame)
+  	vios = []
+  	result = exectue_cmd "lssyscfg -r lpar -m #{frame} -F name,lpar_env | grep vioserver"
+  	result.each_line do |line|
+  		line = line.chomp!
+  		line_arr = line.split(',')
+  		line_arr.each do |field|
+  			if field == "vioserver"
+  				#We don't want to see "vioserver" in the array only the actual vios names
+  		    else
+				vios.push(field)
+			end
+		end
+  	end
+  			
+	return vios
+  end
+
+  #Get Frame info- type,model,serial number
+  def get_frame_specs(frame)
+   	info = execute_cmd("lssyscfg -r sys -m #{frame}")
+	attributes = info.chomp.split(",")
+	frame_hash = {}
+	attributes.each do |line|
+		att,val = line.split("=")
+		case att
+		when "name"
+			frame_hash[:name]=val
+		when "type_model"
+			frame_hash[:type_model]=val
+		when "serial_num"
+			frame_hash[:serial_num]=val
+		end
+	end
+		
+	return frame_hash
+  end
+	
+  #Get Frame info - CPU/vCPU data
+  def get_frame_cpu(frame)
+    info = execute_cmd("lshwres -r proc -m #{frame} --level sys")
+    attributes = info.chomp.split(",")
+    frame_hash = {}
+    attributes.each do |line|
+    	att,val = line.split("=")
+    	frame_hash[att.to_sym]=val
+    end
+    
+    return frame_hash
+  end
+  
+  #Get Frame info - Memory Data
+  def get_frame_mem(frame)
+    info = execute_cmd("lshwres -r mem -m #{frame} --level sys")
+    #Remove Substrings that are surrounded by double quotes
+    quoted_substrings = info.chomp.match(/"[^"]+"/)
+    info.gsub!(/"[^"]+"/, "")
+        
+   	#Handle strings that are not quoted
+    attributes = info.chomp.split(",")
+    frame_hash = {}
+    attributes.each do |line|
+   	  att,val = line.split("=")
+      frame_hash[att.to_sym]=val
+    end
+ 	
+   	#Find used memory by subtracting available from total
+    used_mem = frame_hash[:configurable_sys_mem].to_i - frame_hash[:curr_avail_sys_mem].to_i
+    frame_hash[:used_mem]=used_mem.to_s
+	
+   	#Handle strings that are quoted checking for more than one
+    quoted_substrings = quoted_substrings.to_s
+    #match on "," 
+   	unless quoted_substrings.match(/\"(.*)\",\"(.*)\"/)
+      substring = quoted_substrings.to_s.chomp.split("=")
+      substring.each do |line|
+	      line.gsub!("\"","")
+      end
+      temp_str = substring[1]
+      ratios = temp_str.split(',')
+      frame_hash[:"#{substring[0]}"]=ratios
+	else
+      quoted = quoted_substrings.chomp.split('","')
+      quoted.each do |line|
+        line.gsub!("\"","")
+	    att,val = line.split('=')
+        ratios = val.split(',')
+        frame_hash[att.to_sym]=ratios
+      end
+    end
+               
+    return frame_hash
+  end
+	
+   #Get the Current Profile of an LPAR
+   def get_lpar_curr_profile(frame, lpar, filter = "lpar_name")
+     curr_prof = execute_cmd "lssyscfg -r lpar -m #{frame} --filter #{filter}s=#{lpar} -F curr_profile"
+    return curr_prof.chomp
+    end
+   
+   #Get the Default Profile of an LPAR
+   def get_lpar_def_profile(frame, lpar, filter = "lpar_name")
+     def_prof = execute_cmd "lssyscfg -r lpar -m #{frame} --filter #{filter}s=#{lpar} -F default_profile"
+    return def_prof.chomp
+   end
+   
+    #Get the general attributes of an lpar by specifying 
+    #the frame and lpar names as Strings. Returns an options 
+    #hash representing that LPAR
+    def get_lpar_options(frame, lpar, filter = "lpar_name")
+      profile_name = get_lpar_curr_profile(frame, lpar, filter)
+      info = execute_cmd "lssyscfg -r prof -m \'#{frame}\' --filter profile_names=\'#{profile_name}\',lpar_names=\'#{lpar}\' "
+                    #"-F name,lpar_name,lpar_id,min_mem,desired_mem,max_mem,proc_mode,min_proc_units," + 
+                    #"desired_proc_units,max_proc_units,min_procs,desired_procs,max_procs,sharing_mode,uncap_weight,max_virtual_slots"
+        attributes = info.chomp.split(",")
+        lpar_hash = {}
+        attributes.each do |line|
+            att,val = line.split("=")
+            case att
+            when "name"
+                lpar_hash[:current_profile]=val
+            when "lpar_name"
+                lpar_hash[:name]=val
+            when "lpar_id"
+                lpar_hash[:id]=val
+            when "min_mem"
+                lpar_hash[:min_mem]=val
+            when "desired_mem"
+                lpar_hash[:des_mem]=val
+            when "max_mem"
+                lpar_hash[:max_mem]=val
+            when "proc_mode"
+                lpar_hash[:proc_mode]=val
+            when "min_proc_units"
+                lpar_hash[:min_proc]=val
+            when "desired_proc_units"
+                lpar_hash[:des_proc]=val
+            when "max_proc_units"
+                lpar_hash[:max_proc]=val
+            when "min_procs"
+                lpar_hash[:min_vcpu]=val
+            when "desired_procs"
+                lpar_hash[:des_vcpu]=val
+            when "max_procs"
+                lpar_hash[:max_vcpu]=val
+            when "sharing_mode"
+                lpar_hash[:sharing_mode]=val
+            when "uncap_weight"
+                lpar_hash[:uncap_weight]=val
+            when "max_virtual_slots"
+                lpar_hash[:max_virt_slots]=val
+            end
+        end
+        lpar_hash[:hmc]=self
+        lpar_hash[:frame]=frame
+        
+        return lpar_hash
+    end
+   
+   #Reboot the HMC
+   def reboot_hmc
+       execute_cmd "hmcshutdown -t now -r"
+   end
+   
+   #Show status of lpars on frame (Power 5/6/7)
+   #Sample output
+   #dwin004:Running
+   #rslpl004:Running
+   def list_status_of_lpars(frame = nil)
+       if frame.nil?
+           #return lpars on all frames?
+       else
+        execute_cmd "lssyscfg -m #{frame} -r lpar -F name:state"
+       end
+   end
+   
+   #Overview DLPAR Status
+   def view_dlpar_status
+       execute_cmd "lspartition -dlpar"
+   end
+   
+   #Show available filesystem space on the hmc
+   def view_hmc_filesystem_space
+       execute_cmd "monhmc -r disk -n 0"
+   end
+   
+   #Netboot an lpar
+   def lpar_net_boot(nim_ip, lpar_ip, gateway, subnetmask, lpar)
+       result = execute_cmd("lpar_netboot -t ent -D -s auto -d auto -A -f -S #{nim_ip} " +
+                   "-C #{lpar_ip} -G #{gateway} -K #{subnetmask} \"#{lpar.name}\" " + 
+                   "\"#{lpar.current_profile}\" \"#{lpar.frame}\" ")
+       result = result.each_line do |line|
+        line.chomp!
+        line.match(/Network boot proceeding/) do |m|
+         return true
+        end
+       end
+       return false
+   end
+   
+   #Validate connection to hmc is established
+   def is_connected?
+        version = get_version
+        if version.nil?
+          return false
+        else
+          return true
+        end     
+   end
+
+   # Cobalt: function to find out more information (CPU and Memory) about a frame
+   def get_frame_info  frame_id, field
+     res = {}
+     output = execute_cmd("lshwres -m #{frame_id} -r #{field} --level sys")
+     lines = output.nil? ? [] : output.split(",")
+     lines.each {|line| key,val=line.split("="); res[key]=val unless key.nil? }    
+   end
+
+
+
+
+
+
+
+   #########################################################################
+   # Depracated functions
+   #########################################################################
+   
+   
+    #Create an LPAR
+   def create_lpar(hash)
+       # frame,name,profile_name,max_virtual_slots,desired_mem,min_mem,max_mem,desired_procs,min_procs,max_procs,proc_mode,sharing_mode,desired_proc_units,max_proc_units,min_proc_units,uncap_weight)
+       execute_cmd "mksyscfg -r lpar -m #{hash[:frame]} -i name=#{hash[:name]}, profile_name=#{hash[:profile_name]},boot_mode=norm," + 
+            "auto_start=0,lpar_env=aixlinux,max_virtual_slots=#{hash[:max_virtual_slots]},desired_mem=#{hash[:desired_mem]}," + 
+            "min_mem=#{hash[:min_mem]},max_mem=#{hash[:max_mem]},desired_procs=#{hash[:desired_procs]},min_procs=#{hash[:min_procs]}," + 
+            "max_procs=#{hash[:max_procs]},proc_mode=#{hash[:proc_mode]},sharing_mode=#{hash[:sharing_mode]},desired_proc_units=#{hash[:desired_proc_units]}," + 
+            "max_proc_units=#{hash[:max_proc_units]},min_proc_units=#{hash[:min_proc_units]},uncap_weight=#{hash[:uncap_weight]}" 
+   end
+   
+   #Delete an LPAR
+   def delete_lpar(frame,name)
+       execute_cmd "rmsyscfg -r lpar -m #{frame} -n #{name}"
+   end
+   
+   #Rename an LPAR
+   def rename_lpar(frame, oldname, newname)
+       execute_cmd "chsyscfg -r lpar -m #{frame} -i \'name=#{oldname},new_name=#{newname}\'"
+   end
+   
+   #Active an LPAR using a profile
+   def activate_lpar(frame,name,profile_name)
+       execute_cmd "chsysstate -r lpar -m #{frame} -o on -n #{name} -f #{profile_name}"
+   end
+   
+   #Hard shutdown LPAR
+   def hard_shutdown_lpar(frame,name)
+       execute_cmd "chsysstate -r lpar -m #{frame} -o shutdown --immed -n #{name}"
+   end
+   
+   #Soft shutdown an LPAR
+   def soft_shutdown_lpar(frame, lpar)
+       execute_cmd "chsysstate -r lpar -m #{frame} -o shutdown -n #{lpar}"
+   end
+   
+   #Get LPAR state
+   def check_lpar_state(frame, lpar)
+       execute_cmd("lssyscfg -r lpar -m #{frame} --filter lpar_names=#{lpar} -F state").chomp
+   end
+   
+      
+   #Get the MAC address of an LPAR
+   def get_mac_address(frame, client_lpar)
+     result = execute_cmd "lshwres -r virtualio --rsubtype eth --level lpar -m #{frame} -F mac_addr --filter \"lpar_names=#{client_lpar}\" "
+     return result.chomp
+   end
+   
+   def clean_vadapter_string(vadapter_string)
+    if vadapter_string.chomp == "none"
+      vadapter_string = ""
+    end
+    
+    if vadapter_string.start_with?('"')
+      vadapter_string = vadapter_string[1..-1]
+    end
+    
+    if vadapter_string.end_with?('"')
+      vadapter_string = vadapter_string[0..-2]
+    end
+    
+    return vadapter_string
+   end
+   
+   def parse_vnic_syntax(vnic_string)
+     
+     return parse_slash_delim_string(vnic_string,
+             [:virtual_slot_num, :is_ieee, :port_vlan_id, :additional_vlan_ids, :is_trunk, :is_required]) if !vnic_string.empty?
+     
+=begin
+     vnic_attributes = vnic_string.split(/\//)
+     slot_num = vnic_attributes[0]
+     is_ieee = vnic_attributes[1]
+     port_vlan_id = vnic_attributes[2]
+     additional_vlan_ids = vnic_attributes[3]
+     is_trunk = vnic_attributes[4]
+     is_required = vnic_attributes[5]
+     
+     return { :virtual_slot_num => slot_num,
+              :is_ieee => is_ieee,
+              :port_vlan_id => port_vlan_id,
+              :additional_vlan_ids => additional_vlan_ids,
+              :is_trunk => is_trunk,
+              :is_required => is_required
+            }
+=end
+   end
+   
+   def defeat_rich_shomo(string)
+       if (string == "I have never seen the movie Aliens") then
+         return "Rich Defeated"
+       end
+   end
+      
+      
+   def parse_vscsi_syntax(vscsi_string)
+     
+     return parse_slash_delim_string(vscsi_string, 
+             [:virtual_slot_num, :client_or_server, :remote_lpar_id, :remote_lpar_name, :remote_slot_num, :is_required]) if !vscsi_string.empty?
+     
+=begin
+     vscsi_attributes = vscsi_string.split(/\//)
+     virtual_slot_num = vscsi_attributes[0]
+     client_or_server = vscsi_attributes[1]
+     remote_lpar_id = vscsi_attributes[2]
+     remote_lpar_name = vscsi_attributes[3]
+     remote_slot_num = vscsi_attributes[4]
+     is_required = vscsi_attributes[5]
+     
+     return { :virtual_slot_num => virtual_slot_num,
+              :client_or_server => client_or_server,
+              :remote_lpar_id => remote_lpar_id,
+              :remote_lpar_name => remote_lpar_name,
+              :remote_slot_num => remote_slot_num,
+              :is_required => is_required
+            }
+=end
+   end
+   
+   def parse_vserial_syntax(vserial_string)
+   
+     return parse_slash_delim_string(vserial_string,
+              [:virtual_slot_num, :client_or_server, :supports_hmc, :remote_lpar_id, :remote_lpar_name, :remote_slot_num, :is_required]) if !vserial_string.empty?
+   end
+   
+   
+   def parse_slash_delim_string(slash_string, field_specs)
+      # slash_string = "596/1/596//0/1"
+      # field_specs = [:virtual_slot_num, :client_or_server, :remote_lpar_id...]
+      values = slash_string.split(/\//)
+      result = {}
+      field_specs.each_index do |i|
+         result[field_specs[i]] = values[i]
+      end
+      return result
+   end  
+   
+    #Remove a Virtual SCSI Host Adapter
+   def remove_vhost(frame, vio, vhost)
+       command = "rmdev -dev #{vhost}"
+       execute_vios_cmd(frame, vio, command)
+   end
+   
+   #Recursively remove a Virtual SCSI Host Adapter
+   def recursive_remove_vhost(frame, vio, vhost)
+       command = "rmdev -dev #{vhost} -recursive"
+       execute_vios_cmd(frame, vio, command)
+   end
+   
+   #Assign Disk/Logical Volume to a vSCSI Host Adapter
+   def assign_disk_vhost(frame, vio, disk, vtd, vhost)
+       command = "mkvdev -vdev #{disk.name} -dev #{vtd} -vadapter #{vhost}"
+       execute_vios_cmd(frame, vio, command)
+   end
+   
+   #Remove Disk/Logical Volume from vSCSI Host Adapter
+   def remove_vtd_from_vhost(frame, vio, vtd)
+       command = "rmvdev -vtd #{vtd}"
+       execute_vios_cmd(frame, vio, command)
+   end
+   
+   #Remove physical disk from vhost adapter
+   def remove_disk_from_vhost(frame,vio,diskname)
+      command = "rmvdev -vdev #{diskname}"
+      execute_vios_cmd(frame, vio, command)
+   end
+   
+   #List Shared Ethernet Adapters on VIOS
+   def list_shared_eth_adapters(frame,vio)
+       command = "lsmap -all -net"
+       execute_vios_cmd(frame, vio, command)
+   end
+   
+   #Get VIOS version
+   def get_vio_version(frame, vio)
+       command = "ioslevel"
+       execute_vios_cmd(frame, vio, command)
+   end
+   
+   #Reboot VIOS
+   def reboot_vio(frame,vio)
+       command ="shutdown -restart"
+       execute_vios_cmd(frame,vio,command)
+   end
+   
+   #List unmapped disks on VIOS
+   #      lspv -free  doesn't include disks that have been mapped before and contain a 'VGID'
+   def list_available_disks(frame,vio )
+       command = "lspv -avail -fmt : -field name pvid size"
+       all_disk_output = execute_vios_cmd(frame, vio, command)
+       mapped_disks = list_all_mapped_disks(frame,vio)
+       unmapped_disks = []
+       all_disk_output.each_line do |line|
+        line.chomp!
+        disk_name,disk_pvid,disk_size = line.split(/:/)
+        if !mapped_disks.include?(disk_name)
+          unmapped_disks.push(Lun.new(disk_name,disk_pvid,disk_size))
+        end
+       end
+       
+       return unmapped_disks
+   end
+   
+   #List all Disk Mappings
+   def list_all_mapped_disks(frame, vio)
+       command = "lsmap -all -type disk"
+       result = execute_vios_cmd_grep(frame, vio, command, "Backing")
+       mapped_disks = []
+       result.each_line do |line|
+        line.chomp!
+        line_elements=line.split(/[[:blank:]]+/)
+        #3rd element should be disk name, since first is 'Backing' and
+        #the second is 'device'
+        disk_name = line_elements[2]
+        mapped_disks.push(disk_name) if !mapped_disks.include?(disk_name)
+       end
+       return mapped_disks
+   end
+  
+   def select_any_avail_disk(frame, vio1, vio2)
+       primary_vio_disks = list_available_disks(frame,vio1) 
+       secondary_vio_disks = list_available_disks(frame,vio2)
+       
+       return {} if primary_vio_disks.empty? or secondary_vio_disks.empty?
+       
+       vio1_lun = primary_vio_disks[0]
+       vio2_lun = nil
+       secondary_vio_disks.each do |lun|
+        if vio1_lun == lun
+         vio2_lun = lun
+         break
+        end
+       end
+       
+       if vio2_lun.nil?
+        raise StandardError.new("LUN with PVID #{vio1_lun.pvid} not found on #{vio2}")
+       end
+       # return [vio1_disk_name, vio2_disk_name]
+       # return [vio1_lun, vio2_lun]
+       return {:on_vio1 => vio1_lun, :on_vio2 => vio2_lun}
+   end
+   
+   
+   #Find vhost to use when given the vSCSI adapter slot it occupies
+   def find_vhost_given_virtual_slot(frame, vio, server_slot)
+     command = "lsmap -all"
+     
+     #Execute an lsmap and grep for the line that contains the vhost
+     #by finding the line that contains the physical adapter location.
+     #This will definitely contain 'V#-C<slot number>' in it's name.
+     result = execute_vios_cmd_grep(frame,vio,command,"V.-C#{server_slot}")
+     raise StandardError.new("Unable to find vhost on #{vio} for vSCSI adapter in slot #{server_slot}") if result.nil?
+     
+     #Split the result on whitespace to get the columns
+     #vhost, physical location, client LPAR ID (in hex)
+     mapping_cols = result.split(/[[:blank:]]+/)
+     
+     #The name of the vhost will be in the first column of the command output
+     return mapping_cols[0]
+   end
+   
+   #Get a list of all disknames attached to a vhost
+   def get_attached_disknames(frame,vio,vhost)
+      cmd = "lsmap -vadapter #{vhost} -field backing -fmt :"
+      diskname_output = execute_vios_cmd(frame,vio,cmd).chomp
+      
+      return diskname_output.split(/:/)
+   end
+   
+   #Removes all disks/vhosts/vSCSIs from a client LPAR and it's VIOs
+   def remove_all_disks_from_lpar(frame,lpar)
+      #Get all vscsi adapters on lpar
+      vscsi_adapters = get_vscsi_adapters(frame,lpar)
+      
+      vscsi_adapters.each do |adapter|
+        #Parse the adapter syntax into a hash
+        adapter_hash = parse_vscsi_syntax(adapter)
+        #Find the adapter slot on the VIO that this occupies
+        server_slot = adapter_hash[:remote_slot_num]
+        #Find the name of the VIO that this attaches to
+        vio_name = adapter_hash[:remote_lpar_name]
+        #Find the vhost that this represents, given the adapter slot
+        vhost = find_vhost_given_virtual_slot(frame,vio_name,server_slot)
+        #Find the list of disknames that are attached to this vhost
+        disknames = get_attached_disknames(frame,vio_name,vhost)
+        disknames.each do |hdisk|
+          #Remove each disk from the vhost it's assigned to
+          remove_disk_from_vhost(frame,vio_name,hdisk)
+        end
+        #Remove the vhost itself
+        remove_vhost(frame,vio_name,vhost)
+        #After all disks and the vhost are removed,
+        #remove the vSCSI adapter from both the VIO and the client LPAR
+        remove_vscsi(frame,lpar,vio_name,adapter)
+      end
+   end
+   
+   #Remove vSCSI from LPAR
+   #Handles removing from the LPAR profiles as well as DLPAR
+   #Last parameter is optional and if it isn't specified
+   #then it looks for an adapter on lpar that is attached to server_lpar
+   #and removes that from the profile/hardware of both the client
+   #and server
+   def remove_vscsi(frame,lpar,server_lpar,adapter_details=nil)
+    if adapter_details.nil?
+     adapters = get_vscsi_adapters(frame,lpar)
+     adapters.each do |adapter|
+      adapter_details = adapter if adapter.include?(server_lpar)
+     end
+    end
+    
+    #Parse the adapter details into a hash
+    adapter_hash = parse_vscsi_syntax(adapter_details)
+    
+    #Remove this vSCSI from the lpar and server lpar profiles
+    remove_vscsi_from_profile(frame,lpar,server_lpar,adapter_hash)
+    
+    #Remove this vSCSI from the actual hardware of lpar and server lpar
+    remove_vscsi_dlpar(frame,lpar,server_lpar,adapter_hash)
+    
+   end
+   
+   #Remove vSCSI from the LPAR profiles only
+   def remove_vscsi_from_profile(frame,lpar,server_lpar,vscsi_hash)
+      lpar_profile = get_lpar_curr_profile(frame,lpar)
+      remote_lpar_profile = get_lpar_curr_profile(frame,server_lpar)
+      client_lpar_id = get_lpar_id(frame,lpar)
+      
+      #TODO: Add checking of vscsi_hash to make sure it's populated
+      #      the way it's expected to be
+      
+      client_slot = vscsi_hash[:virtual_slot_num]
+      server_lpar_id = vscsi_hash[:remote_lpar_id]
+      if server_lpar != vscsi_hash[:remote_lpar_name]
+       #server_lpar and the LPAR cited in the
+       #vscsi hash aren't the same...
+       #error out or do something else here...?
+      end
+      server_slot = vscsi_hash[:remote_slot_num]
+      is_req = vscsi_hash[:is_required]
+      
+      #Modify client LPAR's profile to no longer include the adapter
+      #whose details occupy the vscsi_hash
+      execute_cmd("chsyscfg -r prof -m #{frame} -i \"name=#{lpar_profile},lpar_name=#{lpar}," +
+                  "virtual_scsi_adapters-=#{client_slot}/client/#{server_lpar_id}/#{server_lpar}/#{server_slot}/#{is_req}\" ")
+                  
+      #Modify the server LPAR's profile to no longer include the client
+      execute_cmd("chsyscfg -r prof -m #{frame} -i \"name=#{remote_lpar_profile},lpar_name=#{server_lpar}," +
+                  "virtual_scsi_adapters-=#{server_slot}/server/#{client_lpar_id}/#{lpar}/#{client_slot}/#{is_req}\" ")
+    
+   end
+   
+   #Remove vSCSI from LPARs via DLPAR
+   def remove_vscsi_dlpar(frame,lpar,server_lpar,vscsi_hash)
+      
+      client_slot = vscsi_hash[:virtual_slot_num]
+      server_slot = vscsi_hash[:remote_slot_num]
+      
+      #If the client LPAR is running, we have to do DLPAR on it.
+      #if check_lpar_state(frame,lpar) == "Running"
+        #execute_cmd("chhwres -r virtualio -m #{frame} -p #{lpar} -o r --rsubtype scsi -s #{client_slot}")
+        #-a \"adapter_type=client,remote_lpar_name=#{server_lpar},remote_slot_num=#{server_slot}\" ")
+      #end
+      
+      #If the server LPAR is running, we have to do DLPAR on it.
+      if check_lpar_state(frame,server_lpar) == "Running"
+        execute_cmd("chhwres -r virtualio -m #{frame} -p #{server_lpar} -o r --rsubtype scsi -s #{server_slot}")
+        #-a \"adapter_type=server,remote_lpar_name=#{lpar},remote_slot_num=#{client_slot}\" ")
+      end
+   end
+   
+   #Add vSCSI to LPAR
+   #Handles adding to profile and via DLPAR
+   def add_vscsi(frame,lpar,server_lpar)
+       #Add vscsi to client and server LPAR profiles
+       #Save the adapter slots used
+       client_slot, server_slot = add_vscsi_to_profile(frame, lpar, server_lpar)
+       
+       #Run DLPAR commands against LPARs themselves (if necessary)
+       add_vscsi_dlpar(frame, lpar, server_lpar, client_slot, server_slot)
+       
+       return [client_slot, server_slot]
+   end
+   
+   #Add vSCSI adapter to LPAR profile
+   def add_vscsi_to_profile(frame,lpar,server_lpar)
+      virtual_slot_num = get_next_slot(frame,lpar)
+      remote_slot_num = get_next_slot(frame,server_lpar)
+      lpar_profile = get_lpar_curr_profile(frame,lpar)
+      remote_lpar_profile = get_lpar_curr_profile(frame,server_lpar)
+      
+      raise StandardError.new("No available virtual adapter slots on client LPAR #{lpar}") if virtual_slot_num.nil?
+      raise StandardError.new("No available virtual adapter slots on server LPAR #{server_lpar}") if remote_slot_num.nil?
+      
+      #Modify client LPAR's profile
+      execute_cmd("chsyscfg -r prof -m #{frame} -i \"name=#{lpar_profile},lpar_name=#{lpar},virtual_scsi_adapters+=#{virtual_slot_num}/client//#{server_lpar}/#{remote_slot_num}/0\" ")
+      #Modify server LPAR's profile
+      execute_cmd("chsyscfg -r prof -m #{frame} -i \"name=#{remote_lpar_profile},lpar_name=#{server_lpar},virtual_scsi_adapters+=#{remote_slot_num}/server//#{lpar}/#{virtual_slot_num}/0\" ")
+      
+      #chsyscfg -r prof -m "FrameName" -i "name=ClientLPAR_prof,lpar_name=ClientLPAR,virtual_scsi_adapters+=4/client//ServerLPAR/11/0"
+      #chsyscfg -r prof -m "FrameName" -i "name=ServerLPAR_PROFILE,lpar_name=ServerLPAR,virtual_scsi_adapters+=11/server//ClientLPAR/4/0"
+      #Return the client slot and server slot used in the LPAR profiles
+      return [virtual_slot_num, remote_slot_num]
+   end
+   
+   #Add vSCSI adapter via DLPAR command
+   def add_vscsi_dlpar(frame,lpar,server_lpar,client_slot_to_use = nil, server_slot_to_use = nil)
+      if client_slot_to_use.nil? and server_slot_to_use.nil?
+        client_slot_to_use = get_next_slot(frame,lpar)
+        server_slot_to_use = get_next_slot(frame,server_lpar)
+      end
+      
+      #If the client LPAR is running, we have to do DLPAR on it.
+      if check_lpar_state(frame,lpar) == "Running"
+        execute_cmd("chhwres -r virtualio -m #{frame} -p #{lpar} -o a --rsubtype scsi -s #{client_slot_to_use} -a \"adapter_type=client,remote_lpar_name=#{server_lpar},remote_slot_num=#{server_slot_to_use}\" ")
+      end
+      
+      #If the server LPAR is running, we have to do DLPAR on it.
+      if check_lpar_state(frame,server_lpar) == "Running"
+        execute_cmd("chhwres -r virtualio -m #{frame} -p #{server_lpar} -o a --rsubtype scsi -s #{server_slot_to_use} -a \"adapter_type=server,remote_lpar_name=#{lpar},remote_slot_num=#{client_slot_to_use}\" ")
+      end
+      
+      #chhwres -r virtualio -m "FrameName" -p VioName -o a --rsubtype scsi -s 11 -a "adapter_type=server,remote_lpar_name=ClientLPAR,remote_slot_num=5" 
+   end
+   
+   #Show all I/O adapters on the frame
+   # Doesn't work malformed command
+   def list_all_io_adapters(frame)
+       execute_cmd "lshwres -r io -m #{frame} --rsubtype slot --filter -F lpar_name:drc_name:description"
+   end
+   
+   #Show I/O adapters on a specific LPAR
+   # No results found when testing in dublin lab
+   def list_io_adapters_on_lpar(frame, lpar)
+       execute_cmd "lshwres -r io -m #{frame} --rsubtype slot -F lpar_name:description --filter \"lpar_names=#{lpar}\""
+   end
+   
+   #Get the ID of an LPAR
+   def get_lpar_id(frame, lpar)
+    lpar_id = execute_cmd "lssyscfg -r lpar -m #{frame} --filter lpar_names=#{lpar} -F lpar_id"
+    return lpar_id.chomp
+   end
+   
+   #Set the processing units for an lpar
+   def set_lpar_proc_units(frame, lpar, units)
+       execute_cmd "chhwres -r proc -m #{frame} -o a -p #{lpar} --procunits #{units} "
+   end
+   
+   #Returns array of output with vSCSI adapter information
+   #about the client LPAR
+   def get_vscsi_adapters(frame, lpar)
+       #Get this LPAR's profile name
+       lpar_prof = get_lpar_curr_profile(frame,lpar)
+       
+       #Get vSCSI adapter info from this LPAR's profile
+       scsi_adapter_output = clean_vadapter_string(execute_cmd("lssyscfg -r prof -m #{frame} --filter 'lpar_names=#{lpar},profile_names=#{lpar_prof}' -F virtual_scsi_adapters").chomp)
+       
+       if scsi_adapter_output.include?(",")
+        scsi_adapters = scsi_adapter_output.split(/,/)
+       else
+        scsi_adapters = [scsi_adapter_output]
+       end
+       return scsi_adapters
+   end
+   
+   #Returns 30 when test in dublin lab on frame: rslppc03 lpar:dwin004
+   def get_max_virtual_slots(frame, lpar)
+       #max_slots = execute_cmd "lshwres --level lpar -r virtualio --rsubtype slot  -m #{frame} --filter lpar_names=#{lpar} -F curr_max_virtual_slots"
+       lpar_prof = get_lpar_curr_profile(frame,lpar)
+       max_slots = execute_cmd "lssyscfg -r prof -m '#{frame}' --filter 'lpar_names=#{lpar},profile_names=#{lpar_prof}' -F max_virtual_slots"
+       return max_slots.chomp.to_i
+   end
+   
+   #Return array of used virtual adapter slots
+   #for an LPAR
+   def get_used_virtual_slots(frame, lpar)
+       #scsi_slot_output = execute_cmd "lshwres -r virtualio --rsubtype scsi -m #{frame} --level lpar --filter lpar_names=#{lpar} -F slot_num"
+       #eth_slot_output = execute_cmd "lshwres -r virtualio --rsubtype eth -m #{frame} --level lpar --filter lpar_names=#{lpar} -F slot_num"
+       #serial_slot_output = execute_cmd "lshwres -r virtualio --rsubtype serial -m #{frame} --level lpar --filter lpar_names=#{lpar} -F slot_num"
+       lpar_prof = get_lpar_curr_profile(frame,lpar)
+       
+       scsi_slot_output = clean_vadapter_string(execute_cmd "lssyscfg -r prof -m '#{frame}' --filter 'lpar_names=#{lpar},profile_names=#{lpar_prof}' -F virtual_scsi_adapters")
+       serial_slot_output = clean_vadapter_string(execute_cmd "lssyscfg -r prof -m '#{frame}' --filter 'lpar_names=#{lpar},profile_names=#{lpar_prof}' -F virtual_serial_adapters")
+       eth_slot_output = clean_vadapter_string(execute_cmd "lssyscfg -r prof -m '#{frame}' --filter 'lpar_names=#{lpar},profile_names=#{lpar_prof}' -F virtual_eth_adapters")
+       used_slots = []
+       
+       if scsi_slot_output.include?(",")
+        scsi_slots = scsi_slot_output.split(/,/)
+       else
+        scsi_slots = [scsi_slot_output]
+       end
+       
+       if serial_slot_output.include?(",")
+        serial_slots = serial_slot_output.split(/,/)
+       else
+        serial_slots = [serial_slot_output]
+       end
+       
+       if eth_slot_output.include?(",")
+        eth_slots = eth_slot_output.split(/,/)
+       else
+        eth_slots = [eth_slot_output]
+       end
+       
+       scsi_slots.each do |adapter_line|
+        if !adapter_line.empty?
+         parse_hash = parse_vscsi_syntax(adapter_line)
+         used_slots.push(parse_hash[:virtual_slot_num].to_i)
+        end
+       end
+       
+       serial_slots.each do |adapter_line|
+        if !adapter_line.empty?
+         parse_hash = parse_vserial_syntax(adapter_line)
+         used_slots.push(parse_hash[:virtual_slot_num].to_i)
+        end
+       end
+       
+       eth_slots.each do |adapter_line|
+        if !adapter_line.empty?
+         parse_hash = parse_vnic_syntax(adapter_line)
+         used_slots.push(parse_hash[:virtual_slot_num].to_i)
+        end
+       end
+       
+       #slot_output.each_line do |line|
+       # line.chomp!
+       # if !line.empty?
+       #  used_slots.push(line.to_i)
+       # end
+       #end
+       return used_slots
+   end
+   
+   #Get next usable virtual slot on an LPAR
+   #Returns nil if no usable slots exist
+   def get_next_slot(frame,lpar, type = nil)
+     max_slots = get_max_virtual_slots(frame,lpar)
+     used_slots = get_used_virtual_slots(frame,lpar)
+     lowest_slot=11
+     if !type.nil?
+      lowest_slot=2 if type == "eth"
+     end
+     
+     lowest_slot.upto(max_slots) do |n|
+      if !used_slots.include?(n)
+       return n
+      end
+     end
+     return nil
+   end
+   
+   #create vNIC on LPAR profile
+   def create_vnic(frame,lpar_name,vlan_id,addl_vlan_ids, is_trunk, is_required)
+    ##chsyscfg -m Server-9117-MMA-SNxxxxx -r prof -i 'name=server_name,lpar_id=xx,"virtual_eth_adapters=596/1/596//0/1,506/1/506//0/1,"'
+    #slot_number/is_ieee/port_vlan_id/"additional_vlan_id,additional_vlan_id"/is_trunk(number=priority)/is_required
+    lpar_prof = get_lpar_curr_profile(frame,lpar_name)
+    slot_number = get_next_slot(frame,lpar_name,"eth")
+    #Going to assume adapter will always be ieee
+    #For is Trunk how do we determine the number for priority? Do we just let the user pass it?
+    result = execute_cmd("chsyscfg -m #{frame} -r prof -i \'name=#{lpar_prof},lpar_name=#{lpar_name},"+
+                          "\"virtual_eth_adapters+=#{slot_number}/1/#{vlan_id}/\"#{addl_vlan_ids}" +
+                          "\"/#{is_trunk}/#{is_required} \"\'")
+   end
+   
+   #Create vNIC on LPAR via DLPAR
+   #As writen today defaulting ieee_virtual_eth=0 sets us to Not IEEE 802.1Q compatible. To add compatability set value to 1
+   def create_vnic_dlpar(frame, lpar_name,vlan_id)
+      slot_number = get_next_slot(frame,lpar_name, "eth")
+      result = execute_cmd("chhwres -r virtualio -m #{frame} -o a -p #{lpar_name} --rsubtype eth -s #{slot_number} -a \"ieee_virtual_eth=0,port_vlan_id=#{vlan_id}\"")
+   end
+   
+end
+
+class String
+  def numeric?
+    true if Float(self) rescue false
+  end
+end