framework_gem 0.1.0

data/lib/dsllib/common/mas_db/mas_utils.rb

@@ -0,0 +1,422 @@
+#Test automation script version# TA-5.5.mdn released time stamp: 12-03-12 14:40:20
+
+require './dsllib/common/utils/tmc_utils'
+require './dsllib/common/mas_db/mas_conductor'
+
+# Use it to verify whether mas commmand line is working or not
+# * *Returns* :
+# - Returns true if successful, else false
+def mas_command_line_accessible?
+  begin
+    loginfo2 "Execution mdiags command ...",false
+    result = exec_mas_cmd "mdiags"
+    return (result.downcase.include?('mystro diagnostics'))
+  rescue StandardError => e
+    loginfo2 "MAS command error : #{e.message}",false
+    return false
+  end
+end
+
+# Use it to change purchase pin from MAS
+def change_purchase_pin_from_mas (purchase_pin='0000')
+  loginfo2 "Changing purchase pin to  #{purchase_pin} from MAS"
+  mac_address = fetch_stb_mac_address
+  exec_mas_cmd "mdiags msg -m #{mac_address} purchasePINUpdate #{purchase_pin}"
+  loginfo2 "Purchase pin successfully changed"
+end
+
+# Use it to chnage parental control pin from MAS
+def change_parental_control_pin_from_mas (parental_control_pin='0000')
+  loginfo2 "Chnaging parental control pin to  #{parental_control_pin} from MAS"
+  mac_address = fetch_stb_mac_address
+  exec_mas_cmd "mdiags msg -m #{mac_address} parentalBlockPINUpdate #{parental_control_pin}"
+  loginfo2 "Parental control pin successfully changed"
+end
+
+# Use it to reset factory settings from MAS
+def reset_factory_settings_from_mas
+  loginfo2 'Resetting factory settings'
+  mac_address = fetch_stb_mac_address
+  cmd = "mdiags msg -m #{mac_address} resetFactoryDefaults"
+  loginfo2 "Executing MAS command: #{cmd}"
+  exec_mas_cmd cmd
+  loginfo2 "Waiting for 10 minutes to let box boot up."
+  sleep 10.min
+  press_power_sleep if stb_standby?
+  loginfo2 "Box sucessfully reset"
+end
+
+# Use it to interrupt a streaming OD session
+def interrupt_od_session_from_mas
+  loginfo2 'Interrupting streaming OD session'
+  mac_address = fetch_stb_mac_address
+  cmd = "mdiags od teardown terminal '#{mac_address}' -02"
+  loginfo2 "Executing MAS command: #{cmd}"
+  output = exec_mas_cmd(cmd)
+  logdebug output
+  if output.include?('Destroying sessions by terminal name')
+    loginfo2 "Streaming OD session interrupted successfully"
+    return true
+  end
+  return false
+end
+
+# Use it to list default items on Enhance Menu
+def list_default_items_available_in_enhanced_menu
+  enhanced_menu_items = []
+  cmd = "cat /usr/local/mystro/conf/EnhancedMenuTemplate.xml  | grep -i nodeName=   | cut -f2 -d'=' | cut -f2 -d '\"'"
+  loginfo2 "Executing MAS command: #{cmd}"
+  result = exec_mas_cmd cmd
+  menu_items = result.gsub("\r", '').split("\n")
+  # Removed last line from the result as it contains the prompt
+  menu_items.pop
+  menu_items.each do |item|
+    if(item != '')
+      enhanced_menu_items.push item
+    end
+  end
+  return enhanced_menu_items
+end
+
+# Use it schedule rdvr events for a program
+# * *Args* :
+# - program -> program on which recording should be scheduled
+# - recording_type -> either SERIES or SINGLE
+# - num_of_episodes:  [ ONE, THREE, FIVE, SEVEN, ALL ]
+# - save_options:  [ SAVE_UNTIL_USER_DELETES, SAVE_UNTIL_SPACE_IS_NEEDED ]
+# - repeat_options:[ ONLY_NEW_AND_SELECTED_AIR_TIME, ALL_EPISODES_AND_SELECTED_AIR_TIME, ONLY_NEW_AND_ALL_AIRINGS, ALL_EPISODES_AND_ALL_AIRINGS ]
+# - priority:  [ MIN, MAX ]
+# * *Returns* :
+# - Returns true if successfully scheduled, else false
+def schedule_rdvr_event_from_mas (program, recording_type='SINGLE', number_of_episodes='ONE', save_options='SAVE_UNTIL_SPACE_IS_NEEDED', repeat_options='ALL_EPISODES_AND_ALL_AIRINGS', adjust_start='0', adjust_stop='0', priority='MIN')
+  loginfo2 "Scheduling RDVR events from MAS"
+  mas_time_zone_diff = mas_conductor_time_zone_diff_in_min
+  mac_address = fetch_stb_mac_address
+
+  program_service_id = program[17]
+  program_event_id = program[15]
+  program_start_time = (program[2] - (mas_time_zone_diff*60)).to_i
+
+  cmd = "mdiags rdvr scheduleEvent #{mac_address} #{program_service_id} #{program_event_id} #{program_start_time} #{recording_type} numEpisodes=#{number_of_episodes} saveOptions=#{save_options} repeatOptions=#{repeat_options} adjustStart=#{adjust_start} adjustStop=#{adjust_stop} priority=#{priority}"
+  loginfo2 "Executing MAS command: #{cmd}"
+  result = exec_mas_cmd cmd
+  logdebug "RESULT: #{result}"
+  if result.include?('TimeoutException_Exception')
+    loginfo2 "Timeout while executing command"
+    return false
+  end
+  success_message = "message=SUCCESS"
+  output =  /(?:OUTPUT:\s\{\s)(.*)\s\}/.match(result)[1]
+
+  if  output.include? success_message
+    loginfo2 'RDVR events scheduled successfully from MAS'
+    return true
+  else
+    loginfo2 "Error occurred in scheduling RDVR events from MAS: #{output}"
+    return false
+  end
+end
+
+# Use it to clear NVRAM from MAS using commnad line
+def clear_nvram_from_mas
+  loginfo2 "Clearing NVRAM from MAS"
+  mac_address = fetch_stb_mac_address
+  cmd = "mdiags msg clearClientNVRAM -m #{mac_address}"
+  loginfo2 "Executing MAS command: #{cmd}"
+  result = exec_mas_cmd cmd
+  sleep 1.min
+  loginfo2 "Cleared NVRAM from MAS"
+end
+
+# Use it to reset NVRAM from MAS using commnad line
+def reset_nvram_from_mas
+  loginfo2 "Resetting NVRAM from MAS"
+  mac_address = fetch_stb_mac_address
+  cmd = "mdiags msg resetClientNVRAM -m #{mac_address}"
+  loginfo2 "Executing MAS command: #{cmd}"
+  result = exec_mas_cmd cmd
+  loginfo2 "Reseted NVRAM from MAS"
+end
+
+# Use it to verify if UMPGatewayRDVR.log has given request and response in last log
+# * *Args* :
+# - request_ary -> Array of requests to be verified
+# - response_ary -> Array of response to be verified
+# * *Returns* :
+# - Returns true if successfully verified, else false
+def mas_umpgatewayrdvr_log_include? request_ary=[], response_ary=[]
+  mac = fetch_stb_mac_address.to_s
+  mac_address = mac.delete(":")
+  loginfo2 "Mac address of this box is #{mac_address}"
+  command = "tail -1000 #{fetch_option(:mas_log_folder)}/UMPGatewayRDVR.log | grep #{mac_address} -A 30"
+  loginfo2 "Command #{command}."
+  mas_string = exec_mas_cmd(command).to_s
+  loginfo2 "MAS command output [#{mas_string}]"
+  splitted_log = mas_string.split(mac_address)
+  if splitted_log.length < 4
+    loginfo2 "Failed to get logs for this box"
+    return false
+  end
+  request = splitted_log[-4].downcase
+  response = splitted_log[-1].downcase
+  logdebug "Request arr : #{request_ary}, Response arr : #{response_ary}"
+  loginfo2 "Request string [#{request}], Response string [#{response}]"
+  request_ary.each{|req|
+    unless request.delete(' ').include?(req.downcase.delete(' '))
+      loginfo2 "Failed to verify request include [#{req}]"
+      return false
+    end
+  }
+  response_ary.each{|res|
+    unless response.delete(' ').include?(res.downcase.delete(' '))
+      loginfo2 "Failed to verify request include [#{res}]"
+      return false
+    end
+  }
+  loginfo2 "Successfully verified all response and requests"
+  return true
+end
+
+# Use it to verify if TerminalRegistration.log has last boot time greater than given time
+# * *Args* :
+# - time -> Array of requests to be verified
+# - mac_address -> Array of response to be verified
+# * *Returns* :
+# - Returns true if successfully verified, else false
+def mas_verify_last_reboot_time_greater_than time, mac = fetch_stb_mac_address.to_s
+
+  if mac.length == 12
+    mac_address = "#{mac[0,2]}:#{mac[2,2]}:#{mac[4,2]}:#{mac[6,2]}:#{mac[8,2]}:#{mac[10,2]}" # Inserting colons in mac address
+  else
+    mac_address = mac
+  end
+  command = "tail -10000 #{fetch_option(:mas_log_folder)}/TerminalRegistration.log |grep #{mac_address}"
+  loginfo2 "Executing mas command [#{command}]"
+  mas_string = exec_mas_cmd(command).to_s
+  loginfo2 "MAS command output:#{mas_string}"
+  last_entry = mas_string.split(mac_address)[-1]
+  unless last_entry.include?('REBOOT_TIME')
+    loginfo2 'No entry found for this box'
+    return false
+  end
+
+  regex = Regexp.new(/(REBOOT_TIME=)(\d\d)(.)(\d\d)(.)(\d{4})(.)(\d\d)(.)(\d\d)(.)(\d\d)/)
+  #Regexp for reading date and time
+  matchdata = regex.match(last_entry)
+  unless matchdata
+    loginfo2 'Failed to get date and time of last entry in log'
+    return false
+  end
+  read_time = Time.local(matchdata[6],matchdata[2],matchdata[4],matchdata[8],matchdata[10],matchdata[12])
+  logdebug "Read time [#{read_time}], Boot time [#{time}]"
+
+  unless (read_time-time)>=0
+    loginfo2 "Failed to verify if last logged boot time is greater than given time"
+    return false
+  end
+
+  loginfo2 "Successfully verified that last logged boot time is greater than given time"
+  return true
+end
+
+# Use it schedule rdvr events for a program
+# * *Args* :
+# - program -> program on which recording should be scheduled
+# - recording_type -> either SERIES or SINGLE
+# - num_of_episodes:  [ ONE, THREE, FIVE, SEVEN, ALL ]
+# - save_options:  [ SAVE_UNTIL_USER_DELETES, SAVE_UNTIL_SPACE_IS_NEEDED ]
+# - repeat_options:[ ONLY_NEW_AND_SELECTED_AIR_TIME, ALL_EPISODES_AND_SELECTED_AIR_TIME, ONLY_NEW_AND_ALL_AIRINGS, ALL_EPISODES_AND_ALL_AIRINGS ]
+# - priority:  [ MIN, MAX ]
+# * *Returns* :
+# - Returns true if successfully scheduled, else false
+def unschedule_rdvr_event_from_mas (program, recording_type='SINGLE')
+  loginfo2 "Scheduling RDVR events from MAS"
+  mas_time_zone_diff = mas_conductor_time_zone_diff_in_min
+  mac_address = fetch_stb_mac_address
+
+  program_service_id = program[17]
+  program_event_id = program[15]
+  program_start_time = (program[2] - (mas_time_zone_diff*60)).to_i
+
+  cmd = "mdiags rdvr unscheduleEvent #{mac_address} #{program_service_id} #{program_event_id} #{program_start_time} #{recording_type}"
+  loginfo2 "Executing MAS command: #{cmd}"
+  result = exec_mas_cmd cmd
+  logdebug "RESULT: #{result}"
+  if result.include?('TimeoutException_Exception')
+    loginfo2 "Timeout while executing command"
+    return false
+  end
+  success_message = "message=SUCCESS"
+  output =  /(?:OUTPUT:\s\{\s)(.*)\s\}/.match(result)[1]
+
+  if  output.include? success_message
+    loginfo2 'RDVR event unscheduled from MAS'
+    return true
+  else
+    loginfo2 "Error occurred in unscheduling RDVR events from MAS: #{output}"
+    return false
+  end
+end
+
+# Use it to verify if asset is purchased from mdiags
+# * *Args* :
+# - asset -> OD asset to verify
+# - mac_addresses -> Array of mac address
+# - whole_house_purchase:  true if purchase is for all boxes
+# * *Returns* :
+# - Returns true if successfully verified, else false
+def mas_verify_asset_purchased? asset, mac_addresses, whole_house_purchase = true
+  asset_id = asset[:id]
+  purchase_ids = []
+
+  mac_addresses.each do |mac|
+    if mac.length == 12
+      mac_address = "#{mac[0,2]}:#{mac[2,2]}:#{mac[4,2]}:#{mac[6,2]}:#{mac[8,2]}:#{mac[10,2]}" # Inserting colons in mac address
+    else
+      mac_address = mac
+    end
+    command = "mdiags od r | grep #{asset_id} | grep #{mac_address}"
+    output = exec_mas_cmd(command)
+    if output.nil? or output.empty?
+      loginfo "The purchase for the asset #{asset[:title]} is not present for stb with mac #{mac}"
+      return false
+    end
+    regexp = /^(\d+)\s+(\d+).+'(.*)'\s+(\d+).*$/
+    matched = regexp.match(output)
+    if matched.nil?
+      loginfo2 "Purchase id not found"
+      return false
+    end
+    purchase_ids.push(matched[4])
+  end
+
+  if whole_house_purchase
+    return true if purchase_ids.uniq.length.eql?(1)
+    return false
+  end
+
+  return true
+end
+
+# Use it to start/stop On demad Application from MAS
+# * *Args* :
+#   - +action+ -> start (to start OD application), stop (to stop OD application)
+# * *Returns* :
+#   - true if ondemad application started or stopped successfully, false otherwise
+def mas_start_stop_on_demand_application(action = 'start')
+  begin
+    mas_ip = fetch_option(:mas_server_ip)
+    mas_prompt = fetch_option(:mas_server_prompt)
+    mas_username = fetch_option(:mas_username)
+    mas_password = fetch_option(:mas_password)
+    pmclient_prompt = "procmgr>"
+
+    req_queued_status = lock_resource('MAS', 'OD', LOCK_EXCLUSIVE | LOCK_ONETIME, '', 60.min, 10.min) {
+      opened = false
+      open_interactive_ssh(mas_ip, 22, mas_prompt, mas_username, mas_password)
+      opened = true
+
+      result1 = exec_interactive_ssh(pmclient_prompt, "pmclient")
+      logdebug "MAS Command Result1 : #{result1}"
+
+      command = "#{action} 20"
+      result2 = exec_interactive_ssh(pmclient_prompt, command)
+      logdebug "MAS Command Result2 : #{result2}"
+      loginfo2 "On Demand Application stopped"
+
+      result3 =  exec_interactive_ssh(mas_prompt, "q")
+      logdebug "MAS Command Result3 : #{result3}"
+    }
+
+    if req_queued_status == -1
+      loginfo2 "Someone is stuck with OD lock for more than 10 minutes. Aborting..."
+      return false
+    end
+    return true
+  rescue StandardError => e
+    loginfo2 e.message
+    loginfo2 'Unable to start/stop On Demand application'
+    return false
+  ensure
+    close_interactive_ssh if opened
+  end
+end
+
+# Use it to fetch ODN binary logs from STB on MAS
+# * *Args* :
+#   - +ip_addr+ -> ip address of the stb
+# * *Returns* :
+#   - true if logs fetched else false
+def mas_fetch_odn_binary_logs_from_stb(ip_addr = fetch_ip)
+  begin
+    return false if ip_addr.nil?
+
+    mas_ip = fetch_option(:mas_server_ip)
+    mas_prompt = fetch_option(:mas_server_prompt)
+    mas_username = fetch_option(:mas_username)
+    mas_password = fetch_option(:mas_password)
+
+    opened = false
+    open_interactive_ssh(mas_ip, 22, mas_prompt, mas_username, mas_password)
+    opened = true
+
+    begin
+      logdebug "Running script to fetch ODN Binary logs..."
+      result3 = exec_interactive_ssh(mas_prompt, "/usr/local/mystro/scripts/ODNscripts/MAS_ODNBinaryLogs #{ip_addr}")
+      logdebug "Output: #{result3}"
+    rescue StandardError => e
+      logdebug e.to_s
+      logdebug "Still fetching ODN binary logs..."
+      opened = false
+    end
+    close_interactive_ssh if opened
+
+    log_fetched = false
+    10.times do
+      opened = false
+      open_interactive_ssh(mas_ip, 22, mas_prompt, mas_username, mas_password)
+      opened = true
+      result5 = exec_interactive_ssh(mas_prompt, "ls *#{ip_addr}* | grep -i zip")
+      logdebug "Output: #{result5}"
+
+      unless result5.to_s.include?('ODNBinaryLogs')
+        logdebug "Still fetching logs from STB... Will try again in 3 minutes."
+        close_interactive_ssh if opened
+        sleep 3.min
+      else
+        logdebug "ODN binary logs fetched from STB"
+        log_fetched = true
+        break
+      end
+    end
+    return false unless log_fetched
+
+    result6 = exec_interactive_ssh(mas_prompt, "ls -t | grep '#{ip_addr}'")
+    logdebug "Output: #{result6}"
+
+    start_index = result6.index('ODN')
+    end_index = result6.index('zip')
+    log_name = result6[start_index..end_index+2]
+    logdebug "ODN Binary log file: [#{log_name}]"
+    logdebug "Moving log file to directory /tmp"
+    result7 = exec_interactive_ssh(mas_prompt, "mv #{log_name} /tmp")
+    close_interactive_ssh if opened
+    loginfo2 "ODN Binary log file: [#{log_name}] created in /tmp"
+    return true
+  rescue StandardError => e
+    loginfo2 "Unexpected Failure: #{e.message}"
+    return false
+  ensure
+    close_interactive_ssh if opened
+  end
+end
+
+# Use it to reboot STB (after delay) from MAS
+# * *Args* :
+#   - +delay+ -> no. of seconds after which STB will be rebooted
+def mas_reboot_stb_with_delay(delay=0)
+  loginfo2 "Rebooting STB after #{delay} seconds from MAS"
+  mac_address = fetch_stb_mac_address
+  exec_mas_cmd "mdiags msg -m #{mac_address} reboot #{delay}"
+  loginfo2 "STB will be rebooted after #{delay} seconds"
+end

data/lib/dsllib/common/remote_diagnostics/mdn_remote_diagnostics.rb

@@ -0,0 +1,1335 @@
+#Test automation script version# TA-5.5.mdn released time stamp: 12-03-12 14:40:20
+
+require 'rubygems'
+require 'net/telnet'
+require 'nokogiri'
+require 'timeout'
+require './dsllib/common/utils/tmc_utils'
+
+# Use it to fetch channel no. of active tuner from its IP address
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - Channel no. on which the active tuner is
+def fetch_active_tuner(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to fetch active tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    doc = Nokogiri::HTML(patched_resp)
+    active=doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    if active=='TV'
+      tuner = doc.xpath("//table[1]/tr[2]/td[4]").inner_html
+    else
+      tuner = doc.xpath("//table[1]/tr[3]/td[4]").inner_html
+    end
+    loginfo2 "Tuner is on channel: #{tuner}"
+    return tuner
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  end
+end
+
+# Use it to check if active tuner of MDN STB is recording
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - true if active tuner is recording
+def active_tuner_recording?(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to check recording on active tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Check if active tuner recording"
+    doc = Nokogiri::HTML(patched_resp)
+    active=doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    if active=='TV'
+      is_recording=doc.xpath("//table[1]/tr[2]/td[5]").inner_html
+    else
+      is_recording=doc.xpath("//table[1]/tr[3]/td[5]").inner_html
+    end
+    loginfo2 "Value of Is Recording flag from MDN remote diags is: #{is_recording}"
+    if is_recording=='1'
+      loginfo2 "Active tuner is recording"
+      return true
+    end
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to check if active tuner recording' if retries == 4
+  end
+end
+
+# Use it to check if standby tuner of MDN STB is recording
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - true if standby tuner is recording
+def standby_tuner_recording?(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to check recording on standby tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Check if standby tuner recording"
+    doc = Nokogiri::HTML(patched_resp)
+    active=doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    if active!='TV'
+      is_recording=doc.xpath("//table[1]/tr[2]/td[5]").inner_html
+    else
+      is_recording=doc.xpath("//table[1]/tr[3]/td[5]").inner_html
+    end
+    loginfo2 "Value of Is Recording flag from MDN remote diags is: #{is_recording}"
+    if is_recording=='1'
+      loginfo2 "Standby tuner is recording"
+      return true
+    end
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to check if standby tuner recording' if retries == 4
+  end
+end
+
+# Use it to fetch channel no. of PIP tuner from its IP address
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - Channel no. on which the PIP tuner is
+def fetch_pip_tuner(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to fetch PIP tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    doc = Nokogiri::HTML(patched_resp)
+    active=doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    standby=doc.xpath("//table[1]/tr[3]/td[6]").inner_html
+    if active=='VIDEO_OUT'
+      tuner = doc.xpath("//table[1]/tr[2]/td[4]").inner_html
+    elsif standby=='VIDEO_OUT'
+      tuner = doc.xpath("//table[1]/tr[3]/td[4]").inner_html
+    else
+      loginfo2 'PIP not turned ON'
+      tuner = ''
+    end
+    loginfo2 "PIP tuner is on channel: #{tuner}"
+    return tuner
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  end
+end
+
+# Use it to check if PIP tuner of MDN STB is recording
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - true if PIP tuner is recording
+def pip_tuner_recording?(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to check recording on PIP tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Check if standby tuner recording"
+    doc = Nokogiri::HTML(patched_resp)
+    active=doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    if active =='VIDEO_OUT'
+      is_recording=doc.xpath("//table[1]/tr[2]/td[5]").inner_html
+    else
+      is_recording=doc.xpath("//table[1]/tr[3]/td[5]").inner_html
+    end
+    loginfo2 "Value of Is Recording flag from MDN remote diags is: #{is_recording}"
+    if is_recording=='1'
+      loginfo2 "PIP tuner is recording"
+      return true
+    end
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to check if PIP tuner recording' if retries == 4
+  end
+end
+
+# Use it to fetch the tuner no. of the channels from its IP address
+# * *Args*    :
+# - IP address of MDN STB and array of active & standby tuner channels
+# * *Returns* :
+#   -Array of Tuner number of the active & standby channels
+def fetch_tuner_number(ip, channels)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to fetch active tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    doc = Nokogiri::HTML(patched_resp)
+    tuner = []
+    tuner_0 = doc.xpath("//table[1]/tr[2]/td[4]").inner_html
+    tuner_1 = doc.xpath("//table[1]/tr[3]/td[4]").inner_html
+    if ((tuner_0 == channels[0].to_s) ||(tuner_1 == channels[1].to_s))
+      tuner[0] = channels[0]
+      tuner[1] = channels[1]
+    elsif ((tuner_0 == channels[1].to_s) ||(tuner_1 == channels[0].to_s))
+      tuner[0] = channels[1]
+      tuner[1] = channels[0]
+    end
+    return tuner
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  end
+end
+
+# Use it to fetch the destination of the specified channel from its IP address
+# * *Args*    :
+# - IP address of MDN STB
+# - Channel number whose destination is required
+# * *Returns* :
+#   - Destination of the channel passed
+def fetch_tuner_destination(ip, channel)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to fetch active tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    loginfo2 "patched_resp : #{patched_resp}",false
+    sleep 5.sec
+    destination = ''
+    doc = Nokogiri::HTML(patched_resp)
+    if channel.to_s == doc.xpath("//table[1]/tr[2]/td[4]").inner_html
+      destination = doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    else
+      destination = doc.xpath("//table[1]/tr[3]/td[6]").inner_html
+    end
+    loginfo2 "destination : #{destination}",false
+    return destination
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  end
+end
+
+# Private method
+# Use it to fetch the airtime catalog ID's from MDN remote diagnostics
+# * *Args*    :
+# * *Returns* :
+#   - array of airtime catalog ID's
+def _fetch_mdn_airtime_catalog_id(ip)
+  retries = 0
+  retries_catalogs = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to MDN Remote Diags to fetch Airtime catalog ID's using IP: #{stb_ip}"
+    for i in 1..4
+      patched_resp = "<HTML><BODY>"
+      server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+      loginfo2 "Opening disk info and fetching airtime catalogs list"
+      options = {
+        'String' => "GET /disk HTTP/1.1\nHost: #{stb_ip}\n",
+        'Match' => /(airtGrp)/,
+        'Timeout' => 180
+      }
+      server.cmd(options) do |response|
+        patched_resp << response
+      end
+      sleep 5.sec
+      doc = Nokogiri::HTML(patched_resp)
+      logdebug doc
+      data = []
+      doc.xpath("//a").each{|e| if e.text.include?('airtGrp'); logdebug "#{e['href']} -> #{e.text.split('-')[1]}"; data.push(e.text.split('-')[1]);end }
+      if data.size == 0
+        loginfo2 'Unable to fetch airtime catalogs list from MDN remote diagnostics'
+        retries_catalogs += 1
+      end
+      break if data.size != 0
+      loginfo2 "Retry for catalogs list: [#{retries_catalogs}]" if retries_catalogs < 4
+    end
+    return data
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry: [#{retries}]" if retries < 4
+    retry unless retries == 4
+    tcinvalid "Web Diagnostics not accessible" if retries == 4
+  end
+end
+
+# Use it to fetch channel no. of standby tuner(if it is recording) from its IP address
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - Channel no. on which the standby tuner is
+def fetch_recording_standby_tuner(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to fetch active tuner using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    doc = Nokogiri::HTML(patched_resp)
+
+    dest = doc.xpath("//table[1]/tr[2]/td[6]").inner_html
+    isRecording = doc.xpath("//table[1]/tr[2]/td[5]").inner_html
+    channel = ''
+    if dest =='DISK' && isRecording == '1'
+      channel = doc.xpath("//table[1]/tr[2]/td[4]").inner_html
+    else
+      dest = doc.xpath("//table[1]/tr[3]/td[6]").inner_html
+      isRecording = doc.xpath("//table[1]/tr[3]/td[5]").inner_html
+      if dest =='DISK' && isRecording == '1'
+        channel = doc.xpath("//table[1]/tr[3]/td[4]").inner_html
+      end
+    end
+    loginfo2 "Tuner is on channel: #{channel}"
+    return channel
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 "Unable to fetch airtime catalog ID's" if retries == 4
+  end
+end
+
+# Use it to check if tuner 0 of MDN STB is recording
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - true if tuner 0 is recording
+def tuner_0_recording?(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to check recording on tuner 0 using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "patched_resp : #{patched_resp}",false
+    loginfo2 "Check if tuner 0 recording"
+    doc = Nokogiri::HTML(patched_resp)
+    is_recording=doc.xpath("//table[1]/tr[2]/td[5]").inner_html
+    loginfo2 "Value of Is Recording flag from MDN remote diags is: #{is_recording}"
+    if is_recording=='1'
+      loginfo2 "Tuner 0 is recording"
+      return true
+    end
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to check if standby tuner recording' if retries == 4
+  end
+end
+
+# Use it to check if tuner 1 of MDN STB is recording
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - true if tuner 1 is recording
+def tuner_1_recording?(ip)
+  retries = 0
+  stb_ip = ip
+  begin
+    loginfo2 "Connecting to Remote Diags to check recording on tuner 1 using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Resource Scheduler"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "patched_resp : #{patched_resp}",false
+    loginfo2 "Check if tuner 1 recording"
+    doc = Nokogiri::HTML(patched_resp)
+    is_recording=doc.xpath("//table[1]/tr[3]/td[5]").inner_html
+    loginfo2 "Value of Is Recording flag from MDN remote diags is: #{is_recording}"
+    if is_recording=='1'
+      loginfo2 "Tuner 0 is recording"
+      return true
+    end
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to check if standby tuner recording' if retries == 4
+  end
+end
+
+# Use it to fetch app handler name from Atlas Application (remote diags)
+# * *Args*    :
+# - IP address of MDN STB
+# * *Returns* :
+#   - String app handler name (e.g. set0, ond0, etc)
+def fetch_atlas_applications_focused_app_handler_name(stb_ip = fetch_ip)
+  retries = 0
+  begin
+    loginfo2 "Connecting to Remote Diags to fetch app handler name using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    loginfo2 "Opening Atlas Applications"
+    server.cmd("GET /apps HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Fethcing app handler name from Atlas Applications"
+    doc = Nokogiri::HTML(patched_resp)
+    app_handler_name=doc.xpath("/html/body/table[1]/tr[2]/td[2]").inner_text.to_s
+    loginfo2 "App handler name : #{app_handler_name}"
+    return app_handler_name
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  rescue StandardError => e
+    loginfo2 "StandardError : #{e.message}"
+  end
+
+  loginfo2 'Unable to fetch app handler name from Atlas Applications'
+  return ""
+end
+
+def fetch_link_on_mdn_web_diagnostics(stb_ip)
+  links = {}
+  retries=0
+  begin
+    loginfo2 "Connecting to Remote Diags to verify link and its fields using IP: #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+
+    loginfo2 "Opening home page info"
+    server.cmd("GET /home HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    doc = Nokogiri::HTML(patched_resp)
+    doc.xpath("//a").map{ |e| links[e.text.strip.gsub(/\s/,'_').gsub(/\W/,'').downcase.to_sym]=e['href']}
+    return links
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to fetch links' if retries == 4
+  end
+end
+
+def verify_mdn_remote_diagnostic_file_operations(stb_ip)
+  retries = 0
+  begin
+    server=_connect_to_remote_diags(stb_ip)
+    return false if server.nil?
+    loginfo2 "Opening File Operations link"
+    patched_resp = "<HTML><BODY>"
+    server.cmd("GET /fo HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    doc = Nokogiri::HTML(patched_resp)
+
+    lines=[]
+    count=0
+    doc.to_s.split("\n").each {|line| lines.push(line)}
+
+    loginfo2 'Verify Header Information'
+    fields = []
+    expected_fields=['IB Errors','OOB Errors','Last BFS Read Error','Last Stream Exception','Num pending fileOps']
+    fields = lines.find_all{|item| item.include?('File Operations')}[1].to_s.split("<br>").to_a
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify Columns'
+    columns =[]
+    expected_columns=['U Handle','I Handle','Path','Owner','Queued State','Size','Priority','Read State']
+    (1..8).each {|i| columns.push(doc.xpath("//table[1]/tr[1]/td[#{i}]").inner_html)}
+    expected_columns.each{|clm| columns.find_all{|item| if item.include?("#{clm}"); loginfo2 "Table column: #{item} verified"; count+=1; end}}
+
+    loginfo2 'Verify Back to Main page link'
+    doc.xpath("//a").each{|e| if e.text.include?('Back to Main Page'); loginfo2 "#{e['href']} -> #{e.text}"; count+=1;end }
+
+    loginfo2 'All Header Information and Columns on File operations link verified' if count == 14
+    return true if count == 14
+    loginfo2 'All Header Information and Columns on File operations link not verified'
+    return false
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out on opening File operations page...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to verify File operations' if retries == 4
+  end
+end
+
+#Private method
+def _connect_to_remote_diags(stb_ip)
+  server = nil
+  retries=0
+  begin
+    loginfo2 "Connecting to MDN Remote Diags home page using IP: #{stb_ip}"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 "Unable to connect to MDN remote diagnostics" if retries == 4
+    return nil
+  end
+  return server
+end
+
+def verify_mdn_remote_diagnostic_sdv_information(stb_ip)
+  retries = 0
+  begin
+    server=_connect_to_remote_diags(stb_ip)
+    return false if server.nil?
+
+    loginfo2 "Opening SDV information"
+    patched_resp = "<HTML><BODY>"
+    server.cmd("GET /sdv HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Verify information on SDV information link"
+    doc = Nokogiri::HTML(patched_resp)
+
+    headers=[]
+    doc.xpath("//h2").each{|e| headers.push(e.text)}
+    lines=[]
+    count=0
+    doc.to_s.split("\n").each {|line| lines.push(line)}
+
+    loginfo2 'Verify CVCT Section Information'
+    fields = []
+    expected_fields=['version_number','Total number of sections','Total number of channels in MC']
+    fields = lines.find_all {|item| item.include?('CVCT Section Information')}[0].to_s.split("</h2>")[1].split("<br>").to_a
+    headers.find_all{|item| if item.include?('CVCT Section Information'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify SDV MiniCarousel Channel Map Table'
+    headers.find_all{|item| if item.include?('SDV MiniCarousel Channel Map Table'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    loginfo2 'Verify Table Columns'
+    columns =[]
+    expected_columns=['source_id','program','frequency','modulation']
+    (1..4).each {|i| columns.push(doc.xpath("//table[1]/tr[1]/td[#{i}]").inner_html)}
+    expected_columns.each{|clm| columns.find_all{|item| if item.include?("#{clm}"); loginfo2 "Table column: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify CVCT IP Resource Descriptor'
+    fields = []
+    expected_fields=['Descriptor_Tag','Descriptor_Length','IP_Port','Primary_IP_Address','Secondary_IP_Address']
+    fields = lines.find_all {|item| item.include?('CVCT IP Resource Descriptor')}[0].to_s.split("</h2>")[1].split("<br>").to_a
+    headers.find_all{|item| if item.include?('CVCT IP Resource Descriptor'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify CVCT Client Configuration Parameters Descriptor'
+    fields = []
+    expected_fields=['Descriptor_Tag','Descriptor_Length','ResendSDBPrgSelectRequest','LuaReportingInterval','ChannelMapReadInterval','MessageResponseTimeOut',
+      'MessageRequestMaxRetriesCount','MessageRequestRetryInterval','BandwidthReclaimUITimeout']
+    fields = lines.find_all {|item| item.include?('CVCT Client Configuration Parameters Descriptor')}[0].to_s.split("</h2>")[1].split("<br>").to_a
+    headers.find_all{|item| if item.include?('CVCT Client Configuration Parameters Descriptor'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify SDV Tuner Usage'
+    fields = []
+    expected_fields=['Tuner1 Status']
+    fields = lines.find_all {|item| item.include?('SDV Tuner Usage')}[0].to_s.split('00000">')[1].split("<br>").to_a
+    headers.find_all{|item| if item.include?('SDV Tuner Usage'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify SDV Channel Change Messages'
+    headers.find_all{|item| if item.include?('CVCT Client Configuration Parameters Descriptor'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    fields = []
+    fields = lines.find_all {|item| item.include?('SDV Channel Change Messages')}[0].to_s.split('/h2><table><tr><td><font color="#000000">')[1].to_s.split('<br></font></td></tr><br></table></body></html>')[0].to_s.split('<br></font></td></tr><tr><td><font color="#000000">').to_a
+    fields.each{|fld| loginfo2 fld}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify Back to Main page link'
+    doc.xpath("//a").each{|e| if e.text.include?('Back to Main Page'); loginfo2 "Link #{e['href']} -> #{e.text} verified"; count+=1;end }
+
+    loginfo2 'All information on SDV link verified' if count == 29
+    return true if count == 29
+    loginfo2 'All information on SDV link not verified'
+    return false
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out on opening SDV page...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to verify SDV information' if retries == 4
+  end
+end
+
+def verify_mdn_remote_diagnostic_resource_scheduler(stb_ip)
+  retries = 0
+  begin
+    server=_connect_to_remote_diags(stb_ip)
+    return false if server.nil?
+
+    loginfo2 "Opening Resource scheduler"
+    patched_resp = "<HTML><BODY>"
+    server.cmd("GET /rs HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Verify information on Resource Scheduler link"
+    doc = Nokogiri::HTML(patched_resp)
+
+    headers=[]
+    doc.xpath("//h2").each{|e| headers.push(e.text)}
+
+    lines=[]
+    count=0
+    doc.to_s.split("\n").each {|line| lines.push(line)}
+
+    loginfo2 'Verify Scheduled Events Table'
+    headers.find_all{|item| if item.include?('Scheduled Events'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    loginfo2 'Verify Table Columns'
+    columns =[]
+    expected_columns=['Type','State','StartTime','PreEventTime','Duration','ReqPriority','ServiceID','Freq','CH']
+    (1..9).each {|i| columns.push(doc.xpath("//table[3]/tr[1]/td[#{i}]").inner_html)}
+    expected_columns.each{|clm| columns.find_all{|item| if item.include?("#{clm}"); loginfo2 "Table column: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify Tuner Users Table'
+    headers.find_all{|item| if item.include?('Tuner Users'); loginfo2 "Header: #{item} verified"; count+=1; end}
+    loginfo2 'Verify Table Columns'
+    columns =[]
+    expected_columns=['Number','pTvPlayer','Type','ConvertingUser','WaitingToConvertUser','TsbRecorderUser','handle','ID','dest','bDigital','chan','source','freq','mod','prog','affinity Handle','affinity ID']
+    (1..17).each {|i| columns.push(doc.xpath("//table[2]/tr[1]/td[#{i}]").inner_html)}
+    expected_columns.each{|clm| columns.find_all{|item| if item==clm; loginfo2 "Table column: #{item} verified"; count+=1; end}}
+
+    loginfo2 'All information on Resource scheduler link verified' if count == 28
+    return true if count == 28
+    loginfo2 'All information on Resource scheduler link not verified'
+    return false
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out on opening Resource scheduler page...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to verify Resource scheduler information' if retries == 4
+  end
+end
+
+def verify_mdn_remote_diagnostic_ptv_memory_data(stb_ip)
+  retries = 0
+  begin
+    server=_connect_to_remote_diags(stb_ip)
+    return false if server.nil?
+
+    loginfo2 "Opening PTV Memory Data"
+    patched_resp = "<HTML><BODY>"
+    server.cmd("GET /ptvmemdata HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Verify information on PTV Memory Data link"
+    doc = Nokogiri::HTML(patched_resp)
+    puts (doc.xpath("//title").inner_html)
+
+    lines=[]
+    count=0
+    doc.to_s.split("\n").each {|line| lines.push(line)}
+
+    loginfo2 'Verify PTVALLOC Table'
+    fields = []
+    expected_fields=['PTVALLOC','owner','ptr','size(B)']
+    fields = lines.find_all {|item| item.include?('PTVALLOC')}[0].to_s.split('<tr><td>')[1].to_s.split('</td></tr>')[0].to_s.split("</td><td>").to_a
+    loginfo2 'Verify PTVALLOC Table Columns'
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify PTVHANDLE Table'
+    fields = []
+    expected_fields=['PTVHANDLE','owner','ptr','size(B)']
+    fields = lines.find_all {|item| item.include?('PTVHANDLE')}[0].to_s.split('<tr><td>')[1].to_s.split('</td></tr>')[0].to_s.split("</td><td>").to_a
+    loginfo2 'Verify PTVHANDLE Table Columns'
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify Condition Table'
+    fields = []
+    expected_fields=['Condition','Total Free (KB)','Max Free (KB)']
+    fields = lines.find_all {|item| item.include?('Condition')}[0].to_s.split('<tr><td>')[1].to_s.split('</td></tr>')[0].to_s.split("</td><td>").to_a
+    loginfo2 'Verify Condition Table Columns'
+
+    expected_fields.each{|fld| fields.find_all{|item| if item.include?("#{fld}"); loginfo2 "Field: #{item} verified"; count+=1; end}}
+    loginfo2 '*************************************'
+
+    loginfo2 'Verify Back to Main page link'
+    doc.xpath("//a").each{|e| if e.text.include?('Back to Main Page'); loginfo2 "#{e['href']} -> #{e.text}"; count+=1;end }
+
+    loginfo2 'All information on PTV Memory Data link verified' if count == 12
+    return true if count == 12
+    loginfo2 'All information on PTV Memory Data link not verified'
+    return false
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out on opening PTV memory data page...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to verify PTV Memory Data information' if retries == 4
+  end
+end
+
+def verify_mdn_remote_diagnostic_disk_contents(stb_ip)
+  retries = 0
+  begin
+    server=_connect_to_remote_diags(stb_ip)
+    return false if server.nil?
+
+    loginfo2 "Opening Disk contents"
+    patched_resp = "<HTML><BODY>"
+    server.cmd("GET /disk HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Verify information on Disk contents link"
+    doc = Nokogiri::HTML(patched_resp)
+
+    fields=[]
+    doc.xpath("//b").each{|e| fields.push(e.text)}
+
+    count=0
+    fields.each {|item| loginfo2 "Field: #{item} verified"; count+=1}
+
+    loginfo2 'All information on Disk contents link verified' if count >1
+    return true if count >1
+    loginfo2 'All information on Disk contents link not verified'
+    return false
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out on opening Disk contents page...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to verify Disk contents information' if retries == 4
+  end
+end
+
+def verify_mdn_remote_diagnostic_circular_buffers(stb_ip)
+  retries = 0
+  begin
+    server=_connect_to_remote_diags(stb_ip)
+    return false if server.nil?
+
+    loginfo2 "Opening Circular Buffers"
+    patched_resp = "<HTML><BODY>"
+    server.cmd("GET /cb HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    sleep 5.sec
+    loginfo2 "Verify information on Circular Buffers link"
+    doc = Nokogiri::HTML(patched_resp)
+
+    fields=[]
+    doc.xpath("//a").each{|e| fields.push(e.text)}
+
+    count=0
+    fields.each {|item| loginfo2 "Field: #{item} verified"; count+=1}
+
+    loginfo2 'All information on Circular Buffers link verified' if count >1
+    return true if count >1
+    loginfo2 'All information on Circular Buffers link not verified'
+    return false
+
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out on opening Circular Buffers page...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+    loginfo2 'Unable to verify Circular Buffers information' if retries == 4
+  end
+end
+
+# Private method
+def _mdn_remote_diags_verify_options_on_link stb_ip, link, options
+  retries = 0
+  begin
+    logdebug "Connecting to MDN Remote Diags to verify options on link #{link} for ip #{stb_ip}"
+    patched_resp = "<HTML><BODY>"
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 'Wait for page to open'
+    sleep 5.sec
+    server.cmd("GET #{link} HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+    options.each {|option|
+      loginfo2 "Verifying option : #{option}"
+      unless patched_resp.include?(option)
+        loginfo2 "Option '#{option}' is not present"
+        return false
+      end
+      loginfo2 "Option : #{option} is present"
+    }
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  end
+
+  loginfo2 "Verified all options for link #{link}"
+  return true
+end
+
+def mdn_remote_diags_verify_options option_hash, stb_ip = fetch_ip
+  if stb_ip.nil?
+    loginfo2 'STB does not have IP '
+    return false
+  end
+
+  loginfo2 'Fetching links for all pages'
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  logdebug "Found links : #{options}"
+
+  option_hash.each {|page, values|
+    loginfo2 "Verifying options for page #{page}"
+    if options.has_key?(page)
+      return false unless _mdn_remote_diags_verify_options_on_link(stb_ip, options[page.to_sym],values)
+    else
+      loginfo2 "Link for page #{page} not found"
+      return false
+    end
+  }
+
+  loginfo2 "Verified options on all pages"
+  return true
+end
+
+# Private method
+def _mdn_remote_diags_get_all_code_from_link link, stb_ip = fetch_ip
+  retries = 0
+  patched_resp = ""
+  begin
+    patched_resp = ""
+    server = Net::Telnet::new('Host' => "#{stb_ip}", 'Port' => 8080, 'Telnetmode' => false)
+    loginfo2 "Wait for page to open [#{link}]"
+    sleep 5.sec
+    server.cmd("GET #{link} HTTP/1.1\nHost: #{stb_ip}\n") do |response|
+      patched_resp << response
+    end
+  rescue Timeout::Error
+    loginfo2 'Connection to remote diagnostics Timed Out...'
+    retries += 1
+    loginfo2 "Retry:  #{retries}" if retries < 4
+    retry unless retries == 4
+  end
+  
+  return patched_resp
+end
+
+# Use it to verify if guide catalog was last to load in file operations
+def mdn_remote_diags_verify_last_catalog catalog_name = 'GUIDE', max_time_in_sec = 500
+  bool = false
+  last_row = ''
+  stb_ip = fetch_ip
+
+  (max_time_in_sec/5).times do
+    loginfo2 'Fetching new page'
+    text = _mdn_remote_diags_get_all_code_from_link('/fo',stb_ip)
+
+    doc = Nokogiri::HTML(text)
+    rows = doc.xpath('//tr')
+    paths = rows.collect do |row|
+      row.at_xpath('td[3]/text()').to_s.strip
+    end
+
+    if paths.length == 1
+      break if bool
+    else
+      bool = true
+      last_row = paths[-1]
+    end
+    logdebug "Last path found : #{last_row}"
+
+    sleep 5.sec
+  end
+
+  logdebug "Last row's path value is : #{last_row}"
+  bool = last_row.include?(catalog_name)
+  loginfo2 'Failed to verify if guide was loaded last' unless bool
+  return bool
+end
+
+# Use it to get source of tv player from mdn diags
+# * *Args* :
+#   - +stb_ip+ -> IP address of box
+# * *Returns* :
+#   - source number if source was found, nil otherwise
+def mdn_remote_diags_tv_player_source stb_ip = fetch_ip
+  text = _mdn_remote_diags_get_all_code_from_link('/rs', stb_ip)
+  doc = Nokogiri::HTML(text)
+  rows = doc.xpath('//table[2]/tr')
+  source = nil
+  rows.each do |row|
+    col1 = row.at_xpath('td[1]/text()')
+    logdebug "Row name : #{col1}"
+    unless col1.to_s.include?('er')
+      if row.at_xpath('td[3]/text()').to_s.strip.include?('TV_PLAYER')
+        source = row.at_xpath('td[12]/text()').to_s
+        break
+      end
+    end
+  end
+  loginfo2 'Failed to get source' unless source
+  loginfo2 "Source found: #{source}" if source
+  return source
+end
+
+# Use it to get HDD full status from diags
+# * *Args* :
+#   - +stb_ip+ -> stb ip
+#   - +retries+ -> retries on connection timeout
+# * *Returns* :
+#   - HDD status (String) if successful else nil
+def mdn_remote_diags_get_hdd_status stb_ip = fetch_ip, retries=3
+  begin
+    text = _mdn_remote_diags_get_all_code_from_link('/diags23.html', stb_ip)
+    doc = Nokogiri::HTML(text)
+    status = doc.at_xpath('//table/tr[3]/td').text.scan(/(\d+)%/)[0][0]
+    return status
+  rescue Timeout::Error
+    retries = retries - 1
+    unless retries.eql?(0)
+      loginfo2 "WARNING: Connection timeout... (trying again)"
+      retry
+    end
+    loginfo2 "WARNING: Connection timeout..."
+    return nil
+  rescue StandardError
+    drive_model = doc.at_xpath('//table/tr[4]/td').text.strip.upcase
+    tcinvalid "Disk error : http://#{stb_ip}:8080/diags.html" if drive_model.eql?("NO DISK")
+    return nil
+  end
+end
+
+# Use it to verify whether a tuner numer is on disk
+# * *Args* :
+#   - +tuner_number+ -> Integer(0/1) tuner number
+# * *Returns* :
+#   - true and false if given tuner was on disk or not respectively, nil is case of timeout
+def mdn_remote_diags_verify_tuner_on_disk(tuner_number = 0 )
+  begin
+    text = _mdn_remote_diags_get_all_code_from_link('/rs')
+    doc = Nokogiri::HTML(text)
+    tuner = doc.xpath("//table[1]/tr[#{tuner_number+2}]/td[6]").inner_html
+    loginfo2 "Tuner #{tuner_number} has destination #{tuner}"
+    return tuner.eql?('DISK')
+  rescue Timeout::Error
+    loginfo2 "WARNING: Connection timeout..."
+    return false
+  end
+end
+
+def mdn_remote_diags_source_id stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:network_status],stb_ip)
+  sid = /Source ID:<.*>(\d+|No\sPower)<\/FONT><\/TD><\/TR>/.match(source)
+  if sid.nil?
+    loginfo2 "Source ID not found"
+    return nil
+  end
+  return sid[1]
+end
+
+def mdn_remote_diags_sdv_frequency stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  freq = /SDB Freq<.*>(\d+\.\d+\sMHz)<\/FONT><\/TD><\/TR>/.match(source)
+  if freq.nil?
+    loginfo2 "SDB Freq not found"
+    return nil
+  end
+  return freq[1]
+end
+
+def mdn_remode_diags_stb_sdv_capable? stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  status = /Authorized<.*>(\w+)<\/FONT><\/TD><\/TR>/.match(source)
+  if status.nil?
+    loginfo2 "Authorized not found"
+    return nil
+  end
+  return status[1].casecmp('Yes')==0
+end
+
+def mdn_remote_diags_sdv_packets_sent_recieved stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  packets = /Total\sTx-Rx<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if packets.nil?
+    loginfo2 "Total packets transfered not found"
+    return nil
+  end
+  return packets[1].delete(' ').split('-')
+end
+
+# Use it to verify that each field in diags has a color and that this color is among valid colors
+# * *Args* :
+#   - +valid_codes+ -> Array valid color codes
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - true if verified, else false
+def mdn_remote_diags_verify_color_code_on_each_field valid_codes, stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  counter = 0
+  options.each_value{|link|
+    source = _mdn_remote_diags_get_all_code_from_link(link,stb_ip)
+    page_info = /page\s(\d+)\sof\s(\d+)/.match(source)
+    loginfo2 "Verifying for page [#{page_info[1]}]"
+    fields = source.scan(/<TR><TH ALIGN=RIGHT>(.+)<\/TH><TD>(.+)<\/TD><\/TR>$/)
+    fields.each{|field|
+      unless field[0].eql?('-')
+        color_code = /<FONT COLOR="#(\w+)">.*<\/FONT>/.match(field[1])
+        if color_code.nil?
+          loginfo2 "No color found for field [#{field[0]}]"
+          return false
+        end
+        unless valid_codes.include?(color_code[1])
+          loginfo2 "Unknown color code [#{color_code[1]}] found for field [#{field[0]}]"
+          return false
+        end
+      end
+    }
+    break if page_info[1].eql?(page_info[2])
+  }
+  return true
+end
+
+# Use it to get LUA_Rep_Tx value from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - string if matched else nil
+def mdn_remote_diags_sdv_LUA_Rep_Tx_value stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  value = /LUA\sRep\sTx<.*>(\d*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "LUA Rep Tx not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+# Use it to get SelReq_Tx value from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - string if matched else nil
+def mdn_remote_diags_sdv_SelReq_Tx_value stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  value = /SelReq\sTx<.*>(\d*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "SelReq Tx not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+# Use it to get SelConf_Rx value from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - string if matched else nil
+def mdn_remote_diags_sdv_SelConf_Rx_value stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  value = /SelConf\sRx<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "SelConf Rx not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+#Use it to get current time string from mdn diags from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - time string if value is matched, else nil
+def mdn_remote_diags_current_time_string stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:initialization_status],stb_ip)
+  value = /Current\stime:<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "Current time not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+#Use it to get time stamp from mdn diags from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - time string, else nil
+def mdn_remote_diags_presentation_time_stamp_string stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:mpeg_decoder],stb_ip)
+  value = /Presentation\sTimestamp:<.*>(\d*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "Presentation time stamp not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+#Use it to get secs since read from mdn diags from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - time string, else nil
+def mdn_remote_diags_secs_since_read_string stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:qam_statistics],stb_ip)
+  value = /Secs\sSince\sRead:<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "Secs since read not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+#Use it to get fdc bytes recieved from mdn diags from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - bytes recieved string, else nil
+def mdn_remote_diags_fdc_bytes_received_string  stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:qpsk_statistics],stb_ip)
+  value = /FDC\sBytes\sReceived:<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "FDC bytes recieved not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+# Use it to get SDB_Svc_Group value from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - string if matched else nil
+def mdn_remote_diags_sdb_svc_group_value stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  value = /SDB\sSvc\sGroup<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "SDB Svc Group not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+# Use it to get Registration Time value from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - string if matched else nil
+def mdn_remote_diags_registration_time_value stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  value = /Registration\sTime<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "Registration Time not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+# Use it to get DSMCC SessID value from remote diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - string if matched else nil
+def mdn_remote_diags_dsmcc_sessid_value stb_ip = fetch_ip
+  options = fetch_link_on_mdn_web_diagnostics(stb_ip)
+  source = _mdn_remote_diags_get_all_code_from_link(options[:switched_digital_broadcast],stb_ip)
+  value = /DSMCC\sSessID<.*>(.*)<\/FONT><\/TD><\/TR>/.match(source)
+  if value.nil?
+    loginfo2 "DSMCC SessID not found"
+    return nil
+  end
+  return value[1].to_s
+end
+
+# Use it to get SDV channel change messages
+# * *Returns* :
+#   - list of channel change messages
+# each message is hash that contains index, message_type, data
+# each data element is hash that contains attribute, value (e.g. svcGrpID: 1, client_version: 0, tunerId: 0)
+def mdn_remote_diags_sdv_channel_change_messages stb_ip = fetch_ip
+  retries=3 # Max retries
+  begin
+    text = _mdn_remote_diags_get_all_code_from_link('/sdv', stb_ip)
+    doc = Nokogiri::HTML(text)
+    title_node = doc.xpath("//h2['SDV Channel Change Messages']").last
+    loginfo2 "Fetching data for : #{title_node.text}"
+    result_arr = []
+    title_node.next_sibling.text.scan(/(\d+\/\d+)\s*(\d+:\d+:\d+)\s*\[(\d+)\]\s*(\w*)\s*\(([^\)]*)\)/).each do |data|
+      # Fetch data attributes
+      data_hash = {}
+      data[4].split(",").each do |d1|
+        attr = d1.split(":")
+        data_hash[attr[0].strip.to_sym] = attr[1].strip
+      end
+
+      result_arr.push({
+        :index => data[2].to_i,
+        :message_type => data[3],
+        :data => data_hash
+      })
+    end
+    return result_arr
+  rescue Timeout::Error
+    retries = retries - 1
+    unless retries.eql?(0)
+      loginfo2 "WARNING: Connection timeout... (trying again)"
+      retry
+    end
+    loginfo2 "WARNING: Connection timeout..."
+    return nil
+  end
+end
+
+# Use it to get sdv tuner usage data
+# * *Args*    :
+#   - +stb_ip+ -> ip address of stb
+# * *Returns* :
+#   - Array of tuner status for each tuner
+def mdn_remote_diags_sdv_tuner_usage stb_ip = fetch_ip
+  retries=3 # Max retries
+  begin
+    text = _mdn_remote_diags_get_all_code_from_link('/sdv', stb_ip)
+    doc = Nokogiri::HTML(text)
+    title_node = doc.xpath("//h2").select{|node| node.text == 'SDV Tuner Usage'}[0]
+    loginfo2 "Fetching data for : #{title_node.text}"
+    result_arr = []
+    title_node.next_sibling.text.scan(/Status =(\d+)/).each {|dt|
+      result_arr.push(dt[0].to_i)
+    }
+    return result_arr
+  rescue Timeout::Error
+    retries = retries - 1
+    unless retries.eql?(0)
+      loginfo2 "WARNING: Connection timeout... (trying again)"
+      retry
+    end
+    loginfo2 "WARNING: Connection timeout..."
+    return nil
+  end
+end