root / pykota / trunk / bin / pykota @ 966

#! /usr/bin/env python

# PyKota accounting filter
#
# PyKota - Print Quotas for CUPS and LPRng
#
# (c) 2003 Jerome Alet <alet@librelogiciel.com>
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
#
# $Id$
#
# $Log$
# Revision 1.28  2003/04/26 08:41:24  jalet
# Small code reorganisation (UNTESTED) to allow pluggable accounting
# methods in the future.
#
# Revision 1.27  2003/04/25 09:23:47  jalet
# Debug message passed through !
#
# Revision 1.26  2003/04/25 08:23:23  jalet
# Multiple tries to get the printer's internal page counter, waits for
# one minute maximum for the printer to warm up, actually.
#
# Revision 1.25  2003/04/24 11:53:48  jalet
# Default policy for unknown users/groups is to DENY printing instead
# of the previous default to ALLOW printing. This is to solve an accuracy
# problem. If you set the policy to ALLOW, jobs printed by in nexistant user
# (from PyKota's POV) will be charged to the next user who prints on the
# same printer.
#
# Revision 1.24  2003/04/23 22:13:56  jalet
# Preliminary support for LPRng added BUT STILL UNTESTED.
#
# Revision 1.23  2003/04/15 11:30:57  jalet
# More work done on money print charging.
# Minor bugs corrected.
# All tools now access to the storage as priviledged users, repykota excepted.
#
# Revision 1.22  2003/04/15 11:09:04  jalet
# Small bug was fixed when a printer was never used and its internal
# page counter is not accessible.
#
# Revision 1.21  2003/04/12 17:20:14  jalet
# Better formula for HP workaround
#
# Revision 1.20  2003/04/12 16:58:28  jalet
# The workaround for HP printers was not correct, and there's probably no
# correct way to workaround the problem because we can't save the internal
# page counter in real time. The last job's size is unconditionnally set to
# 5 pages in this case.
#
# Revision 1.19  2003/04/11 08:56:49  jalet
# Comment
#
# Revision 1.18  2003/04/11 08:50:39  jalet
# Workaround for the HP "feature" of saving the page counter to NVRAM
# only every time 10 new pages are printed...
# Workaround for printers with volatile page counters.
#
# Revision 1.17  2003/04/10 21:47:20  jalet
# Job history added. Upgrade script neutralized for now !
#
# Revision 1.16  2003/04/08 20:38:08  jalet
# The last job Id is saved now for each printer, this will probably
# allow other accounting methods in the future.
#
# Revision 1.15  2003/03/29 13:45:27  jalet
# GPL paragraphs were incorrectly (from memory) copied into the sources.
# Two README files were added.
# Upgrade script for PostgreSQL pre 1.01 schema was added.
#
# Revision 1.14  2003/03/07 22:16:57  jalet
# Algorithmically incorrect : last user quota wasn't updated if current
# user wasn't allowed to print.
#
# Revision 1.13  2003/02/27 23:59:28  jalet
# Stupid bug wrt exception handlingand value conversion
#
# Revision 1.12  2003/02/27 23:48:41  jalet
# Correctly maps PyKota's log levels to syslog log levels
#
# Revision 1.11  2003/02/27 22:55:20  jalet
# WARN log priority doesn't exist.
#
# Revision 1.10  2003/02/27 22:43:21  jalet
# Missing import
#
# Revision 1.9  2003/02/27 22:40:26  jalet
# Correctly handles cases where the printer is off.
#
# Revision 1.8  2003/02/09 12:56:53  jalet
# Internationalization begins...
#
# Revision 1.7  2003/02/07 10:23:48  jalet
# Avoid a possible future name clash
#
# Revision 1.6  2003/02/06 22:54:33  jalet
# warnpykota should be ok
#
# Revision 1.5  2003/02/05 22:45:25  jalet
# Forgotten import
#
# Revision 1.4  2003/02/05 22:42:51  jalet
# Typo
#
# Revision 1.3  2003/02/05 22:38:39  jalet
# Typo
#
# Revision 1.2  2003/02/05 22:16:20  jalet
# DEVICE_URI is undefined outside of CUPS, i.e. for normal command line tools
#
# Revision 1.1  2003/02/05 21:28:17  jalet
# Initial import into CVS
#
#
#

import sys
import os
import time

from pykota.tool import PyKotaTool, PyKotaToolError
from pykota.requester import openRequester, PyKotaRequesterError

MAXTRIES = 6     # maximum number of tries to get the printer's internal page counter
TIMETOSLEEP = 10 # number of seconds to sleep between two tries to get the printer's internal page counter

class PyKotaFilter(PyKotaTool) :    
    """Class for the PyKota filter."""
    def __init__(self) :
        PyKotaTool.__init__(self)
        (self.printingsystem, self.printerhostname, self.printername, self.username, self.jobid, self.inputfile) = self.extractInfoFromCupsOrLprng()
        self.requester = openRequester(self.config, self.printername)
    
    def filterInput(self, inputfile) :
        """Transparent filter."""
        mustclose = 0    
        if inputfile is not None :    
            infile = open(inputfile, "rb")
            mustclose = 1
        else :    
            infile = sys.stdin
        data = infile.read(256*1024)    
        while data :
            sys.stdout.write(data)
            data = infile.read(256*1024)
        if mustclose :    
            infile.close()
            
    def acceptJob(self) :        
        """Returns the exit code needed by the printing backend to accept the job and print it."""
        if self.printingsystem == "CUPS" :
            return 0
        elif self.printingsystem == "LPRNG" :    
            return 0
        else :    
            # UNKNOWN
            return -1
            
    def removeJob(self) :            
        """Returns the exit code needed by the printing backend to refuse the job and remove it."""
        if self.printingsystem == "CUPS" :
            return 1
        elif self.printingsystem == "LPRNG" :    
            return 3
        else :    
            # UNKNOWN
            return -1
            
def main() :    
    """Do it, and do it right !"""
    global MAXTRIES, TIMETOSLEEP
    
    # Initializes the current tool
    kotafilter = PyKotaFilter()    
    
    #
    # If this is a CUPS filter, we should act and die like a CUPS filter when needed
    if kotafilter.printingsystem == "CUPS" :
        if len(sys.argv) not in (6, 7) :    
            sys.stderr.write("ERROR: %s job-id user title copies options [file]\n" % sys.argv[0])
            return kotafilter.removeJob()
    
    # Get the last page counter and last username from the Quota Storage backend
    printerid = kotafilter.storage.getPrinterId(kotafilter.printername)
    if printerid is None :
        # The printer is unknown from the Quota Storage perspective
        # we let the job pass through, but log a warning message
        kotafilter.logger.log_message(_("Printer %s not registered in the PyKota system") % kotafilter.printername, "warn")
    else :    
        userid = kotafilter.storage.getUserId(kotafilter.username)
        if userid is None :
            # The user is unknown from the Quota Storage perspective
            # Depending on the default policy for this printer, we
            # either let the job pass through or reject it, but we
            # log a message in any case.
            policy = kotafilter.config.getPrinterPolicy(kotafilter.printername)
            if policy == "ALLOW" :
                action = "POLICY_ALLOW"
            else :    
                action = "POLICY_DENY"
            kotafilter.logger.log_message(_("User %s not registered in the PyKota system, applying default policy (%s) for printer %s") % (kotafilter.username, action, kotafilter.printername), "warn")
            if action == "POLICY_DENY" :
                return kotafilter.removeJob()
        else :
            # Get the page counter directly from the printer itself
            # Tries MAXTRIES times, sleeping two seconds each time, in case the printer is sleeping.
            # This was seen with my Apple LaserWriter 16/600 PS which doesn't answer before having warmed up.
            for i in range(MAXTRIES) :
                try :
                    counterbeforejob = kotafilter.requester.getPrinterPageCounter(kotafilter.printerhostname)
                except PyKotaRequesterError, msg :
                    # can't get actual page counter, assume printer is off or warming up
                    # log the message anyway.
                    kotafilter.logger.log_message("%s" % msg, "warn")
                    counterbeforejob = None
                    printerIsOff = 1
                else :    
                    # printer answered, it is on so we can exit the loop
                    printerIsOff = 0
                    break
                time.sleep(TIMETOSLEEP)    
        
            # get last job information for this printer
            pgc = kotafilter.storage.getPrinterPageCounter(printerid)    
            if pgc is None :
                # The printer hasn't been used yet, from PyKota's point of view
                lasthistoryid = None
                lastjobid = kotafilter.jobid
                lastuserid = userid
                lastusername = kotafilter.username
                lastpagecounter = counterbeforejob
            else :    
                # get last values from Quota Storage
                (lasthistoryid, lastjobid, lastuserid, lastusername, lastpagecounter) = (pgc["id"], pgc["jobid"], pgc["userid"], pgc["username"], pgc["pagecounter"])
                
            # if printer is off then we assume the correct counter value is the last one
            if printerIsOff :
                counterbeforejob = lastpagecounter
                
            # if the internal lifetime page counter for this printer is 0    
            # then this may be a printer with a volatile counter (never
            # saved to NVRAM) which has just been switched off and then on
            # so we use the last page counter from the Quota Storage instead
            # explanation at : http://web.mit.edu/source/third/lprng/doc/LPRng-HOWTO-15.html
            if counterbeforejob == 0 :
                counterbeforejob = lastpagecounter
                
            # Computes the last job size as the difference between internal page
            # counter in the printer and last page counter taken from the Quota
            # Storage database for this particular printer
            try :
                jobsize = (counterbeforejob - lastpagecounter)    
            except TypeError :    
                # never used, and internal page counter not accessible
                jobsize = 0
                
            if jobsize < 0 :
                # Probably an HP printer which was switched off and back on, 
                # its primary counter is only saved in a 10 increment, so
                # it may be lower than the last page counter saved in the
                # Quota Storage. 
                # We unconditionnally set the last job's size to 
                # abs(int((10 - abs(lastcounter(snmp) - lastcounter(storage)) / 2))
                # For more accurate accounting, don't switch off your HP printers !
                # explanation at : http://web.mit.edu/source/third/lprng/doc/LPRng-HOWTO-15.html
                kotafilter.logger.log_message(_("Error in page count value %i for user %s on printer %s") % (jobsize, lastusername, kotafilter.printername), "error")
                jobsize = abs(int((10 - abs(jobsize)) / 2))     # Workaround for HP printers' feature !
                
            # update the quota for the previous user on this printer 
            kotafilter.storage.updateUserPQuota(lastuserid, printerid, jobsize)
            
            # update the last job size in the history
            kotafilter.storage.updateJobSizeInHistory(lasthistoryid, jobsize)
            
            # warns the last user if he is over quota
            kotafilter.warnUserPQuota(lastusername, kotafilter.printername)
                
            # Is the current user allowed to print at all ?
            action = kotafilter.warnUserPQuota(kotafilter.username, kotafilter.printername)
            
            # adds the current job to history    
            kotafilter.storage.addJobToHistory(kotafilter.jobid, kotafilter.storage.getUserId(kotafilter.username), printerid, counterbeforejob, action)
            
            # if not allowed to print then die, else proceed.
            if action == "DENY" :
                # No, just die cleanly
                return kotafilter.removeJob()
        
    # pass the job untouched to the underlying layer
    kotafilter.filterInput(kotafilter.inputfile)      
    
    return kotafilter.acceptJob()

if __name__ == "__main__" :    
    sys.exit(main())