#! /usr/bin/env python # -*- coding: ISO-8859-15 -*- # PyKota Turn Key tool # # PyKota - Print Quotas for CUPS and LPRng # # (c) 2003, 2004, 2005 Jerome Alet # 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # # $Id$ # # import sys import os import pwd import grp import socket import signal from pykota.tool import Tool, PyKotaToolError, PyKotaCommandLineError, crashed, N_ __doc__ = N_("""pkturnkey v%(__version__)s (c) %(__years__)s %(__author__)s A turn key tool for PyKota. When launched, this command will initialize PyKota's database with all existing print queues and some or all users. For now, no prices or limits are set, so printing is fully accounted for, but not limited. That's why you'll probably want to also use edpykota once the database has been initialized. command line usage : pkturnkey [options] [printqueues names] options : -v | --version Prints pkturnkey version number then exits. -h | --help Prints this message then exits. -c | --doconf Give hints about what to put into pykota.conf -d | --dousers Manages users accounts as well. -D | --dogroups Manages users groups as well. Implies -d | --dousers. -e | --emptygroups Includes empty groups. -f | --force Modifies the database instead of printing what it would do. -u | --uidmin uid Only adds users whose uid is greater than or equal to uid. You can pass an username there as well, and its uid will be used automatically. If not set, 0 will be used automatically. Implies -d | --dousers. -U | --uidmax uid Only adds users whose uid is lesser than or equal to uid. You can pass an username there as well, and its uid will be used automatically. If not set, a large value will be used automatically. Implies -d | --dousers. -g | --gidmin gid Only adds groups whose gid is greater than or equal to gid. You can pass a groupname there as well, and its gid will be used automatically. If not set, 0 will be used automatically. Implies -D | --dogroups. -G | --gidmax gid Only adds groups whose gid is lesser than or equal to gid. You can pass a groupname there as well, and its gid will be used automatically. If not set, a large value will be used automatically. Implies -D | --dogroups. examples : $ pkturnkey --dousers --uidmin jerome Will simulate the initialization of PyKota's database will all existing printers and print accounts for all users whose uid is greater than or equal to jerome's one. Won't manage any users group. To REALLY initialize the database instead of simulating it, please use the -f | --force command line switch. You can limit the initialization to only a subset of the existing printers, by passing their names at the end of the command line. """) class PKTurnKey(Tool) : """A class for an initialization tool.""" def listPrinters(self, namestomatch) : """Returns a list of tuples (queuename, deviceuri) for all existing print queues.""" self.printInfo("Extracting all print queues.") result = os.popen("lpstat -v", "r") lines = result.readlines() result.close() printers = [] for line in lines : (begin, end) = line.split(':', 1) deviceuri = end.strip() queuename = begin.split()[-1] if self.matchString(queuename, namestomatch) : printers.append((queuename, deviceuri)) else : self.printInfo("Print queue %s skipped." % queuename) return printers def listUsers(self, uidmin, uidmax) : """Returns a list of users whose uids are between uidmin and uidmax.""" self.printInfo("Extracting all users whose uid is between %s and %s." % (uidmin, uidmax)) return [(entry[0], entry[3]) for entry in pwd.getpwall() if uidmin <= entry[2] <= uidmax] def listGroups(self, gidmin, gidmax, users) : """Returns a list of groups whose gids are between gidmin and gidmax.""" self.printInfo("Extracting all groups whose gid is between %s and %s." % (gidmin, gidmax)) groups = [(entry[0], entry[2], entry[3]) for entry in grp.getgrall() if gidmin <= entry[2] <= gidmax] gidusers = {} usersgid = {} for u in users : gidusers.setdefault(u[1], []).append(u[0]) usersgid.setdefault(u[0], []).append(u[1]) membership = {} for g in range(len(groups)) : (gname, gid, members) = groups[g] newmembers = {} for m in members : newmembers[m] = m try : usernames = gidusers[gid] except KeyError : pass else : for username in usernames : if not newmembers.has_key(username) : newmembers[username] = username for member in newmembers.keys() : if not usersgid.has_key(member) : del newmembers[member] membership[gname] = newmembers.keys() return membership def runCommand(self, command, dryrun) : """Launches an external command.""" self.printInfo("%s" % command) if not dryrun : os.system(command) def createPrinters(self, printers, dryrun=0) : """Creates all printers in PyKota's database.""" if printers : needswarning = [p[0] for p in printers if p[1].find("cupspykota") == -1] command = "pkprinters --add %s" % " ".join(['"%s"' % p[0] for p in printers]) self.runCommand(command, dryrun) for p in needswarning : self.printInfo(_("Printer %s is not managed by PyKota yet. Please modify printers.conf and restart CUPS.") % p, "warn") def createUsers(self, users, printers, dryrun=0) : """Creates all users in PyKota's database.""" if users : printersnames = [p[0] for p in printers] command = "edpykota --add --noquota --printer %s %s" \ % (",".join(['"%s"' % p for p in printersnames]), \ " ".join(['"%s"' % u for u in users])) self.runCommand(command, dryrun) def createGroups(self, groups, printers, dryrun=0) : """Creates all groups in PyKota's database.""" if groups : printersnames = [p[0] for p in printers] commands = ["edpykota --add --groups --noquota --printer %s %s" \ % (",".join(['"%s"' % p for p in printersnames]), \ " ".join(['"%s"' % g for g in groups.keys()]))] revmembership = {} for (groupname, usernames) in groups.items() : for username in usernames : revmembership.setdefault(username, []).append(groupname) for (username, groupnames) in revmembership.items() : commands.append('edpykota --ingroups %s "%s"' \ % (",".join(['"%s"' % g for g in groupnames]), username)) for command in commands : self.runCommand(command, dryrun) def supportsSNMP(self, hostname, community) : """Returns 1 if the printer accepts SNMP queries, else 0.""" try : from pysnmp.asn1.encoding.ber.error import TypeMismatchError from pysnmp.mapping.udp.error import SnmpOverUdpError from pysnmp.mapping.udp.role import Manager from pysnmp.proto.api import alpha except ImportError : sys.stderr.write("pysnmp doesn't seem to be installed. SNMP checks will be ignored !\n") return 0 pageCounterOID = ".1.3.6.1.2.1.43.10.2.1.4.1.1" # SNMPv2-SMI::mib-2.43.10.2.1.4.1.1 def retrieveSNMPValues(hostname, community) : """Retrieves a printer's internal page counter and status via SNMP.""" ver = alpha.protoVersions[alpha.protoVersionId1] req = ver.Message() req.apiAlphaSetCommunity(community) req.apiAlphaSetPdu(ver.GetRequestPdu()) req.apiAlphaGetPdu().apiAlphaSetVarBindList((pageCounterOID, ver.Null())) tsp = Manager() try : tsp.sendAndReceive(req.berEncode(), \ (hostname, 161), \ (handleAnswer, req)) except : raise "No SNMP !" tsp.close() def handleAnswer(wholeMsg, notusedhere, req): """Decodes and handles the SNMP answer.""" ver = alpha.protoVersions[alpha.protoVersionId1] rsp = ver.Message() try : rsp.berDecode(wholeMsg) except TypeMismatchError, msg : raise "No SNMP !" else : if req.apiAlphaMatch(rsp): errorStatus = rsp.apiAlphaGetPdu().apiAlphaGetErrorStatus() if errorStatus: raise "No SNMP !" else: self.values = [] for varBind in rsp.apiAlphaGetPdu().apiAlphaGetVarBindList(): self.values.append(varBind.apiAlphaGetOidVal()[1].rawAsn1Value) try : pagecounter = self.values[0] except : raise "No SNMP !" else : self.SNMPOK = 1 return 1 self.SNMPOK = 0 try : retrieveSNMPValues(hostname, community) except : self.SNMPOK = 0 return self.SNMPOK def supportsPJL(self, hostname, port) : """Returns 1 if the printer accepts PJL queries over TCP, else 0.""" def alarmHandler(signum, frame) : raise "Timeout !" pjlsupport = 0 signal.signal(signal.SIGALRM, alarmHandler) signal.alarm(2) # wait at most 2 seconds s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try : s.connect((hostname, port)) s.send("\033%-12345X@PJL INFO STATUS\r\n\033%-12345X") answer = s.recv(1024) if not answer.startswith("@PJL") : raise "No PJL !" except : pass else : pjlsupport = 1 s.close() signal.alarm(0) signal.signal(signal.SIGALRM, signal.SIG_IGN) return pjlsupport def hintConfig(self, printers) : """Gives some hints about what to put into pykota.conf""" if not printers : return sys.stderr.flush() # ensure outputs don't mix print print "--- CUT ---" print "# Here are some lines that we suggest you add at the end" print "# of the pykota.conf file. These lines gives possible" print "# values for the way print jobs' size will be computed." print "# NB : it is possible that a manual configuration gives" print "# better results for you. As always, your mileage may vary." print "#" for (name, uri) in printers : print "[%s]" % name accounter = "software()" try : uri = uri.split("cupspykota:", 2)[-1] except (ValueError, IndexError) : pass else : while uri and uri.startswith("/") : uri = uri[1:] try : (backend, destination) = uri.split(":", 1) if backend not in ("ipp", "http", "https", "lpd", "socket") : raise ValueError except ValueError : pass else : while destination.startswith("/") : destination = destination[1:] checkauth = destination.split("@", 1) if len(checkauth) == 2 : destination = checkauth[1] parts = destination.split("/")[0].split(":") if len(parts) == 2 : (hostname, port) = parts try : port = int(port) except ValueError : port = 9100 else : (hostname, port) = parts[0], 9100 if self.supportsSNMP(hostname, "public") : accounter = "hardware(snmp)" elif self.supportsPJL(hostname, 9100) : accounter = "hardware(pjl)" elif self.supportsPJL(hostname, 9101) : accounter = "hardware(pjl:9101)" elif self.supportsPJL(hostname, port) : accounter = "hardware(pjl:%s)" % port print "accounter : %s" % accounter print print "--- CUT ---" def main(self, names, options) : """Intializes PyKota's database.""" if not self.config.isAdmin : raise PyKotaCommandLineError, "%s : %s" % (pwd.getpwuid(os.geteuid())[0],\ _("You're not allowed to use this command.")) if not names : names = ["*"] self.printInfo(_("Please be patient...")) dryrun = not options["force"] if dryrun : self.printInfo(_("Don't worry, the database WILL NOT BE MODIFIED.")) else : self.printInfo(_("Please WORRY NOW, the database WILL BE MODIFIED.")) if options["dousers"] : if not options["uidmin"] : self.printInfo(_("System users will have a print account as well !"), "warn") uidmin = 0 else : try : uidmin = int(options["uidmin"]) except : try : uidmin = pwd.getpwnam(options["uidmin"])[2] except KeyError, msg : raise PyKotaCommandLineError, _("Unknown username %s : %s") \ % (options["uidmin"], msg) if not options["uidmax"] : uidmax = sys.maxint else : try : uidmax = int(options["uidmax"]) except : try : uidmax = pwd.getpwnam(options["uidmax"])[2] except KeyError, msg : raise PyKotaCommandLineError, _("Unknown username %s : %s") \ % (options["uidmax"], msg) if uidmin > uidmax : (uidmin, uidmax) = (uidmax, uidmin) users = self.listUsers(uidmin, uidmax) else : users = [] if options["dogroups"] : if not options["gidmin"] : self.printInfo(_("System groups will have a print account as well !"), "warn") gidmin = 0 else : try : gidmin = int(options["gidmin"]) except : try : gidmin = grp.getgrnam(options["gidmin"])[2] except KeyError, msg : raise PyKotaCommandLineError, _("Unknown groupname %s : %s") \ % (options["gidmin"], msg) if not options["gidmax"] : gidmax = sys.maxint else : try : gidmax = int(options["gidmax"]) except : try : gidmax = grp.getgrnam(options["gidmax"])[2] except KeyError, msg : raise PyKotaCommandLineError, _("Unknown groupname %s : %s") \ % (options["gidmax"], msg) if gidmin > gidmax : (gidmin, gidmax) = (gidmax, gidmin) groups = self.listGroups(gidmin, gidmax, users) if not options["emptygroups"] : for (groupname, members) in groups.items() : if not members : del groups[groupname] else : groups = [] printers = self.listPrinters(names) if printers : self.createPrinters(printers, dryrun) self.createUsers([entry[0] for entry in users], printers, dryrun) self.createGroups(groups, printers, dryrun) if dryrun : self.printInfo(_("Simulation terminated.")) else : self.printInfo(_("Database initialized !")) if options["doconf"] : self.hintConfig(printers) if __name__ == "__main__" : retcode = 0 try : short_options = "hvdDefu:U:g:G:c" long_options = ["help", "version", "dousers", "dogroups", \ "emptygroups", "force", "uidmin=", "uidmax=", \ "gidmin=", "gidmax=", "doconf"] # Initializes the command line tool manager = PKTurnKey(doc=__doc__) manager.deferredInit() # parse and checks the command line (options, args) = manager.parseCommandline(sys.argv[1:], \ short_options, \ long_options, \ allownothing=1) # sets long options options["help"] = options["h"] or options["help"] options["version"] = options["v"] or options["version"] options["dousers"] = options["d"] or options["dousers"] options["dogroups"] = options["D"] or options["dogroups"] options["emptygroups"] = options["e"] or options["emptygroups"] options["force"] = options["f"] or options["force"] options["uidmin"] = options["u"] or options["uidmin"] options["uidmax"] = options["U"] or options["uidmax"] options["gidmin"] = options["g"] or options["gidmin"] options["gidmax"] = options["G"] or options["gidmax"] options["doconf"] = options["c"] or options["doconf"] if options["uidmin"] or options["uidmax"] : if not options["dousers"] : manager.printInfo(_("The --uidmin or --uidmax command line option implies --dousers as well."), "warn") options["dousers"] = 1 if options["gidmin"] or options["gidmax"] : if not options["dogroups"] : manager.printInfo(_("The --gidmin or --gidmax command line option implies --dogroups as well."), "warn") options["dogroups"] = 1 if options["dogroups"] : if not options["dousers"] : manager.printInfo(_("The --dogroups command line option implies --dousers as well."), "warn") options["dousers"] = 1 if options["help"] : manager.display_usage_and_quit() elif options["version"] : manager.display_version_and_quit() else : retcode = manager.main(args, options) except KeyboardInterrupt : sys.stderr.write("\nInterrupted with Ctrl+C !\n") retcode = -3 except PyKotaCommandLineError, msg : sys.stderr.write("%s : %s\n" % (sys.argv[0], msg)) retcode = -2 except SystemExit : pass except : try : manager.crashed("pkturnkey failed") except : crashed("pkturnkey failed") retcode = -1 try : manager.storage.close() except (TypeError, NameError, AttributeError) : pass sys.exit(retcode)