Add sensibility
[uccvend-vendserver.git] / sql-edition / servers / VendServer.py
index c6a9416..b1274da 100755 (executable)
 #!/usr/bin/python
 #!/usr/bin/python
+# vim:ts=4
 
 
-import sys, os, string, socket, time, re
+USE_DB = 0
+
+import sys, os, string, re, pwd
+if USE_DB: import pg
+from time import time, sleep
 from popen2 import popen2
 from popen2 import popen2
-from pyPgSQL import PgSQL
 from LATClient import LATClient
 from LATClient import LATClient
-from CRC import do_crc
-from binascii import unhexlify
-
-asynchronous_responses = [     '400', '401', # door open/closed
-                                                       '610',        # switches changed
-                                                ]
-
-class VendingMachine:
-       def __init__(self, rfh, wfh):
-               self.secret = 'AAAAAAAAAAAAAAAA'
-               self.rfh = rfh
-               self.wfh = wfh
-               self.challenge = None
-               # Initialise ourselves into a known state
-               self.wfh.write('\n')
-               self.await_prompt()
-               self.wfh.write('echo off\n')
-               self.await_prompt()
-               self.wfh.write('PING\n')
-               code = ''
-               while code != '000':
-                       (code, _) = self.get_response()
-
-       def await_prompt(self):
-               self.wfh.flush()
-               state = 1
-               prefix = ''
-               s = ''
-               while True:
-                       s = self.rfh.read(1)
-                       if s == '': raise Exception
-                       if s == '\n' or s == '\r':
-                               state = 1
-                               prefix = ''
-                       if (s == '#' or s == '%') and state == 1: state = 2
-                       if s == ' ' and state == 2:
-                               if prefix == '':
-                                       self.challenge = None
-                                       return
-                               if re.search('^[0-9a-fA-F]{4}$', prefix):
-                                       self.challenge = unhexlify(prefix)
-                                       return
-
-       def get_response(self):
-               self.wfh.flush()
-               while True:
-                       s = ''
-                       while s == '':
-                               s = self.rfh.readline()
-                               if s == '': return None
-                               s = s.strip('\r\n')
-                       code = s[0:3]
-                       text = s[4:]
-                       if code in asynchronous_responses:
-                               self.handle_event(code, text)
+from VendingMachine import VendingMachine
+from ConfigParser import ConfigParser
+from HorizScroll import HorizScroll
+
+GREETING = 'UCC SNACKS'
+PIN_LENGTH = 4
+
+DOOR = 1
+SWITCH = 2
+KEY = 3
+
+class DispenseDatabase:
+       def __init__(self, vending_machine, host, name, user, password):
+               self.vending_machine = vending_machine
+               self.db = pg.DB(dbname = name, host = host, user = user, passwd = password)
+               self.db.query('LISTEN vend_requests')
+
+       def process_requests(self):
+               print 'processing'
+               query = 'SELECT request_id, request_slot FROM vend_requests WHERE request_handled = false'
+               try:
+                       outstanding = self.db.query(query).getresult()
+               except (pg.error,), db_err:
+                       sys.stderr.write('Failed to query database: %s\n'%(db_err.strip()))
+                       return
+               for (id, slot) in outstanding:
+                       (worked, code, string) = self.vending_machine.vend(slot)
+                       print (worked, code, string)
+                       if worked:
+                               query = 'SELECT vend_success(%s)'%id
+                               self.db.query(query).getresult()
                        else:
                        else:
-                               self.await_prompt()
-                               return (code, text)
+                               query = 'SELECT vend_failed(%s)'%id
+                               self.db.query(query).getresult()
+
+       def handle_events(self):
+               notifier = self.db.getnotify()
+               while notifier is not None:
+                       self.process_requests()
+                       notify = self.db.getnotify()
 
 
-       def handle_event(self, code, text):
+def scroll_options(username, mk, welcome = False):
+       if welcome:
+               msg = [(center('WELCOME'), False, 0.8),
+                          (center(username), False, 0.8)]
+       else:
+               msg = []
+       choices = ' '*10+'CHOICES: '
+       try:
+               coke_machine = file('/home/other/coke/coke_contents')
+               cokes = coke_machine.readlines()
+               coke_machine.close()
+       except:
+               cokes = []
                pass
                pass
+       for c in cokes:
+               c = c.strip()
+               (slot_num, price, slot_name) = c.split(' ', 2)
+               if slot_name == 'dead': continue
+               choices += '%s8-%s (%sc) '%(slot_num, slot_name, price)
+       choices += '55-DOOR '
+       choices += 'OR A SNACK. '
+       choices += '99 TO READ AGAIN. '
+       choices += 'CHOICE?   '
+       msg.append((choices, False, None))
+       mk.set_messages(msg)
+
+def get_pin(uid):
+       try:
+               info = pwd.getpwuid(uid)
+       except KeyError:
+               return None
+       if info.pw_dir == None: return False
+       pinfile = os.path.join(info.pw_dir, '.pin')
+       try:
+               s = os.stat(pinfile)
+       except OSError:
+               return None
+       if s.st_mode & 077:
+               return None
+       try:
+               f = file(pinfile)
+       except IOError:
+               return None
+       pinstr = f.readline()
+       f.close()
+       if not re.search('^'+'[0-9]'*PIN_LENGTH+'$', pinstr):
+               return None
+       return int(pinstr)
+
+def has_good_pin(uid):
+       return get_pin(uid) != None
+
+def verify_user_pin(uid, pin):
+       if get_pin(uid) == pin:
+               info = pwd.getpwuid(uid)
+               return info.pw_name
+       else:
+               return None
+
+def door_open_mode(vending_machine):
+       print "Entering open door mode"
+       v.display("DOOR  OPEN")
+       while True:
+               e = v.next_event()
+               if e == None: break
+               (event, params) = e
+               if event == DOOR:
+                       if params == 1: # door closed
+                               v.display("BYE BYE!")
+                               sleep(1)
+                               return
+
+def center(str):
+       LEN = 10
+       return ' '*((LEN-len(str))/2)+str
+
+class MessageKeeper:
+       def __init__(self, vendie):
+               # Each element of scrolling_message should be a 3-tuple of
+               # ('message', True/False if it is to be repeated, time to display)
+               self.scrolling_message = []
+               self.v = vendie
+               self.next_update = None
+
+       def set_message(self, string):
+               self.scrolling_message = [(string, False, None)]
+               self.update_display(True)
 
 
-       def authed_message(self, message):
-               if self.challenge == None:
-                       return message
-               crc = do_crc('%c%c'%(self.challenge >> 8, self.challenge & 0xff))
-               crc = do_crc(self.secret, crc)
-               crc = do_crc(message, crc)
-               return message+'|'+('%04x'%crc)
-
-       def ping(self):
-               self.wfh.write('PING\n')
-               (code, string) = self.get_response()
-               return (code == '000', code, string)
-
-       def vend(self, item):
-               if not re.search('^[0-9][0-9]$', item):
-                       return (False, 'Invalid item requested (%s)'%item)
-               self.wfh.write(self.authed_message(('V%s\n'%item)+'\n'))
-               (code, string) = self.get_response()
-               return (code, string)
-
-       def beep(self, duration = None, synchronous = True):
-               msg = 'B'
-               if synchronous: msg += 'S'
-               if duration != None:
-                       if duration > 255: duration = 255
-                       if duration < 1: duration = 1
-                       msg += '%02x'%duration
-               self.wfh.write(msg+'\n')
-               (code, string) = self.get_response()
-               return (code == '500', code, string)
-
-       def silence(self, duration = None, synchronous = True):
-               msg = 'C'
-               if synchronous: msg += 'S'
-               if duration != None:
-                       if duration > 255: duration = 255
-                       if duration < 1: duration = 1
-                       msg += '%02x'%duration
-               self.wfh.write(msg+'\n')
-               (code, string) = self.get_response()
-               # FIXME: workaround a bug in rom W. should be just: return (code == '500', code, string)
-               return (code == '500' or code == '501', code, string)
-
-       def display(self, string):
-               if len(string) > 10:
-                       string = string[0:10]
-               self.wfh.write('D'+string+'\n')
-               (code, string) = self.get_response()
-               return (code == '300', code, string)
+       def set_messages(self, strings):
+               self.scrolling_message = strings
+               self.update_display(True)
+
+       def update_display(self, forced = False):
+               if not forced and self.next_update != None and time() < self.next_update:
+                       return
+               if len(self.scrolling_message) > 0:
+                       if len(self.scrolling_message[0][0]) > 10:
+                               (m, r, t) = self.scrolling_message[0]
+                               a = []
+                               exp = HorizScroll(m).expand(padding = 0, wraparound = False)
+                               if t == None:
+                                       t = 0.1
+                               else:
+                                       t = t / len(exp)
+                               for x in exp:
+                                       a.append((x, r, t))
+                               del self.scrolling_message[0]
+                               self.scrolling_message = a + self.scrolling_message
+                       newmsg = self.scrolling_message[0]
+                       if newmsg[2] != None:
+                               self.next_update = time() + newmsg[2]
+                       else:
+                               self.next_update = None
+                       self.v.display(self.scrolling_message[0][0])
+                       if self.scrolling_message[0][1]:
+                               self.scrolling_message.append(self.scrolling_message[0])
+                       del self.scrolling_message[0]
+
+       def done(self):
+               return len(self.scrolling_message) == 0
 
 if __name__ == '__main__':
 
 if __name__ == '__main__':
+       cp = ConfigParser()
+       cp.read('/etc/dispense/servers.conf')
+       DBServer = cp.get('Database', 'Server')
+       DBName = cp.get('Database', 'Name')
+       DBUser = cp.get('VendingMachine', 'DBUser')
+       DBPassword = cp.get('VendingMachine', 'DBPassword')
+
+       ServiceName = cp.get('VendingMachine', 'ServiceName')
+       ServicePassword = cp.get('VendingMachine', 'Password')
        # Open vending machine via LAT
        # Open vending machine via LAT
-       latclient = LATClient(service = 'VEND', password = 'dmscptd')
-       (rfh, wfh) = latclient.get_fh()
+       if 0:
+               latclient = LATClient(service = ServiceName, password = ServicePassword)
+               (rfh, wfh) = latclient.get_fh()
+       else:
+               #(rfh, wfh) = popen2('../../virtualvend/vvend.py')
+               import socket
+               sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+               sock.connect(('localhost', 5150))
+               rfh = sock.makefile('r')
+               wfh = sock.makefile('w')
        v = VendingMachine(rfh, wfh)
        print 'PING is', v.ping()
        v = VendingMachine(rfh, wfh)
        print 'PING is', v.ping()
-       print 'BEEP is', v.beep()
-       print 'VEND 11 is', v.vend('11')
-       print 'SILENCE is', v.silence()
-       print 'DISPLAY is', v.display('GOOD NIGHT')
+
+       if USE_DB: db = DispenseDatabase(v, DBServer, DBName, DBUser, DBPassword)
+       cur_user = ''
+       cur_pin = ''
+       cur_selection = ''
+
+       mk = MessageKeeper(v)
+       mk.set_message(GREETING)
+       logout_timeout = None
+       last_timeout_refresh = None
+
+       while True:
+               if USE_DB: db.handle_events()
+
+               if logout_timeout != None:
+                       time_left = logout_timeout - time()
+                       if time_left < 5 and (last_timeout_refresh is None or last_timeout_refresh > time_left):
+                               mk.set_message('LOGOUT: '+str(int(time_left)))
+                               last_timeout_refresh = int(time_left)
+                               cur_selection = ''
+
+               if logout_timeout != None and logout_timeout - time() <= 0:
+                       logout_timeout = None
+                       cur_user = ''
+                       cur_pin = ''
+                       cur_selection = ''
+                       mk.set_message(GREETING)
+
+               if logout_timeout and not mk.done(): logout_timeout = None
+               if len(cur_pin) == PIN_LENGTH and mk.done() and logout_timeout == None:
+                       # start autologout
+                       logout_timeout = time() + 15
+
+               mk.update_display()
+
+               e = v.next_event(0)
+               if e == None:
+                       e = v.next_event(0.1)
+                       if e == None:
+                               continue
+               (event, params) = e
+               print e
+               if event == DOOR:
+                       if params == 0:
+                               door_open_mode(v);
+                               cur_user = ''
+                               cur_pin = ''
+                               mk.set_message(GREETING)
+               elif event == SWITCH:
+                       # don't care right now.
+                       pass
+               elif event == KEY:
+                       key = params
+                       # complicated key handling here:
+                       if len(cur_user) < 5:
+                               if key == 11:
+                                       cur_user = ''
+                                       mk.set_message(GREETING)
+                                       continue
+                               cur_user += chr(key + ord('0'))
+                               mk.set_message('UID: '+cur_user)
+                               if len(cur_user) == 5:
+                                       uid = int(cur_user)
+                                       if not has_good_pin(uid):
+                                               mk.set_messages(
+                                                       [(center('INVALID'), False, 0.7),
+                                                        (center('PIN'), False, 0.7),
+                                                        (center('SETUP'), False, 1.0),
+                                                        (GREETING, False, None)])
+                                               cur_user = ''
+                                               cur_pin = ''
+                                               continue
+                                       cur_pin = ''
+                                       mk.set_message('PIN: ')
+                                       continue
+                       elif len(cur_pin) < PIN_LENGTH:
+                               if key == 11:
+                                       if cur_pin == '':
+                                               cur_user = ''
+                                               mk.set_message(GREETING)
+                                               continue
+                                       cur_pin = ''
+                                       mk.set_message('PIN: ')
+                                       continue
+                               cur_pin += chr(key + ord('0'))
+                               mk.set_message('PIN: '+'X'*len(cur_pin))
+                               if len(cur_pin) == PIN_LENGTH:
+                                       username = verify_user_pin(int(cur_user), int(cur_pin))
+                                       if username:
+                                               v.beep(0, False)
+                                               cur_selection = ''
+                                               scroll_options(username, mk, True)
+                                               continue
+                                       else:
+                                               v.beep(40, False)
+                                               mk.set_messages(
+                                                       [(center('BAD PIN'), False, 1.0),
+                                                        (center('SORRY'), False, 0.5),
+                                                        (GREETING, False, None)])
+                                               cur_user = ''
+                                               cur_pin = ''
+                                               continue
+                       elif len(cur_selection) == 0:
+                               if key == 11:
+                                       cur_pin = ''
+                                       cur_user = ''
+                                       cur_selection = ''
+                                       v.display('BYE!')
+                                       sleep(0.5)
+                                       mk.set_message(GREETING)
+                                       continue
+                               cur_selection += chr(key + ord('0'))
+                               mk.set_message('SELECT: '+cur_selection)
+                       elif len(cur_selection) == 1:
+                               if key == 11:
+                                       cur_selection = ''
+                                       logout_timeout = None
+                                       scroll_options(username, mk)
+                                       continue
+                               else:
+                                       cur_selection += chr(key + ord('0'))
+                                       #make_selection(cur_selection)
+                                       # XXX this should move somewhere else:
+                                       if cur_selection == '55':
+                                               v.display('GOT DOOR?')
+                                               os.system('su - "%s" -c "dispense door"'%username)
+                                       elif cur_selection == '99':
+                                               scroll_options(username, mk)
+                                               cur_selection = ''
+                                               continue
+                                       elif cur_selection[1] == '8':
+                                               v.display('GOT COKE?')
+                                               os.system('su - "%s" -c "dispense %s"'%(username, cur_selection[0]))
+                                       else:
+                                               v.display('HERES A '+cur_selection)
+                                               v.vend(cur_selection)
+                                       sleep(0.5)
+                                       v.display('THANK YOU')
+                                       sleep(0.5)
+                                       cur_selection = ''
+                                       logout_timeout = time() + 10

UCC git Repository :: git.ucc.asn.au