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

from time import *

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

import common

keypadTimeout = 31 #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

           cv.notify()

           cv.release()

           threadDoneExcp=ctrlDException("thread exiting cleanly")

       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

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

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

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"

       cv.wait()

    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: ")

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

   print "connected, now accepting input"

   logMessage("connected to database")

   #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 = db.cursor()

      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-----------\nid# ", id.group(1)

            common.sendKeyRequest()

            startTime = time.time()

            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

            resp = None

            while resp==None:

               try:

                  resp = common.readKey()

               except TimoutException:

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

                  break

               #no lock since we are just reading and we can afford to

               #miss a loop

               if idready == True:

                  #if someone swipes, break out of the loop

                  print "**swipe during read, bailing out"

                  logMessage("user swipped during keypad read")

                  break

               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)

                     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

               elif resp == None or ord(resp) == 0: #if we get noise, send timeout to reset and sync states

                  print "ERROR: got strange byte, timing out"

                  logMessage("ERROR: got 0 as a byte, sending timeout (cardbox power issue?)")

               else:

                  break

   except ctrlDException:

      print "got a ctrl-D, exiting cleanly"

   finally:

      if not threadDone:

         print "stopping id reader thread..."

         idt.stop()