tiebreaker 0.0.2

data/classes/common.rb

@@ -0,0 +1,37 @@
+class ALLVARS
+	@@configisvlalid = true
+	@@configisvlalid = true
+	@@sitecrashed = ""
+	@@isseparated = false
+	@@mutex = Mutex.new
+
+	def mutex
+		return @@mutex
+	end
+	
+	def configisvlalid
+		return @@configisvlalid
+	end
+
+	def setconfigisvalid(isvalid)
+		 @@configisvlalid = isvalid
+	end
+
+	def sitecrashed
+		return @@sitecrashed
+	end
+
+	def setsitecrashed(site)
+		 @@sitecrashed = site
+	end
+
+	def isseparated
+		return @@isseparated
+	end
+
+	def setseparated(separated)
+		 @@isseparated = separated
+	end
+
+
+end

data/classes/confreader.rb

@@ -0,0 +1,16 @@
+require 'json';
+
+class CONFREADER 
+	attr_reader :hashedjson, :error_in_parsing_json
+	@hashedjson = ""
+	def initialize(conf_file)
+		begin
+			@error_in_parsing_json = ""
+			rawcontent = File.read(conf_file)
+			@hashedjson = JSON.parse(rawcontent)
+		rescue Exception=>e
+			@error_in_parsing_json = e.message
+		end
+
+	end
+end

data/classes/main.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby
+$:.unshift File.dirname(__FILE__)
+require "confreader"
+require "worker"
+require "common"
+require 'logger'
+
+logger = Logger.new(File.join(File.dirname(__FILE__),"../logs/tiebraker_main.log"), 'weekly')
+logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+logger.info "Started"
+
+allvariables = ALLVARS.new
+# config check
+conf = CONFREADER.new(File.join(File.dirname(__FILE__), '../config.json'));
+if ! conf.error_in_parsing_json.empty? then
+	logger.fatal "Error at parsing json #{conf.error_in_parsing_json}"
+	exit
+end
+
+conf.hashedjson["configs"].each {|x| 
+	logger.info x
+	if  allvariables.configisvlalid then
+		if (x.has_key?("config_name") & x.has_key?("primary_ip") & x.has_key?("secondary_ip") & x.has_key?("primary_svm")   & x.has_key?("secondary_svm") & 
+			x.has_key?("primary_user") & x.has_key?("primary_password") & x.has_key?("secondary_user") & x.has_key?("secondary_password") & 
+			x.has_key?("primary_site_name") & x.has_key?("ips_to_check_on_primary_from_secondary") & x.has_key?("ips_to_check_on_primary") & 
+			x.has_key?("ips_to_check_on_secondary") & x.has_key?("fc_topology_check") & x.has_key?("check_fc_switches_on_primary") &
+			x.has_key?("primary_svm_user") & x.has_key?("primary_svm_password") & x.has_key?("secondary_svm_user") & x.has_key?("secondary_svm_password")
+		    ) then
+			logger.info "The config has all the keys."
+
+			if ( (x["ips_to_check_on_primary"].class.name == 'Array') & (x["ips_to_check_on_secondary"].class.name == 'Array') & 
+				(x["ips_to_check_on_primary_from_secondary"].class.name == 'Array') & (x["check_fc_switches_on_primary"].class.name == 'Array')) then
+				logger.info "Found all the array type keys."
+				if ( (x["ips_to_check_on_primary"].count>0) & (x["ips_to_check_on_secondary"].count>0) & (x["ips_to_check_on_primary_from_secondary"].count>0) &
+					(  ( x["fc_topology_check"] & (x["check_fc_switches_on_primary"].count>0) ) ||  ! x["fc_topology_check"] )
+					
+					) then
+					logger.info "The array types have more than zero elements in the config. It is Ok."
+				else
+					logger.fatal "There are keys with array type with no elements"
+					allvariables.setconfigisvalid(false)
+				end
+			else
+				logger.fatal "Some keys must be type of array!"
+				allvariables.setconfigisvalid(false)
+				
+			end
+
+		else
+			logger.fatal "There are missing keys in the config."
+			allvariables.setconfigisvalid(false)
+		end
+
+	end
+} 
+
+exit if !allvariables.configisvlalid
+
+
+# start workers
+threads = []
+conf.hashedjson["configs"].each {|x| 
+	logger.debug x
+	threads << Thread.new { WORKER.new(x) }
+} 
+
+
+begin
+	anythreadalive = false
+	logger.info "Number of threads: #{threads.size}"
+	threads.each {|x| 
+		# exit if not x.alive?
+ 		anythreadalive = anythreadalive | x.alive?
+ 		x.exit if not x.alive?
+	} 
+	logger.info "Any thread alive: #{anythreadalive }"
+	sleep 10
+end while anythreadalive
+

data/classes/ntap.rb

@@ -0,0 +1,610 @@
+$:.unshift File.dirname(__FILE__)
+
+require "NaServer"
+require "common"
+require 'net/ssh'
+
+class NETAPP
+
+	attr_reader :primary_ip, :primary_user, :primary_password, :secondary_ip, :secondary_user, :secondary_password, :primary_svm, :secondary_svm
+
+
+#	def initialize(primary_ip, primary_user, primary_password, secondary_ip, secondary_user, secondary_password, primary_svm, secondary_svm, ips_to_check_on_primary_from_secondary)
+	def initialize(config, logger, vsms_properties)
+		@logger = logger
+		@primary_ip = config["primary_ip"]
+		@primary_user = config["primary_user"]
+		@primary_password = config["primary_password"]
+		@secondary_ip = config["secondary_ip"]
+		@secondary_user = config["secondary_user"]
+		@secondary_password = config["secondary_password"]
+		@primary_svm = config["primary_svm"]
+		@secondary_svm = config["secondary_svm"]
+		@ips_to_check_on_primary_from_secondary = config["ips_to_check_on_primary_from_secondary"]
+		@config_name = config['config_name']
+
+        @primary_svm_user = config["primary_svm_user"]
+        @primary_svm_password = config["primary_svm_password"]
+        @secondary_svm_user = config["secondary_svm_user"]
+        @secondary_svm_password = config["secondary_svm_password"]
+		
+		@connection = NaServer.new(@secondary_ip, 1, 3)
+		@connection.set_admin_user(@secondary_user, @secondary_password)
+
+		@connection_primary = NaServer.new(@primary_ip, 1, 3)
+		@connection_primary.set_admin_user(@primary_user, @primary_password)
+
+		@fc_topology_check = config["fc_topology_check"]
+		@check_fc_switches_on_primary = config["check_fc_switches_on_primary"]
+		
+		@all_nodes = list_nodes_on_secondary if vsms_properties.size != 0
+		
+		@vsms_properties = vsms_properties
+		if vsms_properties.size > 0	then
+			@primary_svm_luns = @vsms_properties["primary_vsm_properties"]["luns"] #Array of HASH["path","online","serial-number"]
+			@secondary_svm_management_interfaces = @vsms_properties["secondary_vsm_properties"]["management_lifs"] # Array of HASH ["address", "interface-name", "administrative-status", "operational-status"]
+			@secondary_svm_data_interfaces = @vsms_properties["secondary_vsm_properties"]["data_lifs"]	# Array of HASH ["interface-name", "administrative-status", "data-protocol"]
+		end 
+	end 
+	# initialize
+
+
+	def ping_primary_from_secondary
+		@logger.info "#{@config_name}: Trying ping primary site from  NetApp on secondary site.."
+		can_ping_primary_from_secondary = false
+		@logger.info "#{@config_name}: The following ips are used on secondary netapp to check wheter the primary is alive: #{@ips_to_check_on_primary_from_secondary}"
+		@all_nodes.each do |node|
+			@ips_to_check_on_primary_from_secondary.each do |ip_to_check_on_primary_from_secondary|
+				if not can_ping_primary_from_secondary then
+					@logger.info "#{@config_name}: Trying ping: #{node} -> #{ip_to_check_on_primary_from_secondary}"
+					xcommand = NaElement.new("net-cluster-ping")
+					xcommand.child_add_string("destination-address", ip_to_check_on_primary_from_secondary)
+					xcommand.child_add_string("node", node)
+					xcommand.child_add_string("retry-count","1");
+					result = @connection.invoke_elem(xcommand)
+
+					if (result.results_status() == "failed") 
+		            	# do some logging
+		            	@logger.warn "#{@config_name}: Unable to ping: #{node} -> #{ip_to_check_on_primary_from_secondary}  #{result.results_reason()}"
+		            else
+		            	@logger.info "#{@config_name}: Ping is succes: #{node} -> #{ip_to_check_on_primary_from_secondary} "
+		            	can_ping_primary_from_secondary = true
+		         	end
+				end # if not can_ping_primary_from_secondary
+			end # ips_to_check_on_primary_from_secondary.each do
+		end # @all_nodes.each do 
+		if 	(@fc_topology_check ) & !(can_ping_primary_from_secondary) then
+			fc_switches = @check_fc_switches_on_primary.uniq
+			@logger.info "#{@config_name}: Have to discover FC topology..."
+			Net::SSH.start(@secondary_ip , @secondary_user, :password => @secondary_password) do |ssh|
+  				@all_nodes.each do |node|
+  					if !can_ping_primary_from_secondary then
+						@logger.info "#{@config_name}: Trying to discover FC topology on node: #{node}"
+	  					result = ssh.exec!("system node run -node #{node} -command fcp topology show")
+	  					arr_of_result = result.split("\r\n")
+  						arr_of_result.keep_if {|elem| elem.include?("Switch Name:")}
+  						arr_of_result.each_index { |idx|
+    						arr_of_result[idx].gsub!("Switch Name:","").strip!
+  						}
+  						arr_of_result.uniq!
+						aggr_arr = (arr_of_result + fc_switches).uniq
+						if aggr_arr.count < arr_of_result.count+fc_switches.count then
+							can_ping_primary_from_secondary = true
+							@logger.info "#{@config_name}: The FC topology contains switches from primary site: #{node}"  
+						else
+							@logger.warn "#{@config_name}: The FC topology does not contain switches from primary site: #{node}"  
+						end
+
+  					end # if !can_ping_primary_from_secondary then
+  				end # @all_nodes.each do |node|
+			end # Net::SSH.start("172.16.0.150", "admin", :password => "next1rapass1") do |ssh|
+		end # if (@fc_topology_check ) & !(can_ping_primary_from_secondary) then
+		
+		return can_ping_primary_from_secondary
+	end # ping_primary_from_secondary
+
+	def list_nodes_on_secondary
+		xcommand = NaElement.new("cluster-node-get-iter")
+		xcommand.child_add_string("desired-attributes","node-name")
+		result = @connection.invoke_elem(xcommand)
+		 
+		 if (result.results_status() == "failed") 
+            @logger.fatal "#{@config_name}: Unable to retrieve nodes: #{result.results_reason()}"
+            # do some logging
+         else
+         	@logger.info "#{@config_name}: Successfuly retrieved nodes"
+         end
+
+         nodeinfo = result.child_get("attributes-list")
+         result_list = nodeinfo.children_get()
+         nodes = []
+         result_list.each do |node| 
+         	nodes.push(node.child_get_string("node-name")) if node.child_get_string("is-node-healthy")
+         end
+        return nodes
+    end	# list_nodes_on_secondary
+	
+	def failover
+		success = true
+		if quiesce then
+			if smirror_break
+					if start_secondary_svm
+					else
+						success = false
+					end
+			else
+				success = false
+			end
+			
+		else
+		 success = false
+		end
+		return success
+	end
+	
+	def quiesce
+=begin
+		success = true
+		@logger.info "#{@config_name}:Trying to quiesce snapmirror relationship"
+		xcommand = NaElement.new("snapmirror-quiesce")
+		xcommand.child_add_string("destination-location", "#{@secondary_svm}:")
+		result = @connection.invoke_elem(xcommand)
+		if (result.results_status() == "failed") 
+            @logger.fatal "#{@config_name}: Unable to quiesce snapmirror relationship: #{result.results_reason()}"
+			 success = false
+        end
+		return success
+=end
+	return true
+	end
+	
+	
+	def smirror_break
+		success = true
+		smirror_abort
+		@logger.info "#{@config_name}:Trying to break snapmirror relationship"
+		xcommand = NaElement.new("snapmirror-break")
+		xcommand.child_add_string("destination-location", "#{@secondary_svm}:")
+		result = @connection.invoke_elem(xcommand)
+		if (result.results_status() == "failed") 
+            @logger.fatal "#{@config_name}: Unable to break snapmirror relationship: #{result.results_reason()}"
+			 success = false
+        end
+        waitforsnapmirror("broken-off") if success
+		return success	
+	end
+	
+	def smirror_abort
+		@logger.info "#{@config_name}:Trying to abort snapmirror transfer"
+		xcommand = NaElement.new("snapmirror-abort")
+		xcommand.child_add_string("destination-location", "#{@secondary_svm}:")
+		result = @connection.invoke_elem(xcommand)
+		if (result.results_status() == "failed") 
+            @logger.fatal "#{@config_name}: Unable to abort snapmirror transfer: #{result.results_reason()}"
+        end
+        #
+        waitforsnapmirror("idle")
+       
+	end
+=begin
+	def waitforsnapmirror(required_state)
+ 		xcommand = NaElement.new("snapmirror-get")
+		xcommand.child_add_string("destination-location", "#{@secondary_svm}:")
+		
+		output = @connection.invoke_elem(xcommand).children_get()[0].children_get()[0].child_get("relationship-status").content if required_state.eql?("idle")
+
+		output = @connection.invoke_elem(xcommand).children_get()[0].children_get()[0].child_get("mirror-state").content if required_state.eql?("broken-off")
+		
+		#while not @connection.invoke_elem(xcommand).children_get()[0].children_get()[0].child_get("relationship-status").content.eql?("idle")
+		while not output.eql?(required_state)
+	     @logger.warn "#{@config_name}: Waiting to #{required_state} state... Currently: #{output}"
+       	 sleep 1
+       	 output = @connection.invoke_elem(xcommand).children_get()[0].children_get()[0].child_get("relationship-status").content
+    	end	
+	end
+=end
+
+
+def waitforsnapmirror(state)
+	result_out = ""
+	while not result_out.eql?(state)
+ 		xcommand = NaElement.new("snapmirror-get")
+		xcommand.child_add_string("destination-location", "SVM-S1-SAPHANA01-DR:")
+		smattribs_desired   = NaElement.new("desired-attributes")
+		sminfo_desired      = NaElement.new("snapmirror-info")
+		relationship_status_desired = NaElement.new("relationship-status")
+		mirror_state_desired = NaElement.new("mirror-state")
+
+		sminfo_desired.child_add(relationship_status_desired)
+		sminfo_desired.child_add(mirror_state_desired)
+		smattribs_desired.child_add(sminfo_desired)
+		xcommand.child_add(smattribs_desired)
+		sm_elements = @connection.invoke_elem(xcommand)
+		#puts sm_elements.inspect
+		 sm_elements.children_get.each{ |sminfo|
+		 	sminfo.children_get.each { | smi |
+		 		if state.eql?("broken-off") then
+		 			result_out = smi.child_get_string("mirror-state")
+		 		else
+		 			result_out = smi.child_get_string("relationship-status")
+		 		end
+		 	}
+
+		}
+		@logger.warn "#{@config_name}: Waiting for #{state} state... Currently: #{result_out}"
+	end
+end
+
+	def start_secondary_svm
+		success = true
+		set_admin_state_of_data_lifs_on_secondary_svm("down")
+
+		@logger.info "#{@config_name}:Trying to start svm: #{@secondary_svm}"
+		xcommand = NaElement.new("vserver-start")
+		xcommand.child_add_string("vserver-name", @secondary_svm)
+		result = @connection.invoke_elem(xcommand)
+		if (result.results_status() == "failed") 
+            @logger.fatal "#{@config_name}: Unable to start SVM #{@secondary_svm}:  #{result.results_reason()}"
+			 success = false
+        else
+        	@logger.info "#{@config_name}: Successfuly start SVM: #{@secondary_svm}"
+        end
+        sleep 10
+        set_state_of_luns_on_secondary_svm("offline")
+        change_serial_of_luns_on_secondary_svm
+        set_state_of_luns_on_secondary_svm("online")
+        set_admin_state_of_data_lifs_on_secondary_svm("up")
+
+		return success	
+	end
+
+	def set_admin_state_of_data_lifs_on_secondary_svm(state)
+		success = true
+		@logger.info "#{@config_name}:Trying to #{state} data interfaces"
+		@secondary_svm_data_interfaces.each{ |lif|
+			xcommand = NaElement.new("net-interface-modify")
+			xcommand.child_add_string("interface-name", lif["interface-name"])
+			xcommand.child_add_string("vserver", @secondary_svm)
+			
+			if state.eql?("up")  then
+				xcommand.child_add_string("administrative-status", lif["administrative-status"])
+			else
+				xcommand.child_add_string("administrative-status", state)
+			end # state.eql?("up")  then
+
+			result = @connection.invoke_elem(xcommand)
+			
+			if (result.results_status() == "failed") 
+            	@logger.fatal "#{@config_name}: Unable to #{state} data lif #{lif['interface-name']}: #{result.results_reason()}"
+				success = false
+       		 else
+       		 	if state.eql?("up")  then
+            		@logger.info "#{@config_name}: Successfuly #{lif['administrative-status']} data lif #{lif['interface-name']}"
+            	else
+            		@logger.info "#{@config_name}: Successfuly #{state} data lif #{lif['interface-name']}"
+            	end #if state.eql?("up")  then
+
+       		 end
+		}
+	end #  set_admin_state_of_data_lifs_on_secondary_svm(state)
+
+
+def set_state_of_luns_on_secondary_svm(state)
+		success = true
+		@logger.info "#{@config_name}:Trying to change the  state of luns to #{state}"
+		con_success = false
+				#puts @secondary_svm_management_interfaces.inspect
+				@secondary_svm_management_interfaces.each{ |lif|
+				
+					if ! con_success &  lif["administrative-status"].eql?("up") then
+
+						vconnection_secondary  = NaServer.new(lif["address"], 1, 3)
+#						puts lif.inspect
+						vconnection_secondary.set_admin_user(@secondary_svm_user, @secondary_svm_password)
+						xcommand = NaElement.new("system-get-version")
+						result = vconnection_secondary.invoke_elem(xcommand)
+						if (result.results_status() == "failed") 
+		            		@logger.fatal "#{@config_name}: Unable to connect secondary SVM #{@secondary_svm} for changing luns state to #{state}: #{result.results_reason()}"
+						 	#success = false
+		       			else
+		       				con_success = true
+		       			end	
+
+						if con_success then
+							@primary_svm_luns.each{ |lun| 
+								xcommand = NaElement.new("lun-#{state}") #lun-online / lun-offline
+								xcommand.child_add_string("path", lun["path"])
+
+								if state.eql?("online") then
+									if lun["online"].eql?("true") then 
+										result = vconnection_secondary.invoke_elem(xcommand)
+										if (result.results_status() == "failed") 
+			            					@logger.error "#{@config_name}: Unable to #{state} lun #{lun['path']} #{@secondary_svm}: #{result.results_reason()}"
+			    		        		else
+					            			@logger.info "#{@config_name}: Successfuly set  #{state} lun #{lun['path']} #{@secondary_svm} "            			
+					            		end
+									end
+								else # state.eql?("online") --> offline
+									result = vconnection_secondary.invoke_elem(xcommand)
+									if (result.results_status() == "failed") 
+			            					@logger.error "#{@config_name}: Unable to #{state} lun #{lun['path']} #{@secondary_svm}: #{result.results_reason()}"
+			    		        	else
+					            			@logger.info "#{@config_name}: Successfuly set  #{state} lun #{lun['path']} #{@secondary_svm} "            			
+					            	end
+								end # state.eql?("online")
+							}
+						end
+					end
+				}
+end # end def set_state_of_luns_on_secondary_svm(state)
+
+
+def change_serial_of_luns_on_secondary_svm
+		success = true
+		@logger.info "#{@config_name}:Trying to change serial-number of luns"
+		con_success = false
+		@secondary_svm_management_interfaces.each{ |lif|
+			if ! con_success &  lif["administrative-status"].eql?("up") then
+				vconnection_secondary  = NaServer.new(lif["address"], 1, 3)
+				vconnection_secondary.set_admin_user(@secondary_svm_user, @secondary_svm_password)
+				xcommand = NaElement.new("system-get-version")
+				result = vconnection_secondary.invoke_elem(xcommand)
+				if (result.results_status() == "failed") 
+            		@logger.fatal "#{@config_name}: Unable to connect secondary SVM #{@secondary_svm}: #{result.results_reason()}"
+				 	#success = false
+       			else
+       				con_success = true
+       			end	
+				if con_success then
+					@primary_svm_luns.each{ |lun| 
+					xcommand = NaElement.new("lun-set-serial-number")
+					xcommand.child_add_string("path", lun["path"])
+					xcommand.child_add_string("serial-number", lun["serial-number"])
+
+					result = vconnection_secondary.invoke_elem(xcommand)
+						if (result.results_status() == "failed") 
+	            			@logger.error "#{@config_name}: Unable to change the serial of lun #{lun['path']} #{@secondary_svm}: #{result.results_reason()}"
+	            		else
+	            			@logger.info "#{@config_name}: Successfuly changed the serial of lun #{lun['path']} #{@secondary_svm}"
+	            		end
+					}
+				end
+			end
+		}
+end # end def set_state_of_luns_on_secondary_svm(state)
+
+
+
+def get_management_interfaces(primary_or_secondary)
+		management_interfaces=[]
+
+		xcommand    = NaElement.new("net-interface-get-iter")
+		netattribs_desired  = NaElement.new("desired-attributes")
+		interfaceinfo_desired        = NaElement.new("net-interface-info")
+		vserver_name_desired         = NaElement.new("vserver")
+		firewallpolicy_desired	     = NaElement.new("firewall-policy")
+		dataprotocols_desired        = NaElement.new("data-protocols")
+
+		dataprotocols_array_desired  = NaElement.new("data-protocol")
+		dataprotocols_desired.child_add(dataprotocols_array_desired)
+
+		operationalstatus_desired    = NaElement.new("operational-status")
+		administrativestatus_desired = NaElement.new("administrative-status")
+
+		address_desired    			 = NaElement.new("address")
+
+		interfaceinfo_desired.child_add(vserver_name_desired)
+		interfaceinfo_desired.child_add(firewallpolicy_desired)
+		interfaceinfo_desired.child_add(dataprotocols_desired)
+		interfaceinfo_desired.child_add(operationalstatus_desired)
+		interfaceinfo_desired.child_add(administrativestatus_desired)
+		interfaceinfo_desired.child_add(address_desired)
+
+		netattribs_desired.child_add(interfaceinfo_desired)
+
+		netattribs_query         	= NaElement.new("query")
+		interfaceinfo_query      	=  NaElement.new("net-interface-info")
+		svm = ""
+		if primary_or_secondary.eql?("primary") then
+			svm = @primary_svm
+		else
+			svm = @secondary_svm
+		end
+
+		interfaceinfo_query.child_add_string("vserver",svm)
+		
+		#interfaceinfo_query.child_add_string("administrative-status","up") #if primary_or_secondary.eql?("primary")
+		dataprotocols_query     	= NaElement.new("data-protocols")
+		dataprotocols_query.child_add_string("data-protocol","none")
+		interfaceinfo_query.child_add(dataprotocols_query)
+
+		netattribs_query.child_add(interfaceinfo_query)
+
+		xcommand.child_add(netattribs_desired)
+		xcommand.child_add(netattribs_query)
+
+		if primary_or_secondary.eql?("primary") then
+			output	= @connection_primary.invoke_elem(xcommand)
+		else
+			output	= @connection.invoke_elem(xcommand)
+		end
+
+		if (output.results_status() == "failed") 	then 
+			@logger.fatal "#{@config_name}: Unable to connect to #{svm} for getting management interfaces: #{output.results_reason()}"
+		 	return nil
+		end
+
+		result_count 				= output.child_get_int("num-records")
+		#puts output.inspect
+		if result_count>0 then
+			info_interfaces = output.children_get()
+			info_interfaces.each { |interface_element_info|
+				if interface_element_info.class.name.eql?("NaElement") then
+					interface_info = interface_element_info.children_get()
+					interface_info.each{|interface|
+						management_interface = Hash.new
+						management_interface["address"] = interface.child_get_string("address")
+						management_interface["interface-name"] = interface.child_get_string("interface-name")
+						management_interface["administrative-status"] = interface.child_get_string("administrative-status")
+						management_interface["operational-status"] = interface.child_get_string("operational-status")
+						management_interfaces.push(management_interface)
+					}
+				end
+			}
+		else
+		end # result_count>0 then
+		@logger.info "#{@config_name}: Retrieved management interfaces from #{svm}: #{management_interfaces.inspect}"
+		return management_interfaces
+	end #get_management_interfaces
+
+def get_data_interfaces(primary_or_secondary,protocol)
+		data_interfaces=[]
+
+		xcommand    = NaElement.new("net-interface-get-iter")
+		netattribs_desired  = NaElement.new("desired-attributes")
+		interfaceinfo_desired        = NaElement.new("net-interface-info")
+		vserver_name_desired         = NaElement.new("vserver")
+		dataprotocols_desired        = NaElement.new("data-protocols")
+
+		dataprotocols_array_desired  = NaElement.new("data-protocol")
+		dataprotocols_desired.child_add(dataprotocols_array_desired)
+
+		administrativestatus_desired = NaElement.new("administrative-status")
+
+		interfaceinfo_desired.child_add(vserver_name_desired)
+		interfaceinfo_desired.child_add(dataprotocols_desired)
+		interfaceinfo_desired.child_add(administrativestatus_desired)
+
+		netattribs_desired.child_add(interfaceinfo_desired)
+
+		netattribs_query         	= NaElement.new("query")
+		interfaceinfo_query      	=  NaElement.new("net-interface-info")
+		
+		svm = ""
+		if primary_or_secondary.eql?("primary") then
+			svm = @primary_svm
+		else
+			svm = @secondary_svm
+		end
+
+		interfaceinfo_query.child_add_string("vserver",svm)
+
+		dataprotocols_query     	= NaElement.new("data-protocols")
+		dataprotocols_query.child_add_string("data-protocol",protocol)
+		interfaceinfo_query.child_add(dataprotocols_query)
+
+		netattribs_query.child_add(interfaceinfo_query)
+
+		xcommand.child_add(netattribs_desired)
+		xcommand.child_add(netattribs_query)
+
+		output 	= @connection.invoke_elem(xcommand)
+		 if (output.results_status() == "failed") 	then 
+			@logger.fatal "#{@config_name}: Unable to connect to #{svm} for getting data interfaces: #{output.results_reason()}"
+		 	return nil
+		 end
+
+		result_count = output.child_get_int("num-records")
+
+		if result_count>0 then
+=begin	
+			vsconnection  = NaServer.new("172..0.", 1, 3)
+			vsconnection.set_admin_user("vsadmin", "")
+			vsxcommand    = NaElement.new("system-get-version")
+			puts vsconnection.invoke_elem(vsxcommand).inspect
+=end
+			info_interfaces = output.children_get()
+			info_interfaces.each { |interface_element_info|
+				if interface_element_info.class.name.eql?("NaElement") then
+					interface_info = interface_element_info.children_get()
+					interface_info.each{|interface|
+						data_interface = Hash.new
+ 						data_interface["interface-name"] = interface.child_get_string("interface-name")
+						data_interface["administrative-status"] = interface.child_get_string("administrative-status")
+						data_interface["data-protocol"] = protocol
+						data_interfaces.push(data_interface)
+					}
+				end
+			}
+		else
+		end # result_count>0 then
+		@logger.info "#{@config_name}: Retrieved data interfaces from #{svm} (#{primary_or_secondary}): #{data_interfaces.inspect}"
+		return data_interfaces
+	end # get_data_interfaces(primary_or_secondary)
+
+	def get_primary_luns
+		primary_luns=[]
+		xcommand    = NaElement.new("lun-get-iter")
+		lunattribs_desired   = NaElement.new("desired-attributes")
+		luninfo_desired      = NaElement.new("lun-info")
+
+		vserver_name_desired = NaElement.new("vserver")
+		lun_path_desired     = NaElement.new("path")
+		lun_online_desired    = NaElement.new("online")
+		lun_serialnumber_desired   = NaElement.new("serial-number")
+
+		luninfo_desired.child_add(vserver_name_desired)
+		luninfo_desired.child_add(lun_path_desired)
+		luninfo_desired.child_add(lun_online_desired)
+		luninfo_desired.child_add(lun_serialnumber_desired)
+
+		lunattribs_desired.child_add(luninfo_desired)
+
+		lunattribs_query    = NaElement.new("query")
+		luninfo_query 		= NaElement.new("lun-info")
+		luninfo_query.child_add_string("vserver", @primary_svm)
+		lunattribs_query.child_add(luninfo_query)
+		xcommand.child_add(lunattribs_desired)
+		xcommand.child_add(lunattribs_query)
+		#puts xcommand.inspect
+		result = @connection_primary.invoke_elem(xcommand)
+		#puts result.inspect
+		 if (result.results_status() == "failed") 	then 
+				@logger.fatal "#{@config_name}: Unable to connect to #{@primary_svm} for getting luns: #{result.results_reason()}"
+			 	return nil
+			 end
+
+		lun_elements = result.children_get()
+		
+		lun_elements.each{ | lun_element |
+			if lun_element.class.name.eql?("NaElement") then
+				luns_info = lun_element.children_get()
+				luns_info.each{|lun_info|
+					lun  = Hash.new
+	 				lun["path"] = lun_info.child_get_string("path")
+	 				lun["online"] = lun_info.child_get_string("online")
+	 				lun["serial-number"] = lun_info.child_get_string("serial-number")
+	 				primary_luns.push(lun)
+				}
+			end # lun_element.class.name.eql?("NaElement") then
+		}
+
+			@logger.info "#{@config_name}: Retrieved luns from #{@primary_svm}: #{primary_luns.inspect}"
+
+		return primary_luns
+		#puts result.inspect
+	end # end get_primary_luns
+	
+	def test_connection(destination, caller)
+		##################
+		con_success = true
+		xcommand = NaElement.new("system-get-version")
+		if destination.eql?("primary_cluster")
+			result = @connection_primary.invoke_elem(xcommand)
+		elsif destination.eql?("secondary_cluster")
+			result = @connection.invoke_elem(xcommand)
+		else
+		end	#destination.eql?("primary_cluster")
+
+		if (result.results_status() == "failed") 
+        	@logger.fatal "#{@config_name}: Unable to connect #{destination} while attempting to check connection for #{caller}: #{result.results_reason()}"
+			con_success = false
+       	else 
+			@logger.info "#{@config_name}: Successfuly connect #{destination} while attempting to check connection for #{caller}"
+	    end
+
+	    return con_success
+	end # end test connection
+
+end #class end
+