#! /usr/bin/env python # -*- coding: ISO-8859-15 -*- # PyKota Users Manager # # PyKota - Print Quotas for CUPS and LPRng # # (c) 2003, 2004, 2005, 2006 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 os import sys import pwd import grp from pykota.tool import PyKotaTool, PyKotaToolError, PyKotaCommandLineError, crashed, N_ from pykota.storage import StorageUser, StorageGroup __doc__ = N_("""pkusers v%(__version__)s (c) %(__years__)s %(__author__)s An Users and Groups Manager for PyKota. command line usage : pkusers [options] user1 user2 user3 ... userN or : pkusers --groups [options] group1 group2 group3 ... groupN options : -v | --version Prints pkusers's version number then exits. -h | --help Prints this message then exits. -a | --add Adds users if they don't exist on the database. If they exist, they are modified unless -s|--skipexisting is also used. -d | --delete Deletes users from the quota storage. -D | --description d Adds a textual description to users or groups. -g | --groups Edit users groups instead of users. -o | --overcharge f Sets the overcharging factor applied to the user when computing the cost of a print job. Positive or negative floating point values are allowed, this allows you to do some really creative things like giving money to an user whenever he prints. The number of pages in a print job is not modified by this coefficient, only the cost of the job for a particular user. Only users have such a coefficient. -i | --ingroups g1[,g2...] Puts the users into each of the groups listed, separated by commas. The groups must already exist in the Quota Storage. -L | --list Lists users or groups. -l | --limitby l Choose if the user/group is limited in printing by its account balance or by its page quota. The default value is 'quota'. Allowed values are 'quota' 'balance' 'noquota' 'noprint' and 'nochange' : - quota : limit by number of pages per printer. - balance : limit by number of credits in account. - noquota : no limit, accounting still done. - nochange : no limit, accounting not done. - noprint : printing is denied. NB : nochange and noprint are not supported for groups. -b | --balance b Sets the user's account balance to b. Account balance may be increase or decreased if b is prefixed with + or -. WARNING : when decreasing account balance, the total paid so far by the user is decreased too. Groups don't have a real balance, but the sum of their users' account balance. -C | --comment txt Defines some informational text to be associated with a change to an user's account balance. Only meaningful if -b | --balance is also used. -r | --remove In combination with the --ingroups option above, remove users from the specified users groups. -s | --skipexisting In combination with the --add option above, tells pkusers to not modify existing users. user1 through userN and group1 through groupN can use wildcards if the --add option is not set. examples : $ pkusers --add john paul george ringo/ringo@example.com This will add users john, paul, george and ringo to the quota database. User ringo's email address will also be set to 'ringo@example.com' $ pkusers --ingroups coders,it jerome User jerome is put into the groups "coders" and "it" which must already exist in the quota database. $ pkusers --limitby balance jerome This will tell PyKota to limit jerome by his account's balance when printing. $ pkusers --balance +10.0 --comment "He paid with his blood !" jerome This will increase jerome's account balance by 10.0 (in your own currency). You can decrease the account balance with a dash prefix, and set it to a fixed amount with no prefix. A comment will be stored for this balance change. $ pkusers --delete jerome rachel This will completely delete jerome and rachel from the quota database. All their quotas and jobs will be deleted too. $ pkusers --overcharge 2.5 poorstudent This will overcharge the poorstudent user by a factor of 2.5. $ pkusers --overcharge -1 jerome User jerome will actually earn money whenever he prints. $ pkusers --overcharge 0 boss User boss can print at will, it won't cost him anything because the cost of each print job will be multiplied by zero before charging his account. """) class PKUsers(PyKotaTool) : """A class for a users and users groups manager.""" def modifyEntry(self, entry, groups, limitby, description, overcharge=None, balance=None, balancevalue=None, comment=None, email=None) : """Modifies an entry.""" if description is not None : # NB : "" is allowed ! entry.setDescription(description) if limitby : entry.setLimitBy(limitby) if not groups : if email : entry.Email = email if overcharge is not None : # NB : 0 is allowed ! entry.setOverChargeFactor(overcharge) if balance : if balance.startswith("+") or balance.startswith("-") : newbalance = float(entry.AccountBalance or 0.0) + balancevalue newlifetimepaid = float(entry.LifeTimePaid or 0.0) + balancevalue entry.setAccountBalance(newbalance, newlifetimepaid, comment) else : diff = balancevalue - float(entry.AccountBalance or 0.0) newlifetimepaid = float(entry.LifeTimePaid or 0.0) + diff entry.setAccountBalance(balancevalue, newlifetimepaid, comment) def manageUsersGroups(self, ugroups, user, remove) : """Manage user group membership.""" for ugroup in ugroups : if remove : ugroup.delUserFromGroup(user) else : ugroup.addUserToGroup(user) def main(self, names, options) : """Manage users or groups.""" names = self.sanitizeNames(options, names) suffix = (options["groups"] and "Group") or "User" if not options["add"] : if not options["list"] : self.display(_("Extracting datas...")) if not names : # NB : can't happen for --delete because it's catched earlier names = ["*"] entries = getattr(self.storage, "getMatching%ss" % suffix)(",".join(names)) if not entries : raise PyKotaCommandLineError, _("There's no %s matching %s") % (_(suffix.lower()), " ".join(names)) if options["list"] : if suffix == "User" : maildomain = self.config.getMailDomain() smtpserver = self.config.getSMTPServer() for entry in entries : email = entry.Email if not email : if maildomain : email = "%s@%s" % (entry.Name, maildomain) elif smtpserver : email = "%s@%s" % (entry.Name, smtpserver) else : email = "%s@%s" % (entry.Name, "localhost") msg = "%s - <%s>" % (entry.Name, email) if entry.Description : msg += " - %s" % entry.Description print msg print " %s" % (_("Limited by : %s") % entry.LimitBy) print " %s" % (_("Account balance : %.2f") % (entry.AccountBalance or 0.0)) print " %s" % (_("Total paid so far : %.2f") % (entry.LifeTimePaid or 0.0)) print " %s" % (_("Overcharging factor : %.2f") % entry.OverCharge) print else : for entry in entries : msg = "%s" % entry.Name if entry.Description : msg += " - %s" % entry.Description print msg print " %s" % (_("Limited by : %s") % entry.LimitBy) print " %s" % (_("Group balance : %.2f") % (entry.AccountBalance or 0.0)) print " %s" % (_("Total paid so far : %.2f") % (entry.LifeTimePaid or 0.0)) print elif options["delete"] : self.display("\n%s..." % _("Deletion")) getattr(self.storage, "deleteMany%ss" % suffix)(entries) self.display("\n") else : limitby = options["limitby"] if limitby : limitby = limitby.strip().lower() if limitby : if limitby not in ('quota', 'balance', 'noquota', \ 'noprint', 'nochange') : raise PyKotaCommandLineError, _("Invalid limitby value %s") % options["limitby"] if (limitby in ('nochange', 'noprint')) and options["groups"] : raise PyKotaCommandLineError, _("Invalid limitby value %s") % options["limitby"] overcharge = options["overcharge"] if overcharge : try : overcharge = float(overcharge.strip()) except (ValueError, AttributeError) : raise PyKotaCommandLineError, _("Invalid overcharge value %s") % options["overcharge"] balance = options["balance"] if balance : balance = balance.strip() try : balancevalue = float(balance) except ValueError : raise PyKotaCommandLineError, _("Invalid balance value %s") % options["balance"] if options["ingroups"] : usersgroups = self.storage.getMatchingGroups(options["ingroups"]) if not usersgroups : raise PyKotaCommandLineError, _("There's no users group matching %s") % " ".join(options["ingroups"].split(',')) else : usersgroups = [] description = options["description"] if description : description = options["description"].strip() comment = options["comment"] if comment : comment = options["comment"].strip() skipexisting = options["skipexisting"] groups = options["groups"] remove = options["remove"] self.storage.beginTransaction() try : if options["add"] : self.display("%s...\n" % _("Creation")) rejectunknown = self.config.getRejectUnknown() nbtotal = len(names) for i in range(nbtotal) : ename = names[i] email = None if not groups : splitname = ename.split('/', 1) # username/email if len(splitname) == 1 : splitname.append("") (ename, email) = splitname if email and (email.count('@') != 1) : raise PyKotaCommandLineError, _("Invalid email address %s") % email if self.isValidName(ename) : reject = 0 if rejectunknown : if groups : try : grp.getgrnam(ename) except KeyError : self.printInfo(_("Unknown group %s") % ename, "error") reject = 1 else : try : pwd.getpwnam(ename) except KeyError : self.printInfo(_("Unknown user %s") % ename, "error") reject = 1 if not reject : entry = globals()["Storage%s" % suffix](self.storage, ename) if groups : self.modifyEntry(entry, groups, limitby, \ description) else : self.modifyEntry(entry, groups, limitby, \ description, overcharge,\ balance, balancevalue, \ comment, email) oldentry = getattr(self.storage, "add%s" % suffix)(entry) if oldentry is not None : if skipexisting : self.printInfo(_("%s %s already exists, skipping.") % (_(suffix), ename)) else : self.printInfo(_("%s %s already exists, will be modified.") % (_(suffix), ename)) if groups : self.modifyEntry(oldentry, groups, \ limitby, description) else : self.modifyEntry(oldentry, groups, limitby, \ description, overcharge,\ balance, balancevalue, \ comment, email) oldentry.save() if not groups : self.manageUsersGroups(usersgroups, oldentry, remove) elif usersgroups and not groups : self.manageUsersGroups(usersgroups, \ self.storage.getUser(ename), \ remove) else : raise PyKotaCommandLineError, _("Invalid name %s") % ename percent = 100.0 * float(i) / float(nbtotal) self.display("\r%.02f%%" % percent) else : self.display("\n%s...\n" % _("Modification")) nbtotal = len(entries) for i in range(nbtotal) : entry = entries[i] if groups : self.modifyEntry(entry, groups, limitby, description) else : self.modifyEntry(entry, groups, limitby, description, \ overcharge, balance, balancevalue, \ comment) self.manageUsersGroups(usersgroups, entry, remove) entry.save() percent = 100.0 * float(i) / float(nbtotal) self.display("\r%.02f%%" % percent) except : self.storage.rollbackTransaction() raise else : self.storage.commitTransaction() if not options["list"] : self.done() if __name__ == "__main__" : retcode = 0 try : defaults = { \ "comment" : "", \ } short_options = "hvaD:dgl:rso:i:b:C:L" long_options = ["help", "version", "add", "description=", \ "delete", "groups", "list", "remove", \ "skipexisting", "overcharge=", \ "ingroups=", "limitby=", "balance=", "comment=", \ ] # Initializes the command line tool manager = PKUsers(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["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["limitby"] = options["l"] or options["limitby"] options["balance"] = options["b"] or options["balance"] options["ingroups"] = options["i"] or options["ingroups"] options["overcharge"] = options["o"] or options["overcharge"] options["comment"] = options["C"] or options["comment"] or defaults["comment"] if options["help"] : manager.display_usage_and_quit() elif options["version"] : manager.display_version_and_quit() elif (options["delete"] and (options["add"] or options["remove"] or options["description"])) \ or (options["skipexisting"] and not options["add"]) \ or (options["list"] and (options["add"] or options["delete"] or options["remove"] or options["description"])) \ or (options["groups"] and (options["balance"] or options["ingroups"] or options["overcharge"])) : raise PyKotaCommandLineError, _("incompatible options, see help.") elif options["remove"] and not options["ingroups"] : raise PyKotaCommandLineError, _("You have to pass user groups names on the command line") elif (not args) and (options["add"] or options["delete"]) : raise PyKotaCommandLineError, _("You have to pass user or group names on the command line") 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("pkusers failed") except : crashed("pkusers failed") retcode = -1 try : manager.storage.close() except (TypeError, NameError, AttributeError) : pass sys.exit(retcode)