root / pykota / trunk / bin / edpykota @ 3432

Revision 3432, 17.2 kB (checked in by jerome, 16 years ago)

edpykota now supports new style command line handling.

  • 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: utf-8 -*-*-
3#
4# PyKota : Print Quotas for CUPS
5#
6# (c) 2003, 2004, 2005, 2006, 2007, 2008 Jerome Alet <alet@librelogiciel.com>
7# This program is free software: you can redistribute it and/or modify
8# it under the terms of the GNU General Public License as published by
9# the Free Software Foundation, either version 3 of the License, or
10# (at your option) any later version.
11#
12# This program is distributed in the hope that it will be useful,
13# but WITHOUT ANY WARRANTY; without even the implied warranty of
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15# GNU General Public License for more details.
16#
17# You should have received a copy of the GNU General Public License
18# along with this program.  If not, see <http://www.gnu.org/licenses/>.
19#
20# $Id$
21#
22#
23
24"""A print quota entries manager for PyKota."""
25
26import sys
27
28import pykota.appinit
29from pykota.utils import run
30from pykota.commandline import PyKotaOptionParser
31from pykota.errors import PyKotaCommandLineError
32from pykota.tool import Percent, PyKotaTool
33from pykota.storage import StorageUserPQuota, StorageGroupPQuota
34
35class EdPyKota(PyKotaTool) :
36    """A class for edpykota."""
37    def modifyPQEntry(self, pqkey, pqentry, noquota, softlimit, hardlimit, increase, reset, hardreset, suffix, used) :
38        """Modifies a print quota entry."""
39        if noquota or ((softlimit is not None) and (hardlimit is not None)) :
40            pqentry.setLimits(softlimit, hardlimit)
41        if increase :
42            newsoft = (pqentry.SoftLimit or 0) + increase
43            newhard = (pqentry.HardLimit or 0) + increase
44            if (newsoft >= 0) and (newhard >= 0) :
45                pqentry.setLimits(newsoft, newhard)
46            else :
47                self.printInfo(_("You can't set negative limits for %s") % pqkey, "error")
48        if reset :
49            pqentry.reset()
50        if hardreset :
51            pqentry.hardreset()
52        if suffix == "User" :
53            if used :
54                pqentry.setUsage(used)
55
56    def main(self, names, options) :
57        """Edit user or group quotas."""
58        islist = (options.action == "list")
59        isadd = (options.action == "add")
60        isdelete = (options.action == "delete")
61
62        if not islist :
63            self.adminOnly()
64
65        names = self.sanitizeNames(names, options.groups)
66        if not names :
67            if isdelete :
68                raise PyKotaCommandLineError, _("You must specify users or groups names on the command line.")
69            names = [u"*"]
70
71        if (((islist or isdelete) and (options.used  \
72                                      or options.softlimit \
73                                      or options.hardlimit \
74                                      or options.reset \
75                                      or options.hardreset \
76                                      or options.noquota \
77                                      or options.increase \
78                                      or options.skipexisting))) \
79             or (options.groups and (options.used \
80                                  or options.increase \
81                                  or options.reset \
82                                  or options.hardreset)) :
83            raise PyKotaCommandLineError, _("Incompatible command line options. Please look at the online help or manual page.")
84
85        suffix = (options.groups and "Group") or "User"
86        printernames = options.printer.split(",")
87
88        if not islist :
89            percent = Percent(self)
90            percent.display("%s..." % _("Extracting datas"))
91        printers = self.storage.getMatchingPrinters(options.printer)
92        entries = getattr(self.storage, "getMatching%ss" % suffix)(",".join(names))
93        if not islist :
94            percent.setSize(len(printers) * len(entries))
95
96        if islist :
97            for printer in printers :
98                for entry in entries :
99                    pqentry = getattr(self.storage, "get%sPQuota" % suffix)(entry, printer)
100                    if pqentry.Exists :
101                        self.display("%s@%s\n" % (entry.Name, printer.Name))
102                        self.display("    %s\n" % (_("Page counter : %s") % pqentry.PageCounter))
103                        self.display("    %s\n" % (_("Lifetime page counter : %s") % pqentry.LifePageCounter))
104                        self.display("    %s\n" % (_("Soft limit : %s") % pqentry.SoftLimit))
105                        self.display("    %s\n" % (_("Hard limit : %s") % pqentry.HardLimit))
106                        self.display("    %s\n" % (_("Date limit : %s") % pqentry.DateLimit))
107                        self.display("    %s (Not supported yet)\n" % (_("Maximum job size : %s") % ((pqentry.MaxJobSize and (_("%s pages") % pqentry.MaxJobSize)) or _("Unlimited"))))
108                        if hasattr(pqentry, "WarnCount") :
109                            self.display("    %s\n" % (_("Warning banners printed : %s") % pqentry.WarnCount))
110                        self.display("\n")
111        elif isdelete :
112            percent.display("\n%s..." % _("Deletion"))
113            getattr(self.storage, "deleteMany%sPQuotas" % suffix)(printers, entries)
114            percent.display("\n")
115        else :
116            used = options.used
117            if used :
118                used = used.strip()
119                try :
120                    int(used)
121                except ValueError :
122                    raise PyKotaCommandLineError, _("Invalid used value %s.") % used
123
124            increase = options.increase
125            if increase :
126                try :
127                    increase = int(increase.strip())
128                except ValueError :
129                    raise PyKotaCommandLineError, _("Invalid increase value %s.") % increase
130
131            softlimit = hardlimit = None
132            if not options.noquota :
133                if options.softlimit :
134                    try :
135                        softlimit = int(options.softlimit.strip())
136                        if softlimit < 0 :
137                            raise ValueError
138                    except ValueError :
139                        raise PyKotaCommandLineError, _("Invalid softlimit value %s.") % options.softlimit
140                if options.hardlimit :
141                    try :
142                        hardlimit = int(options.hardlimit.strip())
143                        if hardlimit < 0 :
144                            raise ValueError
145                    except ValueError :
146                        raise PyKotaCommandLineError, _("Invalid hardlimit value %s.") % options.hardlimit
147                if (softlimit is not None) and (hardlimit is not None) and (hardlimit < softlimit) :
148                    self.printInfo(_("Hard limit %(hardlimit)i is less than soft limit %(softlimit)i, values will be exchanged.") \
149                                       % locals())
150                    (softlimit, hardlimit) = (hardlimit, softlimit)
151                if hardlimit is None :
152                    hardlimit = softlimit
153                    if hardlimit is not None :
154                        self.printInfo(_("Undefined hard limit set to soft limit (%s).") % str(hardlimit))
155                if softlimit is None :
156                    softlimit = hardlimit
157                    if softlimit is not None :
158                        self.printInfo(_("Undefined soft limit set to hard limit (%s).") % str(softlimit))
159
160            self.storage.beginTransaction()
161            try :
162                if isadd :
163                    percent.display("\n%s...\n" % _("Creation"))
164                    if not entries :
165                        self.printInfo(_("No entry matches %s. Please use pkusers to create them first.") \
166                                           % (" ".join(names)), "warn")
167
168                    factory = globals()["Storage%sPQuota" % suffix]
169                    for printer in printers :
170                        pname = printer.Name
171                        for entry in entries :
172                            ename = entry.Name
173                            pqkey = "%s@%s" % (ename, pname)
174                            pqentry = factory(self.storage, entry, printer)
175                            self.modifyPQEntry(pqkey,
176                                               pqentry,
177                                               options.noquota,
178                                               softlimit,
179                                               hardlimit,
180                                               increase,
181                                               options.reset,
182                                               options.hardreset,
183                                               suffix,
184                                               used)
185                            oldpqentry = getattr(self.storage, "add%sPQuota" % suffix)(pqentry)
186                            if oldpqentry is not None :
187                                if options.skipexisting :
188                                    self.logdebug("%s print quota entry %s@%s already exists, skipping." \
189                                                      % (suffix, ename, pname))
190                                else :
191                                    self.logdebug("%s print quota entry %s@%s already exists, will be modified." \
192                                                      % (suffix, ename, pname))
193                                    self.modifyPQEntry(pqkey,
194                                                       oldpqentry,
195                                                       options.noquota,
196                                                       softlimit,
197                                                       hardlimit,
198                                                       increase,
199                                                       options.reset,
200                                                       options.hardreset,
201                                                       suffix,
202                                                       used)
203                                    oldpqentry.save()
204                            percent.oneMore()
205                else :
206                    percent.display("\n%s...\n" % _("Modification"))
207                    for printer in printers :
208                        for entry in entries :
209                            pqkey = "%s@%s" % (entry.Name, printer.Name)
210                            pqentry = getattr(self.storage, "get%sPQuota" % suffix)(entry, printer)
211                            if pqentry.Exists :
212                                self.modifyPQEntry(pqkey,
213                                                   pqentry,
214                                                   options.noquota,
215                                                   softlimit,
216                                                   hardlimit,
217                                                   increase,
218                                                   options.reset,
219                                                   options.hardreset,
220                                                   suffix,
221                                                   used)
222                                pqentry.save()
223                            percent.oneMore()
224            except :
225                self.storage.rollbackTransaction()
226                raise
227            else :
228                self.storage.commitTransaction()
229
230        if not islist :
231            percent.done()
232
233if __name__ == "__main__" :
234    parser = PyKotaOptionParser(description=_("Manages PyKota print quota entries for users or users groups. A print quota entry is related to both an user and a printer, or to both a group and a printer, meaning that for example different users can have different page count limits on the same printer. If an user doesn't have a print quota entry on a particular printer, he won't be allowed to print to it."),
235                                usage="edpykota [options] [usernames|groupnames]")
236    parser.add_option("-a", "--add",
237                            action="store_const",
238                            const="add",
239                            dest="action",
240                            help=_("Add new, or modify existing, users or groups print quota entries."))
241    parser.add_option("-d", "--delete",
242                            action="store_const",
243                            const="delete",
244                            dest="action",
245                            help=_("Delete the specified users or groups print quota entries. When deleting users print quota entries, the matching jobs are also deleted from the printing history."))
246    parser.add_option("-S", "--softlimit",
247                            dest="softlimit",
248                            help=_("Set the soft page count limit for the specified print quota entries. Users can print over this limit for a number of days specified in the 'gracedelay' directive in pykota.conf"))
249    parser.add_option("-H", "--hardlimit",
250                            dest="hardlimit",
251                            help=_("Set the hard page count limit for the specified print quota entries. Users are never allowed to print over this limit."))
252    parser.add_option("-g", "--groups",
253                            action="store_true",
254                            dest="groups",
255                            help=_("Manage groups print quota entries instead of users print quota entries."))
256    parser.add_option("-I", "--increase",
257                            dest="increase",
258                            help=_("Increase the existing soft and hard page count limits for the specified print quota entries. You can decrease the values instead by prefixing this parameter with a negative sign."))
259    parser.add_option("-L", "--list",
260                            action="store_const",
261                            const="list",
262                            dest="action",
263                            help=_("Display detailed informations about the specified users or groups print quota entries."))
264    parser.add_option("-n", "--noquota",
265                            dest="noquota",
266                            action="store_true",
267                            help=_("Set no limit for both soft and hard page counts for the specified users or groups print quota entries."))
268    parser.add_option("-P", "--printer",
269                            dest="printer",
270                            default="*",
271                            help=_("Specify a comma separated list of printers you want to manage print quota entries on. The default is '*', meaning all printers."))
272    parser.add_option("-r", "--reset",
273                            dest="reset",
274                            action="store_true",
275                            help=_("Reset the actual page counter for the specified users print quota entries (doesn't work for groups print quota entries). The life time page counter is left unchanged."))
276    parser.add_option("-R", "--hardreset",
277                            dest="hardreset",
278                            action="store_true",
279                            help=_("Reset the actual and life time page counters for the specified users print quota entries (doesn't work for groups print quota entries). This is a shortcut for --used 0."))
280    parser.add_option("-s", "--skipexisting",
281                            action="store_true",
282                            dest="skipexisting",
283                            help=_("If --add is used, ensure that existing users or groups print quota entries won't be modified."))
284    parser.add_option("-U", "--used",
285                            dest="used",
286                            help=_("Set the values of both the actual and life time page counters for the specified users print quota entries (doesn't work for groups print quota entries). This can be useful when migrating from a different print quota software. The values can also be increased or decreased by prefixing this parameter with either a positive or negative sign."))
287
288    parser.add_example("--add john paul george ringo",
289                       _("Would create print quota entries with no page count limits for these four users on all existing printers."))
290    parser.add_example("--printer HP --softlimit 50 --hardlimit 60 jerome",
291                       _("Would allow user 'jerome' to print up to 60 pages on printer 'HP'. This user would be warned when he would have reached 50 pages on this printer. Both the user and printer must have been created previously using the pkusers and pkprinters commands, respectively."))
292    parser.add_example("--groups --softlimit 500 --hardlimit 600 support financial",
293                       _("Would set soft and hard page count limits on any printer for groups 'support' and 'financial'."))
294    parser.add_example('--reset --printer HP jerome "jo*"',
295                       _("Would reset the actual page counter for users 'jerome' and all users whose name begins with 'jo' on printer 'HP'."))
296    parser.add_example("--printer HPCOLOR --noquota jerome",
297                       _("Would allow this user to print without any page limit on printer 'HPCOLOR'. Depending on how this user is limited, he may still be subject to being limited by the number of available credits in his account."))
298    parser.add_example("--add --skipexisting",
299                       _("Would create a print quota entry for each user on each printer for which none already existed. You'll most likely want to use this command at least once after initial setup."))
300    run(parser, EdPyKota)
Note: See TracBrowser for help on using the browser.