import os

import io

import re

import sys

import gzip

import glob

import time

import json

import threading

import datetime

import traceback

import urllib

import base64

from collections import defaultdict

from Queue import Queue

import socket

try:

# Python 2.x

from SocketServer import ThreadingMixIn

from SimpleHTTPServer import SimpleHTTPRequestHandler

from BaseHTTPServer import HTTPServer

except ImportError:

# Python 3.x

from socketserver import ThreadingMixIn

from http.server import SimpleHTTPRequestHandler, HTTPServer

from qrcode import QRCode

from tornado.template import Template

from ParseHtmlPayload import ParseHtmlPayload

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

import urlparse

from StringIO import StringIO

import Utils

import Model

from GetResults import GetResultsRAM, GetResultsBaseline, GetRaceName

from Synchronizer import syncfunc

from ThreadPoolMixIn import ThreadPoolMixIn

class CrossMgrServer(ThreadPoolMixIn, HTTPServer):

pass

reCrossMgrHtml = re.compile( r'^\d\d\d\d-\d\d-\d\d-.*\.html$' )

futureDate = datetime.datetime( datetime.datetime.now().year+20, 1, 1 )

with io.open( os.path.join(Utils.getImageFolder(), 'CrossMgr.ico'), 'rb' ) as f:

favicon = f.read()

def readBase64( fname ):

with io.open( os.path.join(Utils.getImageFolder(), fname), 'rb' ) as f:

return "data:image/png;base64," + base64.b64encode( f.read() )

with io.open( os.path.join(Utils.getImageFolder(), 'CrossMgrHeader.png'), 'rb' ) as f:

DefaultLogoSrc = readBase64('CrossMgrHeader.png')

icons = {

}

with io.open(os.path.join(Utils.getHtmlFolder(), 'Index.html'), encoding='utf-8') as f:

indexTemplate = Template( f.read() )

PORT_NUMBER = 8765

def gzipEncode( content ):

return out.getvalue()

def validContent( content ):

return content.strip().endswith( '</html>' )

@syncfunc

def getCurrentHtml():

return Model.getCurrentHtml()

@syncfunc

def getCurrentTTCountdownHtml():

return Model.getCurrentTTCountdownHtml()

@syncfunc

def getCurrentTTStartListHtml():

return Model.getCurrentTTStartListHtml()

with io.open(os.path.join(Utils.getHtmlFolder(), 'LapCounter.html'), encoding='utf-8') as f:

lapCounterTemplate = f.read()

def getLapCounterHtml():

return lapCounterTemplate

def coreName( fname ):

return os.path.splitext(os.path.basename(fname).split('?')[0])[0].replace('_TTCountdown','').replace('_TTStartList','').strip('-')

class Generic( object ):

def __init__( self, **kwargs ):

self.__dict__.update( kwargs )

class ContentBuffer( object ):

return result

#-----------------------------------------------------------------------

contentBuffer = ContentBuffer()

DEFAULT_HOST = None

def SetFileName( fname ):

if fname.endswith( '.cmn' ):

fname = os.path.splitext(fname)[0] + '.html'

q.put( {'cmd':'fileName', 'fileName':fname} )

def GetPreviousFileName():

return file

def getQRCodePage( urlPage ):

return result.getvalue().encode( 'utf-8' )

def getIndexPage( share=True ):

return indexTemplate.generate( **info )

#---------------------------------------------------------------------------

def WriteHtmlIndexPage():

return fname

class CrossMgrHandler( BaseHTTPRequestHandler ):

return

#--------------------------------------------------------------------------

def GetCrossMgrHomePage( ip=None ):

return 'http://{}:{}'.format(hostname, PORT_NUMBER)

server = None

def WebServer():

time.sleep( 5 )

def queueListener( q ):

server = None

q = Queue()

qThread = threading.Thread( target=queueListener, name='queueListener', args=(q,) )

qThread.daemon = True

qThread.start()

webThread = threading.Thread( target=WebServer, name='WebServer' )

webThread.daemon = True

webThread.start()

from websocket_server import WebsocketServer

#-------------------------------------------------------------------

def message_received(client, server, message):

msg = json.loads( message )

if msg['cmd'] == 'send_baseline' and (msg['raceName'] == 'CurrentResults' or msg['raceName'] == GetRaceName()):

server.send_message( client, json.dumps(GetResultsBaseline()) )

wsServer = None

def WsServerLaunch():

time.sleep( 5 )

def WsQueueListener( q ):

wsServer = None

wsQ = Queue()

wsQThread = threading.Thread( target=WsQueueListener, name='WsQueueListener', args=(wsQ,) )

wsQThread.daemon = True

wsQThread.start()

wsThread = threading.Thread( target=WsServerLaunch, name='WsServer' )

wsThread.daemon = True

wsThread.start()

wsTimer = None

wsTimerDur = None

wsTimerDurMax = 4

def WsPost():

wsTimer = None

def WsRefresh( updatePrevious=False ):

wsTimer.start()

#-------------------------------------------------------------------

def GetLapCounterRefresh():

return { 'cmd':'refresh', 'labels':[], 'foregrounds':[], 'backgrounds':[] }

def lap_counter_new_client(client, server):

server.send_message( client, json.dumps(GetLapCounterRefresh()) )

wsLapCounterServer = None

def WsLapCounterServerLaunch():

time.sleep( 5 )

def WsLapCounterQueueListener( q ):

wsLapCounterServer = None

wsLapCounterQ = Queue()

wsLapCounterQThread = threading.Thread( target=WsLapCounterQueueListener, name='WsLapCounterQueueListener', args=(wsLapCounterQ,) )

wsLapCounterQThread.daemon = True

wsLapCounterQThread.start()

wsLapCounterThread = threading.Thread( target=WsLapCounterServerLaunch, name='WsLapCounterServer' )

wsLapCounterThread.daemon = True

wsLapCounterThread.start()

lastRaceName, lastMessage = None, None

def WsLapCounterRefresh():

lastMessage, lastRaceName = message, raceName

if __name__ == '__main__':

SetFileName( os.path.join('Gemma', '2015-11-10-A Men-r4-.html') )

print 'Started httpserver on port ' , PORT_NUMBER

try:

time.sleep( 10000 )

except KeyboardInterrupt:

q.put( {'cmd':'exit'} )