root / pykota / trunk / bin / edpykota @ 2282

Revision 2267, 26.6 kB (checked in by jerome, 19 years ago)

Moved the copyright strings out of the docstrings

  • Property svn:eol-style set to native
  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Revision
Line 
1#! /usr/bin/env python
2# -*- coding: ISO-8859-15 -*-
3
4# PyKota Print Quota Editor
5#
6# PyKota - Print Quotas for CUPS and LPRng
7#
8# (c) 2003, 2004, 2005 Jerome Alet <alet@librelogiciel.com>
9# This program is free software; you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation; either version 2 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program; if not, write to the Free Software
21# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
22#
23# $Id$
24#
25#
26
27import sys
28import os
29import pwd
30import grp
31from pykota.tool import PyKotaTool, PyKotaToolError, crashed, N_
32from pykota.config import PyKotaConfigError
33from pykota.storage import PyKotaStorageError
34
35__doc__ = N_("""edpykota v%s (c) %s %s
36
37A Print Quota editor for PyKota.
38
39command line usage :
40
41  edpykota [options] user1 user2 ... userN
42 
43  edpykota [options] group1 group2 ... groupN
44
45options :
46
47  -v | --version       Prints edpykota's version number then exits.
48  -h | --help          Prints this message then exits.
49 
50  -a | --add           Adds users and/or printers if they don't
51                       exist on the Quota Storage Server.
52                       
53  -d | --delete        Deletes users/groups from the quota storage.
54                       Printers are never deleted.
55                       
56  -c | --charge p[,j]  Sets the price per page and per job to charge
57                       for a particular printer. Job price is optional.
58                       If both are to be set, separate them with a comma.
59                       Floating point values are allowed.
60                       
61  -o | --overcharge f  Sets the overcharging factor applied to the user
62                       when computing the cost of a print job. Positive or
63                       negative floating point values are allowed,
64                       this allows you to do some really creative
65                       things like giving money to an user whenever
66                       he prints. The number of pages in a print job
67                       is not modified by this coefficient, only the
68                       cost of the job for a particular user.
69                       Only users have a coefficient.
70 
71  -i | --ingroups g1[,g2...]  Puts the users into each of the groups
72                              listed, separated by commas. The groups
73                              must already exist in the Quota Storage.
74 
75  -u | --users         Edit users print quotas, this is the default.
76 
77  -P | --printer p     Edit quotas on printer p only. Actually p can
78                       use wildcards characters to select only
79                       some printers. The default value is *, meaning
80                       all printers.
81                       You can specify several names or wildcards,
82                       by separating them with commas.
83 
84  -G | --pgroups pg1[,pg2...] Adds the printer(s) to the printer groups
85                       pg1, pg2, etc... which must already exist.
86                       A printer group is just like a normal printer,
87                       only that it is usually unknown from the printing
88                       system. Create printer groups exactly the same
89                       way that you create printers, then add other
90                       printers to them with this option.
91                       Accounting is done on a printer and on all
92                       the printer groups it belongs to, quota checking
93                       is done on a printer and on all the printer groups
94                       it belongs to.
95 
96  -g | --groups        Edit users groups print quotas instead of users.
97                         
98  -p | --prototype u|g Uses user u or group g as a prototype to set
99                       print quotas
100                       
101  -n | --noquota       Doesn't set a quota but only does accounting.
102 
103  -r | --reset         Resets the actual page counter for the user
104                       or group to zero on the specified printers.
105                       The life time page counter is kept unchanged.
106                       
107  -R | --hardreset     Resets the actual and life time page counters
108                       for the user or group to zero on the specified
109                       printers. This is a shortcut for '--used 0'.
110                       
111  -l | --limitby l     Choose if the user/group is limited in printing                     
112                       by its account balance or by its page quota.
113                       The default value is 'quota'. Allowed values
114                       are 'quota' 'balance' 'quota-then-balance' and
115                       'balance-then-quota'.
116                       WARNING : quota-then-balance and balance-then-quota
117                       are not yet implemented.
118                       
119  -b | --balance b     Sets the user's account balance to b.                     
120                       Account balance may be increase or decreased
121                       if b is prefixed with + or -.
122                       WARNING : when decreasing account balance,
123                       the total paid so far by the user is decreased
124                       too.
125                       Groups don't have a real balance, but the
126                       sum of their users' account balance.
127                       
128  -S | --softlimit sl  Sets the quota soft limit to sl pages.                       
129 
130  -H | --hardlimit hl  Sets the quota hard limit to hl pages.
131
132  -U | --used usage    Sets the pagecounters for the user to usage pages;
133                       useful for migrating users from a different system
134                       where they have already used some pages. Actual
135                       and Life Time page counters may be increased or decreased
136                       if usage is prefixed with + or -.
137                       WARNING : BOTH page counters are modified in all cases,
138                       so be careful.
139                       NB : if 'usage' equals '0', then the action taken is
140                       the same as if --hardreset was used.
141
142  user1 through userN and group1 through groupN can use wildcards
143  if the --add option is not set.
144 
145examples :                             
146
147  $ edpykota --add -p jerome john paul george ringo/ringo@example.com
148 
149  This will add users john, paul, george and ringo to the quota
150  database, and set their print quotas to the same values than user
151  jerome. User jerome must already exist.
152  User ringo's email address will also be set to 'ringo@example.com'
153 
154  $ edpykota --printer lp -S 50 -H 60 jerome
155 
156  This will set jerome's print quota on the lp printer to a soft limit
157  of 50 pages, and a hard limit of 60 pages. If either user jerome or
158  printer lp doesn't exist on the Quota Storage Server then nothing is done.
159
160  $ edpykota --add --printer lp --ingroups coders,it -S 50 -H 60 jerome
161 
162  Same as above, but if either user jerome or printer lp doesn't exist
163  on the Quota Storage Server they are automatically added. Also
164  user jerome is put into the groups "coders" and "it" which must
165  already exist in the Quota Storage.
166           
167  $ edpykota -g -S 500 -H 550 financial support           
168 
169  This will set print quota soft limit to 500 pages and hard limit
170  to 550 pages for groups financial and support on all printers.
171 
172  $ edpykota --reset jerome "jo*"
173 
174  This will reset jerome's page counter to zero on all printers, as
175  well as every user whose name begins with 'jo'.
176  Their life time page counter on each printer will be kept unchanged.
177  You can also reset the life time page counters by using the
178  --hardreset | -R command line option.
179 
180  $ edpykota --printer hpcolor --noquota jerome
181 
182  This will tell PyKota to not limit jerome when printing on the
183  hpcolor printer. All his jobs will be allowed on this printer, but
184  accounting of the pages he prints will still be kept.
185  Print Quotas for jerome on other printers are unchanged.
186 
187  $ edpykota --limitby balance jerome
188 
189  This will tell PyKota to limit jerome by his account's balance
190  when printing.
191 
192  $ edpykota --balance +10.0 jerome
193 
194  This will increase jerome's account balance by 10.0 (in your
195  own currency). You can decrease the account balance with a
196  dash prefix, and set it to a fixed amount with no prefix.
197 
198  $ edpykota --delete jerome rachel
199 
200  This will completely delete jerome and rachel from the Quota Storage
201  database. All their quotas and jobs will be deleted too.
202 
203  $ edpykota --printer lp --charge 0.1
204 
205  This will set the page price for printer lp to 0.1. Job price
206  will not be changed.
207 
208  $ edpykota --printer hplj1,hplj2 --pgroups Laser,HP
209 
210  This will put printers hplj1 and hplj2 in printers groups Laser and HP.
211  When printing either on hplj1 or hplj2, print quota will also be
212  checked and accounted for on virtual printers Laser and HP.
213 
214  $ edpykota --overcharge 2.5 poorstudent
215 
216  This will overcharge the poorstudent user by a factor of 2.5.
217 
218  $ edpykota --overcharge -1 jerome
219 
220  User jerome will actually earn money whenever he prints.
221 
222  $ edpykota --overcharge 0 boss
223 
224  User boss can print at will, it won't cost him anything because the
225  cost of each print job will be multiplied by zero before charging
226  his account.
227
228This program is free software; you can redistribute it and/or modify
229it under the terms of the GNU General Public License as published by
230the Free Software Foundation; either version 2 of the License, or
231(at your option) any later version.
232
233This program is distributed in the hope that it will be useful,
234but WITHOUT ANY WARRANTY; without even the implied warranty of
235MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
236GNU General Public License for more details.
237
238You should have received a copy of the GNU General Public License
239along with this program; if not, write to the Free Software
240Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
241
242Please e-mail bugs to: %s""") 
243       
244class EdPyKota(PyKotaTool) :       
245    """A class for edpykota."""
246    def main(self, names, options) :
247        """Edit user or group quotas."""
248        if not self.config.isAdmin :
249            raise PyKotaToolError, "%s : %s" % (pwd.getpwuid(os.geteuid())[0], _("You're not allowed to use this command."))
250       
251        suffix = (options["groups"] and "Group") or "User"       
252       
253        softlimit = hardlimit = None
254
255        used = options["used"]
256        if used :
257            used = used.strip()
258            try :
259                int(used)
260            except ValueError :
261                raise PyKotaToolError, _("Invalid used value %s.") % used
262
263        if not options["noquota"] :
264            if options["softlimit"] :
265                try :
266                    softlimit = int(options["softlimit"].strip())
267                except ValueError :   
268                    raise PyKotaToolError, _("Invalid softlimit value %s.") % options["softlimit"]
269            if options["hardlimit"] :
270                try :
271                    hardlimit = int(options["hardlimit"].strip())
272                except ValueError :   
273                    raise PyKotaToolError, _("Invalid hardlimit value %s.") % options["hardlimit"]
274            if (softlimit is not None) and (hardlimit is not None) and (hardlimit < softlimit) :       
275                # error, exchange them
276                self.printInfo(_("Hard limit %i is less than soft limit %i, values will be exchanged.") % (hardlimit, softlimit))
277                (softlimit, hardlimit) = (hardlimit, softlimit)
278           
279        overcharge = options["overcharge"]
280        if overcharge :
281            try :
282                overcharge = float(overcharge.strip())
283            except (ValueError, AttributeError) :   
284                raise PyKotaToolError, _("Invalid overcharge value %s") % options["overcharge"]
285               
286        balance = options["balance"]
287        if balance :
288            balance = balance.strip()
289            try :
290                balancevalue = float(balance)
291            except ValueError :   
292                raise PyKotaToolError, _("Invalid balance value %s") % options["balance"]
293           
294        if options["charge"] :
295            try :
296                charges = [float(part) for part in options["charge"].split(',', 1)]
297            except ValueError :   
298                raise PyKotaToolError, _("Invalid charge amount value %s") % options["charge"]
299            else :   
300                if len(charges) > 2 :
301                    charges = charges[:2]
302                if len(charges) != 2 :
303                    charges = [charges[0], None]
304                   
305        limitby = options["limitby"]
306        if limitby :
307            limitby = limitby.strip().lower()
308        if limitby and (limitby not in ('quota', 'balance', 'quota-then-balance', 'balance-then-quota')) :   
309            raise PyKotaToolError, _("Invalid limitby value %s") % options["limitby"]
310           
311        if options["ingroups"] :   
312            groupnames = [gname.strip() for gname in options["ingroups"].split(',')]
313        else :   
314            groupnames = []
315           
316        rejectunknown = self.config.getRejectUnknown()   
317        printeradded = 0
318        printers = self.storage.getMatchingPrinters(options["printer"])
319        if not printers :
320            pname = options["printer"]
321            if options["add"] and pname :
322                if self.isValidName(pname) :
323                    printers = [ self.storage.addPrinter(pname) ]
324                    if printers[0].Exists :
325                        printeradded = 1
326                    else :   
327                        raise PyKotaToolError, _("Impossible to add printer %s") % pname
328                else :   
329                    raise PyKotaToolError, _("Invalid printer name %s") % pname
330            else :
331                raise PyKotaToolError, _("There's no printer matching %s") % pname
332        if not names :   
333            if options["delete"] :   
334                raise PyKotaToolError, _("You have to pass user or group names on the command line")
335            else :
336                names = getattr(self.storage, "getAll%ssNames" % suffix)() # all users or groups
337               
338        printersgroups = []       
339        if options["pgroups"] :       
340            printersgroups = self.storage.getMatchingPrinters(options["pgroups"])
341           
342        if options["prototype"] :   
343            protoentry = getattr(self.storage, "get%s" % suffix)(options["prototype"])
344            if not protoentry.Exists :
345                raise PyKotaToolError, _("Prototype object %s not found in Quota Storage.") % protoentry.Name
346            else :   
347                limitby = protoentry.LimitBy
348                balancevalue = protoentry.AccountBalance
349                if balancevalue is not None :
350                    balance = str(abs(balancevalue))
351                else :   
352                    balance = None
353                overcharge = getattr(protoentry, "OverCharge", None)
354           
355        todelete = {}   
356        changed = {} # tracks changes made at the user/group level
357        for printer in printers :
358            for pgroup in printersgroups :
359                pgroup.addPrinterToGroup(printer)   
360               
361            if options["charge"] :
362                (perpage, perjob) = charges
363                printer.setPrices(perpage, perjob)   
364               
365            if options["prototype"] :
366                protoquota = getattr(self.storage, "get%sPQuota" % suffix)(protoentry, printer)
367                if not protoquota.Exists :
368                    self.printInfo(_("Prototype %s not found in Quota Storage for printer %s.") % (protoentry.Name, printer.Name))
369                else :   
370                    (softlimit, hardlimit) = (protoquota.SoftLimit, protoquota.HardLimit)
371                   
372            if not options["noquota"] :   
373                if hardlimit is None :   
374                    hardlimit = softlimit
375                    if hardlimit is not None :
376                        self.printInfo(_("Undefined hard limit set to soft limit (%s) on printer %s.") % (str(hardlimit), printer.Name))
377                if softlimit is None :   
378                    softlimit = hardlimit
379                    if softlimit is not None :
380                        self.printInfo(_("Undefined soft limit set to hard limit (%s) on printer %s.") % (str(softlimit), printer.Name))
381                       
382            if options["add"] :   
383                allentries = []   
384                for name in names :
385                    email = ""
386                    if not options["groups"] :
387                        splitname = name.split('/', 1)     # username/email
388                        if len(splitname) == 1 :
389                            splitname.append("")
390                        (name, email) = splitname
391                        if email and (email.count('@') != 1) :
392                            self.printInfo(_("Invalid email address %s") % email)
393                            email = ""
394                    entry = getattr(self.storage, "get%s" % suffix)(name)
395                    if email and not options["groups"] :
396                        entry.Email = email
397                    entrypquota = getattr(self.storage, "get%sPQuota" % suffix)(entry, printer)
398                    allentries.append((entry, entrypquota))
399            else :   
400                allentries = getattr(self.storage, "getPrinter%ssAndQuotas" % suffix)(printer, names)
401               
402            for (entry, entrypquota) in allentries :
403                if not changed.has_key(entry.Name) :
404                    changed[entry.Name] = {}
405                    if not options["groups"] :
406                        changed[entry.Name]["ingroups"] = []
407                       
408                if not entry.Exists :       
409                    # not found
410                    if options["add"] :
411                        # In case we want to add something, it is crucial
412                        # that we DON'T check with the system accounts files
413                        # like /etc/passwd because users may be defined
414                        # only remotely
415                        if self.isValidName(entry.Name) :
416                            reject = 0
417                            if rejectunknown :
418                                if options["groups"] :
419                                    try :
420                                        grp.getgrnam(entry.Name)
421                                    except KeyError :   
422                                        self.printInfo(_("Unknown group %s") % entry.Name, "error")
423                                        reject = 1
424                                else :   
425                                    try :
426                                        pwd.getpwnam(entry.Name)
427                                    except KeyError :   
428                                        self.printInfo(_("Unknown user %s") % entry.Name, "error")
429                                        reject = 1
430                            if not reject :       
431                                entry = getattr(self.storage, "add%s" % suffix)(entry)
432                        else :   
433                            if options["groups"] :
434                                self.printInfo(_("Invalid group name %s") % entry.Name)
435                            else :   
436                                self.printInfo(_("Invalid user name %s") % entry.Name)
437                elif options["delete"] :               
438                    todelete[entry.Name] = entry
439                               
440                if entry.Exists and (not entrypquota.Exists) :
441                    # not found
442                    if options["add"] :
443                        entrypquota = getattr(self.storage, "add%sPQuota" % suffix)(entry, printer)
444                       
445                if not entrypquota.Exists :     
446                    self.printInfo(_("Quota not found for object %s on printer %s.") % (entry.Name, printer.Name))
447                else :   
448                    if options["noquota"] or options["prototype"] or ((softlimit is not None) and (hardlimit is not None)) :
449                        entrypquota.setLimits(softlimit, hardlimit)
450                    if limitby :
451                        if changed[entry.Name].get("limitby") is None :
452                            entry.setLimitBy(limitby)
453                            changed[entry.Name]["limitby"] = limitby
454                   
455                    if options["reset"] :
456                        entrypquota.reset()
457                       
458                    if options["hardreset"] :   
459                        entrypquota.hardreset()
460                       
461                    if not options["groups"] :
462                        if used :
463                            entrypquota.setUsage(used)
464                           
465                        if overcharge is not None :   
466                            if changed[entry.Name].get("overcharge") is None :
467                                entry.setOverChargeFactor(overcharge)
468                                changed[entry.Name]["overcharge"] = overcharge
469                               
470                        if balance :
471                            if changed[entry.Name].get("balance") is None :
472                                if balance.startswith("+") or balance.startswith("-") :
473                                    newbalance = float(entry.AccountBalance or 0.0) + balancevalue
474                                    newlifetimepaid = float(entry.LifeTimePaid or 0.0) + balancevalue
475                                    entry.setAccountBalance(newbalance, newlifetimepaid)
476                                else :
477                                    diff = balancevalue - float(entry.AccountBalance or 0.0)
478                                    newlifetimepaid = float(entry.LifeTimePaid or 0.0) + diff
479                                    entry.setAccountBalance(balancevalue, newlifetimepaid)
480                                changed[entry.Name]["balance"] = balance
481                               
482                        for groupname in groupnames :       
483                            # not executed if option --ingroups is not used
484                            if groupname not in changed[entry.Name]["ingroups"] :
485                                group = self.storage.getGroup(groupname)
486                                if group.Exists :
487                                    self.storage.addUserToGroup(entry, group)
488                                    changed[entry.Name]["ingroups"].append(groupname)
489                                else :
490                                    self.printInfo(_("Group %s not found in the PyKota Storage.") % groupname)
491                       
492        # Now delete what has to be deleted               
493        for (name, entry) in todelete.items() :               
494            entry.delete()
495                     
496if __name__ == "__main__" : 
497    retcode = 0
498    try :
499        defaults = { \
500                     "printer" : "*", \
501                   }
502        short_options = "vhdo:c:l:b:i:naugrp:P:S:H:G:RU:"
503        long_options = ["help", "version", "overcharge=", "charge=", "delete", "limitby=", "balance=", "ingroups=", "noquota", "add", "users", "groups", "reset", "hardreset", "prototype=", "printer=", "softlimit=", "hardlimit=", "pgroups=", "used="]
504       
505        # Initializes the command line tool
506        editor = EdPyKota(doc=__doc__)
507        editor.deferredInit()
508       
509        # parse and checks the command line
510        (options, args) = editor.parseCommandline(sys.argv[1:], short_options, long_options)
511       
512        # sets long options
513        options["help"] = options["h"] or options["help"]
514        options["version"] = options["v"] or options["version"]
515        options["add"] = options["a"] or options["add"]
516        options["users"] = options["u"] or options["users"]
517        options["groups"] = options["g"] or options["groups"]
518        options["prototype"] = options["p"] or options["prototype"]
519        options["printer"] = options["P"] or options["printer"] or defaults["printer"]
520        options["softlimit"] = options["S"] or options["softlimit"]
521        options["hardlimit"] = options["H"] or options["hardlimit"] 
522        options["reset"] = options["r"] or options["reset"] 
523        options["noquota"] = options["n"] or options["noquota"]
524        options["limitby"] = options["l"] or options["limitby"]
525        options["balance"] = options["b"] or options["balance"] 
526        options["delete"] = options["d"] or options["delete"] 
527        options["ingroups"] = options["i"] or options["ingroups"]
528        options["charge"] = options["c"] or options["charge"]
529        options["pgroups"] = options["G"] or options["pgroups"]
530        options["hardreset"] = options["R"] or options["hardreset"] 
531        options["used"] = options["U"] or options["used"]
532        options["overcharge"] = options["o"] or options["overcharge"]
533       
534        if options["help"] :
535            editor.display_usage_and_quit()
536        elif options["version"] :
537            editor.display_version_and_quit()
538        elif options["users"] and options["groups"] :   
539            raise PyKotaToolError, _("incompatible options, see help.")
540        elif (options["add"] or options["prototype"]) and options["delete"] :   
541            raise PyKotaToolError, _("incompatible options, see help.")
542        elif (options["reset"] or options["hardreset"] or options["limitby"] or options["used"] or options["balance"] or options["overcharge"] or options["softlimit"] or options["hardlimit"]) and options["prototype"] :
543            raise PyKotaToolError, _("incompatible options, see help.")
544        elif options["noquota"] and (options["prototype"] or options["hardlimit"] or options["softlimit"]) :
545            raise PyKotaToolError, _("incompatible options, see help.")
546        elif options["groups"] and (options["balance"] or options["ingroups"] or options["used"] or options["overcharge"]) :
547            raise PyKotaToolError, _("incompatible options, see help.")
548        else :
549            retcode = editor.main(args, options)
550    except KeyboardInterrupt :       
551        sys.stderr.write("\nInterrupted with Ctrl+C !\n")
552    except SystemExit :       
553        pass
554    except :
555        try :
556            editor.crashed("edpykota failed")
557        except :   
558            crashed("edpykota failed")
559        retcode = -1
560
561    try :
562        editor.storage.close()
563    except (TypeError, NameError, AttributeError) :   
564        pass
565       
566    sys.exit(retcode)   
Note: See TracBrowser for help on using the browser.