root / pykota / trunk / bin / pkprinters @ 3413

#! /usr/bin/env python
# -*- coding: utf-8 -*-*-
#
# PyKota : Print Quotas for CUPS
#
# (c) 2003, 2004, 2005, 2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.
#
# $Id$
#
#

import os
import sys
import pwd

import pykota.appinit
from pykota.utils import *

from pykota.errors import PyKotaCommandLineError
from pykota.tool import Percent, PyKotaTool
from pykota.storage import StoragePrinter

from pkipplib import pkipplib

__doc__ = N_("""pkprinters v%(__version__)s (c) %(__years__)s %(__author__)s

A Printers Manager for PyKota.

command line usage :

  pkprinters [options] printer1 printer2 printer3 ... printerN

options :

  -v | --version       Prints pkprinters's version number then exits.
  -h | --help          Prints this message then exits.

  -a | --add           Adds printers if they don't exist on the Quota
                       Storage Server. If they exist, they are modified
                       unless -s|--skipexisting is also used.

  -d | --delete        Deletes printers from the quota storage.

  -D | --description d Adds a textual description to printers.

  -C | --cups          Also modifies the DeviceURI in CUPS' printers.conf

  -c | --charge p[,j]  Sets the price per page and per job to charge.
                       Job price is optional.
                       If both are to be set, separate them with a comma.
                       Floating point and negative values are allowed.

  -g | --groups pg1[,pg2...] Adds or Remove the printer(s) to the printer
                       groups pg1, pg2, etc... which must already exist.
                       A printer group is just like a normal printer,
                       only that it is usually unknown from the printing
                       system. Create printer groups exactly the same
                       way that you create printers, then add other
                       printers to them with this option.
                       Accounting is done on a printer and on all
                       the printer groups it belongs to, quota checking
                       is done on a printer and on all the printer groups
                       it belongs to.
                       If the --remove option below is not used, the
                       default action is to add printers to the specified
                       printer groups.

  -l | --list          List informations about the printer(s) and the
                       printers groups it is a member of.

  -r | --remove        In combination with the --groups option above,
                       remove printers from the specified printers groups.

  -s | --skipexisting  In combination with the --add option above, tells
                       pkprinters to not modify existing printers.

  -m | --maxjobsize s  Sets the maximum job size allowed on the printer
                       to s pages.

  -p | --passthrough   Activate passthrough mode for the printer. In this
                       mode, users are allowed to print without any impact
                       on their quota or account balance.

  -n | --nopassthrough Deactivate passthrough mode for the printer.
                       Without -p or -n, printers are created in
                       normal mode, i.e. no passthrough.

  printer1 through printerN can contain wildcards if the --add option
  is not set.

examples :

  $ pkprinters --add -D "HP Printer" --charge 0.05,0.1 hp2100 hp2200 hp8000

  Will create three printers named hp2100, hp2200 and hp8000.
  Their price per page will be set at 0.05 unit, and their price
  per job will be set at 0.1 unit. Units are in your own currency,
  or whatever you want them to mean.
  All of their descriptions will be set to the string "HP Printer".
  If any of these printers already exists, it will also be modified
  unless the -s|--skipexisting command line option is also used.

  $ pkprinters --delete "*"

  This will completely delete all printers and associated quota information,
  as well as their job history. USE WITH CARE !

  $ pkprinters --groups Laser,HP "hp*"

  This will put all printers which name matches "hp*" into printers groups
  Laser and HP, which MUST already exist.

  $ pkprinters --groups LexMark --remove hp2200

  This will remove the hp2200 printer from the LexMark printer group.
""")

class PKPrinters(PyKotaTool) :
    """A class for a printers manager."""
    def modifyPrinter(self, printer, charges, perpage, perjob, description, passthrough, nopassthrough, maxjobsize) :
        if charges :
            printer.setPrices(perpage, perjob)
        if description is not None :        # NB : "" is allowed !
            printer.setDescription(description)
        if nopassthrough :
            printer.setPassThrough(False)
        if passthrough :
            printer.setPassThrough(True)
        if maxjobsize is not None :
            printer.setMaxJobSize(maxjobsize)

    def managePrintersGroups(self, pgroups, printer, remove) :
        """Manage printer group membership."""
        for pgroup in pgroups :
            if remove :
                pgroup.delPrinterFromGroup(printer)
            else :
                pgroup.addPrinterToGroup(printer)

    def getPrinterDeviceURI(self, printername) :
        """Returns the Device URI attribute for a particular printer."""
        if not printername :
            return ""
        cups = pkipplib.CUPS()
        req = cups.newRequest(pkipplib.IPP_GET_PRINTER_ATTRIBUTES)
        req.operation["printer-uri"] = ("uri", cups.identifierToURI("printers", printername))
        try :
            return cups.doRequest(req).printer["device-uri"][0][1]
        except :
            self.printInfo(_("Impossible to retrieve %(printername)s's DeviceURI") % locals(), "warn")
            return ""

    def isPrinterCaptured(self, printername=None, deviceuri=None) :
        """Returns True if the printer is already redirected through PyKota's backend, else False."""
        if (deviceuri or self.getPrinterDeviceURI(printername)).find("cupspykota:") != -1 :
            return True
        else :
            return False

    def reroutePrinterThroughPyKota(self, printer) :
        """Reroutes a CUPS printer through PyKota."""
        uri = self.getPrinterDeviceURI(printer.Name)
        if uri and (not self.isPrinterCaptured(deviceuri=uri)) :
             newuri = "cupspykota://%s" % uri
             os.system('lpadmin -p "%s" -v "%s"' % (printer.Name, newuri))
             self.logdebug("Printer %s rerouted to %s" % (printer.Name, newuri))

    def deroutePrinterFromPyKota(self, printer) :
        """Deroutes a PyKota printer through CUPS only."""
        uri = self.getPrinterDeviceURI(printer.Name)
        if uri and self.isPrinterCaptured(deviceuri=uri) :
             newuri = uri.replace("cupspykota:", "")
             if newuri.startswith("//") :
                 newuri = newuri[2:]
             os.system('lpadmin -p "%s" -v "%s"' % (printer.Name, newuri))
             self.logdebug("Printer %s rerouted to %s" % (printer.Name, newuri))

    def main(self, names, options) :
        """Manage printers."""
        if not options["list"] :
            self.adminOnly()

        docups = options["cups"]

        if not options["list"] :
            percent = Percent(self)

        if not options["add"] :
            if not options["list"] :
                percent.display("%s..." % _("Extracting datas"))
            if not names :      # NB : can't happen for --delete because it's catched earlier
                names = ["*"]
            printers = self.storage.getMatchingPrinters(",".join(names))
            if not printers :
                if not options["list"] :
                    percent.display("\n")
                raise PyKotaCommandLineError, _("There's no printer matching %s") % " ".join(names)
            if not options["list"] :
                percent.setSize(len(printers))

        if options["list"] :
            for printer in printers :
                parents = ", ".join([p.Name for p in self.storage.getParentPrinters(printer)])
                print "%s [%s] (%s + #*%s)" % \
                      (printer.Name, printer.Description, printer.PricePerJob, \
                       printer.PricePerPage)
                print "    %s" % (_("Passthrough mode : %s") % ((printer.PassThrough and _("ON")) or _("OFF")))
                print "    %s" % (_("Maximum job size : %s") % ((printer.MaxJobSize and (_("%s pages") % printer.MaxJobSize)) or _("Unlimited")))
                print "    %s" % (_("Routed through PyKota : %s") % ((self.isPrinterCaptured(printer.Name) and _("YES")) or _("NO")))
                if parents :
                    print "    %s %s" % (_("in"), parents)
                print
        elif options["delete"] :
            percent.display("\n%s..." % _("Deletion"))
            self.storage.deleteManyPrinters(printers)
            percent.display("\n")
            if docups :
                percent.display("%s...\n" % _("Rerouting printers to CUPS"))
                for printer in printers :
                    self.deroutePrinterFromPyKota(printer)
                    percent.oneMore()
        else :
            if options["groups"] :
                printersgroups = self.storage.getMatchingPrinters(options["groups"])
                if not printersgroups :
                    raise PyKotaCommandLineError, _("There's no printer matching %s") % " ".join(options["groups"].split(','))
            else :
                printersgroups = []

            if options["charge"] :
                try :
                    charges = [float(part) for part in options["charge"].split(',', 1)]
                except ValueError :
                    raise PyKotaCommandLineError, _("Invalid charge amount value %s") % options["charge"]
                else :
                    if len(charges) > 2 :
                        charges = charges[:2]
                    if len(charges) != 2 :
                        charges = [charges[0], None]
                    (perpage, perjob) = charges
            else :
                charges = perpage = perjob = None

            if options["maxjobsize"] :
                try :
                    maxjobsize = int(options["maxjobsize"])
                    if maxjobsize < 0 :
                        raise ValueError
                except ValueError :
                    raise PyKotaCommandLineError, _("Invalid maximum job size value %s") % options["maxjobsize"]
            else :
                maxjobsize = None

            description = options["description"]
            if description :
                description = description.strip()

            nopassthrough = options["nopassthrough"]
            passthrough = options["passthrough"]
            remove = options["remove"]
            skipexisting = options["skipexisting"]
            self.storage.beginTransaction()
            try :
                if options["add"] :
                    percent.display("%s...\n" % _("Creation"))
                    percent.setSize(len(names))
                    for pname in names :
                        if self.isValidName(pname) :
                            printer = StoragePrinter(self.storage, pname)
                            self.modifyPrinter(printer, charges, perpage, perjob, \
                                           description, passthrough, \
                                           nopassthrough, maxjobsize)
                            oldprinter = self.storage.addPrinter(printer)

                            if docups :
                                 self.reroutePrinterThroughPyKota(printer)

                            if oldprinter is not None :
                                if skipexisting :
                                    self.logdebug(_("Printer %s already exists, skipping.") % pname)
                                else :
                                    self.logdebug(_("Printer %s already exists, will be modified.") % pname)
                                    self.modifyPrinter(oldprinter, charges, \
                                               perpage, perjob, description, \
                                               passthrough, nopassthrough, \
                                               maxjobsize)
                                    oldprinter.save()
                                    self.managePrintersGroups(printersgroups, oldprinter, remove)
                            elif printersgroups :
                                self.managePrintersGroups(printersgroups, \
                                                          self.storage.getPrinter(pname), \
                                                          remove)
                        else :
                            raise PyKotaCommandLineError, _("Invalid printer name %s") % pname
                        percent.oneMore()
                else :
                    percent.display("\n%s...\n" % _("Modification"))
                    for printer in printers :
                        self.modifyPrinter(printer, charges, perpage, perjob, \
                                           description, passthrough, \
                                           nopassthrough, maxjobsize)
                        printer.save()
                        self.managePrintersGroups(printersgroups, printer, remove)
                        if docups :
                            self.reroutePrinterThroughPyKota(printer)
                        percent.oneMore()
            except :
                self.storage.rollbackTransaction()
                raise
            else :
                self.storage.commitTransaction()

        if not options["list"] :
            percent.done()

if __name__ == "__main__" :
    retcode = 0
    try :
        short_options = "hvaCc:D:dg:lrsnpm:"
        long_options = ["help", "version", "add", "cups", "charge=", "description=", \
                        "delete", "groups=", "list", "remove", \
                        "skipexisting", "passthrough", "nopassthrough", \
                        "maxjobsize="]

        # Initializes the command line tool
        manager = PKPrinters(doc=__doc__)
        manager.deferredInit()

        # parse and checks the command line
        (options, args) = manager.parseCommandline(sys.argv[1:], short_options, long_options)

        # sets long options
        options["help"] = options["h"] or options["help"]
        options["version"] = options["v"] or options["version"]
        options["add"] = options["a"] or options["add"]
        options["cups"] = options["C"] or options["cups"]
        options["charge"] = options["c"] or options["charge"]
        options["description"] = options["D"] or options["description"]
        options["delete"] = options["d"] or options["delete"]
        options["groups"] = options["g"] or options["groups"]
        options["list"] = options["l"] or options["list"]
        options["remove"] = options["r"] or options["remove"]
        options["skipexisting"] = options["s"] or options["skipexisting"]
        options["maxjobsize"] = options["m"] or options["maxjobsize"]
        options["passthrough"] = options["p"] or options["passthrough"]
        options["nopassthrough"] = options["n"] or options["nopassthrough"]

        if options["help"] :
            manager.display_usage_and_quit()
        elif options["version"] :
            manager.display_version_and_quit()
        elif (options["delete"] and (options["add"] or options["groups"] or options["charge"] or options["remove"] or options["description"])) \
           or (options["skipexisting"] and not options["add"]) \
           or (options["list"] and (options["add"] or options["delete"] or options["groups"] or options["charge"] or options["remove"] or options["description"])) \
           or (options["passthrough"] and options["nopassthrough"]) \
           or (options["remove"] and options["add"]) :
            raise PyKotaCommandLineError, _("incompatible options, see help.")
        elif options["remove"] and not options["groups"] :
            raise PyKotaCommandLineError, _("You have to pass printer groups names on the command line")
        elif (not args) and (options["add"] or options["delete"]) :
            raise PyKotaCommandLineError, _("You have to pass printer names on the command line")
        else :
            retcode = manager.main(args, options)
    except KeyboardInterrupt :
        logerr("\nInterrupted with Ctrl+C !\n")
        retcode = -3
    except PyKotaCommandLineError, msg :
        logerr("%s : %s\n" % (sys.argv[0], msg))
        retcode = -2
    except SystemExit :
        pass
    except :
        try :
            manager.crashed("pkprinters failed")
        except :
            crashed("pkprinters failed")
        retcode = -1

    try :
        manager.storage.close()
    except (TypeError, NameError, AttributeError) :
        pass

    sys.exit(retcode)