#!/usr/bin/env python
################################################################################
#\defgroup difxmessages DiFXMessages
#
#\brief Echo UDP message traffice from DiFX Processes  
#
#Usage: <b><code>DiFXMessages [options] [list of message types]</code></b>
#
#  <i>DiFXMessages</i> collects an echos UDP message traffic intercepted
#  on the DiFX server.  Messages are printed in their raw XML form and/or
#  parsed into component content. Desired message traffic can be limited to a
#  message type (specified by name or a number), source hostname(s), or 
#  message identifier (which is often a DiFX job name).  By default ALL traffic is echoed.
#
#  <h3>Command Line Arguments</h3>
#
#  <table border="0" cellspacing="25">
#  <tr><td><pre><b>-h, --help</b></pre>                   <td>Print help information and quit.
#  <tr><td><pre><b>-H, --hostname <i>NAME</i></b></pre>   <td>Use <i>NAME</i> as the host of the DiFX server program.
#                                                          Default is to use DIFX_CONTROL_HOST environment variable.
#  <tr><td><pre><b>-i, --identifier <i>NAME</i></b></pre> <td>Echo only messages with the named identifier.  This is (often)
#                                                          the DiFX job name, so this option can be used to monitor a
#                                                          job or jobs to some degree.  The named identifier is a regular
#                                                          expression, so multiple jobs can be matched.
#  <tr><td><pre><b>-p, --parse</b></pre>                  <td>Toggle whether to parse XML messages into a readable format.
#                                                          Default is to do so.
#  <tr><td><pre><b>-P, --port <i>PORT</i></b></pre>       <td>Use <i>PORT</i> as the TCP port to communicated with the DiFX server.
#                                                          Default is to use DIFX_CONTROL_PORT environment variable.
#  <tr><td><pre><b>-r, --raw</b></pre>                    <td>Toggle whether to echo \"raw\" XML message strings.  Default is
#                                                          to do so.
#  <tr><td><pre><b>-R, --restrict</b></pre>               <td>Tell difxServer to restrict messages it sends to those types
#                                                          Selected.  This can cut down on socket traffic, however currently
#                                                          not all message types are supported.  As a consequence this
#                                                          feature is off by default.
#  <tr><td><pre><b>-s, --source <i>LIST</i></b></pre>     <td>Echo only messages originating from one of the comma-separated LIST
#                                                          of node names.  Default is to echo all sources.
#  <tr><td><pre><b>-S, --stats</b></pre>                  <td>Toggle whether to produce a list of statistics (messages received, etc.)
#                                                          when collection is terminated.  Default is not to do so.
#  <tr><td><pre><b>-t, --type <i>LIST</i></b></pre>       <td>Indicate the following items are a list of message types you wish to
#                                                          echo.  This isn't an explicitly required argument, as the list can be
#                                                          included as the final argument(s) - seem below.
#  </table>
#
#  <h4>list of message types</h4>
#
#  The "list of message types" that follows command line arguments is a comma-separated list of one or more message
#  types, identified either by name or number.  Default behavior (when you list nothing) is to echo all messages.
#  Legal message numbers and types are:
#
#  <table>
#  <tr><td><b>Type Number<td>Type Name</b>
#  <tr><td>1 <td>DifxLoadMessage
#  <tr><td>2 <td>DifxAlertMessage
#  <tr><td>3 <td>Mark5StatusMessage
#  <tr><td>4 <td>DifxStatusMessage
#  <tr><td>5 <td>DifxInfoMessage
#  <tr><td>6 <td>DifxDatastreamMessage
#  <tr><td>7 <td>DifxCommand
#  <tr><td>8 <td>DifxParameter
#  <tr><td>9 <td>DifxStart
#  <tr><td>10 <td>DifxStop
#  <tr><td>11 <td>Mark5VersionMessage
#  <tr><td>12 <td>Mark5ConditionMessage
#  <tr><td>13 <td>DifxTransientMessage
#  <tr><td>14 <td>DifxSmartMessage
#  <tr><td>15 <td>Mark5DriveStatsMessage
#  <tr><td>16 <td>DifxDiagnosticMessage
#  <tr><td>17 <td>DifxFileTransfer
#  <tr><td>18 <td>DifxFileOperation
#  <tr><td>19 <td>DifxVex2DifxRun
#  <tr><td>20 <td>DifxMachinesDefinition
#  <tr><td>21 <td>DifxGetDirectory
#  <tr><td>22 <td>DifxMk5Control
#  <tr><td>23 <td>DifxMark5Copy
#  </table>
#
################################################################################
program = 'DiFXMessages'
version = '0.1'
author  = 'John Spitzak'
verdate = '20150602'

import sys
import time
import DiFXControl
import xml.parsers.expat
import re

#===============================================================================
#  Class to monitor callbacks from the Client class and act on them.
#===============================================================================
class Responder:
	
	def __init__( self ):
		self.keepGoing = True
		self.parseXML = True
		self.rawXML = True
		self.echoAllMessages = True
		self.echoAllSources = True
		self.identifierRE = None
		self.messageTypes = []
		self.echoSources = []
		self.receivedInfo = {}
	
	#---------------------------------------------------------------------------	
	#  Callback triggered when the monitoring client receives a new DiFX message.
	#---------------------------------------------------------------------------	
	def messageCallback( self, data ):
		#  Parse the message.
		try:
			xmlDat = DiFXControl.parseXML( data )
			#  Add the information about the received message types to the dictionary.
			#  This is rather complex - the dictionary contains a message type as a key,
			#  and then a list of other info, including the total number of messages,
			#  the total number of bytes, then another dictionary keyed by sending
			#  node.
			#  See if this message type exists already in the dictionary.
			try:
				messList = self.receivedInfo[ xmlDat.typeStr ]
			except KeyError:
				#  Create a new list entry
				messList = []
				messList.append( 0 )
				messList.append( 0 )
				messList.append( {} )
				self.receivedInfo[ xmlDat.typeStr ] = messList
			#  Add the information from this type to the list
			messList[0] += 1
			messList[1] += len( data )
			#  See if this is a message type we are interested in.
			if self.echoAllMessages or xmlDat.typeStr in self.messageTypes:
				#  See if it is from a source we are interested in.
				if self.echoAllSources or xmlDat.fromNode in self.echoSources:
					if self.identifierRE == None or self.identifierRE.match( xmlDat.identifier ) != None:
						if self.rawXML:
							print(data)
						if self.parseXML:
							print("")
							print("Message Type:          ", xmlDat.typeStr)
							print("From:                  ", xmlDat.fromNode)
							print("Identifier:            ", xmlDat.identifier)
							print("MPI Process ID:        ", xmlDat.mpiProcessId)
							print("Sequence Number:       ", xmlDat.seqNumber)
							if xmlDat.typeStr == "DifxLoadMessage":
								print("")
								print("CPU Load:              ", xmlDat.cpuLoad)
								print("Total Memory:          ", xmlDat.totalMemory)
								print("Used Memory:           ", xmlDat.usedMemory)
								print("Net Receive Rate:      ", xmlDat.netRXRate)
								print("Net Transmit Rate:     ", xmlDat.netTXRate)
								print("Number of Cores:       ", xmlDat.nCore)
							elif xmlDat.typeStr == "DifxAlertMessage":
								print("")
								print("Input File:            ", xmlDat.inputFile)
								print("Alert Message:         ", xmlDat.alertMessage)
								print("Severity:              ", xmlDat.severity)
							elif xmlDat.typeStr == "Mark5StatusMessage":
								print("")
								print("Input File:            ", xmlDat.inputFile)
								print("BankA VSN:             ", xmlDat.bankAVSN)
								print("BankB VSN:             ", xmlDat.bankBVSN)
								print("Status Word:           ", xmlDat.statusWord)
								print("Active Bank:           ", xmlDat.activeBank)
								print("State:                 ", xmlDat.state)
								print("Scan Number:           ", xmlDat.scanNumber)
								print("Scan Name:             ", xmlDat.scanName)
								print("Position:              ", xmlDat.position)
								print("Play Rate:             ", xmlDat.playRate)
							elif xmlDat.typeStr == "DifxStatusMessage":
								print("")
								print("Input File:            ", xmlDat.inputFile)
								print("State:                 ", xmlDat.state)
								print("Message:               ", xmlDat.message)
								print("Visibility MJD:        ", xmlDat.visibilityMJD)
								print("Job Start MJD:         ", xmlDat.jobstartMJD)
								print("Job Stop MJD:          ", xmlDat.jobstopMJD)
								if len( xmlDat.weights ) > 0:
									print("Weights:               ")
									for wt in xmlDat.weights:
										print("    Antenna:           ", wt[0])
										print("    Weight:            ", wt[1])
							elif xmlDat.typeStr == "DifxInfoMessage":
								print("")
								print("Message:               ", xmlDat.message)
							elif xmlDat.typeStr == "DifxCommandMessage":
								print("")
								print("Command:               ", xmlDat.command)
							elif xmlDat.typeStr == "DifxParameter":
								print("")
								print("Target MPI ID:         ", xmlDat.targetMpiId)
								print("Name:                  ", xmlDat.name)
								print("Value:                 ", xmlDat.value)
								for k in list(xmlDat.index.keys()):
									newStr = "Index" + xmlDat.index[k] + ":"
									while len( newStr ) < len( "                       " ):
										newStr += " "
									print(newStr)
							elif xmlDat.typeStr == "DifxStart":
								print("")
								print("input:                 ", xmlDat.inputFile)
								print("Head Node:             ", xmlDat.manager) 
								if len( xmlDat.datastream ) > 0:
									print("Data Streams")
									for node in xmlDat.datastream:
										print("    " + node)
								if len( xmlDat.process ) > 0:
									print("Processors                         Threads")
									for node in xmlDat.process:
										newStr = "    " + node[0]
										while len( tmpStr ) < len( "Processors                         " ):
											newStr += " "
										newStr += str( node[1] )
										print(newStr)
								print("Force:                 ", xmlDat.force)
								print("DiFX Version:          ", xmlDat.difxVersion)
								print("Restart Seconds:       ", xmlDat.restartSeconds)
								print("Function:              ", xmlDat.function)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
							elif xmlDat.typeStr == "DifxStop":
								print("Input File:            ", xmlDat.inputFile)
								print("MPI Wrapper:           ", xmlDat.mpiWrapper)
								print("DiFX Version:          ", xmlDat.difxVersion)
								print("DiFX Program:          ", xmlDat.difxProgram)
							elif xmlDat.typeStr == "DifxTransientMessage":
								print("")
								print("Job ID:                ", xmlDat.jobId)
								print("Start MJD:             ", xmlDat.startMJD)
								print("Stop MJD:              ", xmlDat.stopMJD)
								print("Priority:              ", xmlDat.priority)
								print("Destination Directory: ", xmlDat.destDir)
								print("Comment:               ", xmlDat.comment)
								print("dm:                    ", xmlDat.dm)
							elif xmlDat.typeStr == "DifxSmartMessage":
								print("")
								print("MJD:                   ", xmlDat.mjd)
								print("VSN:                   ", xmlDat.vsn)
								print("Slot:                  ", xmlDat.slot)
								if len( xmlDat.smarts ) > 0:
									print("S.M.A.R.T Values:")
									for smart in xmlDat.smarts:
										print("S.M.A.R.T ID:      ", smart[0])
										print("Value:             ", smart[1])
							elif xmlDat.typeStr == "DifxDiagnosticMessage":
								print("")
								print("Diagnostic Type:       ", xmlDat.diagnosticType)
								if xmlDat.diagnosticType == "MemoryUsage":
									print("Bytes:                 ", xmlDat.bytes)
								elif xmlDat.diagnosticType == "BufferStatus":
									print("Thread Id:             ", xmlDat.threadId)
									print("#Buffer Elements:      ", xmlDat.numBufElements)
									print("Start Buffer Element:  ", xmlDat.startBufElement)
									print("Active Buffer Elements:", xmlDat.activeBufElements)
								elif xmlDat.diagnosticType == "ProcessingTime":
									print("Thread ID:             ", xmlDat.threadId)
									print("Microsec:              ", xmlDat.microsec)
								elif xmlDat.diagnosticType == "DataConsumed":
									print("Bytes:                 ", xmlDat.bytes)
								elif xmlDat.diagnosticType == "InputDatarate":
									print("Bytes per Second:      ", xmlDat.bytespersec)
								elif xmlDat.diagnosticType == "NumSubintsLost":
									print("#Subints Lost:         ", xmlDat.numSubintsLost)
							elif xmlDat.typeStr == "Mark5VersionMessage":
								print("")
								print("Api Version:           ", xmlDat.ApiVer)
								print("Api Date:              ", xmlDat.ApiDate)
								print("Firmware Version:      ", xmlDat.FirmVer)
								print("Mon Version:           ", xmlDat.MonVer)
								print("Xbar Version:          ", xmlDat.XbarVer)
								print("Ata Version:           ", xmlDat.AtaVer)
								print("UAta Version:          ", xmlDat.UAtaVer)
								print("Driver Version:        ", xmlDat.DriverVer)
								print("Board Type:            ", xmlDat.BoardType)
								print("Serial Number:         ", xmlDat.SerialNum)
								if xmlDat.daughterBoards:
									print("Daughter Boards:")
									print("    PCB Version:       ", xmlDat.PCBVer)
									print("    PCB Type:          ", xmlDat.PCBType)
									print("    PCB SubType:       ", xmlDat.PCBSubType)
									print("    FPGA Config:       ", xmlDat.FPGAConfig)
									print("    FPGA Conf Version: ", xmlDat.FPGAConfigVer)
									print("    Serial Number:     ", xmlDat.dbSerialNum)
									print("    Num Channels:      ", xmlDat.NumChannels)
							elif xmlDat.typeStr == "Mark5DriveStatsMessage":
								print("")
								print("Serial Number:         ", xmlDat.serialNumber)
								print("Model Number:          ", xmlDat.modelNumber)
								print("Size:                  ", xmlDat.size)
								print("Mmodule VSN:           ", xmlDat.moduleVSN)
								print("Module Slot:           ", xmlDat.moduleSlot)
								print("Start MJD:             ", xmlDat.startMJD)
								print("Stop MJD:              ", xmlDat.stopMJD)
								print("Type:                  ", xmlDat.driveType)
								print("Start Byte:            ", xmlDat.startByte)
								for k in list(xmlDat.bins.keys()):
									newStr = "Bin" + xmlDat.bins[k] + ":"
									while len( newStr ) < len( "                       " ):
										newStr += " "
									print(newStr)
							elif xmlDat.typeStr == "DifxFileTransfer":
								print("")
								print("Origin:                ", xmlDat.origin)
								print("Destination:           ", xmlDat.destination)
								print("Data Node:             ", xmlDat.dataNode)
								print("Address:               ", xmlDat.address)
								print("Direction:             ", xmlDat.direction)
								print("Port:                  ", xmlDat.port)
							elif xmlDat.typeStr == "DifxFileOperation":
								print("")
								print("Path:                  ", xmlDat.path)
								print("Operation:             ", xmlDat.operation)
								print("Data Node:             ", xmlDat.dataNode)
								print("Arguments:             ", xmlDat.arg)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
							elif xmlDat.typeStr == "DifxVex2difxRun":
								print("")
								print("User:                  ", xmlDat.user)
								print("Head Node:             ", xmlDat.headNode)
								print("DiFX Version:          ", xmlDat.difxVersion)
								print("Pass Path:             ", xmlDat.passPath)
								print("v2d File:              ", xmlDat.v2dFile)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
								print("Calcif Only:           ", xmlDat.calcifOnly)
							elif xmlDat.typeStr == "DifxMachinesDefinition":
								print("")
								print("input:                 ", xmlDat.inputFile)
								print("Head Node:             ", xmlDat.manager) 
								if len( xmlDat.datastream ) > 0:
									print("Data Streams")
									for node in xmlDat.datastream:
										print("    " + node)
								if len( xmlDat.process ) > 0:
									print("Processors                         Threads")
									for node in xmlDat.process:
										newStr = "    " + node[0]
										while len( tmpStr ) < len( "Processors                         " ):
											newStr += " "
										newStr += str( node[1] )
										print(newStr)
								print("DiFX Version:          ", xmlDat.difxVersion)
								print("Test Processors:       ", xmlDat.testProcessors)
								print("Machines File:         ", xmlDat.machinesFile)
								print("Threads File:          ", xmlDat.threadsFile)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
							elif xmlDat.typeStr == "DifxGetDirectory":
								print("")
								print("DiFX Version:          ", xmlDat.difxVersion)
								print("Mark5:                 ", xmlDat.mark5)
								print("VSN:                   ", xmlDat.vsn)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
								print("Generate New:          ", xmlDat.generateNew)
							elif xmlDat.typeStr == "DifxMk5Control":
								print("")
								print("Command:               ", xmlDat.command)
								print("Target Node:           ", xmlDat.targetNode)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
							elif xmlDat.typeStr == "DifxMark5Copy":
								print("")
								print("DiFX Version:          ", xmlDat.difxVersion)
								print("Mark5:                 ", xmlDat.mark5)
								print("VSN:                   ", xmlDat.vsn)
								print("Scans:                 ", xmlDat.scans)
								print("Destination:           ", xmlDat.destination)
								print("Address:               ", xmlDat.address)
								print("Port:                  ", xmlDat.port)
							else:
								#  Unknown message format
								pass
							if self.rawXML:
								print("")
		except xml.parsers.expat.ExpatError as e:
			self.keepGoing = False
		
	#---------------------------------------------------------------------------
	#  Callback triggered when the monitoring client fails (it returns an 
	#  identifier so we know what failed).
	#---------------------------------------------------------------------------
	def failCallback( self, failureID ):
		if failureID == DiFXControl.Client.BROKEN_SOCKET:
			print("broken socket")
		elif failureID == DiFXControl.Client.FAILED_CONNECTION:
			print("connection failed")
		self.keepGoing = False

#===============================================================================
#  MAIN
#===============================================================================
host = None
port = None
printStats = False
restrictTypes = False

#  Create a new instance of the Responder class to receive callbacks from the
#  DiFX client.
responder = Responder()

#  Command line arguments...
try:
	i = 1
	doingSources = False
	doingTypes = False
	while i < len( sys.argv ):
		#  Any option should shut off these things...
		if sys.argv[i].strip()[0] == '-':
			doingSources = False
			doingTypes = False
		#  Check against legal argument types.  Anything we don't recognize is assumed
		#  to be part of a list of message types.
		if sys.argv[i] in [ "-h", "--help" ]:
			print('\n%s ver %s  %s  %s' % (program, version, author, verdate))
			print("A program for monitoring DiFX UDP message traffic.")
			print("Usage: %s [options] [<list of message types>]" % ( sys.argv[0] ))
			print("")
			print("Options can include:")
			print("")
			print("   --help")
			print("   -h         Print this help information and quit.")
			print("")
			print("   --hostname NAME")
			print("   -H NAME    Use NAME as the host of the difxServer program.")
			print("              Default is to use DIFX_CONTROL_HOST environment variable.")
			print("")
			print("   --identifier NAME")
			print("   -i         Echo only messages with the named identifier.  This is (often)")
			print("              the DiFX job name, so this option can be used to monitor a")
			print("              job or jobs to some degree.  The named identifier is a regular")
			print("              expression, so multiple jobs can be matched.")
			print("")
			print("   --parse")
			print("   -p         Toggle whether to parse XML messages into a readable format.")
			print("              Default is to do so.")
			print("")
			print("   --port PORT")
			print("   -P PORT    Use PORT as the TCP port to communicated with the difxServer.")
			print("              Default is to use DIFX_CONTROL_PORT environment variable.")
			print("")
			print("   --raw")
			print("   -r         Toggle whether to echo \"raw\" XML message strings.  Default is")
			print("              to do so.")
			print("")
			print("   --restrict")
			print("   -R         Tell difxServer to restrict messages it sends to those types")
			print("              Selected.  This can cut down on socket traffic, however currently")
			print("              not all message types are supported.  As a consequence this")
			print("              feature is off by default.")
			print("")
			print("   --source LIST")
			print("   -s LIST    Echo only messages originating from one of the comma-separated LIST")
			print("              of node names.  Default is to echo all sources.")
			print("")
			print("   --stats")
			print("   -S         Toggle whether to produce a list of statistics (messages received, etc.)")
			print("              when collection is terminated.  Default is not to do so.")
			print("")
			print("   --type LIST")
			print("   -t LIST    Indicate the following items are a list of message types you wish to")
			print("              echo.  This isn't an explicitly required argument, as the list can be")
			print("              included as the final argument(s) - seem below.")
			print("")
			print("<list of message types> is a comma-separated list of one or more message")
			print("types, identified either by name or number.  Default behavior is to echo all messages.")
			print("Legal message numbers and types are:")
			print("")
			print("       1 : DifxLoadMessage")
			print("       2 : DifxAlertMessage")
			print("       3 : Mark5StatusMessage")
			print("       4 : DifxStatusMessage")
			print("       5 : DifxInfoMessage")
			print("       6 : DifxDatastreamMessage")
			print("       7 : DifxCommand")
			print("       8 : DifxParameter")
			print("       9 : DifxStart")
			print("      10 : DifxStop")
			print("      11 : Mark5VersionMessage")
			print("      12 : Mark5ConditionMessage")
			print("      13 : DifxTransientMessage")
			print("      14 : DifxSmartMessage")
			print("      15 : Mark5DriveStatsMessage")
			print("      16 : DifxDiagnosticMessage")
			print("      17 : DifxFileTransfer")
			print("      18 : DifxFileOperation")
			print("      19 : DifxVex2DifxRun")
			print("      20 : DifxMachinesDefinition")
			print("      21 : DifxGetDirectory")
			print("      22 : DifxMk5Control")
			print("      23 : DifxMark5Copy")
			print("")
			exit( 0 )
		elif sys.argv[i] in [ "-H", "--hostname" ]:
			host = sys.argv[i+1]
			i = i + 1
		elif sys.argv[i] in [ "-i", "--identifier" ]:
			responder.identifierRE = re.compile( sys.argv[i+1] )
			i = i + 1
		elif sys.argv[i] in [ "-p", "--parse" ]:
			if responder.parseXML == True:
				responder.parseXML = False
			else:
				responder.parseXML = True
		elif sys.argv[i] in [ "-P", "--port" ]:
			port = int( sys.argv[i+1] )
			i = i + 1
		elif sys.argv[i] in [ "-r", "--raw" ]:
			if responder.rawXML:
				responder.rawXML = False
			else:
				responder.rawXML = True
		elif sys.argv[i] in [ "-R", "--restrict" ]:
			restrictTypes = True
		elif sys.argv[i] in [ "-s", "--source" ]:
			#  Indicates a list of sources follows.
			doingSources = True
			responder.echoAllSources = False
		elif sys.argv[i] in [ "-S", "--stats" ]:
			if printStats:
				printStats = False
			else:
				printStats = True
		elif sys.argv[i] in [ "-t", "--type" ]:
			#  Indicates a list of types follows.  Redundant variable - not really used.
			doingTypes = True
		elif doingSources:
			#  Should be a source node.
			for st in sys.argv[i].strip().split( "," ):
				responder.echoSources.append( st.strip() )
			#  If the last character is not a comma, assume the list of sources is
			#  ending.
			if sys.argv[i].strip().endswith( "," ) != True:
				doingSources = False
		else:
			#  Presumed to be a message type, or list of message types.  No longer
			#  doing the default (all)!
			if responder.echoAllMessages:
				responder.echoAllMessages = False
			#  This single argument might be more than one item.  Split it up.
			for st in sys.argv[i].strip().split( "," ):
				#  Translate any (known) integer into a message string.  Otherwise just
				#  assume the string is a legal message type.  The user won't be warned
				#  of an unrecognized type, but we don't have to keep the list of types
				#  up to date that way - any new message will be recognized immediately.
				if st.strip() == "1":
					responder.messageTypes.append( "DifxLoadMessage" )
				elif st.strip() == "2":
					responder.messageTypes.append( "DifxAlertMessage" )
				elif st.strip() == "3":
					responder.messageTypes.append( "Mark5StatusMessage" )
				elif st.strip() == "4":
					responder.messageTypes.append( "DifxStatusMessage" )
				elif st.strip() == "5":
					responder.messageTypes.append( "DifxInfoMessage" )
				elif st.strip() == "6":
					responder.messageTypes.append( "DifxDatastreamMessage" )
				elif st.strip() == "7":
					responder.messageTypes.append( "DifxCommand" )
				elif st.strip() == "8":
					responder.messageTypes.append( "DifxParameter" )
				elif st.strip() == "9":
					responder.messageTypes.append( "DifxStart" )
				elif st.strip() == "10":
					responder.messageTypes.append( "DifxStop" )
				elif st.strip() == "11":
					responder.messageTypes.append( "Mark5VersionMessage" )
				elif st.strip() == "12":
					responder.messageTypes.append( "Mark5ConditionMessage" )
				elif st.strip() == "13":
					responder.messageTypes.append( "DifxTransientMessage" )
				elif st.strip() == "14":
					responder.messageTypes.append( "DifxSmartMessage" )
				elif st.strip() == "15":
					responder.messageTypes.append( "Mark5DriveStatsMessage" )
				elif st.strip() == "16":
					responder.messageTypes.append( "DifxDiagnosticMessage" )
				elif st.strip() == "17":
					responder.messageTypes.append( "DifxFileTransfer" )
				elif st.strip() == "18":
					responder.messageTypes.append( "DifxFileOperation" )
				elif st.strip() == "19":
					responder.messageTypes.append( "DifxVex2DifxRun" )
				elif st.strip() == "20":
					responder.messageTypes.append( "DifxMachinesDefinition" )
				elif st.strip() == "21":
					responder.messageTypes.append( "DifxGetDirectory" )
				elif st.strip() == "22":
					responder.messageTypes.append( "DifxMk5Control" )
				elif st.strip() == "23":
					responder.messageTypes.append( "DifxMark5Copy" )
				else:
					responder.messageTypes.append( st.strip() )
		i = i + 1

except RuntimeError:
	print("Usage: %s [options] [<list of message types>]" % ( sys.argv[0] ))
	exit( 0 )
	
#  Open a new connection to the difxServer...
difx = DiFXControl.Client()
difx.connect( host = host, port = port )
if difx.socketOK:
	difx.monitor()
	difx.relayPackets()
	if restrictTypes:
		difx.messageSelection( responder.messageTypes )
	difx.addRelayCallback( responder.messageCallback )
	difx.addFailCallback( responder.failCallback )
	
	while responder.keepGoing:
		try:
			time.sleep( .1 )
		except KeyboardInterrupt:
			responder.keepGoing = False

difx.close()

if printStats and difx.bytesReceived > 0:
	print("")
	print("Total bytes received:", difx.bytesReceived)
	if len( list(responder.receivedInfo.keys()) ):
		print("")
		print("Message Type                   Num Recieved (dropped)     Bytes Received")
		for mess in list(responder.receivedInfo.keys()):
			outStr = mess
			while len( outStr ) < len( "Message Type                   " ):
				outStr += " "
			if not responder.echoAllMessages and not mess in responder.messageTypes:
				outStr += "("
			outStr += str( responder.receivedInfo[ mess ][0] )
			if not responder.echoAllMessages and not mess in responder.messageTypes:
				outStr += ")"
			while len( outStr ) < len( "Message Type                   Num Recieved (dropped)     " ):
				outStr += " "
			outStr += str( responder.receivedInfo[ mess ][1] )
			print(outStr)