JChip.py

from __future__ import print_function

import socket
import six
import sys
import time
import datetime
import atexit
import math
import re
import os
import wx
import wx.lib.newevent
import Utils
import Model
import select
from threading import Thread as Process
from six.moves.queue import Queue, Empty

ChipReaderEvent, EVT_CHIP_READER = wx.lib.newevent.NewEvent()

stripLeadingZeros = Utils.stripLeadingZeros

readerEventWindow = None
def sendReaderEvent( tagTimes ):
	if tagTimes and readerEventWindow:
		wx.PostEvent( readerEventWindow, ChipReaderEvent(tagTimes = tagTimes) )

combine = datetime.datetime.combine
reTimeChars = re.compile( '^\d\d:\d\d:\d\d\.\d+' )

CR = u'\r'			# JChip delimiter

dateToday = datetime.date.today()
tSameCount = 0
tLast = None

def reset( raceDate = None ):
	global dateToday
	global tSameCount
	global tLast
	
	dateToday = raceDate or datetime.date.today()
	tLast = None
	tSameCount = 0

DEFAULT_HOST = '0.0.0.0'		# Listen to all available network cards on this computer.
DEFAULT_PORT = int(os.environ.get('JCHIP_REMOTE_PORT',53135))

q = None
shutdownQ = None
listener = None

def socketSend( s, message ):
	sLen = 0
	while sLen < len(message):
		sLen += s.send( message[sLen:].encode() )
		
def socketByLine( s ):
	buffer = s.recv( 4096 ).decode()
	while 1:
		nl = buffer.find( CR )
		if nl >= 0:
			yield buffer[:nl+1]
			buffer = buffer[nl+1:]
		else:
			more = s.recv( 4096 ).decode()
			if more:
				buffer = buffer + more
			else:
				break
	if buffer:
		yield buffer

# if we get the same time, make sure we give it a small offset to make it unique, but preserve the order.
tSmall = datetime.timedelta( seconds = 0.00001 )
tDay = datetime.timedelta( days = 1 )

def parseTime( tStr, day = 0 ):
	global dateToday
	global tLast
	global tSameCount
	
	hh, mm, ss = tStr.split(':')
	t = combine(dateToday, datetime.time()) + datetime.timedelta(
			seconds = (float(hh) * 60.0 * 60.0) + (float(mm)  * 60.0) + float(ss) )
	
	t += tDay * day
	
	if tLast is None:
		tLast = t - tSmall
	
	# Add a small offset to equal times so the order is preserved.
	if t == tLast:
		tSameCount += 1
	else:
		tSameCount = 0
		tLast = t
	
	return t + tSmall * tSameCount if tSameCount > 0 else t

def safeRemove( lst, x ):
	while 1:
		try:
			lst.remove( x )
		except ValueError:
			return

def safeAppend( lst, x ):
	if x not in lst:
		lst.append( x )
		
reUnprintable = re.compile( r'[\x00-\x19\x7f-\xff]' )
def formatAscii( s ):
	r = []
	charsPerLine = 40
	for i in six.moves.range(0, len(s), charsPerLine):
		line = s[i:i+charsPerLine]
		r.append( ''.join( '.{}'.format(c) for c in reUnprintable.sub('.', line)) )
		r.append( ''.join( '{:02x}'.format(ord(c)) for c in line ) )
	return '\n'.join( r )
	
def Server( q, shutdownQ, HOST, PORT, startTime ):
	global readerEventWindow
	
	if not readerEventWindow:
		readerEventWindow = Utils.mainWin
	
	#-----------------------------------------------------
	# Support multiple connections to a JChip client.
	# If we get a Address Already in use, we wait some time and try again
	#
	while 1:
		server = None
		server = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
		server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
		server.setblocking( 0 )
		try:
			server.bind((HOST, PORT))
		except IOError as e:
			if e.errno == 48:
				server = None
				time.sleep(2)
				continue
			else:
				raise e
		server.listen( 5 )
		break
	
	# List of ports for select.
	inputs = [server]
	outputs = []
	
	#
	# Read and write buffers and state for JChip readers.
	#
	readerReadStr, readerWriteStr, readerName, readerComputerTimeDiff, nameReader = {}, {}, {}, {}, {}
	
	def closeReader( s ):
		safeRemove( inputs, s )
		safeRemove( outputs, s )
		try:
			del nameReader[readerName[s]]
		except ValueError:
			pass
		for state in [readerReadStr, readerWriteStr, readerName, readerComputerTimeDiff]:
			state.pop( s, None )
		s.close()
	
	def qLog( category, message ):
		q.put( (category, message) )
		Utils.writeLog( u'JChip: {}: {}'.format(category, message) )
	
	while inputs:
		# qLog( 'waiting', 'for communication' )
		readable, writable, exceptional = select.select( inputs, outputs, inputs, 2 )
		
		try:
			# Check if we have been told to shutdown.
			shutdownQ.get_nowait()
			break
		except Empty:
			pass

		# qLog( 'waiting', 'len(readable)=%d, len(writable)=%d, len(exceptional)=%d' % (len(readable), len(writable), len(exceptional) ) )
		#----------------------------------------------------------------------------------
		# Handle inputs.
		#
		for s in readable:
			if s is server:
				# This is the listener.  Accept the connection from a JChip reader.
				connCur, addr = s.accept()
				connCur.setblocking( 0 )
				inputs.append( connCur )
				readerReadStr[connCur], readerWriteStr[connCur] = u'', u''
				qLog( 'connection', 'established {}'.format(addr) )
				continue
			
			# This socket is a data socket.  Get the data.
			try:
				data = s.recv( 4096 ).decode()
			except Exception as e:
				qLog( 'connection', 'error: {}'.format(e) )
				data = None
			
			if not data:
				# No data - close this socket.
				qLog( 'connection', 'disconnected: {}'.format(readerName.get(s, '<unknown>')) )
				closeReader( s )
				continue
			
			# qLog( 'connection', 'recv: \n{}\n'.format( formatAscii(data) ) )
			
			# Accumulate the data.
			readerReadStr[s] += data
			if not readerReadStr[s].endswith( CR ):
				continue	# Missing delimiter - need to get more data.
				
			# The message is delimited.  Process the messages.
			tagTimes = []
			lines = readerReadStr[s].split( CR )
			readerReadStr[s] = ''
			for line in lines:
				line = line.strip()
				if not line:
					continue
				try:
					if line.startswith( 'D' ):
						# The tag and time are always separated by at least one space.
						iSpace = line.find( ' ' )
						if iSpace < 0:
							qLog( 'error', line.strip() )
							continue
						tag = line[2:iSpace]	# Skip the D and first initial letter (always the same).
						
						# Find the first colon of the time and parse the time working backwards.
						iColon = line.find( ':' )
						if iColon < 0:
							qLog( 'error', line.strip() )
							continue
							
						m = reTimeChars.match( line[iColon-2:] )
						if not m:
							qLog( 'error', line.strip() )
							continue
						tStr = m.group(0)
						
						# Find the second field separated by a space after the time.
						# The second character of the field is the day count.
						iSecondField = line.find( ' ', iColon ) + 1
						if iSecondField >= 0:
							try:
								day = int(line[iSecondField+1:iSecondField+2])
							except:
								day = 0
						
						try:
							iDate = line.index( 'date=' ) + 5
							YYYY, MM, DD = int(line[iDate:iDate+4]), int(line[iDate+4:iDate+6]), int(line[iDate+6:iDate+8])
							if Model.race and Model.race.isRunning():
								raceStartTime = Model.race.startTime
								startDate = datetime.date( raceStartTime.year, raceStartTime.month, raceStartTime.day )
								tagDate = datetime.date( YYYY, MM, DD )
								day = (tagDate - startDate).days
						except ValueError:
							pass
						
						t = parseTime( tStr, day )
						t += readerComputerTimeDiff.get(s, datetime.timedelta())
						
						tag = stripLeadingZeros(tag)
						q.put( ('data', tag, t) )
						tagTimes.append( (tag, t) )
						
					elif line.startswith( 'N' ):
						name = line[5:].strip()		# Skip the cmd and current number of recorded times.
						
						# Check if this reader is known to us already.
						# If so, the reader has dropped its previous connection and is reconnecting.
						# Close the previous connection as it is no longer needed.
						if name in nameReader:
							s_dropped = nameReader[name]
							qLog( 'transmitting', '"{}" is reconnecting'.format(readerName[s]) )
							closeReader( s_dropped )
						
						readerName[s] = name
						nameReader[name] = s
						q.put( ('name', name) )
						
						# Now, get the reader's current time.
						cmd = u'GT'
						qLog( 'transmitting', '{} command to "{}" (gettime)'.format(cmd, readerName[s]) )
						readerWriteStr[s] += u'{}{}'.format(cmd, CR)
						safeAppend( outputs, s )
					
					elif line.startswith( 'GT' ):
						tNow = datetime.datetime.now()
						
						iStart = 3
						hh, mm, ss, hs = [int(line[i:i+2]) for i in range(iStart, iStart + 4 * 2, 2)]
						try:
							iDate = line.index( 'date=' ) + 5
							YYYY, MM, DD = int(line[iDate:iDate+4]), int(line[iDate+4:iDate+6]), int(line[iDate+6:iDate+8])
							tJChip = datetime.datetime( YYYY, MM, DD, hh, mm, ss, hs * 10000 )
						except ValueError:
							tJChip = datetime.datetime.combine( tNow.date(), datetime.time(hh, mm, ss, hs * 10000) )
						except Exception as e:
							tJChip = datetime.datetime.combine( tNow.date(), datetime.time(hh, mm, ss, hs * 10000) )
							
						readerComputerTimeDiff[s] = tNow - tJChip
						
						qLog( 'getTime', '({})={:02d}:{:02d}:{:02d}.{:02d}'.format(line[2:].strip(), hh,mm,ss,hs) )
						rtAdjust = readerComputerTimeDiff[s].total_seconds()
						if rtAdjust > 0:
							behindAhead = 'Behind'
						else:
							behindAhead = 'Ahead'
							rtAdjust *= -1
						qLog( 'timeAdjustment', 
								'"{}" is: {} {} (relative to computer)'.format(
									readerName.get(s, '<<unknown>>'),
									behindAhead,
									Utils.formatTime(rtAdjust, True)
								) )
						
						# Send command to start sending data.
						cmd = u'S0000'
						qLog( 'transmitting', '{} command to "{}" (start transmission)'.format(
							cmd, readerName.get(s, '<<unknown>>')) )
						readerWriteStr[s] += u'{}{}'.format(cmd, CR)
						safeAppend( outputs, s )
					else:
						q.put( ('unknown', line ) )
						
				except (ValueError, KeyError, IndexError) as e:
					qLog( 'exception', '{}: {}'.format(line, e) )
					pass
			
			sendReaderEvent( tagTimes )
		#----------------------------------------------------------------------------------
		# Handle outputs.
		#
		for s in writable:
			# Write out the waiting data.  If we sent it all, remove it from the outputs list.
			try:
				readerWriteStr[s] = readerWriteStr[s][s.send(readerWriteStr[s].encode()):]
			except Exception as e:
				qLog( 'exception', u'send error: {}'.format(e) )
				readerWriteStr[s] = u''
			if not readerWriteStr[s]:
				outputs.remove( s )
			
		#----------------------------------------------------------------------------------
		# Handle exceptional list.
		#
		for s in exceptional:
			# Close the socket and remove its state.
			closeReader( s )
	
	server.close()

def GetData():
	data = []
	while 1:
		try:
			data.append( q.get_nowait() )
		except (Empty, AttributeError):
			break
	return data

def StopListener():
	global q
	global listener
	global shutdownQ

	# Terminate the server process if it is running.
	# Add a number of shutdown commands as we may check a number of times.
	if listener:
		for i in six.moves.range(32):
			shutdownQ.put( 'shutdown' )
		listener.join()
	listener = None
	
	# Purge the queues.
	while q:
		try:
			q.get_nowait()
		except Empty:
			q = None
			break
	
	shutdownQ = None
		
def StartListener( startTime = datetime.datetime.now(),
					HOST = DEFAULT_HOST, PORT = DEFAULT_PORT ):
	global q
	global shutdownQ
	global listener
	global dateToday
	dateToday = startTime.date()
	
	StopListener()
	
	q = Queue()
	shutdownQ = Queue()
	listener = Process( target = Server, args=(q, shutdownQ, HOST, PORT, startTime) )
	listener.name = 'JChip Listener'
	listener.daemon = True
	listener.start()
	
def IsListening():
	return listener is not None
	
@atexit.register
def CleanupListener():
	global shutdownQ
	global listener
	if listener and listener.is_alive():
		shutdownQ.put( 'shutdown' )
		listener.join()
	listener = None
	
if __name__ == '__main__':
	StartListener()
	count = 0
	for count in six.moves.range(50):
		time.sleep( 1 )
		sys.stdout.write( '.' )
		messages = GetData()
		if messages:
			sys.stdout.write( '\n' )
		for m in messages:
			print( m )
		sys.stdout.flush()