#!/usr/bin/tclsh

# Description:
#    - This script is written using IxNetwork low level api
#      because HLT currently isn't supporting Quick Test RFC's yet.
#
#    - All stats will be copied from the Windows C: drive to the local 
#      Linux path where this script is executed.
#
# Note:
#      For back-to-back port experimenting:
#      The QuickTest configuration must configure the port protocol interface and
#      Traffic Items first and then configure the QuickTest.
#      In the QuickTest Traffic Selection, select "Existing Config" to use the
#      Traffic Item because this allows back-to-back ports with ip gateways
#      pointing to the back-to-back ports.
#
# Note that if you want to run your configuration dynamically without having any hardware 
# dependency, you can save your configuration file without chassis and port assignment.
# Then, you can load the configuration and add the chassis and ports as shown below.
package req Ixia

set ixiaChassisIp 10.219.117.101
set ixNetworkTclServer 10.219.117.103
set ixNetworkVersion 7.40

# true or false to reassign ports.
set reassignPorts true
# This variable of ports will be ignored if $reassignPorts is set to false
set remapPorts {{1 5} {1 6}} ;# card port 

# The full path to the config file/configFileName.ixncfg if it is not in the same folder
set ixnConfigFile  /home/hgee/MyIxiaWork/Temp/QuickTest_7.12.ixncfg


proc SendIxNetCmd { commandLine } {
    catch {eval $commandLine} errMsg
    if {$errMsg != "::ixNet::OK"} {
	puts "Error: $errMsg --> $commandLine"
	exit
    } else {
	puts "Info: $errMsg --> $commandLine"
	return $errMsg
    }
}

proc ApplyTraffic {} {
    puts "\nApplying configuration to hardware ..."
    set traffic [ixNet getRoot]traffic

    set stopCounter 10
    for {set startCounter 1} {$startCounter <= $stopCounter} {incr startCounter} {
	catch {ixNet exec apply $traffic} errMsg
	if {$errMsg != "::ixNet::OK" && $startCounter < $stopCounter} {
	    puts "ApplyTraffic warning: Attempting to apply traffic: $startCounter/$stopCounter tries"
	    after 1000
	    continue
	}
	if {$errMsg != "::ixNet::OK" && $startCounter == $stopCounter} {
	    puts "ApplyTraffic error: $errMsg"
	    exit
	}
	if {$errMsg == "::ixNet::OK" && $startCounter < $stopCounter} {
	    puts "Successfully applied traffic to hardware"
	    break
	}
    }
    after 2000
}

proc VerifyPortState { {StopTimer 60} } {
    set portDownList {}
    set stopTime $StopTimer
    puts \n
    foreach vPort [ixNet getList [ixNet getRoot] vport] {
	set port [GetVportConnectedToPort $vPort]
	for {set timer 1} {$timer <= $stopTime} {incr timer} {
	    if {$timer == $stopTime} {
		lappend portDownList $port
	    }

	    if {[ixNet getAttribute $vPort -state] == "up"} {
		puts "Info: VerifyPortState: $port is up"
		break
	    } else {
		puts "VerifyPortState: $port is still not up. Waited $timer/$stopTime seconds"
		after 1000
		continue
	    }
	}
    }

    if {$portDownList != ""} {
	puts "VerifyPortState: Ports can't come up: $portDownList\n"
	exit
    }
    puts "VerifyPortState: All ports are up"
}

proc GetVportConnectedToPort { vport } {
    # ::ixNet::OBJ-/availableHardware/chassis:"10.205.4.35"/card:1/port:1
    set connectedTo [ixNet getAttribute $vport -connectedTo]
    set connectedTo [lrange [split $connectedTo /] 3 4]
    set card [lindex [split [lindex $connectedTo 0] :] end]
    set port [lindex [split [lindex $connectedTo 1] :] end]
    return $card/$port    
}

proc SendArp { vPort } {
    set port [GetVportConnectedToPort $vPort]
    foreach interface [ixNet getList $vPort interface] {

	# Don't send arps on Unconnected (Routed) and GRE interfaces
	set interfaceType [ixNet getAttribute $interface -type]

	if {[regexp "default" $interfaceType]} {
	    set isIntEnabled [ixNet getAttribute $interface -enabled]
	    if {$isIntEnabled == "true" || $isIntEnabled == "True"} {
		puts "SendArp on: $interface"
		
		catch {ixNet exec sendArp $interface} ipv4ErrMsg
		catch {ixNet exec sendNs $interface} ipv6ErrMsg2
		if {$ipv4ErrMsg != "::ixNet::OK" || $ipv6ErrMsg2 != "::ixNet::OK" } {
		    set message "SendArp error on port $port"
		    return [list 0 $message]
		}
	    }
	}
    }
    return [list 1 "Sent arp on $port"]
}

proc SendArpOnAllPorts {} {
    puts \n
    foreach vp [ixNet getList [ixNet getRoot] vport] {
	set arpResult [SendArp $vp]
	if {[lindex $arpResult 0] != 1} {
	    exit
	    #return [list 0 "SendArpOnAllPorts failed"]
	}
    }
    after 2000
    return [list 1 "SendArponAllPorts passed"]
}

proc VerifyArpDiscoveries { {ExitTest doNotExitTest} } {
    # First, get a list of all the expected Gateway IP addresses for this vPort.
    # Get only if the interface is enabled. We don't care about gateways if the
    # interface isn't enable.
    # Then get a list of all the discovered arps.
    # At the end, compare the two list. Any left overs are unresolved arps.
    
    set resolvedArp {}
    set allIpGateways {}

    foreach vP [ixNet getList [ixNet getRoot] vport] {
	# Refresh the arp table on this vport first
	ixNet execute refreshUnresolvedNeighbors $vP

	set currentVportInterfaceList [ixNet getList $vP interface]

	foreach int $currentVportInterfaceList {

	    # Ignore the Unconnected (Routed), and GRE interfaces
	    set interfaceType [ixNet getAttribute $int -type]

	    if {[regexp "default" $interfaceType]} {
		# Only lappend the Gateway if the Interface is enabled.
		set isIntEnabled [ixNet getAttribute $int -enabled]
		if {$isIntEnabled == "true" || $isIntEnabled == "True"} {
		    catch {ixNet getAttribute $int/ipv4 -gateway} ipv4GatewayReturn
		    
		    if {[regexp "null" $ipv4GatewayReturn] != 1} {
			if {[lsearch $allIpGateways $ipv4GatewayReturn] == -1} {
			    lappend allIpGateways $ipv4GatewayReturn
			}
		    }
		    
		    catch {ixNet getList $int ipv6} ipv6GatewayList
		    if {$ipv6GatewayList != ""} {
			foreach ipv6Gateway $ipv6GatewayList {
			    set ipv6 [ixNet getAttribute $ipv6Gateway -gateway]
			    
			    if {$ipv6 != "0:0:0:0:0:0:0:0"} {
				if {[lsearch $allIpGateways $ipv6] == -1} {
				    lappend allIpGateways $ipv6
				}
			    }
			}
		    }
		}
	    }
	}
    }

    puts "Expected ARPs to be resolved:\n"
    foreach arp $allIpGateways {
	puts "\t$arp"
    }
    puts \n

    foreach vP [ixNet getList [ixNet getRoot] vport] {
	# Get all the discovered ARPs for the current vPort
	set vPortInterfaceList [ixNet getList $vP discoveredNeighbor]
	
	if {$vPortInterfaceList != ""} {
	    set currentPort [GetVportConnectedToPort $vP]

	    # vPortInt = ::ixNet::OBJ-/vport:1/discoveredNeighbor:1
	    foreach vPortInt $vPortInterfaceList {
		set currentVp [join [lrange [split $vPortInt /] 0 1] /]
		
		set discoveredIp [ixNet getAttribute $vPortInt -neighborIp]
		set discoveredMac [ixNet getAttribute $vPortInt -neighborMac]
		
		puts "Discovered arp on $currentPort: $discoveredIp : $discoveredMac"
		
		if {$discoveredMac != "" || $discoveredMac != "00:00:00:00:00:00"} {
		    if {[lsearch $allIpGateways $discoveredIp] != -1} {
			lappend resolvedArp $discoveredIp
		    }
		}
	    }
	}
    }

    # Now compare the expected list of arps with what is resolved.
    # Any left overs are unresovled arps.
    foreach resolvedGateway $resolvedArp {
	if {[lsearch $allIpGateways $resolvedGateway] != -1} {
	    set index [lsearch $allIpGateways $resolvedGateway]
	    set allIpGateways [lreplace $allIpGateways $index $index]
	}
    }

    if {$allIpGateways != ""} {
	foreach unresolvedArp $allIpGateways {
	    puts "\tError: Unresolved Arp: $unresolvedArp"
	}
	exit
    } else {
	puts "All arps are resolved"
    }
}

proc GetStatView { statType {getStatsBy trafficItem} } {
    # $statType is one of the following statistics
    # $viewList: 
    # {::ixNet::OBJ-/statistics/view:"Port Statistics"} 
    # {::ixNet::OBJ-/statistics/view:"Tx-Rx Frame Rate Statistics"} 
    # {::ixNet::OBJ-/statistics/view:"Port CPU Statistics"} 
    # {::ixNet::OBJ-/statistics/view:"Global Protocol Statistics"}
    # {::ixNet::OBJ-/statistics/view:"Flow Statistics"} 
    # {::ixNet::OBJ-/statistics/view:"Flow Detective"}  
    # {::ixNet::OBJ-/statistics/view:"Data Plane Port Statistics"} 
    # {::ixNet::OBJ-/statistics/view:"User Defined Statistics"} 
    # {::ixNet::OBJ-/statistics/view:"Traffic Item Statistics"}
    set viewList [ixNet getList [ixNet getRoot]/statistics view]
    #puts "\nviewList: $viewList\n"

    set statViewSelection $statType

    set flowStatsViewIndex [lsearch -regexp $viewList $statViewSelection]
    if {$flowStatsViewIndex == -1} {
	puts "ViewStats: No \"$statViewSelection\" found"
	exit
    }

    # $view: ::ixNet::OBJ-/statistics/view:"Flow Statistics"
    set view [lindex $viewList $flowStatsViewIndex]

    # New way of getting stats. Andy thinks he implemented this in 6.30.
    # If not 6.30, then 7.0
    # ixNet -strip exec getValue $statView "10.205.4.35/Card01/Port01" "Stat Name"
    #   10.205.4.35/Card01/Port01

    ixNet setAttribute $view -enabled true
    ixNet commit

    # $columnList:
    # {Tx Port} {Rx Port} {Traffic Item} {Ethernet II:Destination MAC Address} {Ethernet II:Source MAC Address} {Ethernet II:Ethernet-Type} {Ethernet II:PFC Queue} {IPv4 :Precedence} {IPv4 :Source Address} {IPv4 :Destination Address} {Custom Tracking: Byte Offset 0} {Source/Dest Endpoint Pair} {Source/Dest Value Pair} {Source/Dest Port Pair} {Source Endpoint} {Source Port} {Dest Endpoint} {Frame Size} {Flow Group} {Traffic Group ID} {Tx Frames} {Rx Frames} {Frames Delta} {Loss %} {Tx Frame Rate} {Rx Frame Rate} {Rx Bytes} {Tx Rate (Bps)} {Rx Rate (Bps)} {Tx Rate (bps)} {Rx Rate (bps)} {Tx Rate (Kbps)} {Rx Rate (Kbps)} {Tx Rate (Mbps)} {Rx Rate (Mbps)} {Store-Forward Avg Latency (ns)} {Store-Forward Min Latency (ns)} {Store-Forward Max Latency (ns)} {First TimeStamp} {Last TimeStamp}
    
    set columnList [ixNet getAttribute ${view}/page -columnCaptions]
    #puts "\nColumnList: $columnList\n"

    set startTime 1
    set stopTime 30
    while {$startTime < $stopTime} {
	set totalPages [ixNet getAttribute $view/page -totalPages]
	if {[regexp -nocase "null" $totalPages]} {
	    puts "Getting total pages for $view is not ready. $startTime/$stopTime"
	    after 2000
	} else {
	    break
	}
    }
    
    # Iterrate through each page 
    for {set currPage 1} {$currPage <= $totalPages} {incr currPage} {
	catch {ixNet setAttribute $view/page -currentPage $currPage} errMsg
	if {$errMsg != "::ixNet::OK"} {
	    puts "GetResults: Failed to get statistic for current page."
	    exit
	}
	ixNet commit
	
	# Wait for statistics to populate on current page
	set whileLoopStopCounter 0
	while {[ixNet getAttribute $view/page -isReady] != "true"} {
	    if {$whileLoopStopCounter == "5"} {
		puts "ViewStats: Could not get stats"
		exit
	    }
	    if {$whileLoopStopCounter < 5} {
		puts "\nViewStats: Not ready yet.  Waiting $whileLoopStopCounter/5 seconds ..."
		after 1000
	    }
	    incr whileLoopStopCounter
	}
	
	set pageList [ixNet getAttribute $view/page -rowValues] ;# first list of all rows in the page
	set totalFlowStatistics [llength $pageList]

	# totalPageList == The total amount of flow statistics
	for {set pageListIndex 0} {$pageListIndex <= $totalFlowStatistics} {incr pageListIndex} {
	    set rowList [lindex $pageList $pageListIndex] ;# second list of 1 ingress and x egress rows
	    #puts "\nrowList: $rowList\n"

	    for {set rowIndex 0} {$rowIndex < [llength $rowList]} {incr rowIndex} {
		# cellList: 1/1/1 1/1/2 TI0-Flow_1 1.1.1.1-1.1.2.1 4000 4000 0 0 0 0 256000 0 0 0 0 0 0 0 0 0 0 0 00:00:00.684 00:00:00.700
		set cellList [lindex $rowList $rowIndex] ;# third list of cell values
		
		#puts "\n--- cellList $pageListIndex: $cellList ---\n"

		if {$statViewSelection == "Port Statistics"} {
		    # 10.205.4.35/Card01/Port01
		    set portIndex [lsearch  $columnList "Stat Name"]
		    set port [lindex $cellList $portIndex]
		    set cardNum [string range [lindex [split $port /] 1] 4 end]
		    set portNum [string range [lindex [split $port /] 2] 4 end]

		    foreach column $columnList item $cellList {
			if {[regexp "Link State" $column]} {
			    keylset getStats port.$cardNum/$portNum.linkState $item
			}
			if {[regexp "Misdirected" $column]} {
			    keylset getStats port.$cardNum/$portNum.misdirectedPktCount $item
			}
			if {[regexp "CRC" $column]} {
			    keylset getStats port.$cardNum/$portNum.crcError $item
			}
		    }
		}

		if {$statViewSelection == "Flow Statistics" || $statViewSelection == "Traffic Item Statistics" || $statViewSelection == "Flow Detective"} {
		    # Get the Traffic Item name
		    set trafficItemIndex [lsearch $columnList "Traffic Item"]
		    if {$trafficItemIndex == -1} {
			set trafficItem "UnknownTrafficItem $pageListIndex"
		    } else {
			set trafficItem [lindex $cellList $trafficItemIndex]
		    }
		    
		    # Get the Flow Group
		    set flowGroupIndex [lsearch $columnList "Flow Group"]
		    if {$flowGroupIndex == -1} {
			set flowGroup "$pageListIndex"
		    } else {
			# Flow Group 0008
			set flowGroup [lindex [lindex $cellList $flowGroupIndex] end]
		    }
		    
		    set rxPortIndex [lsearch $columnList "Rx Port"]
		    set rxPort [lindex $cellList $rxPortIndex]
		    
		    foreach column $columnList item $cellList {
			if {[regexp "VLAN:VLAN Priority" $column]} {
			    set column "Vlan Priority"
			}
			
			if {[regexp "VLAN:VLAN-ID" $column]} {
			    set column "Vlan ID"
			}
			
			if {$getStatsBy == "trafficItem"} {
			    if {[regexp "Traffic Item" $column] == 0} {
				keylset getStats trafficItem.[join $trafficItem _].flowGroup.Flow_Group_$flowGroup.[join $column _] $item
			    }
			}
			
			if {$getStatsBy == "port"} {
			    if {[regexp "Rx Port" $column] == 0} {
				keylset getStats rxPort.$rxPort.trafficItem.[join $trafficItem _].[join $column _] $item
			    }
			}
		    }
		}
	    }
	}
    }

    return $getStats
}

proc KeylPrint {keylist {space ""}} {
    upvar $keylist kl
    set result ""
    foreach key [keylkeys kl] {
	set value [keylget kl $key]
	if {[catch {keylkeys value}]} {
	    append result "$space$key: $value\n"
	} else {
	    set newspace "$space "
	    append result "$space$key:\n[KeylPrint value $newspace]"
	}
    }
    return $result
}

SendIxNetCmd "ixNet connect $ixNetworkTclServer -version $ixNetworkVersion"

# This will clear the old configs
SendIxNetCmd "ixNet rollback"
SendIxNetCmd "ixNet execute newConfig"
set root [ixNet getRoot]

# Load previously saved configuration, make sure to provide the full path to the
# IxNetwork config file, if the file is not in the same folder as this script
SendIxNetCmd "ixNet exec loadConfig [ixNet readFrom $ixnConfigFile]"

# Uncomment this out if you want to reassign ports and 
# not want to use the saved config ports.
if {$reassignPorts == "true"} {
    puts "\nResassigning ports\n"
    # Add the chassis here
    set sg_chassis [ixNet add $root/availableHardware chassis]
    # ::ixNet::OBJ-/availableHardware/chassis:L13
    if {[regexp "/availableHardware/chassis:L\[0-9]+" $sg_chassis] == 0} {
	puts "Error: $errMsg"
	exit
    }
    
    SendIxNetCmd "ixNet setAttribute $sg_chassis -hostname $ixiaChassisIp"
    puts "Please wait 40 seconds for all ports to reboot ..."
    SendIxNetCmd "ixNet commit"
    
    # Physical port list
    set portList {}
    # set portList [list [list $ixiaChassisIp $card $port1] [list $ixiaChassisIp $card $port2]]
    foreach port $remapPorts {
	lappend portList [list $ixiaChassisIp [lindex $port 0] [lindex $port 1]]
    }

    # Virtual port list from the config file
    set vPortList [ixNet getList $root vport]
    
    # This will assign the virtual ports to the actual ports
    #  ::ixNet::OBJ-/vport:1 ::ixNet::OBJ-/vport:2
    catch {ixTclNet::AssignPorts $portList {} $vPortList true} errMsg
    puts "Info: Assigned ports: $errMsg"
}


ApplyTraffic
VerifyPortState

# ::ixNet::OBJ-/quickTest
set quickTest [ixNet getList $root quickTest]
if {[regexp "::ixNet::OBJ-/quickTest" $quickTest] == 0} {
    puts "Error: quickTest"
    exit
}


# ::ixNet::OBJ-/quickTest/rfc2544throughput:1
set throughputList [ixNet getList $quickTest rfc2544throughput]

if {[regexp "::ixNet::OBJ-/quickTest/rfc2544throughput:\[0-9]+" $throughputList] == 0} {
    puts "Error: throughputList"
    exit
}

set test1 [lindex $throughputList 0]

# ixNet exec apply ::ixNet::OBJ-/quickTest/rfc2544throughput:1
SendIxNetCmd "ixNet exec apply $test1"

SendArpOnAllPorts
VerifyArpDiscoveries

puts "\n==== RFC test: $test1 ====\n"

# ixNet exec start ::ixNet::OBJ-/quickTest/rfc2544throughput:1
SendIxNetCmd "ixNet exec start $test1"

# ixNet getAttribute $test1/results ...
#   Attributes:
#     -duration (readOnly=True, type=kString)
#     -isRunning (readOnly=True, type=kBool)
#     -progress (readOnly=True, type=kString)
#     -result (readOnly=True, type=kString)
#     -resultPath (readOnly=True, type=kString)
#     -startTime (readOnly=True, type=kString)
#     -status (readOnly=True, type=kString)
#
# Right after exec start
#   -duration 
#   -isRunning true
#   -progress -progress Trial 1/1 Iteration 1, Size 64, Rate 10 % 
#   -result 
#   -resultPath C:\Users\hgee\AppData\Local\Ixia\IxNetwork\data\result\DP.Rfc2544Tput\eb2465e5-b0ca-4160-81fc-1fda223554f4\Run0001
#   -startTime 06/06/13 15:05:11
#   -status none
#
# When QT is complete
#    -duration 00:04:54
#    -isRunning false
#    -progress 
#    -result pass
#    -resultPath C:\Users\hgee\AppData\Local\Ixia\IxNetwork\data\result\DP.Rfc2544Tput\eb2465e5-b0ca-4160-81fc-1fda223554f4\Run0001
#    -startTime 06/06/13 15:05:11
#    -status none



# Remove all the previous QuickTest results
foreach quickTestResultFiles {QuickTest_iteration.csv QuickTest_results.csv QuickTest_logFile.txt} {
    catch {exec rm $quickTestResultFiles} errMsg
}

for {set i 0} {$i <= 180} {incr i} {
    if {$i == "180"} {
	puts "Waited for 3 minutes and $test1 can't seem to come up. Exiting."
	exit
    }
    set progress [ixNet getAttribute $test1/results -progress]
    # When we see "Iteration", means the QT has started
    if {[regexp "Iteration" $progress] == 0} {
	puts "Quick Test is not ready yet .... $i/180"
	after 1000
    } else {
	break
    }
}

set resultPath [ixNet getAttribute $test1/results -resultPath]
puts "\nReading results from: $resultPath\n"

set attributeList {-duration -isRunning -progress -result -resultPath -startTime -status}
foreach attrib $attributeList {
    puts "$attrib [ixNet getAttribute $test1/results $attrib]"
}

set isThereQtLogFileFlag 0
# Progress: complete
#           Trial 1/1 Iteration 7, Size 64, Rate 98.594 % Transmitting frames for 10 seconds
#           Trial 1/1 Iteration 7, Size 64, Rate 98.594 % Wait for 8 seconds Wait 35.0770073%complete
#           Trial 1/1 Iteration 7, Size 64, Rate 98.594 %
# 
while {1}  {
    set progress [ixNet getAttribute $test1/results -progress]
    set status [ixNet getAttribute $test1/results -status]
    puts "Progress: $progress ; Status: $status"
    
    #catch {ixNet exec copyFile [ixNet readFrom $resultPath\\iteration.csv -ixNetRelative] [ixNet writeTo QuickTest_iteration.csv -overwrite]} errMsg
    
    #catch {ixNet exec copyFile [ixNet readFrom $resultPath\\results.csv -ixNetRelative] [ixNet writeTo QuickTest_results.csv -overwrite]} errMsg
    
    # Sometimes the QT logFile takes a little longer to get generated.
    # Must wait until the first iteration is done so there is a logFile result
    if {$isThereQtLogFileFlag == 0} {
	set timeStop 180
	for {set timer 0} {$timer <= $timeStop} {incr timer 2} {
	    set progress [ixNet getAttribute $test1/results -progress]
	    set status [ixNet getAttribute $test1/results -status]

	    catch {ixNet exec copyFile [ixNet readFrom $resultPath\\logFile.txt -ixNetRelative] [ixNet writeTo QuickTest_logFile.txt -overwrite]} errMsg
	    
	    catch {exec ls QuickTest_logFile.txt} isThereQtLogFile
	    
	    if {[regexp "No such file" $isThereQtLogFile]} {
		puts "No QuickTest logFile generated yet. Waiting $timer/$timeStop seconds"
		after 2000
	    }
	    if {[regexp "No such file" $isThereQtLogFile] == 0} {
		puts "QuickTest logFile is generated on the IxNet Tcl server"
		set isThereQtLogFileFlag 1
		break
	    }
	    if {$timer == $timeStop && $isThereQtLogFileFlag == 0} {
		puts "IxNet Tcl Server failed to generate the QT logFile on..."
		puts "$resultPath.  Exiting test"
		exit
	    }	    
	}
    }

    catch {ixNet exec copyFile [ixNet readFrom $resultPath\\iteration.csv -ixNetRelative] [ixNet writeTo QuickTest_iteration.csv -overwrite]} iterationCsvFileMsg
    
    catch {ixNet exec copyFile [ixNet readFrom $resultPath\\logFile.txt -ixNetRelative] [ixNet writeTo QuickTest_logFile.txt -overwrite]} errMsg

    # Uncomment this if you want iteration stats.
    # These are the same thing as keylget
    if 0 {
	if {$iterationCsvFileMsg == "::ixNet::OK"} {
	    set iterationStats [exec cat QuickTest_iteration.csv]
	    set fileId [open QuickTest_logFile.txt]
	    set fileContents [read $fileId]
	    close $fileId
	    foreach iterationLine [split $iterationStats \n] {
		# I could get any of the following stats from the iteration file
		# Trial,Framesize,Iteration,Tx Port,Rx Port,Traffic Item,IPv4 :Precedence,Flow Group,Tx Rate (% Line Rate),Rx Throughput (% Line Rate),Rx Throughput (fps),Rx Throughput (Mbps),Tx Count (frames),Rx Count (frames),Frame Loss (frames),Frame Loss (%),Min Latency (ns),Max Latency (n),Avg Latency (ns)
	    }
	}
    }

    set currentLogFile [exec cat QuickTest_logFile.txt]
    #puts \n$currentLogFile\n
    set statView [GetStatView "Port Statistics"]
    puts \n[KeylPrint statView]\n
    set statView [GetStatView "Flow Statistics"]
    puts \n[KeylPrint statView]\n

    set fileId [open QuickTest_logFile.txt]
    set fileContents [read $fileId]
    close $fileId

    foreach line [split $fileContents \n] {
	# BINARY iteration 1, Trial 1, Frame Size 64,  Rate  10 % RFC 2544 Throughput test, Started 4:48:15 PM
	# BINARY iteration 2, Trial 1, Frame Size 64,  Rate  55 % RFC 2544 Throughput test, Started 4:48:45 PM
	# BINARY iteration 3, Trial 1, Frame Size 64,  Rate  77.5 % RFC 2544 Throughput test, Started 4:49:16 PM
	# BINARY iteration 4, Trial 1, Frame Size 64,  Rate  88.75 % RFC 2544 Throughput test, Started 4:49:46 PM
	# BINARY iteration 5, Trial 1, Frame Size 64,  Rate  94.375 % RFC 2544 Throughput test, Started 4:50:16 PM
	# BINARY iteration 6, Trial 1, Frame Size 64,  Rate  97.188 % RFC 2544 Throughput test, Started 4:50:45 PM
	# BINARY iteration 7, Trial 1, Frame Size 64,  Rate  98.594 % RFC 2544 Throughput test, Started 4:51:15 PM
	# BINARY iteration 8, Trial 1, Frame Size 64,  Rate  99.297 % RFC 2544 Throughput test, Started 4:51:45 PM
	# BINARY iteration 9, Trial 1, Frame Size 64,  Rate  100 % RFC 2544 Throughput test, Started 4:52:15 PM
	# 06/06/2013 16:52:44: Ethernet - 001 :  Total frames transmitted: 14880952
	# 06/06/2013 16:52:44: 
	# 06/06/2013 16:52:44: Collecting receive statistics ...
	# 06/06/2013 16:52:44: Ethernet - 002 :  Total frames received: 14880952
	
	# 06/06/2013 16:52:44: Tx Port   Rx Port  Traffic Item  Flow Group  Tx Rate (% Line Rate) Rx Throughput (% Line Rate)  Rx Throughput (fps)  Rx Throughput (Mbps)  Tx Count (frames)  Rx Count (frames)  Frame Loss (frames)  Frame Loss (%)  Min Latency (ns)  Max Latency (ns)  Avg Latency (ns)  
	#06/06/2013 16:52:44: ********************************************************************************************************************************************************************************************************************************************************************************************************************************
	#06/06/2013 16:52:44: Ethernet - 001  Ethernet - 002  Traffic Item 1  Traffic Item 1-EndpointSet-1 - Flow Group 0001  100.000                100.000                      1488095.213          761.905               14880952           14880952           0                    0.000           640               680               652  

	if {[regexp "BINARY *iteration *(\[0-9]+), *Trial *(\[0-9]+), *Frame *Size *(\[0-9]+), *Rate *(\[0-9]+).*Started *(\[0-9]+.*)" $line - iteration trial frameSize rate startTime]} {
	    puts "\nIteration $iteration, Trial $trial, FrameSize $frameSize, Rate $rate%, StartTime $startTime"
	}
	
	if 0 {
	    # 06/06/2013 16:52:44: Ethernet - 001 :  Total frames transmitted: 14880952
	    if {[regexp "\[0-9]+/\[0-9]+/\[0-9]+ *(\[0-9:]+) *(.*) : *Total *frames *transmitted: *(\[0-9]+)" $line - startTime portName totalTx]} {
		puts "\t$startTime $portName TotalTx: $totalTx"
	    }
	    # 06/06/2013 16:52:44: Ethernet - 002 :  Total frames received: 14880952
	    if {[regexp "\[0-9]+/\[0-9]+/\[0-9]+ *(\[0-9:]+) *(.*) : *Total *frames *received: *(\[0-9]+)" $line - startTime portName totalRx]} {
		puts "\t$startTime $portName TotalRx: $totalRx"
	    }
	}
    }

    set progress [ixNet getAttribute $test1/results -progress]
    puts "\n--- Current progress: $progress ---\n"
    if {[regexp "Trial" $progress] == 0 || [regexp "^complete" $progress]} {
	puts "Progress: Quick Test has stopped."
	break
    } else {
	puts "Sleeping 20 seconds ..."
	after 20000
    }
}

# All statistic logs are copied from the C: drive to the local Linux path
# where this script was executed.
ixNet exec copyFile [ixNet readFrom $resultPath\\iteration.csv -ixNetRelative] [ixNet writeTo QuickTest_iteration.csv -overwrite]
ixNet exec copyFile [ixNet readFrom $resultPath\\results.csv -ixNetRelative] [ixNet writeTo QuickTest_results.csv -overwrite]
ixNet exec copyFile [ixNet readFrom $resultPath\\logFile.txt -ixNetRelative] [ixNet writeTo QuickTest_logFile.txt -overwrite]


if 0 {
    set waitForTest [ixNet exec waitForTest $test1]
}


# TODO:  VerifyTrafficStatus

# You need to call this in the loop to get the status when the test is complete 
# or stopped before you run the next test
# ::ixNet::OK-{kArray,{{kString,isRunning},{kString,False},{kString,status},{kString,The execution was aborted.},{kString,result},{kString,fail},{kString,resultPath},{kString,C:\Users\hgee\AppData\Local\Ixia\IxNetwork\data\result\DP.Rfc2544Tput\c5f38e39-17a8-47f2-a3c8-9a82ebf4d274\Run0001}}}

#catch {ixNet exec waitForTest $test1} errMsg
#puts "\nInfo: waitForTest: $errMsg"


# or if you want to run all the rfc2544throughput tests, do as follows

#foreach test $throughputList {

#    ixNet exec apply $test
#     after 5000
#    ixNet exec waitForTest $test1
#}