release-station

#!/usr/bin/python

EXTRA_MODULES="/usr/share/pharos-release-station/modules"
LOGGER_NAME="pharos-release-station"
UI_FILE="/usr/share/pharos-release-station/release-station.ui"
CONFIG_FILE="/etc/pharos-release-station/config.ini"
CONFIG_DEFAULTS = { "edi_use_ssl": "true",
                    "admin_password": "change_this",
                    "logo_image_file": "/usr/share/pharos-release-station/logo.png",
                    "idcard_image_file": "/usr/share/pharos-release-station/id-card.jpg",
                  }


from gi.repository import GObject, GLib, Gtk, Gdk, GdkPixbuf

from optparse import OptionParser

import ConfigParser, io

import sys, os.path, time, traceback
import logging
import logging.handlers
import threading

# Local modules as separate packages
import omega, magtek

sys.path.append(EXTRA_MODULES)
# Modules kept separate but shipped with this
import auth_krb5, omega_site

logger = logging.getLogger(LOGGER_NAME)

class ReleaseStationInternalError(Exception):
    pass

class ReleaseStation:
    def __init__(self, options, config, quitFunction):
        """Constructor

        options -- dictionary of values from OptionParser
        config -- ConfigParser configuration
        quitFunction -- something callable (i.e. GLib.MainLoop().quit or Gtk.main_quit)
        """
        self.builder = Gtk.Builder()
        self.config = config
        self.quitFunction = quitFunction
        self.threads = []
        try: 
            self.builder.add_from_file(options.ui_file)
            logger.debug("Builder UI loaded")
        except GLib.GError, e:
            logger.exception("Unable to load UI:")
            sys.exit(1)
        
        # Gtk signal handlers
        handlers = {
            "kpEvent": self.cbKeyPress,
            "cb_admin_off": self.cbAdminOff,
            "cb_login": self.cbLogin, 
            "cb_toggle_tabs": self.cbToggleTabs, 
            "cb_user_activate": self.cbUserActivate,
            "cb_exit": self.cbExit,
            "cb_exit_app": self.cbExitApp,
            "cb_restart_app": self.cbRestartApp,
            "cb_print": self.cbPrint,
            "cb_printall": self.cbPrintAll,
            "cb_delete": self.cbDelete
        }
        self.winMain = self.builder.get_object("winMain")
        self.winMain.resize(640,480)
        self.winMain.set_position(Gtk.WindowPosition.CENTER)
        self.builder.get_object("nbMain").set_current_page(0)
        self.builder.get_object("imgLogo")
        try:
            pixbuf = GdkPixbuf.Pixbuf.new_from_file(config.get('ReleaseStation', 'logo_image_file'))
        except GLib.GError as e:
            logger.exception("Failed to load image file")
            pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False, 8, 10, 10)
        self.builder.get_object("imgLogo").set_from_pixbuf(pixbuf)
        try:
            pixbuf = GdkPixbuf.Pixbuf.new_from_file(config.get('ReleaseStation', 'idcard_image_file'))
        except GLib.GError as e:
            pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False, 8, 10, 10)
        self.builder.get_object("imgCard").set_from_pixbuf(pixbuf)
        self.winMain.show_all()
        logger.debug("Main screen turn on!")
        self.builder.connect_signals(handlers)
        logger.debug("We get signal!")
        # Because we don't have a window manager
        Gdk.Window.focus(self.winMain.get_window(), Gdk.CURRENT_TIME)
        # GNOME 3 turns off button images by default.  Turn it on
        self.gtkSettings = Gtk.Settings.get_default()
        self.gtkSettings.set_property('gtk-button-images', True)

        self.magtek = None
        try:
            self.magtek = magtek.MagTek()
        except magtek.MagTekException as e:
            logger.warn("Error while initializing MagTek module: %s", e.message)

        # Omega connection
        try:
            self.omega = omega.Omega(config.get('ReleaseStation', 'edi_server'), 
                                     config.getboolean('ReleaseStation', 'edi_use_ssl'))
            self.omega.start_session(config.get('ReleaseStation', 'omega_name'),
                                     config.get('ReleaseStation', 'site_password'))
        except omega.OmegaException as e:
            logger.exception("An error occurred while connecting to Pharos")
            sys.exit(1)
        self.builder.get_object("lblTerminalName").set_text("Terminal: " + config.get('ReleaseStation', 'omega_name'))
        self.builder.get_object("lblPrinterName").set_text("Printer: " + self.omega.printer)
        self.jobListStore = self.builder.get_object("jobList")
        self.jobListStore.clear()
        if self.magtek is None:
            logger.warning("Card reader not found.  Card swiping will be disabled.")
        elif self.magtek.getInterfaceType() != magtek.MagTek.INTERFACE_TYPE_HID:
            logger.warning("Card reader not in HID mode.  Swiping will be disabled.")
            self.magtek = None
        self.builder.get_object("treeviewPrintJobs").get_selection().connect("changed", self._selectionChanged)
        if self.magtek is None:
            self.builder.get_object("lblOr").set_visible(False)
            self.builder.get_object("frmSwipe").set_visible(False)


    def _ensureConnection(self):
        try:
            if not self.omega.connected():
                logger.debug("Starting new session...")
                self.omega.start_session(config.get('ReleaseStation', 'omega_name'), config.get('ReleaseStation', 'site_password'))
                logger.info("Started new session.")
        except omega.OmegaException as e:
            self._errDialog("An error occurred while reconnecting to Pharos: %s" % e.message, False)
            sys.exit(1)

    def cbAdminOff(self, widget):
        self.builder.get_object("adminBox").set_visible(False)

    def toggleAdminMode(self):
        if self.builder.get_object("adminBox").get_visible():
            self.builder.get_object("adminBox").set_visible(False)
        else:
            dlg = self.builder.get_object("adminDialog")
            if dlg.run() == Gtk.ResponseType.OK:
                if self.config.get('ReleaseStation', "admin_password") == self.builder.get_object("adminPassword").get_text():
                    logger.info("Enabling admin mode")
                    self.builder.get_object("adminBox").set_visible(True)
                else:
                    self._errDialog("Password incorrect", False)
            self.builder.get_object("adminPassword").set_text('')
            dlg.hide()
            

    def cbKeyPress(self, widget, event):
        logger.debug("Keypress event received by %s", widget)
        if widget is self.builder.get_object("winMain"):
            if event.keyval == Gdk.KEY_F12:
                self.toggleAdminMode()
        elif event.keyval == Gdk.KEY_Escape:
            self.resetLoginScreen()

    def cbExitApp(self, widget):
        self.quitApp()

    def cbRestartApp(self, widget):
        self.quitApp()
        sys.exit(128)

    def quitApp(self):
        for t in self.threads:
            if not isinstance(t, threading.Thread):
                logger.fatal("Thread %s is not a thread!", t)
                continue
            try:
                t.stop()
            except Exception as e:
                logger.fatal("Exception while terminating thread: %s", e)
        self.quitFunction()

    def cbToggleTabs(self, widget):
        nb = self.builder.get_object("nbMain")
        if nb.get_show_tabs():
            nb.set_show_tabs(False)
            widget.set_label("Show Tabs")
        else:
            nb.set_show_tabs(True)
            widget.set_label("Hide Tabs")

    def cbExit(self, widget):
        self.returnToLogin()

    def resetLoginScreen(self):
        self.builder.get_object("tfUsername").set_text("")
        self.builder.get_object("tfPassword").set_text("")
        self.builder.get_object("tfUsername").grab_focus()
        

    def returnToLogin(self):
        # Clear the job ListStore
        self.jobListStore.clear()
        # reset the UI on the release pane
        self._toggleJobButtons(False)
        self.queueProgress('hide')
        self.builder.get_object("queueLbl").set_text("(please wait)")
        self.builder.get_object("queueLbl").set_visible(True)
        self.builder.get_object("treeviewWindow").set_visible(False)
        for lbl in ("lblUsername", "lblBalance", "lblSoftQuota", "lblPrintingPlan"):
            self.builder.get_object(lbl).set_text("")
        # Unlock the user
        if self._currentUser is not None:
            self.omega.unlockUser(self._currentUser)
        self._currentUser = None
        self.builder.get_object("nbMain").set_current_page(0)
        self.resetLoginScreen()

    def _toggleJobButtons(self, state):
        for b in ('btnDelete', 'btnPrint'):
            self.builder.get_object(b).set_sensitive(state)

    def _selectionChanged(self, widget, user_data=None):
        if self._getSelectedJob() is not None:
            self._toggleJobButtons(True)

    def cbUserActivate(self, widget):
        # Move focus to password field if user hits "Enter"
        if len(widget.get_text()) > 0:
            self.builder.get_object("tfPassword").grab_focus()

    # TODO: locking?  Handle if locked on another terminal
    def cbLogin(self, widget):
        logger.debug("In login callback")
        uname = self.builder.get_object("tfUsername").get_text()
        password = self.builder.get_object("tfPassword").get_text()
        if len(uname) < 1 or len(password) < 1:
            return
        krbauth = auth_krb5.Authenticator('pharos-release-station')
        if krbauth.authenticate(uname, password):
            logger.debug("Got username: %s", uname)
            if uname:
                self._currentUser = uname
                self.displayJobList()
        else:
            self._errDialog("Error: %s" % krbauth.error, False)
            self.resetLoginScreen()

    def _errDialog(self, message, verbose=True):
        msg = message
        dlg = Gtk.MessageDialog(self.winMain,
                                Gtk.DialogFlags.DESTROY_WITH_PARENT,
                                Gtk.MessageType.ERROR,
                                Gtk.ButtonsType.CLOSE,
                                message + ("\n\n(Please visit the TechCash office in W20-021\n or report this error to icp-help@mit.edu.)" if verbose else ""))
        dlg.set_title("Error")
        red = Gdk.RGBA()
        red.parse("#993333")
        white = Gdk.RGBA()
        white.parse("white")
        dlg.override_background_color(0, red)
        dlg.override_color(0, white)
        logger.debug("Running _errDialog")
        dlg.run()
        logger.debug("Done with _errDialog")
        dlg.destroy()
        logger.debug("Destroyed _errDialog")

    def _pulseBar(self):
        logger.debug('Pulsing queue progress bar')
        self.queueProgress('pulse')
        while Gtk.events_pending():
            Gtk.main_iteration()

    def loginProgress(self, op='hide'):
        if op == 'hide':
            self.builder.get_object("loginProgress").hide()
        elif op == 'pulse':
            self.builder.get_object("loginProgress").show()
            self.builder.get_object("loginProgress").pulse()
        else:
            logger.warning("Unknown progress bar operation '%s'", op)

    def queueProgress(self, op='hide'):
        if op == 'hide':
            self.builder.get_object("queueProgress").hide()
        elif op == 'pulse':
            self.builder.get_object("queueProgress").show()
            self.builder.get_object("queueProgress").pulse()
        else:
            logger.warning("Unknown progress bar operation '%s'", op)

    def displayJobList(self):
        if self._currentUser is None:
            raise ReleaseStationInternalError("_currentUser is None in displayJobList()")
        self._ensureConnection()
        self.builder.get_object("nbMain").set_current_page(1)
        while Gtk.events_pending():
            Gtk.main_iteration()
        self.queueProgress('pulse')
        logger.debug("Calling getUserDetails")
        try:
            details = self.omega.getUserDetails(self._currentUser)
        except omega.PharosEDIException as e:
            logger.info("getUserDetails threw exception: %s", e.message)
            # Ugh
            self._errDialog(e.message, not ("user is locked" in e.message))
            self.returnToLogin()
            return
        localdetails = omega_site.Details(details)
        if not localdetails.isActive():
            self._errDialog("Your Pharos account is flagged as inactive.  The most common cause of this is a change in your affiliation, such as graduating.  Contact the TechCash office and request that your Pharos account be re-activated.", False)
            self.returnToLogin()
            return
        self.builder.get_object("lblUsername").set_text(self._currentUser)
        self.builder.get_object("lblBalance").set_text("%d pages" % localdetails.getPageBalance())
        self.builder.get_object("lblSoftQuota").set_text("Yes" if localdetails.canExceedQuota() else "No")
        self.builder.get_object("lblPrintingPlan").set_text(localdetails.getAffiliation())
        self._pulseBar()
        logger.debug("Calling getPrintJobsForUser")
        try:
            jobs = self.omega.getPrintJobsForUser(self._currentUser, self._pulseBar)
        except omega.PharosEDIException as e:
            logger.error("getPrintJobsForUser threw exception: %s", e.message)
            self._errDialog("Error while retrieving print jobs: " + e.message)
            self.returnToLogin()
            return
        logger.debug("Found %d jobs", len(jobs))
        self.jobobjs = {}
        self.jobListStore.clear()
        if len(jobs) == 0:
            self.builder.get_object("queueLbl").set_text("No print jobs found.")
        if jobs:
            self.builder.get_object("queueLbl").set_visible(False)
            self.builder.get_object("treeviewWindow").set_visible(True)
            for j in jobs:
                self._pulseBar()
                Gtk.main_iteration_do(False)
                # TODO: Just store the object in the Liststore, but it needs to be a subclass of GObject
                self.jobobjs[j.job_id] = j
                self.jobListStore.append((j.job_id, j.username, j.formattedDate("%b %m %H:%M"), j.pages, j.jobname))
            # Select the first job, emulate the Omegas
            self.builder.get_object("treeviewPrintJobs").get_selection().select_iter(self.jobListStore.get_iter_first())
        self.queueProgress('hide')

    def _getSelectedJob(self):
        tree = self.builder.get_object("treeviewPrintJobs")
        model, it = tree.get_selection().get_selected()
        if it != None:
            return model[it][0]
        else:
            return None

    def _askQuestion(self, questionTxt):
        dlg = Gtk.MessageDialog(self.winMain,
                                Gtk.DialogFlags.DESTROY_WITH_PARENT,
                                Gtk.MessageType.QUESTION,
                                Gtk.ButtonsType.YES_NO,
                                questionTxt)
        dlg.set_title("Question")
        response = dlg.run()
        dlg.destroy()
        return (response == Gtk.ResponseType.YES)

    def cbPrint(self, widget):
        job = self._getSelectedJob()
        self._releaseJob(job)
        self.displayJobList()

    def _releaseJob(self, jobid):
        if jobid is not None and jobid in self.jobobjs:
            try:
                self.omega.releaseJob(jobid, self.jobobjs[jobid].queue, self.jobobjs[jobid].username)
            except omega.PharosEDIException as e:
                self._errDialog("Error while releasing job:\n%s" % (e.message))


    def cbPrintAll(self, widget):
        if self._askQuestion("Are you sure you want to print all jobs?"):
            print >>sys.stderr, self.jobobjs
            for k in self.jobobjs:
                self._releaseJob(k)
        self.displayJobList()

    def cbDelete(self, widget):
        job = self._getSelectedJob()
        if job is not None:
            try:
                self.omega.deleteJob(job, self.jobobjs[job].queue)
            except omega.PharosEDIException(e):
                self._errDialog("Error while deleting job:\n%s" % (e.message))
        self.displayJobList()

    def checkForSwipe(self, swipeData=None):
        track2 = swipeData.getTrack(2)
        logger.debug("Track 2: %s", track2)
        if swipeData.getTrack(1) is not None and swipeData.getTrack(1).startswith("%B"):
            self._errDialog("Sorry, you can't pay for printing with a credit or debit card.\n\nBut thanks for the credit card number, it'll come in handy!\n\n(just kidding about that last part)", False)
            return
        if track2 is None:
            self._errDialog("Couldn't read your card.  Please try again.\n\nIf your ID is old or your magnetic stripe is worn\nor damaged, you may need a replacement card.", False)
            return
        if swipeData.getTrack(3) is None or swipeData.getTrack(1):
            if not self._askQuestion("That doesn't look like an MIT ID card.  Try to continue anyway?"):
                return

        username = None
        logger.debug("Looking up card...")
        try:
            self._ensureConnection()
            username = self.omega.getUsernameFromCard(track2)
        except omega.PharosEDIException as e:
            self._errDialog(e.message, False)
        if len(username) > 0:
            self._currentUser = username
            self.displayJobList()
        else:
            logger.warn("Got username (%s), shouldn't happen", username)

    def _excepthook(self, type, value, tb):
        logger.critical("UNHANDLED EXCEPTION:\n%s\n", ''.join(traceback.format_exception(type, value, tb)))
        dlg = Gtk.MessageDialog(self.winMain,
                                Gtk.DialogFlags.DESTROY_WITH_PARENT,
                                Gtk.MessageType.ERROR,
                                Gtk.ButtonsType.CLOSE,
                                "An unexpected error occurred. Consult the logs for more details.\nThe program will now quit.\n")
        dlg.run()
        dlg.destroy()
        self.quitApp()
        sys.exit(1)

class CardReaderThread(threading.Thread):
    stop_event = threading.Event()

    def __init__(self, reader=None, consumer_object=None):
        super(CardReaderThread, self).__init__(None, None, 'CardReaderThread')
        self.consumer_object = consumer_object
        self.reader = reader
        self.logger = logging.getLogger(LOGGER_NAME).getChild("CardReaderThread")

    # A callback to stop the blocking loop in readCard
    def _readerCallback(self, dataLen=0):
        self.logger.debug("_readerCallback: %d", dataLen)
        if dataLen > 0:
            Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT, 
                                 self.consumer_object.loginProgress, 'pulse')
        return not self.stop_event.isSet()

    def run(self):
        self.logger.debug("Starting card reader thread")
        while not self.stop_event.isSet():
            if self.reader is None:
                self.logger.debug("No reader found")
                self.stop()
                continue
            swipeData = None
            try:
                self.logger.debug("Calling readCard...")
                swipeData = self.reader.readCard(True, self._readerCallback)
            except magtek.MagTekException as e:
                logger.exception("Exception while reading card")
                self.consumer_object.quitApp()
                sys.exit(128)
            except Exception as e:
                self.logger.warning("Exception while reading card data: %s", e)
            if swipeData is None:
                self.logger.debug("swipeData = None, user probably cancelled...")
            else:
                self.logger.debug("Got swipe data")
                if self.consumer_object is not None:
                    # Add an idle callback.  Doing this any other way will block the UI.
                    Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT, 
                                         self.consumer_object.loginProgress, 'hide')
                    Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT, 
                                         self.consumer_object.checkForSwipe, swipeData)
                    self.logger.debug("idle thread callback added")
                else:
                    logger.warn("consumer_object is None, cannot notify")

    def stop(self):
        logger.debug("Stopping thread.")
        self.stop_event.set()

if __name__ == '__main__':
    # Initialize logging
    log_handler = logging.StreamHandler()
    log_handler.setFormatter(
        logging.Formatter('%(asctime)s:%(levelname)s:%(message)s'))
    log_handler.setLevel(logging.WARNING)
    logger.addHandler(log_handler)
    # Parse command line options
    parser = OptionParser()
    parser.set_defaults(debug=False)
    parser.add_option("--debug", action="store_true", dest="debug")
    parser.add_option("--ui", action="store", type="string",
                      default=UI_FILE, dest="ui_file")
    parser.add_option("--cfg", action="store", type="string",
                      default=CONFIG_FILE, dest="config_file")
    (options, args) = parser.parse_args()
    if options.debug:
        logger.setLevel(logging.DEBUG)
        debug_handler = logging.StreamHandler()
        debug_handler.setFormatter(
            logging.Formatter('%(levelname)s:%(message)s'))
        logger.addHandler(debug_handler)
    # Parse config file
    if not os.path.isfile(options.config_file):
        logger.error("Config file %s not found", options.config_file)
        sys.exit(1)
    config = ConfigParser.RawConfigParser(CONFIG_DEFAULTS)
    config.readfp(io.BytesIO("[ReleaseStation]\n"))
    config.read(options.config_file)
    # This initializes threading support in the PyGObject bindings.  This is not
    # a GObject API call.
    GObject.threads_init()
    # Initialize Gdk.Gtk thread support
    Gdk.threads_init()
    Gtk.init(None)
    main_loop = GLib.MainLoop()
    try:
        alpha = ReleaseStation(options, config, main_loop.quit)
        cardReader = CardReaderThread(alpha.magtek, alpha)
        alpha.threads.append(cardReader)
        cardReader.start()
        sys.excepthook = alpha._excepthook
    except Exception as e:
        logger.exception("Unexpected error while starting application")
    try:
        main_loop.run()
    except KeyboardInterrupt:
        logger.debug("KeyboardInterrupt received, shutting down...")
        cardReader.stop()
        logger.debug("Threads stopped.  Quitting main_loop")
        main_loop.quit()
    except Exception as e:
        logger.exception("A fatal error occurred while runing the main loop.")