Tooltron

#!/usr/bin/python

"""

  This file is part of Tooltron.

  Tooltron is free software: you can redistribute it and/or modify

  it under the terms of the Lesser GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  Tooltron is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  Lesser GNU General Public License for more details.

  You should have received a copy of the Lesser GNU General Public License

  along with Tooltron.  If not, see <http://www.gnu.org/licenses/>.

  Copyright 2009 Bradford Neuman <bneuman@andrew.cmu.edu>

"""

################################################################################

## tooltron.py is the main tooltron server

# It connects to the civicrm database of mysql and sends commands to

# the cardbox and tools.  It must be connected over usb to the card

# reader, and the two arguments specify the devices to use for the

# serial communication to the card and tool boxes.

#

# This script requires the modules seen below, which may not be

# present by default

#

# Because of a problem with card scans buffering in stdio, there is a

# seperate thread which stores the last swiped id. To cleanly exit the

# program type C-d

#

# email bradneuman@gmail.com if you have any questions

################################################################################

import re

import sys

import MySQLdb

import getpass

import datetime

from datetime import date

from time import *

sys.path.append('../common')

import common

keypadTimeout = 12 #in seconds

#this table maps which keypad button to press for each tool. This

#list should probably be printed next to the swipe box

tools = {

   'Bandsaw':[],

   'DrillPress':['3','8'],

   'Mill':['4'],

   'Lathe':[],

   #HACK: since the saw isn't used I use it for testing random boards

   'ChopMiterSaw':['1','2','5','6','7','9']

}

#this table maps keypad button numbers to tool IDs. The default is

#that the tool id is 10+the keypad number, but this would change if

#boards were swapped out. The tool ID number should be printed on the

#tool board, but needs to be hand coded into the toolbox code

ids = {

   '1':11,

   '2':12,

   '3':13,

   '4':14,

   '5':15,

   '6':16,

   '7':17,

   '8':18,

   '9':19,

   '0':13

}

#################################################

#this code spawns a thread which always puts the last card id in the

#lastid variable.

#################################################

import threading

import time

import select

import os

lastid = None

idready = False

threadDone = False

threadDoneExcp = None

cv = threading.Condition()

class ctrlDException (Exception):

   def __init__(self,str):

      Exception.__init__(self)

      self.str = str

   def __str__(self):

      return "Ctrl-D pressed: " + self.str

class idThread ( threading.Thread ):

   def __init__ (self):

      threading.Thread.__init__(self)

      self.wpipe = None

   def stop (self):

      self.stop_thread = True

      if self.wpipe != None:

         # write to this pipe so that the select will drop out

         self.wpipe.write('!')

   def run (self):

       global lastid

       global idready

       global threadDone

       global threadDoneExcp

       self.stop_thread = False

       [r,w] = os.pipe()

       self.rpipe = os.fdopen(r,'r')

       self.wpipe = os.fdopen(w,'w')

       try:

          while not self.stop_thread:

             # hang until we either get keyboard input or are told to stop

             [active,a,b] = select.select([sys.stdin,self.rpipe],[],[])

             if not self.stop_thread:

                l = raw_input()

                cv.acquire()

                try:

                   id = re.search('%([0-9]*)=.*', l)

                   if id != None:

                      lastid = id

                      print "!!! setting idready"

                      idready = True

                      cv.notify()

                   else:

                      ifready = False

                finally:

                   cv.release()

          print "thread stopped"

       except EOFError:

           cv.acquire()

           idready = True

           lastid=None

           threadDoneExcp=ctrlDException("thread exiting cleanly")

           cv.notify()

           cv.release()

       except Exception, e:

          threadDoneExcp = e #TODO: provide a line number or something?

       finally:

          print "id thread getting ready to exit..."

          threadDone = True

          cv.acquire()

          idready = False

          cv.notify()

          cv.release()

          print "id thread exiting"

#end thread

###############################################

try:

   flog = open("/var/log/tooltron", "a")

except IOError as e:

   print "\n*********************************************"

   print "File /var/log/tooltron could not be opened!"

   print e

   print "Using local file 'tooltron.log'"

   print "*********************************************\n"

   flog = open("tooltron.log","a")

finally:

   print flog

def logMessage(str):

   flog.write(strftime("%Y.%m.%d %H:%M:%S ") + str + "\n")

   flog.flush()

logMessage("----- SERVER STARTED -----")

def keypad2toolID(t):

   if t in ids:

      return ids[t]

   else:

      return -1

def reverseTool(tn):

   for t in tools:

      if tn in tools[t]:

         return t

   return 'invalid'

#keep count of successive non-acks

toolFails = tools.copy()

for t in toolFails:

   toolFails[t] = 0

def get_last_id():

    global idready

    global lastid

    global threadDoneExcp

    got = None

    print ">>> locking for last_id"

    cv.acquire()

    while not idready:

       if threadDoneExcp != None:

          print "thread has been exited"

          raise threadDoneExcp

       print ">>> wait"

       try:

          cv.wait()

       # if the user hits ctrl-c, cleanly exit

       except KeyboardInterrupt:

          print "cv.wait() got a keyboard interupt!"

          cv.release()

          return None

    print ">>> idready set"

    got = lastid

    idready = False

    cv.release()

    print ">>> done"

    return got

def clear_id():

    global idready

    global lastid

    print "=== locking to clear idready flag"

    cv.acquire()

    idready = False

    lastid = None

    cv.release()

    print "=== done"

    return

if len(sys.argv) < 2:

   print "usage: tooltron.py /path/to/bus/device"

   exit(-1)

if not common.initBus(sys.argv[1]):

    print "usage: tooltron.py /path/to/bus/device"

else:

   pw = getpass.getpass("mysql password: ")

   #start the id scan thread AFTER the getpass prompt

   idt = idThread()

   idt.start()

   # If there are any uncaught exceptions in the rest of the code, we need to kill the id thread

   # so the program as a whole will exit

   try:

      cursor = None

      qry = "SELECT tools_6 FROM civicrm_value_roboclub_info_2 WHERE card_number_1 = "

      def sendTool(t):

         tn = keypad2toolID(t)

         common.sendTool(tn)

      # This function eats the rest of the packet where data is what we have so far

      def flushPacket(data):

         while len(data) < 6:

            data += bus.read(1)

         plen = data[4]

         if plen > 0:

            bus.read(ord(plen))

      while True:

         id = get_last_id()

         if id != None:

            print "\--------------------\n",strftime("%Y.%m.%d %H:%M:%S \n"),"id# ", id.group(1)

            # Send a key request

            common.sendMessage(2, common.TT_GET_KEY, "")

            # listen for an ACK or a key response

            msg = common.readMessage()

            if msg == None:

               print "ERROR: Timeout waiting for response from key request!"

               continue

            # resp hols the key response, so set it to None since we don't have one yet

            resp = None

            [src,dest,cmd,data] = msg

            src = ord(src)

            dest = ord(dest)

            # print "tooltron.py has message:"

            # print "src:", src

            # print "dest:", dest

            # print "cmd:", cmd

            # print "data: {",data,"}"

            #TODO: no magic number '2' for cardbox or '1' for server

            if src == 2 and dest == 1:

               if cmd == common.TT_ACK:

                  print "got ACK from cardbox"

               elif cmd == common.TT_SEND_KEY:

                  print "got key response instead of ACK from cardbox"

                  print "using key: ", data

                  resp = data[0]

               else:

                  print "ERROR: got some other packet type: ", cmd, " (data = {", data, "})"

                  continue

            else:

               print "ERROR: got confusing packet. Excpecting something from cardbox (2) but got:"

               common.printMsg(msg)

               continue

            # start the timer so we can timeout if we are still waiting for a key response

            startTime = time.time()

            # while we are (or might be) waiting for a key response, do the MySQL stuff

            if cursor != None:

               cursor.close()

            db = MySQLdb.connect(host="roboclub8.frc.ri.cmu.edu", user="tooltron", passwd=pw, db="civicrm")

            print "connected to mysql server"

            cursor = db.cursor()

            print "got db cursor"

            cursor.execute(qry + id.group(1))

            result = cursor.fetchall()

            acl = []

            for r in result:

               tls = r[0].split("\x01")

               for t in tls:

                  if t != '':

                     try:

                        acl.extend (tools[t])

                     except KeyError:

                        #this doesn't really matter

                        pass

            print "user has access to:", acl

            user = ""

            #query for name

            qry2 = "SELECT civicrm_contact.display_name \

                    FROM civicrm_value_roboclub_info_2 \

                    INNER JOIN (civicrm_contact) \

                    ON civicrm_value_roboclub_info_2.entity_id = civicrm_contact.id \

                    WHERE civicrm_value_roboclub_info_2.card_number_1 = " + id.group(1) + ";"

            cursor.execute(qry2)

            result = cursor.fetchall()

            if len(result) > 0:

               user += result[0][0]

            qry2 = "SELECT civicrm_email.email \

                    FROM civicrm_value_roboclub_info_2 \

                    INNER JOIN (civicrm_email) \

                    ON civicrm_email.contact_id = civicrm_value_roboclub_info_2.entity_id \

                    WHERE civicrm_value_roboclub_info_2.card_number_1 = " + id.group(1) + ";"

            cursor.execute(qry2)

            result = cursor.fetchall()

            if len(result) > 0:

               user += " ("+result[0][0]+")"

            if user == "":

               user = str(id.group(1))

            print user

            # check if member has paid recently 

            # first, figure out what semester it is

            today = date.today()

            # semester start dates

            aug20 = datetime.date(today.year, 8, 20) # Fall semester

            may21 = datetime.date(today.year, 5, 21) # summer

            jan1  = datetime.date(today.year, 1,  1) # Spring semester

            # if they don't fall after those two, its fall

            if today > aug20:

               print "its fall semester!"

               #its fall, so they must have paid after may21 (either full year of half) to be paid

               qry3 = "SELECT civicrm_value_roboclub_info_2.date_paid_10 >= STR_TO_DATE('" + may21.strftime('%m/%d/%Y') + "', '%m/%d/%Y') ,  \

                       DATE_FORMAT(civicrm_value_roboclub_info_2.date_paid_10, '%M %d %Y') \

                       FROM civicrm_value_roboclub_info_2 \

                       WHERE civicrm_value_roboclub_info_2.card_number_1 = " + id.group(1) + ";"

            elif today > may21:

               print "its summer!"

               #its summer, so they need to have paid either full year since aug20 or one semester since jan 1

               qry3 = "SELECT (civicrm_value_roboclub_info_2.date_paid_10 >= STR_TO_DATE('" + aug20.strftime('%m/%d/%Y') + "', '%m/%d/%Y') AND \

                               civicrm_value_roboclub_info_2.amount_paid_11 = 25) OR \

                              (civicrm_value_roboclub_info_2.date_paid_10 >= STR_TO_DATE('" + jan1.strftime('%m/%d/%Y') + "', '%m/%d/%Y') AND \

                               civicrm_value_roboclub_info_2.amount_paid_11 = 15) , \

                       DATE_FORMAT(civicrm_value_roboclub_info_2.date_paid_10, '%M %d %Y') \

                       FROM civicrm_value_roboclub_info_2 \

                       WHERE civicrm_value_roboclub_info_2.card_number_1 = " + id.group(1) + ";"

               cursor.execute(qry3)

               result = cursor.fetchall()

               print result

            else:

               print "its spring!"

               #its spring, so they must have either paid full after aug20 or one semester since jan 1 (this is the same as summer)

               qry3 = "SELECT (civicrm_value_roboclub_info_2.date_paid_10 >= STR_TO_DATE('" + aug20.strftime('%m/%d/%Y') + "', '%m/%d/%Y') AND \

                               civicrm_value_roboclub_info_2.amount_paid_11 = 25) OR \

                              (civicrm_value_roboclub_info_2.date_paid_10 >= STR_TO_DATE('" + jan1.strftime('%m/%d/%Y') + "', '%m/%d/%Y') AND \

                               civicrm_value_roboclub_info_2.amount_paid_11 = 15) , \

                       DATE_FORMAT(civicrm_value_roboclub_info_2.date_paid_10, '%M %d %Y') \

                       FROM civicrm_value_roboclub_info_2 \

                       WHERE civicrm_value_roboclub_info_2.card_number_1 = 810797813"

#" + id.group(1) + ";"

            cursor.execute(qry3)

            result = cursor.fetchall()

            if len(result) == 0 or result[0][0] == 0 or result[0][0] == "NULL":

               print "DENIED: user has not paid recently enough!"

               if len(result[0]) >= 2:

                  print "date_paid: ",result[0][1]

                  logMessage(user + " has not paid since " + result[0][1] + ", revoking access!")

               else:

                  logMessage(user + " has not paid, revoking access!")

               acl = []

            # while we don't have a valid response

            # Note that this might already be set above when we were heoping for an ACK

            while resp==None:

               try:

                  resp = common.readKey()

               except common.TimeoutException:

                  print "got TIMEOUT from keypad, breaking out of loop"

                  break

               if idready == True:

                  #if someone swipes while waiting for keypad, ignore it

                  print "got swipe during transaction, ignoring"

               if time.time() - startTime > keypadTimeout:

                  print "KEYPAD TIMEOUT!"

                  logMessage("keypad timed out")

                  common.sendMessage(2,common.TT_TIMEOUT,'')

                  break

            #if we have a valid response

            #sometimes the FTDI chip seems to give a zero as a string when power is reset

            if resp != None and ord(resp) != 0 and resp != common.TT_TIMEOUT:

               toolName = reverseTool(resp)

               toolNameLong = toolName + " (k="+str(resp)+"("+str(ord(resp))+"), t="+str(keypad2toolID(resp))+")"

               print "request:",resp,"(",ord(resp),") ",toolNameLong

               if acl.count(resp) > 0:

                  common.sendAck(2)

                  time.sleep(0.5)

                  sendTool(resp)

                  print "ACCESS GRANTED"

                  logMessage(user+" ACCESSED tool "+toolNameLong)

                  if common.checkAck(resp):

                     print "ACK"

                     toolFails[toolName] = 0

                  else:

                     print "NO ACK!!!!"

                     logMessage("tool "+toolNameLong+" did not ACK")

                     toolFails[toolName] += 1

                     if toolFails[toolName] > common.MAX_TOOL_FAILS:

                        #TODO: send email

                        logMessage("WARNING: tool "+toolNameLong+

                                   " has failed to ACK "+

                                   str(common.MAX_TOOL_FAILS)+" times in a row.")

               else:

                  common.sendNack(2)

                  print "ACCESS DENIED!!"

                  logMessage(user + " DENIED on tool "+toolNameLong)

               clear_id()

            elif resp == common.TT_TIMEOUT:

               print "TIMEOUT sent from keypad"

               continue

            else:

               break

   except ctrlDException:

      print "got a ctrl-D, exiting cleanly"

      logMessage("NOTICE: tooltron going down because of ctrl-D press")

   finally:

      if not threadDone:

         print "stopping id reader thread..."

         idt.stop()